feat: better auth api handler

app/index.tsx

@@ -1,35 +0,0 @@
-import { authClient } from '@/lib/auth-client';
-import {  RefreshControl, ScrollView, StatusBar, Text, View } from 'react-native';
-import { useQuery, useZero } from "@rocicorp/zero/react";
-import { queries, type Mutators, type Schema } from '@money/shared';
-import { useState } from 'react';
-
-export default function HomeScreen() {
-  const { data: session } = authClient.useSession();
-
-  const [balances] = useQuery(queries.getBalances(session));
-  const [refreshing, setRefreshing] = useState(false);
-
-  const onRefresh = async () => {
-    setRefreshing(true);
-    // simulate async work
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    setRefreshing(false);
-  };
-
-  return (
-    <>
-      <StatusBar barStyle="dark-content" />
-      <ScrollView contentContainerStyle={{ paddingTop: StatusBar.currentHeight, flexGrow: 1 }} refreshControl={<RefreshControl refreshing={refreshing} onRefresh={onRefresh} />} style={{ paddingHorizontal: 10 }}>
-        {balances.map(balance => <Balance key={balance.id} balance={balance} />)}
-      </ScrollView>
-    </>
-  );
-}
-
-function Balance({ balance }: { balance: { name: string, current: number, avaliable: number } }) {
-  return <View style={{ backgroundColor: "#eee", borderColor: "#ddd", borderWidth: 1, marginBottom: 10, borderRadius: 10 }}>
-    <Text style={{ fontSize: 15, textAlign: "center" }}>{balance.name}</Text>
-    <Text style={{ fontSize: 30, textAlign: "center" }}>{balance.current}</Text>
-  </View>
-}

app/index.web.tsx

@@ -1,99 +0,0 @@
-import { authClient } from '@/lib/auth-client';
-import { Button, Image, Platform, Pressable, ScrollView, Text, View } from 'react-native';
-import { useQuery, useZero } from "@rocicorp/zero/react";
-import { queries, type Mutators, type Schema } from '@money/shared';
-import { useEffect, useState } from 'react';
-import { Link } from 'expo-router';
-
-export default function HomeScreen() {
-  const { data: session } = authClient.useSession();
-
-  const z = useZero<Schema, Mutators>();
-  const [transactions] = useQuery(queries.allTransactions(session));
-  const [balances] = useQuery(queries.getBalances(session));
-
-  const [idx, setIdx] = useState(0);
-  const [accountIdx, setAccountIdx] = useState(0);
-
-  const account = balances.at(accountIdx)!;
-
-  const filteredTransactions = transactions
-    .filter(t => t.account_id == account.plaid_id)
-
-  useEffect(() => {
-    if (Platform.OS != 'web') return;
-    const handleKeyDown = (event: KeyboardEvent) => {
-      if (event.key === "j") {
-        setIdx((prevIdx) => {
-          if (prevIdx + 1 == filteredTransactions.length) return prevIdx;
-          return prevIdx + 1
-        });
-      } else if (event.key === "k") {
-        setIdx((prevIdx) => prevIdx == 0 ? 0 : prevIdx - 1);
-      } else if (event.key == 'g') {
-        setIdx(0);
-      } else if (event.key == "G") {
-        setIdx(transactions.length - 1);
-      } else if (event.key == 'R') {
-        z.mutate.link.updateTransactions();
-        z.mutate.link.updateBalences();
-      } else if (event.key == 'h') {
-        setAccountIdx((prevIdx) => prevIdx == 0 ? 0 : prevIdx - 1);
-      } else if (event.key == 'l') {
-        setAccountIdx((prevIdx) => {
-          if (prevIdx + 1 == balances.length) return prevIdx;
-          return prevIdx + 1
-        });
-      }
-    };
-
-    window.addEventListener("keydown", handleKeyDown);
-
-    return () => {
-      window.removeEventListener("keydown", handleKeyDown);
-    };
-  }, [filteredTransactions, balances]);
-
-  function lpad(n: number): string {
-    const LEN = 9;
-    const nstr = n.toFixed(2).toLocaleString();
-    return Array.from({ length: LEN - nstr.length }).join(" ") + nstr;
-  }
-
-  function uuu(t: typeof filteredTransactions[number]): string | undefined {
-    if (!t.json) return;
-    const j = JSON.parse(t.json);
-    return j.counterparties.filter((c: any) => !!c.logo_url).at(0)?.logo_url || j.personal_finance_category_icon_url;
-  }
-
-  return (
-    <View>
-      <Link prefetch href="/settings">
-        <Button title="Settings" />
-      </Link>
-      <View style={{ flexDirection: "row" }}>
-        <View style={{ backgroundColor: '' }}>
-          {balances.map((bal, i) => <View key={bal.id} style={{ backgroundColor: i == accountIdx ? 'black' : undefined}}>
-            <Text style={{ fontFamily: 'mono', color: i == accountIdx ? 'white' : undefined  }}>{bal.name}: {bal.current} ({bal.avaliable})</Text>
-          </View>)}
-        </View>
-
-        <View>
-          {filteredTransactions.map((t, i) => <Pressable onHoverIn={() => {
-            setIdx(i);
-          }} style={{ backgroundColor: i == idx ? 'black' : undefined, cursor: 'default' as 'auto' }} key={t.id}>
-            <Text style={{ fontFamily: 'mono', color: i == idx ? 'white' : undefined }}>
-              {new Date(t.datetime!).toDateString()}
-              <Text style={{ color: t.amount > 0 ? 'red' : 'green' }}> {lpad(t.amount)}</Text>
-              <Image style={{ width: 15, height: 15, marginHorizontal: 10 }} source={{ uri: uuu(t) || "" }} />
-              {t.name.substring(0, 50)}
-            </Text>
-          </Pressable>)}
-        </View>
-        <ScrollView>
-          <Text style={{ fontFamily: 'mono' }}>{JSON.stringify(JSON.parse(filteredTransactions.at(idx)?.json || "null"), null, 4)}</Text>
-        </ScrollView>
-      </View>
-    </View>
-  );
-}

app/settings.tsx

@@ -1,41 +0,0 @@
-import { SafeAreaView } from 'react-native-safe-area-context';
-import { authClient } from '@/lib/auth-client';
-import { Button, Linking, Text } from 'react-native';
-import { useQuery, useZero } from "@rocicorp/zero/react";
-import { queries, type Mutators, type Schema } from '@money/shared';
-
-export default function HomeScreen() {
-  const { data: session } = authClient.useSession();
-
-  const onLogout = () => {
-    authClient.signOut();
-  }
-  const z = useZero<Schema, Mutators>();
-  const [user] = useQuery(queries.me(session));
-  const [plaidLink] = useQuery(queries.getPlaidLink(session)); 
-
-  return (
-    <SafeAreaView>
-      <Text>Hello {user?.name}</Text>
-      <Button onPress={onLogout} title="Logout" />
-
-      <Text>{JSON.stringify(plaidLink)}</Text>
-      {plaidLink ? <Button onPress={() => {
-        Linking.openURL(plaidLink.link);
-      }} title="Open Plaid" /> : <Text>No plaid link</Text>}
-
-      <Button onPress={() => {
-        z.mutate.link.create();
-      }} title="Generate Link" />
-
-      {plaidLink && <Button onPress={() => {
-        z.mutate.link.get({ link_token: plaidLink.token });
-      }} title="Check Link" />}
-
-      {plaidLink && <Button onPress={() => {
-        z.mutate.link.updateTransactions();
-      }} title="Update transactions" />}
-    </SafeAreaView>
-  );
-}
-

apps/api/package.json

@@ -7,9 +7,12 @@
     "start": "tsx src/index.ts"
   },
   "dependencies": {
+    "@effect/platform": "^0.93.2",
+    "@effect/platform-node": "^0.101.1",
     "@hono/node-server": "^1.19.5",
-    "@money/shared": "link:../shared",
+    "@money/shared": "workspace:*",
     "better-auth": "^1.3.27",
+    "effect": "^3.19.4",
     "hono": "^4.9.12",
     "plaid": "^39.0.0",
     "tsx": "^4.20.6"

apps/api/src/auth.ts

@@ -1,6 +1,6 @@
 import { betterAuth } from "better-auth";
 import { drizzleAdapter } from "better-auth/adapters/drizzle";
-import { genericOAuth } from "better-auth/plugins";
+import { bearer, deviceAuthorization, genericOAuth } from "better-auth/plugins";
 import { expo } from "@better-auth/expo";
 import { drizzleSchema } from "@money/shared/db";
 import { db } from "./db";
@@ -21,7 +21,7 @@ export const auth = betterAuth({
   ],
   advanced: {
     crossSubDomainCookies: {
-          enabled: process.env.NODE_ENV == 'production',
+      enabled: process.env.NODE_ENV == "production",
       domain: "koon.us",
     },
   },
@@ -30,13 +30,15 @@ export const auth = betterAuth({
     genericOAuth({
       config: [
         {
-          providerId: 'koon-family',
+          providerId: "koon-family",
           clientId: process.env.OAUTH_CLIENT_ID!,
           clientSecret: process.env.OAUTH_CLIENT_SECRET!,
           discoveryUrl: process.env.OAUTH_DISCOVERY_URL!,
           scopes: ["profile", "email"],
-        }
-      ]
-    })
-  ]
+        },
+      ],
+    }),
+    deviceAuthorization(),
+    bearer(),
+  ],
 });

apps/api/src/index.ts

@@ -0,0 +1,205 @@
+import * as Layer from "effect/Layer";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import * as HttpLayerRouter from "@effect/platform/HttpLayerRouter";
+import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
+import * as HttpServerRequest from "@effect/platform/HttpServerRequest";
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer";
+import * as NodeHttpServerRequest from "@effect/platform-node/NodeHttpServerRequest";
+import { createServer } from "http";
+import {
+  HttpApi,
+  HttpApiBuilder,
+  HttpApiEndpoint,
+  HttpApiGroup,
+  HttpApiSchema,
+  HttpApiSecurity,
+  HttpMiddleware,
+} from "@effect/platform";
+import { Schema, Data, Console } from "effect";
+import { auth } from "./auth";
+import { AuthSchema } from "@money/shared/auth";
+import { toNodeHandler } from "better-auth/node";
+import { BASE_URL } from "@money/shared";
+
+class CurrentSession extends Context.Tag("CurrentSession")<
+  CurrentSession,
+  { readonly auth: Schema.Schema.Type<typeof AuthSchema> | null }
+>() {}
+
+class Unauthorized extends Schema.TaggedError<Unauthorized>()(
+  "Unauthorized",
+  {},
+  HttpApiSchema.annotations({ status: 401 }),
+) {}
+
+const parseAuthorization = (input: string) =>
+  Effect.gen(function* () {
+    const m = /^Bearer\s+(.+)$/.exec(input);
+    if (!m) {
+      return yield* Effect.fail(
+        new Unauthorized({ message: "Invalid Authorization header" }),
+      );
+    }
+    return m[1];
+  });
+
+export class Authorization extends Context.Tag("Authorization")<
+  Authorization,
+  AuthorizationImpl
+>() {}
+
+export interface AuthorizationImpl {
+  use: <T>(
+    fn: (client: typeof auth) => Promise<T>,
+  ) => Effect.Effect<T, AuthorizationUnknownError | AuthorizationError, never>;
+}
+
+class AuthorizationUnknownError extends Data.TaggedError(
+  "AuthClientUnknownError",
+) {}
+class AuthorizationError extends Data.TaggedError("AuthorizationError")<{
+  message: string;
+}> {}
+
+export const make = () =>
+  Effect.gen(function* () {
+    return Authorization.of({
+      use: (fn) =>
+        Effect.gen(function* () {
+          const data = yield* Effect.tryPromise({
+            try: () => fn(auth),
+            catch: (error) =>
+              error instanceof Error
+                ? new AuthorizationError({ message: error.message })
+                : new AuthorizationUnknownError(),
+          });
+          return data;
+        }),
+    });
+  });
+
+export const AuthorizationLayer = Layer.scoped(Authorization, make());
+
+const SessionMiddleware = HttpLayerRouter.middleware<{
+  provides: CurrentSession;
+}>()(
+  Effect.gen(function* () {
+    const auth = yield* Authorization;
+
+    return (httpEffect) =>
+      Effect.gen(function* () {
+        const request = yield* HttpServerRequest.HttpServerRequest;
+        const headers = request.headers;
+
+        const session = yield* auth
+          .use((auth) => auth.api.getSession({ headers }))
+          .pipe(
+            Effect.flatMap((s) =>
+              s == null ? Effect.succeed(null) : Schema.decode(AuthSchema)(s),
+            ),
+            Effect.tap((s) => Console.debug("Auth result", s)),
+          );
+
+        return yield* Effect.provideService(httpEffect, CurrentSession, {
+          auth: session,
+        });
+      });
+  }),
+);
+
+const HelloRoute = HttpLayerRouter.add(
+  "GET",
+  "/hello",
+
+  Effect.gen(function* () {
+    const { auth } = yield* CurrentSession;
+    return HttpServerResponse.text(`Hello, your name is ${auth?.user.name}`);
+  }),
+).pipe(Layer.provide(SessionMiddleware.layer));
+
+const RootRoute = HttpLayerRouter.add(
+  "GET",
+  "/",
+  Effect.gen(function* () {
+    return HttpServerResponse.text("OK");
+  }),
+);
+
+const authHandler = Effect.gen(function* () {
+  const request = yield* HttpServerRequest.HttpServerRequest;
+  const nodeRequest = NodeHttpServerRequest.toIncomingMessage(request);
+  const nodeResponse = NodeHttpServerRequest.toServerResponse(request);
+
+  nodeResponse.setHeader("Access-Control-Allow-Origin", "http://laptop:8081");
+  nodeResponse.setHeader(
+    "Access-Control-Allow-Methods",
+    "GET, POST, PUT, DELETE, OPTIONS",
+  );
+  nodeResponse.setHeader(
+    "Access-Control-Allow-Headers",
+    "Content-Type, Authorization, B3, traceparent, Cookie",
+  );
+  nodeResponse.setHeader("Access-Control-Max-Age", "600");
+  nodeResponse.setHeader("Access-Control-Allow-Credentials", "true");
+
+  // Handle preflight requests
+  if (nodeRequest.method === "OPTIONS") {
+    nodeResponse.statusCode = 200;
+    nodeResponse.end();
+
+    return;
+    // return nodeResponse;
+  }
+
+  yield* Effect.tryPromise({
+    try: () => toNodeHandler(auth)(nodeRequest, nodeResponse),
+    catch: (error) => {
+      return new AuthorizationError({ message: `${error}` });
+    },
+  });
+
+  // return nodeResponse;
+});
+
+export class AuthContractGroup extends HttpApiGroup.make("auth")
+  .add(HttpApiEndpoint.get("get", "/*"))
+  .add(HttpApiEndpoint.post("post", "/*"))
+  .add(HttpApiEndpoint.options("options", "/*"))
+  .prefix("/api/auth") {}
+
+export class DomainApi extends HttpApi.make("domain").add(AuthContractGroup) {}
+
+export const Api = HttpApi.make("api").addHttpApi(DomainApi);
+
+const AuthLive = HttpApiBuilder.group(Api, "auth", (handlers) =>
+  handlers
+    .handle("get", () => authHandler.pipe(Effect.orDie))
+    .handle("post", () => authHandler.pipe(Effect.orDie))
+    .handle("options", () => authHandler.pipe(Effect.orDie)),
+);
+
+const CorsMiddleware = HttpLayerRouter.middleware(
+  HttpMiddleware.cors({
+    allowedOrigins: ["https://money.koon.us", `${BASE_URL}:8081`],
+    allowedMethods: ["POST", "GET", "OPTIONS"],
+    allowedHeaders: ["Content-Type", "Authorization"],
+    credentials: true,
+  }),
+  // {
+  //   global: true,
+  // },
+);
+
+const AuthRoute = HttpLayerRouter.addHttpApi(Api).pipe(Layer.provide(AuthLive));
+
+const AllRoutes = Layer.mergeAll(RootRoute, AuthRoute, HelloRoute);
+
+HttpLayerRouter.serve(AllRoutes).pipe(
+  Layer.provide(NodeHttpServer.layer(createServer, { port: 3000 })),
+  Layer.provide(AuthorizationLayer),
+  Layer.provide(CorsMiddleware.layer),
+  Layer.launch,
+  NodeRuntime.runMain,
+);

apps/api/src/index_old.ts

@@ -5,13 +5,14 @@ import { cors } from "hono/cors";
 import { auth } from "./auth";
 import { getHono } from "./hono";
 import { zero } from "./zero";
+import { webhook } from "./webhook";
 
 const app = getHono();
 
 app.use(
   "/api/*",
   cors({
-    origin: ['https://money.koon.us', `${BASE_URL}:8081`],
+    origin: ["https://money.koon.us", `${BASE_URL}:8081`],
     allowMethods: ["POST", "GET", "OPTIONS"],
     allowHeaders: ["Content-Type", "Authorization"],
     credentials: true,
@@ -43,6 +44,7 @@ app.use("*", async (c, next) => {
 app.route("/api/zero", zero);
 
 app.get("/api", (c) => c.text("OK"));
+app.get("/api/webhook_receiver", webhook);
 app.get("/", (c) => c.text("OK"));
 
 serve(

apps/api/src/plaid.ts

@@ -0,0 +1,15 @@
+import { Configuration, PlaidApi, PlaidEnvironments } from "plaid";
+
+const configuration = new Configuration({
+  basePath:
+    process.env.PLAID_ENV == "production"
+      ? PlaidEnvironments.production
+      : PlaidEnvironments.sandbox,
+  baseOptions: {
+    headers: {
+      "PLAID-CLIENT-ID": process.env.PLAID_CLIENT_ID,
+      "PLAID-SECRET": process.env.PLAID_SECRET,
+    },
+  },
+});
+export const plaidClient = new PlaidApi(configuration);

apps/api/src/webhook.ts

@@ -0,0 +1,11 @@
+import type { Context } from "hono";
+import { plaidClient } from "./plaid";
+// import { LinkSessionFinishedWebhook, WebhookType } from "plaid";
+
+export const webhook = async (c: Context) => {
+  console.log("Got webhook");
+  const b = await c.req.text();
+  console.log("body:", b);
+
+  return c.text("Hi");
+};

apps/api/src/zero.ts

@@ -8,8 +8,8 @@ import {
   PushProcessor,
   ZQLDatabase,
 } from "@rocicorp/zero/server";
-import { PostgresJSConnection } from '@rocicorp/zero/pg';
-import postgres from 'postgres';
+import { PostgresJSConnection } from "@rocicorp/zero/pg";
+import postgres from "postgres";
 import {
   createMutators as createMutatorsShared,
   isLoggedIn,
@@ -20,24 +20,23 @@ import {
 } from "@money/shared";
 import type { AuthData } from "@money/shared/auth";
 import { getHono } from "./hono";
-import { Configuration, CountryCode, PlaidApi, PlaidEnvironments, Products } from "plaid";
+import {
+  Configuration,
+  CountryCode,
+  PlaidApi,
+  PlaidEnvironments,
+  Products,
+} from "plaid";
 import { randomUUID } from "crypto";
 import { db } from "./db";
-import { balance, plaidAccessTokens, plaidLink, transaction } from "@money/shared/db";
-import { eq, inArray, sql, type InferInsertModel } from "drizzle-orm";
-
-
-const configuration = new Configuration({
-  basePath: process.env.PLAID_ENV == 'production' ? PlaidEnvironments.production : PlaidEnvironments.sandbox,
-  baseOptions: {
-    headers: {
-      'PLAID-CLIENT-ID': process.env.PLAID_CLIENT_ID,
-      'PLAID-SECRET': process.env.PLAID_SECRET,
-    }
-  }
-});
-const plaidClient = new PlaidApi(configuration);
-
+import {
+  balance,
+  plaidAccessTokens,
+  plaidLink,
+  transaction,
+} from "@money/shared/db";
+import { and, eq, inArray, sql, type InferInsertModel } from "drizzle-orm";
+import { plaidClient } from "./plaid";
 
 const processor = new PushProcessor(
   new ZQLDatabase(
@@ -56,7 +55,6 @@ const createMutators = (authData: AuthData | null) => {
       ...mutators.link,
       async create() {
         isLoggedIn(authData);
-        console.log("Creating Link token");
         const r = await plaidClient.linkTokenCreate({
           user: {
             client_user_id: authData.user.id,
@@ -65,9 +63,9 @@ const createMutators = (authData: AuthData | null) => {
           language: "en",
           products: [Products.Transactions],
           country_codes: [CountryCode.Us],
-          hosted_link: {}
+          webhook: "https://webhooks.koon.us/api/webhook_receiver",
+          hosted_link: {},
         });
-        console.log("Result", r);
         const { link_token, hosted_link_url } = r.data;
 
         if (!hosted_link_url) throw Error("No link in response");
@@ -83,23 +81,52 @@ const createMutators = (authData: AuthData | null) => {
       async get(_, { link_token }) {
         isLoggedIn(authData);
 
+        try {
+          const token = await db.query.plaidLink.findFirst({
+            where: and(
+              eq(plaidLink.token, link_token),
+              eq(plaidLink.user_id, authData.user.id),
+            ),
+          });
+          if (!token) throw Error("Link not found");
+          if (token.completeAt) return;
+
           const linkResp = await plaidClient.linkTokenGet({
             link_token,
           });
           if (!linkResp) throw Error("No link respo");
-        console.log(JSON.stringify(linkResp.data, null, 4));
-        const publicToken = linkResp.data.link_sessions?.at(0)?.results?.item_add_results.at(0)?.public_token;
 
-        if (!publicToken) throw Error("No public token");
+          console.log(JSON.stringify(linkResp.data, null, 4));
+
+          const item_add_result = linkResp.data.link_sessions
+            ?.at(0)
+            ?.results?.item_add_results.at(0);
+
+          // We will assume its not done yet.
+          if (!item_add_result) return;
+
           const { data } = await plaidClient.itemPublicTokenExchange({
-          public_token: publicToken,
-        })
+            public_token: item_add_result.public_token,
+          });
 
           await db.insert(plaidAccessTokens).values({
             id: randomUUID(),
             userId: authData.user.id,
             token: data.access_token,
+            logoUrl: "",
+            name: item_add_result.institution?.name || "Unknown",
           });
+
+          await db
+            .update(plaidLink)
+            .set({
+              completeAt: new Date(),
+            })
+            .where(eq(plaidLink.token, link_token));
+        } catch (e) {
+          console.error(e);
+          throw Error("Plaid error");
+        }
       },
 
       async updateTransactions() {
@@ -119,29 +146,39 @@ const createMutators = (authData: AuthData | null) => {
             end_date: new Date().toISOString().split("T")[0],
           });
 
-          const transactions = data.transactions.map(tx => ({
+          const transactions = data.transactions.map(
+            (tx) =>
+              ({
                 id: randomUUID(),
                 user_id: authData.user.id,
                 plaid_id: tx.transaction_id,
                 account_id: tx.account_id,
                 name: tx.name,
                 amount: tx.amount as any,
-            datetime: tx.datetime ? new Date(tx.datetime) : new Date(tx.date),
-            authorized_datetime: tx.authorized_datetime ? new Date(tx.authorized_datetime) : undefined,
+                datetime: tx.datetime
+                  ? new Date(tx.datetime)
+                  : new Date(tx.date),
+                authorized_datetime: tx.authorized_datetime
+                  ? new Date(tx.authorized_datetime)
+                  : undefined,
                 json: JSON.stringify(tx),
-          } satisfies InferInsertModel<typeof transaction>));
+              }) satisfies InferInsertModel<typeof transaction>,
+          );
 
-          await db.insert(transaction).values(transactions).onConflictDoNothing({
+          await db
+            .insert(transaction)
+            .values(transactions)
+            .onConflictDoNothing({
               target: transaction.plaid_id,
             });
 
           const txReplacingPendingIds = data.transactions
-            .filter(t => t.pending_transaction_id)
-            .map(t => t.pending_transaction_id!);
+            .filter((t) => t.pending_transaction_id)
+            .map((t) => t.pending_transaction_id!);
 
-          await db.delete(transaction)
+          await db
+            .delete(transaction)
             .where(inArray(transaction.plaid_id, txReplacingPendingIds));
-
         }
       },
 
@@ -157,25 +194,33 @@ const createMutators = (authData: AuthData | null) => {
 
         for (const account of accounts) {
           const { data } = await plaidClient.accountsBalanceGet({
-            access_token: account.token
+            access_token: account.token,
           });
-          await db.insert(balance).values(data.accounts.map(bal => ({
+          await db
+            .insert(balance)
+            .values(
+              data.accounts.map((bal) => ({
                 id: randomUUID(),
                 user_id: authData.user.id,
                 plaid_id: bal.account_id,
                 avaliable: bal.balances.available as any,
                 current: bal.balances.current as any,
                 name: bal.name,
-          }))).onConflictDoUpdate({
+                tokenId: account.id,
+              })),
+            )
+            .onConflictDoUpdate({
               target: balance.plaid_id,
-            set: { current: sql.raw(`excluded.${balance.current.name}`), avaliable: sql.raw(`excluded.${balance.avaliable.name}`) }
-          })
-        }
-
+              set: {
+                current: sql.raw(`excluded.${balance.current.name}`),
+                avaliable: sql.raw(`excluded.${balance.avaliable.name}`),
               },
+            });
         }
+      },
+    },
   } as const satisfies Mutators;
-}
+};
 
 const zero = getHono()
   .post("/mutate", async (c) => {

apps/expo/.gitignore

@@ -0,0 +1,6 @@
+
+# @generated expo-cli sync-2b81b286409207a5da26e14c78851eb30d8ccbdb
+# The following patterns were generated by expo-cli
+
+expo-env.d.ts
+# @end expo-cli

apps/expo/app/[...route].tsx

@@ -0,0 +1,34 @@
+import { useLocalSearchParams } from "expo-router";
+import { App, type Route } from "@money/ui";
+import { useEffect, useState } from "react";
+import { authClient } from "@/lib/auth-client";
+
+export default function Page() {
+  const { route: initalRoute } = useLocalSearchParams<{ route: string[] }>();
+  const [route, setRoute] = useState(
+    initalRoute ? "/" + initalRoute.join("/") : "/",
+  );
+
+  const { data } = authClient.useSession();
+
+  useEffect(() => {
+    const handler = () => {
+      const newRoute = window.location.pathname.slice(1);
+      setRoute(newRoute);
+    };
+
+    window.addEventListener("popstate", handler);
+    return () => window.removeEventListener("popstate", handler);
+  }, []);
+
+  return (
+    <App
+      auth={data}
+      route={route as Route}
+      setRoute={(page) => {
+        window.history.pushState({}, "", page);
+        setRoute(page);
+      }}
+    />
+  );
+}

apps/expo/app/_layout.tsx

@@ -1,17 +1,23 @@
-import { Stack } from 'expo-router';
-import 'react-native-reanimated';
+import { Stack } from "expo-router";
+import "react-native-reanimated";
 
-import { authClient } from '@/lib/auth-client';
-import { ZeroProvider } from '@rocicorp/zero/react';
-import { useMemo } from 'react';
-import { authDataSchema } from '@/shared/src/auth';
-import { Platform } from 'react-native';
-import type { ZeroOptions } from '@rocicorp/zero';
-import { schema, type Schema, createMutators, type Mutators, BASE_URL } from '@/shared/src';
+import { authClient } from "@/lib/auth-client";
+import { ZeroProvider } from "@rocicorp/zero/react";
+import { useMemo } from "react";
+import { authDataSchema } from "@money/shared/auth";
+import { Platform } from "react-native";
+import type { ZeroOptions } from "@rocicorp/zero";
+import {
+  schema,
+  type Schema,
+  createMutators,
+  type Mutators,
+  BASE_URL,
+} from "@money/shared";
 import { expoSQLiteStoreProvider } from "@rocicorp/zero/react-native";
 
 export const unstable_settings = {
-  anchor: 'index',
+  anchor: "index",
 };
 
 const kvStore = Platform.OS === "web" ? undefined : expoSQLiteStoreProvider();
@@ -25,14 +31,17 @@ export default function RootLayout() {
   }, [session]);
 
   const cookie = useMemo(() => {
-    return Platform.OS == 'web' ? undefined : authClient.getCookie();
+    return Platform.OS == "web" ? undefined : authClient.getCookie();
   }, [session, isPending]);
 
   const zeroProps = useMemo(() => {
     return {
-      storageKey: 'money',
+      storageKey: "money",
       kvStore,
-      server: process.env.NODE_ENV == 'production' ? 'https://zero.koon.us' : `${BASE_URL}:4848`,
+      server:
+        process.env.NODE_ENV == "production"
+          ? "https://zero.koon.us"
+          : `${BASE_URL}:4848`,
       userID: authData?.user.id ?? "anon",
       schema,
       mutators: createMutators(authData),
@@ -44,8 +53,8 @@ export default function RootLayout() {
     <ZeroProvider {...zeroProps}>
       <Stack>
         <Stack.Protected guard={!isPending && !!session}>
-          <Stack.Screen name="index" options={{ headerShown: false }} />
-          <Stack.Screen name="settings" options={{ headerShown: false }} />
+          <Stack.Screen name="[...route]" options={{ headerShown: false }} />
+          <Stack.Screen name="approve" />
         </Stack.Protected>
         <Stack.Protected guard={!isPending && !session}>
           <Stack.Screen name="auth" />

apps/expo/app/approve.tsx

@@ -0,0 +1,19 @@
+import { authClient } from "@/lib/auth-client";
+import { useLocalSearchParams } from "expo-router";
+import { useEffect } from "react";
+import { Text } from "react-native";
+
+export default function Page() {
+  const { code } = useLocalSearchParams<{ code: string }>();
+  const { isPending, data } = authClient.useSession();
+  if (isPending) return <Text>Loading...</Text>;
+  if (!isPending && !data) return <Text>Please log in</Text>;
+
+  useEffect(() => {
+    authClient.device.approve({
+      userCode: code,
+    });
+  }, []);
+
+  return <Text>Approving: {code}</Text>;
+}

apps/expo/app/auth.tsx

@@ -6,7 +6,10 @@ export default function Auth() {
   const onLogin = () => {
     authClient.signIn.oauth2({
       providerId: "koon-family",
-      callbackURL: process.env.NODE_ENV == 'production' ? 'https://money.koon.us' : `${BASE_URL}:8081`,
+      callbackURL:
+        process.env.NODE_ENV == "production"
+          ? "https://money.koon.us"
+          : `${BASE_URL}:8081`,
     });
   };
 
@@ -14,5 +17,5 @@ export default function Auth() {
     <View>
       <Button onPress={onLogin} title="Login with Koon Family" />
     </View>
-  )
+  );
 }

apps/expo/app/index.native.tsx

@@ -0,0 +1,68 @@
+import { authClient } from "@/lib/auth-client";
+import {
+  RefreshControl,
+  ScrollView,
+  StatusBar,
+  Text,
+  View,
+} from "react-native";
+import { useQuery, useZero } from "@rocicorp/zero/react";
+import { queries, type Mutators, type Schema } from "@money/shared";
+import { useState } from "react";
+
+export default function HomeScreen() {
+  const { data: session } = authClient.useSession();
+
+  const [balances] = useQuery(queries.getBalances(session));
+  const [refreshing, setRefreshing] = useState(false);
+
+  const onRefresh = async () => {
+    setRefreshing(true);
+    // simulate async work
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    setRefreshing(false);
+  };
+
+  return (
+    <>
+      <StatusBar barStyle="dark-content" />
+      <ScrollView
+        contentContainerStyle={{
+          paddingTop: StatusBar.currentHeight,
+          flexGrow: 1,
+        }}
+        refreshControl={
+          <RefreshControl refreshing={refreshing} onRefresh={onRefresh} />
+        }
+        style={{ paddingHorizontal: 10 }}
+      >
+        {balances.map((balance) => (
+          <Balance key={balance.id} balance={balance} />
+        ))}
+      </ScrollView>
+    </>
+  );
+}
+
+function Balance({
+  balance,
+}: {
+  balance: { name: string; current: number; avaliable: number };
+}) {
+  return (
+    <View
+      style={{
+        backgroundColor: "#eee",
+        borderColor: "#ddd",
+        borderWidth: 1,
+        marginBottom: 10,
+        borderRadius: 10,
+      }}
+    >
+      <Text style={{ fontSize: 15, textAlign: "center" }}>{balance.name}</Text>
+      <Text style={{ fontSize: 30, textAlign: "center" }}>
+        {balance.current}
+      </Text>
+    </View>
+  );
+}

apps/expo/eslint.config.js

@@ -0,0 +1,10 @@
+// https://docs.expo.dev/guides/using-eslint/
+const { defineConfig } = require("eslint/config");
+const expoConfig = require("eslint-config-expo/flat");
+
+module.exports = defineConfig([
+  expoConfig,
+  {
+    ignores: ["dist/*"],
+  },
+]);

apps/expo/lib/auth-client.ts

@@ -1,11 +1,17 @@
 import { createAuthClient } from "better-auth/react";
-import { genericOAuthClient } from "better-auth/client/plugins";
+import {
+  deviceAuthorizationClient,
+  genericOAuthClient,
+} from "better-auth/client/plugins";
 import { expoClient } from "@better-auth/expo/client";
 import * as SecureStore from "expo-secure-store";
 import { BASE_URL } from "@money/shared";
 
 export const authClient = createAuthClient({
-  baseURL: process.env.NODE_ENV == 'production' ? 'https://money-api.koon.us' : `${BASE_URL}:3000`,
+  baseURL:
+    process.env.NODE_ENV == "production"
+      ? "https://money-api.koon.us"
+      : `${BASE_URL}:3000`,
   plugins: [
     expoClient({
       scheme: "money",
@@ -13,5 +19,6 @@ export const authClient = createAuthClient({
       storage: SecureStore,
     }),
     genericOAuthClient(),
-  ]
+    deviceAuthorizationClient(),
+  ],
 });

apps/expo/metro.config.js

@@ -1,6 +1,6 @@
 const { getDefaultConfig } = require("expo/metro-config");
 
-const config = getDefaultConfig(__dirname)
+const config = getDefaultConfig(__dirname);
 
 // Add wasm asset support
 config.resolver.assetExts.push("wasm");

apps/expo/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@money/expo",
+  "main": "expo-router/entry",
+  "version": "1.0.0",
+  "scripts": {
+    "start": "expo start",
+    "reset-project": "node ./scripts/reset-project.js",
+    "android": "expo start --android",
+    "ios": "expo start --ios",
+    "web": "expo start --web",
+    "build": "expo export --platform web",
+    "lint": "expo lint",
+    "db:migrate": "dotenv -- pnpm run --dir=shared db:migrate",
+    "db:gen": "dotenv -- pnpm run --dir=shared generate:zero"
+  },
+  "dependencies": {
+    "@better-auth/expo": "^1.3.27",
+    "@expo/vector-icons": "^15.0.2",
+    "@money/shared": "workspace:*",
+    "@money/ui": "workspace:*",
+    "@react-navigation/bottom-tabs": "^7.4.0",
+    "@react-navigation/elements": "^2.6.3",
+    "@react-navigation/native": "^7.1.8",
+    "@rocicorp/zero": "^0.23.2025090100",
+    "better-auth": "^1.3.27",
+    "drizzle-orm": "^0.44.6",
+    "expo": "~54.0.13",
+    "expo-constants": "~18.0.9",
+    "expo-crypto": "~15.0.7",
+    "expo-font": "~14.0.9",
+    "expo-haptics": "~15.0.7",
+    "expo-image": "~3.0.9",
+    "expo-linking": "~8.0.8",
+    "expo-router": "~6.0.11",
+    "expo-splash-screen": "~31.0.10",
+    "expo-sqlite": "~16.0.8",
+    "expo-status-bar": "~3.0.8",
+    "expo-symbols": "~1.0.7",
+    "expo-system-ui": "~6.0.7",
+    "expo-web-browser": "~15.0.8",
+    "pg": "^8.16.3",
+    "react": "19.1.0",
+    "react-dom": "19.1.0",
+    "react-native": "0.81.4",
+    "react-native-gesture-handler": "~2.28.0",
+    "react-native-reanimated": "~4.1.1",
+    "react-native-safe-area-context": "~5.6.0",
+    "react-native-screens": "~4.16.0",
+    "react-native-web": "~0.21.0",
+    "react-native-worklets": "0.5.1"
+  },
+  "devDependencies": {
+    "@types/pg": "^8.15.5",
+    "@types/react": "~19.1.0",
+    "dotenv-cli": "^10.0.0",
+    "drizzle-kit": "^0.31.5",
+    "eslint": "^9.25.0",
+    "eslint-config-expo": "~10.0.0",
+    "typescript": "~5.9.2"
+  },
+  "private": true
+}

apps/expo/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "expo/tsconfig.base",
+  "compilerOptions": {
+    "strict": true,
+    "verbatimModuleSyntax": true,
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["**/*.ts", "**/*.tsx", ".expo/types/**/*.ts", "expo-env.d.ts"]
+}

apps/tui/.gitignore

@@ -0,0 +1,34 @@
+# dependencies (bun install)
+node_modules
+
+# output
+out
+dist
+*.tgz
+
+# code coverage
+coverage
+*.lcov
+
+# logs
+logs
+*.log
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# caches
+.eslintcache
+.cache
+*.tsbuildinfo
+
+# IntelliJ based IDEs
+.idea
+
+# Finder (MacOS) folder config
+.DS_Store

apps/tui/README.md

@@ -0,0 +1,15 @@
+# react
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run src/index.tsx
+```
+
+This project was created using `bun create tui`. [create-tui](https://git.new/create-tui) is the easiest way to get started with OpenTUI.

apps/tui/build.ts

@@ -0,0 +1,50 @@
+import esbuild from "esbuild";
+import path from "path";
+
+// Custom plugin to alias "react-native" to react-native-opentui
+const aliasPlugin = {
+  name: "alias-react-native",
+  setup(build) {
+    build.onResolve({ filter: /^react-native$/ }, (args) => {
+      return {
+        path: path.resolve(
+          __dirname,
+          "../../packages/react-native-opentui/index.tsx",
+        ),
+      };
+    });
+  },
+};
+
+// Build configuration
+await esbuild.build({
+  entryPoints: ["src/index.tsx"], // your app entry
+  bundle: true, // inline all dependencies (ui included)
+  platform: "node", // Node/Bun target
+  format: "esm", // keep ESM for top-level await
+  outfile: "dist/index.js",
+  sourcemap: true,
+  plugins: [aliasPlugin],
+  loader: {
+    ".ts": "ts",
+    ".tsx": "tsx",
+  },
+  external: [
+    // leave OpenTUI and Bun built-ins for Bun runtime
+    "react",
+    "@opentui/core",
+    "@opentui/react",
+    "@opentui/react/jsx-runtime",
+    "effect",
+    "@effect/platform",
+    "@effect/platform-bun",
+    "bun:ffi",
+    "@rocicorp/zero",
+    "better-auth",
+    "zod",
+    // "./assets/**/*.scm",
+    // "./assets/**/*.wasm",
+  ],
+});
+
+console.log("✅ App bundled successfully");

apps/tui/lib/auth-client.ts

@@ -0,0 +1,8 @@
+import { config } from "@/src/config";
+import { createAuthClient } from "better-auth/client";
+import { deviceAuthorizationClient } from "better-auth/client/plugins";
+
+export const authClient = createAuthClient({
+  baseURL: config.apiUrl,
+  plugins: [deviceAuthorizationClient()],
+});

apps/tui/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@money/tui",
+  "version": "0.0.1",
+  "scripts": {
+    "build": "bun run build.js",
+    "start": "bun run dist/index.js"
+  },
+  "peerDependencies": {
+    "react": "*"
+  },
+  "dependencies": {
+    "@effect/platform": "^0.93.2",
+    "@effect/platform-bun": "^0.83.0",
+    "@money/shared": "workspace:*",
+    "@money/ui": "workspace:*",
+    "@opentui/core": "^0.1.47",
+    "@opentui/react": "^0.1.47",
+    "@types/qrcode": "^1.5.6",
+    "effect": "^3.19.4",
+    "qrcode": "^1.5.4",
+    "react-native": "^0.82.1",
+    "react-native-opentui": "workspace:*"
+  },
+  "devDependencies": {
+    "esbuild": "^0.27.0"
+  }
+}

apps/tui/src/auth.ts

@@ -0,0 +1,221 @@
+import {
+  Context,
+  Data,
+  Effect,
+  Layer,
+  Schema,
+  Console,
+  Schedule,
+  Ref,
+  Duration,
+} from "effect";
+import { FileSystem } from "@effect/platform";
+import { config } from "./config";
+import { authClient } from "@/lib/auth-client";
+import type { BetterFetchResponse } from "@better-fetch/fetch";
+import { AuthSchema } from "@money/shared/auth";
+
+class AuthClientUnknownError extends Data.TaggedError(
+  "AuthClientUnknownError",
+) {}
+class AuthClientExpiredToken extends Data.TaggedError(
+  "AuthClientExpiredToken",
+) {}
+class AuthClientNoData extends Data.TaggedError("AuthClientNoData") {}
+class AuthClientFetchError extends Data.TaggedError("AuthClientFetchError")<{
+  message: string;
+}> {}
+class AuthClientError<T> extends Data.TaggedError("AuthClientError")<{
+  error: T;
+}> {}
+
+type ErrorType<E> = {
+  [key in keyof ((E extends Record<string, any>
+    ? E
+    : {
+        message?: string;
+      }) & {
+    status: number;
+    statusText: string;
+  })]: ((E extends Record<string, any>
+    ? E
+    : {
+        message?: string;
+      }) & {
+    status: number;
+    statusText: string;
+  })[key];
+};
+
+export class AuthClient extends Context.Tag("AuthClient")<
+  AuthClient,
+  AuthClientImpl
+>() {}
+
+export interface AuthClientImpl {
+  use: <T, E>(
+    fn: (client: typeof authClient) => Promise<BetterFetchResponse<T, E>>,
+  ) => Effect.Effect<
+    T,
+    | AuthClientError<ErrorType<E>>
+    | AuthClientFetchError
+    | AuthClientUnknownError
+    | AuthClientNoData,
+    never
+  >;
+}
+
+export const make = () =>
+  Effect.gen(function* () {
+    return AuthClient.of({
+      use: (fn) =>
+        Effect.gen(function* () {
+          const { data, error } = yield* Effect.tryPromise({
+            try: () => fn(authClient),
+            catch: (error) =>
+              error instanceof Error
+                ? new AuthClientFetchError({ message: error.message })
+                : new AuthClientUnknownError(),
+          });
+          if (error != null)
+            return yield* Effect.fail(new AuthClientError({ error }));
+          if (data == null) return yield* Effect.fail(new AuthClientNoData());
+          return data;
+        }),
+    });
+  });
+
+export const AuthClientLayer = Layer.scoped(AuthClient, make());
+
+const pollToken = ({ device_code }: { device_code: string }) =>
+  Effect.gen(function* () {
+    const auth = yield* AuthClient;
+    const intervalRef = yield* Ref.make(5);
+
+    const tokenEffect = auth.use((client) => {
+      Console.debug("Fetching");
+
+      return client.device.token({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code,
+        client_id: config.authClientId,
+        fetchOptions: { headers: { "user-agent": config.authClientUserAgent } },
+      });
+    });
+
+    return yield* tokenEffect.pipe(
+      Effect.tapError((error) =>
+        error._tag == "AuthClientError" && error.error.error == "slow_down"
+          ? Ref.update(intervalRef, (current) => {
+              Console.debug("updating delay to ", current + 5);
+              return current + 5;
+            })
+          : Effect.void,
+      ),
+      Effect.retry({
+        schedule: Schedule.addDelayEffect(
+          Schedule.recurWhile<Effect.Effect.Error<typeof tokenEffect>>(
+            (error) =>
+              error._tag == "AuthClientError" &&
+              (error.error.error == "authorization_pending" ||
+                error.error.error == "slow_down"),
+          ),
+          () => Ref.get(intervalRef).pipe(Effect.map(Duration.seconds)),
+        ),
+      }),
+    );
+  });
+
+const getFromFromDisk = Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const content = yield* fs.readFileString(config.authPath);
+  const auth = yield* Schema.decode(Schema.parseJson(AuthSchema))(content);
+  if (auth.session.expiresAt < new Date())
+    yield* Effect.fail(new AuthClientExpiredToken());
+  return auth;
+});
+
+const requestAuth = Effect.gen(function* () {
+  const auth = yield* AuthClient;
+  const { device_code, user_code } = yield* auth.use((client) =>
+    client.device.code({
+      client_id: config.authClientId,
+      scope: "openid profile email",
+    }),
+  );
+
+  console.log(`Please use the code: ${user_code}`);
+
+  const { access_token } = yield* pollToken({ device_code });
+
+  const sessionData = yield* auth.use((client) =>
+    client.getSession({
+      fetchOptions: {
+        auth: {
+          type: "Bearer",
+          token: access_token,
+        },
+      },
+    }),
+  );
+  if (sessionData == null) return yield* Effect.fail(new AuthClientNoData());
+
+  const result = yield* Schema.decodeUnknown(AuthSchema)(sessionData);
+
+  const fs = yield* FileSystem.FileSystem;
+  yield* fs.writeFileString(config.authPath, JSON.stringify(result));
+
+  return result;
+});
+
+export const getAuth = Effect.gen(function* () {
+  return yield* getFromFromDisk.pipe(
+    Effect.catchAll(() => requestAuth),
+    Effect.catchTag("AuthClientFetchError", (err) =>
+      Effect.gen(function* () {
+        yield* Console.error("Authentication failed: " + err.message);
+        process.exit(1);
+      }),
+    ),
+    Effect.catchTag("AuthClientNoData", () =>
+      Effect.gen(function* () {
+        yield* Console.error(
+          "Authentication failed: No error and no data was given by the auth server.",
+        );
+        process.exit(1);
+      }),
+    ),
+    Effect.catchTag("ParseError", (err) =>
+      Effect.gen(function* () {
+        yield* Console.error(
+          "Authentication failed: Auth data failed: " + err.toString(),
+        );
+        process.exit(1);
+      }),
+    ),
+    Effect.catchTag("BadArgument", () =>
+      Effect.gen(function* () {
+        yield* Console.error("Authentication failed: Bad argument");
+        process.exit(1);
+      }),
+    ),
+    Effect.catchTag("SystemError", () =>
+      Effect.gen(function* () {
+        yield* Console.error("Authentication failed: System error");
+        process.exit(1);
+      }),
+    ),
+    Effect.catchTag("AuthClientError", ({ error }) =>
+      Effect.gen(function* () {
+        yield* Console.error("Authentication error: " + error.statusText);
+        process.exit(1);
+      }),
+    ),
+    Effect.catchTag("AuthClientUnknownError", () =>
+      Effect.gen(function* () {
+        yield* Console.error("Unknown authentication error");
+        process.exit(1);
+      }),
+    ),
+  );
+});

apps/tui/src/config.ts

@@ -0,0 +1,14 @@
+import { join } from "path";
+import { homedir } from "os";
+
+const PATH = join(homedir(), ".local", "share", "money");
+const AUTH_PATH = join(PATH, "auth.json");
+
+export const config = {
+  dir: PATH,
+  authPath: AUTH_PATH,
+  authClientId: "koon-family",
+  authClientUserAgent: "CLI",
+  zeroUrl: "http://laptop:4848",
+  apiUrl: "http://laptop:3000",
+};

apps/tui/src/index.tsx

@@ -0,0 +1,43 @@
+import { createCliRenderer } from "@opentui/core";
+import { createRoot, useKeyboard } from "@opentui/react";
+import { App, type Route } from "@money/ui";
+import { ZeroProvider } from "@rocicorp/zero/react";
+import { schema } from "@money/shared";
+import { useState } from "react";
+import { AuthClientLayer, getAuth } from "./auth";
+import { Effect, Redacted } from "effect";
+import { BunContext } from "@effect/platform-bun";
+import { kvStore } from "./store";
+import { config } from "./config";
+import { type AuthSchemaType } from "@money/shared/auth";
+
+function Main({ auth }: { auth: AuthSchemaType }) {
+  const [route, setRoute] = useState<Route>("/");
+
+  useKeyboard((key) => {
+    if (key.name == "c" && key.ctrl) process.exit(0);
+  });
+
+  return (
+    <ZeroProvider
+      {...{
+        userID: auth.user.id,
+        auth: Redacted.value(auth.session.token),
+        server: config.zeroUrl,
+        schema,
+        kvStore,
+      }}
+    >
+      <App auth={auth} route={route} setRoute={setRoute} />
+    </ZeroProvider>
+  );
+}
+
+const auth = await Effect.runPromise(
+  getAuth.pipe(
+    Effect.provide(BunContext.layer),
+    Effect.provide(AuthClientLayer),
+  ),
+);
+const renderer = await createCliRenderer({ exitOnCtrlC: false });
+createRoot(renderer).render(<Main auth={auth} />);

apps/tui/src/store.ts

@@ -0,0 +1,131 @@
+import { promises as fs } from "fs";
+import path from "path";
+import type { ReadonlyJSONValue, ZeroOptions } from "@rocicorp/zero";
+import { config } from "./config";
+
+type StoreProvider = ZeroOptions<any>["kvStore"];
+
+const DATA_DIR = config.dir;
+
+function deepFreeze<T>(obj: T): T {
+  if (obj && typeof obj === "object" && !Object.isFrozen(obj)) {
+    Object.freeze(obj);
+    for (const value of Object.values(obj as any)) {
+      deepFreeze(value);
+    }
+  }
+  return obj;
+}
+
+async function loadFile(name: string): Promise<Map<string, ReadonlyJSONValue>> {
+  const filePath = path.join(DATA_DIR, `${name}.json`);
+  try {
+    const buf = await fs.readFile(filePath, "utf8");
+    const obj = JSON.parse(buf) as Record<string, ReadonlyJSONValue>;
+    const frozen = Object.fromEntries(
+      Object.entries(obj).map(([k, v]) => [k, deepFreeze(v)]),
+    );
+    return new Map(Object.entries(frozen));
+  } catch (err: any) {
+    if (err.code === "ENOENT") {
+      return new Map();
+    }
+    throw err;
+  }
+}
+
+async function saveFile(name: string, data: Map<string, ReadonlyJSONValue>) {
+  const filePath = path.join(DATA_DIR, `${name}.json`);
+  const obj = Object.fromEntries(data.entries());
+  await fs.writeFile(filePath, JSON.stringify(obj, null, 2), "utf8");
+}
+
+export const kvStore: StoreProvider = {
+  create: (name: string) => {
+    let closed = false;
+    let dataPromise = loadFile(name);
+
+    const makeRead = async () => {
+      const data = await dataPromise;
+      let txClosed = false;
+      return {
+        closed: txClosed,
+        async has(key: string) {
+          if (txClosed) throw new Error("transaction closed");
+          return data.has(key);
+        },
+        async get(key: string) {
+          if (txClosed) throw new Error("transaction closed");
+          return data.get(key);
+        },
+        release() {
+          txClosed = true;
+        },
+      };
+    };
+
+    const makeWrite = async () => {
+      const data = await dataPromise;
+      let txClosed = false;
+      const staging = new Map<string, ReadonlyJSONValue | undefined>();
+
+      return {
+        closed: txClosed,
+        async has(key: string) {
+          if (txClosed) throw new Error("transaction closed");
+          return staging.has(key)
+            ? staging.get(key) !== undefined
+            : data.has(key);
+        },
+        async get(key: string) {
+          if (txClosed) throw new Error("transaction closed");
+          return staging.has(key) ? staging.get(key) : data.get(key);
+        },
+        async put(key: string, value: ReadonlyJSONValue) {
+          if (txClosed) throw new Error("transaction closed");
+          staging.set(key, deepFreeze(value)); // 🔒 freeze before staging
+        },
+        async del(key: string) {
+          if (txClosed) throw new Error("transaction closed");
+          staging.set(key, undefined);
+        },
+        async commit() {
+          if (txClosed) throw new Error("transaction closed");
+          for (const [k, v] of staging.entries()) {
+            if (v === undefined) {
+              data.delete(k);
+            } else {
+              data.set(k, v);
+            }
+          }
+          await saveFile(name, data);
+          txClosed = true;
+        },
+        release() {
+          txClosed = true;
+        },
+      };
+    };
+
+    return {
+      closed,
+      async read() {
+        if (closed) throw new Error("store closed");
+        return makeRead();
+      },
+      async write() {
+        if (closed) throw new Error("store closed");
+        return makeWrite();
+      },
+      async close() {
+        closed = true;
+      },
+    };
+  },
+
+  async drop(name: string) {
+    const filePath = path.join(DATA_DIR, `${name}.json`);
+    await fs.rm(filePath, { force: true });
+    console.log("destroy db:", name);
+  },
+};

apps/tui/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "react-native": ["../react-native-opentui"],
+      "@/*": ["./*"]
+    },
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/react",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

apps/tui/util/qr.ts

@@ -0,0 +1,24 @@
+import QRCode from "qrcode";
+
+export function QR(value: string): string {
+  const qr = QRCode.create(value, {
+    errorCorrectionLevel: "L",
+    version: 3,
+  });
+
+  const m = qr.modules.data;
+  const size = qr.modules.size;
+
+  // Use half-block characters to compress vertically
+  // Upper half = '▀', lower half = '▄', full = '█', empty = ' '
+  let out = "";
+  for (let y = 0; y < size; y += 2) {
+    for (let x = 0; x < size; x++) {
+      const top = m[y * size + x];
+      const bottom = m[(y + 1) * size + x];
+      out += top && bottom ? "█" : top ? "▀" : bottom ? "▄" : " ";
+    }
+    out += "\n";
+  }
+  return out;
+}

biome.jsonc

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.0.5/schema.json",
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space"
+  },
+  "linter": {
+    "enabled": false
+  },
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  }
+}

eslint.config.js

@@ -1,10 +0,0 @@
-// https://docs.expo.dev/guides/using-eslint/
-const { defineConfig } = require('eslint/config');
-const expoConfig = require('eslint-config-expo/flat');
-
-module.exports = defineConfig([
-  expoConfig,
-  {
-    ignores: ['dist/*'],
-  },
-]);

flake.nix

@@ -19,9 +19,12 @@
         packages = with pkgs; [
           corepack
           nodejs_22
+          bun
+          biome
 
           postgresql
           process-compose
+          cloudflared
         ];
       };
     });

package.json

@@ -1,71 +1,18 @@
 {
   "name": "money",
-  "main": "expo-router/entry",
-  "version": "1.0.0",
-  "scripts": {
-    "start": "expo start",
-    "reset-project": "node ./scripts/reset-project.js",
-    "android": "expo start --android",
-    "ios": "expo start --ios",
-    "web": "expo start --web",
-    "build": "expo export --platform web",
-    "lint": "expo lint",
-    "db:migrate": "dotenv -- pnpm run --dir=shared db:migrate",
-    "db:gen": "dotenv -- pnpm run --dir=shared generate:zero",
-    "dev": "process-compose up -p 0"
-  },
-  "dependencies": {
-    "@better-auth/expo": "^1.3.27",
-    "@expo/vector-icons": "^15.0.2",
-    "@money/shared": "link:shared",
-    "@react-navigation/bottom-tabs": "^7.4.0",
-    "@react-navigation/elements": "^2.6.3",
-    "@react-navigation/native": "^7.1.8",
-    "@rocicorp/zero": "^0.24.2025101500",
-    "better-auth": "^1.3.27",
-    "drizzle-orm": "^0.44.6",
-    "expo": "~54.0.13",
-    "expo-constants": "~18.0.9",
-    "expo-crypto": "~15.0.7",
-    "expo-font": "~14.0.9",
-    "expo-haptics": "~15.0.7",
-    "expo-image": "~3.0.9",
-    "expo-linking": "~8.0.8",
-    "expo-router": "~6.0.11",
-    "expo-splash-screen": "~31.0.10",
-    "expo-sqlite": "~16.0.8",
-    "expo-status-bar": "~3.0.8",
-    "expo-symbols": "~1.0.7",
-    "expo-system-ui": "~6.0.7",
-    "expo-web-browser": "~15.0.8",
-    "pg": "^8.16.3",
-    "react": "19.1.0",
-    "react-dom": "19.1.0",
-    "react-native": "0.81.4",
-    "react-native-gesture-handler": "~2.28.0",
-    "react-native-reanimated": "~4.1.1",
-    "react-native-safe-area-context": "~5.6.0",
-    "react-native-screens": "~4.16.0",
-    "react-native-web": "~0.21.0",
-    "react-native-worklets": "0.5.1"
-  },
-  "devDependencies": {
-    "@types/pg": "^8.15.5",
-    "@types/react": "~19.1.0",
-    "dotenv-cli": "^10.0.0",
-    "drizzle-kit": "^0.31.5",
-    "eslint": "^9.25.0",
-    "eslint-config-expo": "~10.0.0",
-    "typescript": "~5.9.2"
-  },
   "private": true,
+  "scripts": {
+    "dev": "process-compose up -p 0",
+    "tui": "bun run --hot apps/tui/src/index.tsx"
+  },
   "pnpm": {
     "onlyBuiltDependencies": [
       "@rocicorp/zero-sqlite3"
     ],
     "ignoredBuiltDependencies": [
       "esbuild",
-      "protobufjs"
+      "protobufjs",
+      "unrs-resolver"
     ]
   }
 }

packages/react-native-opentui/index.tsx

@@ -0,0 +1,243 @@
+import * as React from "react";
+import type {
+  ViewProps,
+  TextProps,
+  PressableProps,
+  ScrollViewProps,
+  ModalProps,
+  StyleProp,
+  ViewStyle,
+  LinkingImpl,
+} from "react-native";
+import { useTerminalDimensions } from "@opentui/react";
+import { RGBA } from "@opentui/core";
+import { platform } from "node:os";
+import { exec } from "node:child_process";
+
+const RATIO_WIDTH = 8.433;
+const RATIO_HEIGHT = 17;
+
+function attr<K extends keyof ViewStyle>(
+  style: StyleProp<ViewStyle>,
+  name: K,
+  type: "string",
+): Extract<ViewStyle[K], string> | undefined;
+
+function attr<K extends keyof ViewStyle>(
+  style: StyleProp<ViewStyle>,
+  name: K,
+  type: "number",
+): Extract<ViewStyle[K], number> | undefined;
+
+function attr<K extends keyof ViewStyle>(
+  style: StyleProp<ViewStyle>,
+  name: K,
+  type: "boolean",
+): Extract<ViewStyle[K], boolean> | undefined;
+
+function attr<K extends keyof ViewStyle>(
+  style: StyleProp<ViewStyle>,
+  name: K,
+  type: "string" | "number" | "boolean",
+) {
+  if (!style) return undefined;
+
+  const obj: ViewStyle = Array.isArray(style)
+    ? Object.assign({}, ...style.filter(Boolean))
+    : (style as ViewStyle);
+
+  const v = obj[name];
+  return typeof v === type ? v : undefined;
+}
+
+export function View({ children, style }: ViewProps) {
+  const bg =
+    style && "backgroundColor" in style
+      ? typeof style.backgroundColor == "string"
+        ? style.backgroundColor.startsWith("rgba(")
+          ? (() => {
+              const parts = style.backgroundColor.split("(")[1].split(")")[0];
+              const [r, g, b, a] = parts.split(",").map(parseFloat);
+              return RGBA.fromInts(r, g, b, a * 255);
+            })()
+          : style.backgroundColor
+        : undefined
+      : undefined;
+
+  const padding = attr(style, "padding", "number");
+
+  const props = {
+    overflow: attr(style, "overflow", "string"),
+    position: attr(style, "position", "string"),
+    alignSelf: attr(style, "alignSelf", "string"),
+    alignItems: attr(style, "alignItems", "string"),
+    justifyContent: attr(style, "justifyContent", "string"),
+    flexShrink: attr(style, "flexShrink", "number"),
+    flexDirection: attr(style, "flexDirection", "string"),
+    flexGrow:
+      attr(style, "flex", "number") || attr(style, "flexGrow", "number"),
+  };
+
+  return (
+    <box
+      backgroundColor={bg}
+      paddingTop={padding && Math.round(padding / RATIO_HEIGHT)}
+      paddingBottom={padding && Math.round(padding / RATIO_HEIGHT)}
+      paddingLeft={padding && Math.round(padding / RATIO_WIDTH)}
+      paddingRight={padding && Math.round(padding / RATIO_WIDTH)}
+      {...props}
+    >
+      {children}
+    </box>
+  );
+}
+
+export function Pressable({
+  children: childrenRaw,
+  style,
+  onPress,
+}: PressableProps) {
+  const bg =
+    style && "backgroundColor" in style
+      ? typeof style.backgroundColor == "string"
+        ? style.backgroundColor.startsWith("rgba(")
+          ? (() => {
+              const parts = style.backgroundColor.split("(")[1].split(")")[0];
+              const [r, g, b, a] = parts.split(",").map(parseFloat);
+              return RGBA.fromInts(r, g, b, a * 255);
+            })()
+          : style.backgroundColor
+        : undefined
+      : undefined;
+  const flexDirection =
+    style && "flexDirection" in style
+      ? typeof style.flexDirection == "string"
+        ? style.flexDirection
+        : undefined
+      : undefined;
+  const flex =
+    style && "flex" in style
+      ? typeof style.flex == "number"
+        ? style.flex
+        : undefined
+      : undefined;
+  const flexShrink =
+    style && "flexShrink" in style
+      ? typeof style.flexShrink == "number"
+        ? style.flexShrink
+        : undefined
+      : undefined;
+  const overflow =
+    style && "overflow" in style
+      ? typeof style.overflow == "string"
+        ? style.overflow
+        : undefined
+      : undefined;
+  const position =
+    style && "position" in style
+      ? typeof style.position == "string"
+        ? style.position
+        : undefined
+      : undefined;
+  const justifyContent =
+    style && "justifyContent" in style
+      ? typeof style.justifyContent == "string"
+        ? style.justifyContent
+        : undefined
+      : undefined;
+  const alignItems =
+    style && "alignItems" in style
+      ? typeof style.alignItems == "string"
+        ? style.alignItems
+        : undefined
+      : undefined;
+
+  const padding =
+    style && "padding" in style
+      ? typeof style.padding == "number"
+        ? style.padding
+        : undefined
+      : undefined;
+
+  const children =
+    childrenRaw instanceof Function
+      ? childrenRaw({ pressed: true })
+      : childrenRaw;
+
+  return (
+    <box
+      onMouseDown={
+        onPress
+          ? (_event) => {
+              // @ts-ignore
+              onPress();
+            }
+          : undefined
+      }
+      backgroundColor={bg}
+      flexDirection={flexDirection}
+      flexGrow={flex}
+      overflow={overflow}
+      flexShrink={flexShrink}
+      position={position}
+      justifyContent={justifyContent}
+      alignItems={alignItems}
+      paddingTop={padding && Math.round(padding / RATIO_HEIGHT)}
+      paddingBottom={padding && Math.round(padding / RATIO_HEIGHT)}
+      paddingLeft={padding && Math.round(padding / RATIO_WIDTH)}
+      paddingRight={padding && Math.round(padding / RATIO_WIDTH)}
+    >
+      {children}
+    </box>
+  );
+}
+
+export function Text({ style, children }: TextProps) {
+  const fg =
+    style && "color" in style
+      ? typeof style.color == "string"
+        ? style.color
+        : undefined
+      : undefined;
+  return <text fg={fg || "black"}>{children}</text>;
+}
+
+export function ScrollView({ children }: ScrollViewProps) {
+  return <scrollbox>{children}</scrollbox>;
+}
+
+export function Modal({ children, visible }: ModalProps) {
+  const { width, height } = useTerminalDimensions();
+  return (
+    <box
+      visible={visible}
+      position="absolute"
+      width={width}
+      height={height}
+      zIndex={10}
+    >
+      {children}
+    </box>
+  );
+}
+
+export const Platform = {
+  OS: "tui",
+};
+
+export const Linking = {
+  openURL: async (url: string) => {
+    const cmd =
+      platform() == "darwin"
+        ? `open ${url}`
+        : platform() == "win32"
+          ? `start "" "${url}"`
+          : `xdg-open "${url}"`;
+    exec(cmd);
+  },
+} satisfies Partial<LinkingImpl>;
+
+export default {
+  View,
+  Text,
+};

packages/react-native-opentui/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "react-native-opentui",
+  "version": "1.0.0",
+  "main": "index.tsx",
+  "exports": {
+    ".": "./index.tsx"
+  },
+  "peerDependencies": {
+    "react": "*"
+  }
+}

packages/react-native-opentui/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/react",
+    "strict": true,
+    "skipLibCheck": true
+  }
+}

packages/shared/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@money/shared",
+  "version": "0.0.0",
+  "type": "module",
+  "private": true,
+  "exports": {
+    ".": "./src/index.ts",
+    "./auth": "./src/auth.ts",
+    "./db": "./src/db/index.ts"
+  },
+  "dependencies": {
+    "drizzle-zero": "^0.14.3"
+  },
+  "scripts": {
+    "db:gen": "drizzle-zero generate -s ./src/db/schema/public.ts -o ./src/zero-schema.gen.ts -f && sed -i 's/enableLegacyQueries: true,/enableLegacyQueries: false,/g' src/zero-schema.gen.ts && sed -i 's/enableLegacyMutators: true,/enableLegacyMutators: false,/g' src/zero-schema.gen.ts",
+    "db:migrate": "drizzle-kit push"
+  }
+}

packages/shared/src/auth.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { Schema } from "effect";
+
+export const sessionSchema = z.object({
+  id: z.string(),
+  userId: z.string(),
+  expiresAt: z.date(),
+});
+
+export const userSchema = z.object({
+  id: z.string(),
+  email: z.string(),
+  emailVerified: z.boolean(),
+  name: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const authDataSchema = z.object({
+  session: sessionSchema,
+  user: userSchema,
+});
+
+const DateFromDateOrString = Schema.Union(
+  Schema.DateFromString,
+  Schema.DateFromSelf,
+);
+
+export const SessionSchema = Schema.Struct({
+  expiresAt: DateFromDateOrString,
+  token: Schema.Redacted(Schema.String),
+  createdAt: DateFromDateOrString,
+  updatedAt: DateFromDateOrString,
+  ipAddress: Schema.optional(Schema.NullishOr(Schema.String)),
+  userAgent: Schema.optional(Schema.NullishOr(Schema.String)),
+  userId: Schema.String,
+  id: Schema.String,
+});
+
+export const UserSchema = Schema.Struct({
+  name: Schema.String,
+  email: Schema.String,
+  emailVerified: Schema.Boolean,
+  image: Schema.optional(Schema.NullishOr(Schema.String)),
+  createdAt: DateFromDateOrString,
+  updatedAt: DateFromDateOrString,
+  id: Schema.String,
+});
+
+export const AuthSchema = Schema.Struct({
+  session: SessionSchema,
+  user: UserSchema,
+});
+
+export type AuthSchemaType = Schema.Schema.Type<typeof AuthSchema>;
+
+export type Session = z.infer<typeof sessionSchema>;
+export type User = z.infer<typeof userSchema>;
+export type AuthData = z.infer<typeof authDataSchema>;

packages/shared/src/const.ts

@@ -1,3 +1,2 @@
 export const HOST = process.env.EXPO_PUBLIC_TAILSCALE_MACHINE || "localhost";
 export const BASE_URL = `http://${HOST}`;
-

packages/shared/src/db/schema/private.ts

@@ -5,6 +5,7 @@ import {
   text,
   timestamp,
   uniqueIndex,
+  integer,
 } from "drizzle-orm/pg-core";
 import { users } from "./public";
 
@@ -93,9 +94,19 @@ export const auditLogs = pgTable("audit_log", {
   action: text("action").notNull(),
 });
 
-export const plaidAccessTokens = pgTable("plaidAccessToken", {
+export const deviceCodes = pgTable("deviceCode", {
   id: text("id").primaryKey(),
-  userId: text("user_id").notNull(),
-  token: text("token").notNull(),
+  deviceCode: text("device_code").notNull(),
+  userCode: text("user_code").notNull(),
+  userId: text("user_id").references(() => users.id, {
+    onDelete: "set null",
+  }),
+  clientId: text("client_id"),
+  scope: text("scope"),
+  status: text("status").notNull(),
+  expiresAt: timestamp("expires_at"),
+  lastPolledAt: timestamp("last_polled_at"),
+  pollingInterval: integer("polling_interval"),
   createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
 });

packages/shared/src/db/schema/public.ts

@@ -1,5 +1,12 @@
-import { definePermissions } from "@rocicorp/zero";
-import { pgTable, text, boolean, timestamp, uniqueIndex, decimal } from "drizzle-orm/pg-core";
+import {
+  boolean,
+  decimal,
+  pgTable,
+  text,
+  timestamp,
+  pgEnum,
+  uniqueIndex,
+} from "drizzle-orm/pg-core";
 
 export const users = pgTable(
   "user",
@@ -34,6 +41,7 @@ export const plaidLink = pgTable("plaidLink", {
   user_id: text("user_id").notNull(),
   link: text("link").notNull(),
   token: text("token").notNull(),
+  completeAt: timestamp("complete_at"),
   createdAt: timestamp("created_at").notNull().defaultNow(),
 });
 
@@ -44,6 +52,16 @@ export const balance = pgTable("balance", {
   avaliable: decimal("avaliable").notNull(),
   current: decimal("current").notNull(),
   name: text("name").notNull(),
+  tokenId: text("tokenId").notNull(),
   createdAt: timestamp("created_at").notNull().defaultNow(),
   updatedAt: timestamp("updated_at").notNull().defaultNow(),
-})
+});
+
+export const plaidAccessTokens = pgTable("plaidAccessToken", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  logoUrl: text("logoUrl").notNull(),
+  userId: text("user_id").notNull(),
+  token: text("token").notNull(),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+});

packages/shared/src/mutators.ts

@@ -0,0 +1,45 @@
+import type { Transaction } from "@rocicorp/zero";
+import type { AuthData } from "./auth";
+import { type Schema } from "./zero-schema.gen";
+import { isLoggedIn } from "./zql";
+
+type Tx = Transaction<Schema>;
+
+export function createMutators(authData: AuthData | null) {
+  return {
+    link: {
+      async create() {},
+      async get(tx: Tx, { link_token }: { link_token: string }) {},
+      async updateTransactions() {},
+      async updateBalences() {},
+      async deleteAccounts(tx: Tx, { accountIds }: { accountIds: string[] }) {
+        isLoggedIn(authData);
+        for (const id of accountIds) {
+          const token = await tx.query.plaidAccessTokens
+            .where("userId", "=", authData.user.id)
+            .one();
+          if (!token) continue;
+          await tx.mutate.plaidAccessTokens.delete({ id });
+
+          const balances = await tx.query.balance
+            .where("user_id", "=", authData.user.id)
+            .where("tokenId", "=", token.id)
+            .run();
+
+          for (const bal of balances) {
+            await tx.mutate.balance.delete({ id: bal.id });
+            const txs = await tx.query.transaction
+              .where("user_id", "=", authData.user.id)
+              .where("account_id", "=", bal.tokenId)
+              .run();
+            for (const transaction of txs) {
+              await tx.mutate.transaction.delete({ id: transaction.id });
+            }
+          }
+        }
+      },
+    },
+  } as const;
+}
+
+export type Mutators = ReturnType<typeof createMutators>;

packages/shared/src/queries.ts

@@ -0,0 +1,63 @@
+import { syncedQueryWithContext } from "@rocicorp/zero";
+import { z } from "zod";
+import { builder } from "./zero-schema.gen";
+import { type AuthData } from "./auth";
+import { isLoggedIn } from "./zql";
+
+export const queries = {
+  me: syncedQueryWithContext("me", z.tuple([]), (authData: AuthData | null) => {
+    isLoggedIn(authData);
+    return builder.users.where("id", "=", authData.user.id).one();
+  }),
+  allTransactions: syncedQueryWithContext(
+    "allTransactions",
+    z.tuple([]),
+    (authData: AuthData | null) => {
+      isLoggedIn(authData);
+      return builder.transaction
+        .where("user_id", "=", authData.user.id)
+        .orderBy("datetime", "desc")
+        .limit(50);
+    },
+  ),
+  getPlaidLink: syncedQueryWithContext(
+    "getPlaidLink",
+    z.tuple([]),
+    (authData: AuthData | null) => {
+      isLoggedIn(authData);
+      return builder.plaidLink
+        .where(({ cmp, and, or }) =>
+          and(
+            cmp("user_id", "=", authData.user.id),
+            cmp("createdAt", ">", new Date().getTime() - 1000 * 60 * 60 * 4),
+            or(
+              cmp("completeAt", ">", new Date().getTime() - 1000 * 5),
+              cmp("completeAt", "IS", null),
+            ),
+          ),
+        )
+        .orderBy("createdAt", "desc")
+        .one();
+    },
+  ),
+  getBalances: syncedQueryWithContext(
+    "getBalances",
+    z.tuple([]),
+    (authData: AuthData | null) => {
+      isLoggedIn(authData);
+      return builder.balance
+        .where("user_id", "=", authData.user.id)
+        .orderBy("name", "asc");
+    },
+  ),
+  getItems: syncedQueryWithContext(
+    "getItems",
+    z.tuple([]),
+    (authData: AuthData | null) => {
+      isLoggedIn(authData);
+      return builder.plaidAccessTokens
+        .where("userId", "=", authData.user.id)
+        .orderBy("createdAt", "desc");
+    },
+  ),
+};

packages/shared/src/zero-schema.gen.ts

@@ -10,9 +10,11 @@
 
 import type { Row } from "@rocicorp/zero";
 import { createBuilder } from "@rocicorp/zero";
-import type { CustomType } from "drizzle-zero";
+import type { DrizzleToZeroSchema, ZeroCustomType } from "drizzle-zero";
 import type * as drizzleSchema from "./db/schema/public";
 
+type ZeroSchema = DrizzleToZeroSchema<typeof drizzleSchema>;
+
 /**
  * The Zero schema object.
  * This type is auto-generated from your Drizzle schema definition.
@@ -25,8 +27,8 @@ export const schema = {
         id: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "balance",
             "id"
           >,
@@ -34,8 +36,8 @@ export const schema = {
         user_id: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "balance",
             "user_id"
           >,
@@ -44,8 +46,8 @@ export const schema = {
         plaid_id: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "balance",
             "plaid_id"
           >,
@@ -54,8 +56,8 @@ export const schema = {
         avaliable: {
           type: "number",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "balance",
             "avaliable"
           >,
@@ -63,8 +65,8 @@ export const schema = {
         current: {
           type: "number",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "balance",
             "current"
           >,
@@ -72,17 +74,26 @@ export const schema = {
         name: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "balance",
             "name"
           >,
         },
+        tokenId: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "balance",
+            "tokenId"
+          >,
+        },
         createdAt: {
           type: "number",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "balance",
             "createdAt"
           >,
@@ -91,8 +102,8 @@ export const schema = {
         updatedAt: {
           type: "number",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "balance",
             "updatedAt"
           >,
@@ -101,14 +112,77 @@ export const schema = {
       },
       primaryKey: ["id"],
     },
+    plaidAccessTokens: {
+      name: "plaidAccessTokens",
+      columns: {
+        id: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "plaidAccessTokens",
+            "id"
+          >,
+        },
+        name: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "plaidAccessTokens",
+            "name"
+          >,
+        },
+        logoUrl: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "plaidAccessTokens",
+            "logoUrl"
+          >,
+        },
+        userId: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "plaidAccessTokens",
+            "userId"
+          >,
+          serverName: "user_id",
+        },
+        token: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "plaidAccessTokens",
+            "token"
+          >,
+        },
+        createdAt: {
+          type: "number",
+          optional: true,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "plaidAccessTokens",
+            "createdAt"
+          >,
+          serverName: "created_at",
+        },
+      },
+      primaryKey: ["id"],
+      serverName: "plaidAccessToken",
+    },
     plaidLink: {
       name: "plaidLink",
       columns: {
         id: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "plaidLink",
             "id"
           >,
@@ -116,8 +190,8 @@ export const schema = {
         user_id: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "plaidLink",
             "user_id"
           >,
@@ -125,8 +199,8 @@ export const schema = {
         link: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "plaidLink",
             "link"
           >,
@@ -134,17 +208,27 @@ export const schema = {
         token: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "plaidLink",
             "token"
           >,
         },
+        completeAt: {
+          type: "number",
+          optional: true,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "plaidLink",
+            "completeAt"
+          >,
+          serverName: "complete_at",
+        },
         createdAt: {
           type: "number",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "plaidLink",
             "createdAt"
           >,
@@ -159,8 +243,8 @@ export const schema = {
         id: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "id"
           >,
@@ -168,8 +252,8 @@ export const schema = {
         user_id: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "user_id"
           >,
@@ -177,8 +261,8 @@ export const schema = {
         plaid_id: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "plaid_id"
           >,
@@ -186,8 +270,8 @@ export const schema = {
         account_id: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "account_id"
           >,
@@ -195,8 +279,8 @@ export const schema = {
         name: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "name"
           >,
@@ -204,8 +288,8 @@ export const schema = {
         amount: {
           type: "number",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "amount"
           >,
@@ -213,8 +297,8 @@ export const schema = {
         datetime: {
           type: "number",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "datetime"
           >,
@@ -222,8 +306,8 @@ export const schema = {
         authorized_datetime: {
           type: "number",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "authorized_datetime"
           >,
@@ -231,8 +315,8 @@ export const schema = {
         json: {
           type: "string",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "json"
           >,
@@ -240,8 +324,8 @@ export const schema = {
         createdAt: {
           type: "number",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "createdAt"
           >,
@@ -250,8 +334,8 @@ export const schema = {
         updatedAt: {
           type: "number",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "transaction",
             "updatedAt"
           >,
@@ -266,8 +350,8 @@ export const schema = {
         id: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "users",
             "id"
           >,
@@ -275,8 +359,8 @@ export const schema = {
         name: {
           type: "string",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "users",
             "name"
           >,
@@ -284,8 +368,8 @@ export const schema = {
         email: {
           type: "string",
           optional: false,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "users",
             "email"
           >,
@@ -293,8 +377,8 @@ export const schema = {
         emailVerified: {
           type: "boolean",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "users",
             "emailVerified"
           >,
@@ -303,8 +387,8 @@ export const schema = {
         image: {
           type: "string",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "users",
             "image"
           >,
@@ -312,8 +396,8 @@ export const schema = {
         createdAt: {
           type: "number",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "users",
             "createdAt"
           >,
@@ -322,8 +406,8 @@ export const schema = {
         updatedAt: {
           type: "number",
           optional: true,
-          customType: null as unknown as CustomType<
-            typeof drizzleSchema,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
             "users",
             "updatedAt"
           >,
@@ -349,6 +433,11 @@ export type Schema = typeof schema;
  * This type is auto-generated from your Drizzle schema definition.
  */
 export type Balance = Row<Schema["tables"]["balance"]>;
+/**
+ * Represents a row from the "plaidAccessTokens" table.
+ * This type is auto-generated from your Drizzle schema definition.
+ */
+export type PlaidAccessToken = Row<Schema["tables"]["plaidAccessTokens"]>;
 /**
  * Represents a row from the "plaidLink" table.
  * This type is auto-generated from your Drizzle schema definition.

packages/shared/src/zql.ts

@@ -3,7 +3,6 @@ import type { AuthData } from "./auth";
 export function isLoggedIn(
   authData: AuthData | null,
 ): asserts authData is AuthData {
-  console.log("AUTHDATA", authData);
   if (!authData?.user.id) {
     throw new Error("User is not logged in");
   }

packages/ui/components/Button.tsx

@@ -0,0 +1,38 @@
+import { useKeyboard } from "../src/useKeyboard";
+import type { ReactNode } from "react";
+import { Text, Pressable } from "react-native";
+
+export interface ButtonProps {
+  children: ReactNode;
+  onPress?: () => void;
+  variant?: "default" | "secondary" | "destructive";
+  shortcut?: string;
+}
+
+const STYLES: Record<
+  NonNullable<ButtonProps["variant"]>,
+  { backgroundColor: string; color: string }
+> = {
+  default: { backgroundColor: "black", color: "white" },
+  secondary: { backgroundColor: "#ccc", color: "black" },
+  destructive: { backgroundColor: "red", color: "white" },
+};
+
+export function Button({ children, variant, onPress, shortcut }: ButtonProps) {
+  const { backgroundColor, color } = STYLES[variant || "default"];
+
+  useKeyboard((key) => {
+    if (!shortcut || !onPress) return;
+    if (key.name == shortcut) onPress();
+  });
+
+  return (
+    <Pressable onPress={onPress} style={{ backgroundColor }}>
+      <Text style={{ fontFamily: "mono", color }}>
+        {" "}
+        {children}
+        {shortcut && ` (${shortcut})`}{" "}
+      </Text>
+    </Pressable>
+  );
+}

packages/ui/components/Dialog.tsx

@@ -0,0 +1,54 @@
+import { createContext, type ReactNode } from "react";
+import { Modal, View, Text } from "react-native";
+import { useKeyboard } from "../src/useKeyboard";
+
+export interface DialogState {
+  close?: () => void;
+}
+export const Context = createContext<DialogState>({
+  close: () => {},
+});
+
+interface ProviderProps {
+  children: ReactNode;
+  visible?: boolean;
+  close?: () => void;
+}
+export function Provider({ children, visible, close }: ProviderProps) {
+  useKeyboard((key) => {
+    if (key.name == "escape") {
+      if (close) close();
+    }
+  }, []);
+
+  return (
+    <Context.Provider value={{ close }}>
+      <Modal transparent visible={visible}>
+        {/* <Pressable onPress={() => close && close()} style={{ justifyContent: 'center', alignItems: 'center', flex: 1, backgroundColor: 'rgba(0,0,0,0.2)',  }}> */}
+        <View
+          style={{
+            justifyContent: "center",
+            alignItems: "center",
+            flex: 1,
+            backgroundColor: "rgba(0,0,0,0.2)",
+          }}
+        >
+          {visible && children}
+        </View>
+      </Modal>
+    </Context.Provider>
+  );
+}
+
+interface ContentProps {
+  children: ReactNode;
+}
+export function Content({ children }: ContentProps) {
+  return (
+    <View
+      style={{ backgroundColor: "white", padding: 12, alignItems: "center" }}
+    >
+      {children}
+    </View>
+  );
+}

packages/ui/components/List.tsx

@@ -0,0 +1,36 @@
+import { useState, type ReactNode } from "react";
+import { View, Text } from "react-native";
+import { useKeyboard } from "../src/useKeyboard";
+
+export type ListProps<T> = {
+  items: T[];
+  renderItem: (props: { item: T; isSelected: boolean }) => ReactNode;
+};
+export function List<T>({ items, renderItem }: ListProps<T>) {
+  const [idx, setIdx] = useState(0);
+
+  useKeyboard(
+    (key) => {
+      if (key.name == "j") {
+        setIdx((prevIdx) =>
+          prevIdx + 1 < items.length ? prevIdx + 1 : items.length - 1,
+        );
+      } else if (key.name == "k") {
+        setIdx((prevIdx) => (prevIdx == 0 ? 0 : prevIdx - 1));
+      } else if (key.name == "g" && key.shift) {
+        setIdx(items.length - 1);
+      }
+    },
+    [items],
+  );
+
+  return (
+    <View>
+      {items.map((item, index) => (
+        <View style={{ backgroundColor: index == idx ? "black" : undefined }}>
+          {renderItem({ item, isSelected: index == idx })}
+        </View>
+      ))}
+    </View>
+  );
+}

packages/ui/components/Table.tsx

@@ -0,0 +1,192 @@
+import { createContext, use, useState, type ReactNode } from "react";
+import { View, Text } from "react-native";
+import { useKeyboard } from "../src/useKeyboard";
+import type { KeyEvent } from "@opentui/core";
+
+const HEADER_COLOR = "#7158e2";
+const TABLE_COLORS = ["#ddd", "#eee"];
+const SELECTED_COLOR = "#f7b730";
+
+const EXTRA = 5;
+
+export type ValidRecord = Record<string, string | number | null>;
+
+interface TableState {
+  data: unknown[];
+  columns: Column[];
+  columnMap: Map<string, number>;
+  idx: number;
+  selectedFrom: number | undefined;
+}
+
+const INITAL_STATE = {
+  data: [],
+  columns: [],
+  columnMap: new Map(),
+  idx: 0,
+  selectedFrom: undefined,
+} satisfies TableState;
+
+export const Context = createContext<TableState>(INITAL_STATE);
+
+export type Column = {
+  name: string;
+  label: string;
+  render?: (i: number | string) => string;
+};
+
+function renderCell(row: ValidRecord, column: Column): string {
+  const cell = row[column.name];
+  if (cell == undefined) return "n/a";
+  if (cell == null) return "null";
+  if (column.render) return column.render(cell);
+  return cell.toString();
+}
+
+export interface ProviderProps<T> {
+  data: T[];
+  columns: Column[];
+  children: ReactNode;
+  onKey?: (event: KeyEvent, selected: T[]) => void;
+}
+export function Provider<T extends ValidRecord>({
+  data,
+  columns,
+  children,
+  onKey,
+}: ProviderProps<T>) {
+  const [idx, setIdx] = useState(0);
+  const [selectedFrom, setSelectedFrom] = useState<number>();
+
+  useKeyboard(
+    (key) => {
+      if (key.name == "j" || key.name == "down") {
+        if (key.shift && selectedFrom == undefined) {
+          setSelectedFrom(idx);
+        }
+        setIdx((prev) => Math.min(prev + 1, data.length - 1));
+      } else if (key.name == "k" || key.name == "up") {
+        if (key.shift && selectedFrom == undefined) {
+          setSelectedFrom(idx);
+        }
+        setIdx((prev) => Math.max(prev - 1, 0));
+      } else if (key.name == "g" && key.shift) {
+        setIdx(data.length - 1);
+      } else if (key.name == "v") {
+        setSelectedFrom(idx);
+      } else if (key.name == "escape") {
+        setSelectedFrom(undefined);
+      } else {
+        const from = selectedFrom ? Math.min(idx, selectedFrom) : idx;
+        const to = selectedFrom ? Math.max(idx, selectedFrom) : idx;
+        const selected = data.slice(from, to + 1);
+        if (onKey) onKey(key, selected);
+      }
+    },
+    [data, idx, selectedFrom],
+  );
+
+  const columnMap = new Map(
+    columns.map((col) => {
+      return [
+        col.name,
+        Math.max(
+          col.label.length,
+          ...data.map((row) => renderCell(row, col).length),
+        ),
+      ];
+    }),
+  );
+
+  return (
+    <Context.Provider value={{ data, columns, columnMap, idx, selectedFrom }}>
+      {children}
+    </Context.Provider>
+  );
+}
+
+export function Body() {
+  const { columns, data, columnMap, idx, selectedFrom } = use(Context);
+  return (
+    <View>
+      <View style={{ backgroundColor: HEADER_COLOR, flexDirection: "row" }}>
+        {columns.map((column) => (
+          <Text
+            key={column.name}
+            style={{ fontFamily: "mono", color: "white" }}
+          >
+            {rpad(
+              column.label,
+              columnMap.get(column.name)! - column.label.length + EXTRA,
+            )}
+          </Text>
+        ))}
+      </View>
+      {data.map((row, index) => {
+        const isSelected =
+          index == idx ||
+          (selectedFrom != undefined &&
+            ((selectedFrom <= index && index <= idx) ||
+              (idx <= index && index <= selectedFrom)));
+
+        return (
+          <View
+            key={index}
+            style={{
+              backgroundColor: isSelected
+                ? SELECTED_COLOR
+                : TABLE_COLORS[index % 2],
+            }}
+          >
+            <TableRow
+              key={index}
+              row={row as ValidRecord}
+              index={index}
+              isSelected={isSelected}
+            />
+          </View>
+        );
+      })}
+    </View>
+  );
+}
+
+interface RowProps<T> {
+  row: T;
+  index: number;
+  isSelected: boolean;
+}
+function TableRow<T extends ValidRecord>({ row, isSelected }: RowProps<T>) {
+  const { columns, columnMap } = use(Context);
+
+  return (
+    <View style={{ flexDirection: "row" }}>
+      {columns.map((column) => {
+        const rendered = renderCell(row, column);
+        return (
+          <Text
+            key={column.name}
+            style={{
+              fontFamily: "mono",
+              color: isSelected ? "black" : "black",
+            }}
+          >
+            {rpad(
+              rendered,
+              columnMap.get(column.name)! - rendered.length + EXTRA,
+            )}
+          </Text>
+        );
+      })}
+    </View>
+  );
+}
+
+function rpad(input: string, length: number): string {
+  return (
+    input +
+    Array.from({ length })
+      .map((_) => " ")
+      .join("")
+  );
+}

packages/ui/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@money/ui",
+  "private": true,
+  "version": "1.0.0",
+  "description": "",
+  "exports": {
+    ".": "./src/index.tsx"
+  },
+  "dependencies": {
+    "@money/shared": "workspace:*",
+    "react-native-opentui": "workspace:*"
+  },
+  "packageManager": "pnpm@10.18.2"
+}

packages/ui/src/index.tsx

@@ -0,0 +1,94 @@
+import { createContext, use } from "react";
+import { Transactions } from "./transactions";
+import { View, Text } from "react-native";
+import { Settings } from "./settings";
+import { useKeyboard } from "./useKeyboard";
+import type { AuthData } from "@money/shared/auth";
+
+const PAGES = {
+  "/": {
+    screen: <Transactions />,
+    key: "1",
+  },
+  "/settings": {
+    screen: <Settings />,
+    key: "2",
+    children: {
+      "/accounts": {},
+      "/family": {},
+    },
+  },
+};
+
+type Join<A extends string, B extends string> = `${A}${B}` extends `${infer X}`
+  ? X
+  : never;
+
+type ChildRoutes<Parent extends string, Children> = {
+  [K in keyof Children & string]: K extends `/${string}`
+    ? Join<Parent, K>
+    : never;
+}[keyof Children & string];
+
+type Routes<T> = {
+  [K in keyof T & string]:
+    | K
+    | (T[K] extends { children: infer C } ? ChildRoutes<K, C> : never);
+}[keyof T & string];
+
+export type Route = Routes<typeof PAGES>;
+
+interface RouterContextType {
+  auth: AuthData | null;
+  route: Route;
+  setRoute: (route: Route) => void;
+}
+
+export const RouterContext = createContext<RouterContextType>({
+  auth: null,
+  route: "/",
+  setRoute: () => {},
+});
+
+type AppProps = {
+  auth: AuthData | null;
+  route: Route;
+  setRoute: (page: Route) => void;
+};
+
+export function App({ auth, route, setRoute }: AppProps) {
+  return (
+    <RouterContext.Provider value={{ auth, route, setRoute }}>
+      <Main />
+    </RouterContext.Provider>
+  );
+}
+
+function Main() {
+  const { route, setRoute } = use(RouterContext);
+
+  useKeyboard((key) => {
+    const screen = Object.entries(PAGES).find(
+      ([, screen]) => screen.key == key.name,
+    );
+
+    if (!screen) return;
+
+    const [route] = screen as [Route, never];
+
+    setRoute(route);
+  });
+
+  const match =
+    route in PAGES
+      ? (route as keyof typeof PAGES)
+      : (Object.keys(PAGES)
+          .sort((a, b) => b.length - a.length)
+          .find((p) => route.startsWith(p)) as keyof typeof PAGES);
+
+  return (
+    <View style={{ backgroundColor: "white", flex: 1 }}>
+      {PAGES[match].screen}
+    </View>
+  );
+}

packages/ui/src/settings.tsx

@@ -0,0 +1,87 @@
+import { Text, View, Pressable } from "react-native";
+import { use, useState, type ReactNode } from "react";
+import { RouterContext, type Route } from ".";
+import { General } from "./settings/general";
+import { Accounts } from "./settings/accounts";
+import { Family } from "./settings/family";
+import { useKeyboard } from "./useKeyboard";
+import { Modal } from "react-native-opentui";
+
+type SettingsRoute = Extract<Route, `/settings${string}`>;
+
+const TABS = {
+  "/settings": {
+    label: "💽 General",
+    screen: <General />,
+  },
+  "/settings/accounts": {
+    label: "🏦 Bank Accounts",
+    screen: <Accounts />,
+  },
+  "/settings/family": {
+    label: "👑 Family",
+    screen: <Family />,
+  },
+} as const satisfies Record<
+  SettingsRoute,
+  { label: string; screen: ReactNode }
+>;
+
+type Tab = keyof typeof TABS;
+
+export function Settings() {
+  const { route, setRoute } = use(RouterContext);
+
+  useKeyboard(
+    (key) => {
+      if (key.name == "h") {
+        const currentIdx = Object.entries(TABS).findIndex(
+          ([tabRoute, _]) => tabRoute == route,
+        );
+        const routes = Object.keys(TABS) as SettingsRoute[];
+        const last = routes[currentIdx - 1];
+        if (!last) return;
+        setRoute(last);
+      } else if (key.name == "l") {
+        const currentIdx = Object.entries(TABS).findIndex(
+          ([tabRoute, _]) => tabRoute == route,
+        );
+        const routes = Object.keys(TABS) as SettingsRoute[];
+        const next = routes[currentIdx + 1];
+        if (!next) return;
+        setRoute(next);
+      }
+    },
+    [route],
+  );
+
+  return (
+    <View style={{ flexDirection: "row" }}>
+      <View style={{ padding: 10 }}>
+        {Object.entries(TABS).map(([tabRoute, tab]) => {
+          const isSelected = tabRoute == route;
+
+          return (
+            <Pressable
+              key={tab.label}
+              style={{ backgroundColor: isSelected ? "black" : undefined }}
+              onPress={() => setRoute(tabRoute as SettingsRoute)}
+            >
+              <Text
+                style={{
+                  fontFamily: "mono",
+                  color: isSelected ? "white" : "black",
+                }}
+              >
+                {" "}
+                {tab.label}{" "}
+              </Text>
+            </Pressable>
+          );
+        })}
+      </View>
+
+      <View>{TABS[route as Tab].screen}</View>
+    </View>
+  );
+}

packages/ui/src/settings/accounts.tsx

@@ -0,0 +1,167 @@
+import { useQuery, useZero } from "@rocicorp/zero/react";
+import { queries, type Mutators, type Schema } from "@money/shared";
+import { use, useEffect, useState } from "react";
+import { RouterContext } from "..";
+import { View, Text, Linking } from "react-native";
+import { useKeyboard } from "../useKeyboard";
+import { Button } from "../../components/Button";
+import * as Table from "../../components/Table";
+import * as Dialog from "../../components/Dialog";
+
+const COLUMNS: Table.Column[] = [
+  { name: "name", label: "Name" },
+  {
+    name: "createdAt",
+    label: "Added At",
+    render: (n) => new Date(n).toLocaleString(),
+  },
+];
+
+export function Accounts() {
+  const { auth } = use(RouterContext);
+  const [items] = useQuery(queries.getItems(auth));
+  const [deleting, setDeleting] = useState<typeof items>([]);
+  const [isAddOpen, setIsAddOpen] = useState(false);
+
+  const z = useZero<Schema, Mutators>();
+
+  const onDelete = () => {
+    if (!deleting) return;
+    const accountIds = deleting.map((account) => account.id);
+    z.mutate.link.deleteAccounts({ accountIds });
+    setDeleting([]);
+  };
+
+  const addAccount = () => {
+    setIsAddOpen(true);
+  };
+
+  return (
+    <>
+      <Dialog.Provider
+        visible={deleting.length > 0}
+        close={() => setDeleting([])}
+      >
+        <Dialog.Content>
+          <Text style={{ fontFamily: "mono" }}>Delete Account</Text>
+          <Text style={{ fontFamily: "mono" }}> </Text>
+          <Text style={{ fontFamily: "mono" }}>
+            You are about to delete the following accounts:
+          </Text>
+
+          <View>
+            {deleting.map((account) => (
+              <Text style={{ fontFamily: "mono" }}>- {account.name}</Text>
+            ))}
+          </View>
+
+          <Text style={{ fontFamily: "mono" }}> </Text>
+
+          <View style={{ flexDirection: "row" }}>
+            <Button
+              variant="secondary"
+              onPress={() => {
+                setDeleting([]);
+              }}
+              shortcut="n"
+            >
+              Cancel
+            </Button>
+
+            <Text style={{ fontFamily: "mono" }}> </Text>
+
+            <Button
+              variant="destructive"
+              onPress={() => {
+                onDelete();
+              }}
+              shortcut="y"
+            >
+              Delete
+            </Button>
+          </View>
+        </Dialog.Content>
+      </Dialog.Provider>
+
+      <Dialog.Provider visible={isAddOpen} close={() => setIsAddOpen(false)}>
+        <Dialog.Content>
+          <Text style={{ fontFamily: "mono" }}>Add Account</Text>
+          <AddAccount />
+        </Dialog.Content>
+      </Dialog.Provider>
+
+      <View style={{ padding: 10 }}>
+        <View style={{ alignSelf: "flex-start" }}>
+          <Button shortcut="a" onPress={addAccount}>
+            Add Account
+          </Button>
+        </View>
+
+        <Text style={{ fontFamily: "mono" }}> </Text>
+
+        <Table.Provider
+          columns={COLUMNS}
+          data={items}
+          onKey={(key, selected) => {
+            if (key.name == "d") {
+              setDeleting(selected);
+            }
+          }}
+        >
+          <Table.Body />
+        </Table.Provider>
+      </View>
+    </>
+  );
+}
+
+function AddAccount() {
+  const { auth } = use(RouterContext);
+  const [link, details] = useQuery(queries.getPlaidLink(auth));
+  const { close } = use(Dialog.Context);
+
+  const openLink = () => {
+    if (!link) return;
+    Linking.openURL(link.link);
+  };
+
+  const z = useZero<Schema, Mutators>();
+
+  useEffect(() => {
+    console.log(link, details);
+    if (details.type != "complete") return;
+    if (link != undefined) {
+      if (!link.completeAt) {
+        const timer = setInterval(() => {
+          console.log("Checking for link");
+          z.mutate.link.get({ link_token: link.token });
+        }, 1000 * 5);
+        return () => clearInterval(timer);
+      } else {
+        if (close) close();
+        return;
+      }
+    }
+    console.log("Creating new link");
+    z.mutate.link.create();
+  }, [link, details]);
+
+  return (
+    <>
+      <Button onPress={() => close && close()}>close</Button>
+      {link ? (
+        <>
+          <Text style={{ fontFamily: "mono" }}>
+            Please click the button to complete setup.
+          </Text>
+
+          <Button shortcut="return" onPress={openLink}>
+            Open Plaid
+          </Button>
+        </>
+      ) : (
+        <Text style={{ fontFamily: "mono" }}>Loading Plaid Link</Text>
+      )}
+    </>
+  );
+}

packages/ui/src/settings/family.tsx

@@ -0,0 +1,5 @@
+import { Text } from "react-native";
+
+export function Family() {
+  return <Text style={{ fontFamily: "mono" }}>Welcome to family</Text>;
+}

packages/ui/src/settings/general.tsx

@@ -0,0 +1,5 @@
+import { Text } from "react-native";
+
+export function General() {
+  return <Text style={{ fontFamily: "mono" }}>Welcome to settings</Text>;
+}

packages/ui/src/transactions.tsx

@@ -0,0 +1,85 @@
+import * as Table from "../components/Table";
+import { useQuery, useZero } from "@rocicorp/zero/react";
+import {
+  queries,
+  type Mutators,
+  type Schema,
+  type Transaction,
+} from "@money/shared";
+import { use } from "react";
+import { View, Text } from "react-native";
+import { RouterContext } from ".";
+
+const FORMAT = new Intl.NumberFormat("en-US", {
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2,
+});
+
+export type Account = {
+  name: string;
+  createdAt: number;
+};
+
+const COLUMNS: Table.Column[] = [
+  {
+    name: "createdAt",
+    label: "Date",
+    render: (n) => new Date(n).toDateString(),
+  },
+  { name: "amount", label: "Amount" },
+  { name: "name", label: "Name" },
+];
+
+export function Transactions() {
+  const { auth } = use(RouterContext);
+  const [items] = useQuery(queries.allTransactions(auth));
+
+  const z = useZero<Schema, Mutators>();
+
+  return (
+    <Table.Provider
+      data={items}
+      columns={COLUMNS}
+      onKey={(key) => {
+        if (key.name == "r" && key.shift) {
+          z.mutate.link.updateTransactions();
+        }
+      }}
+    >
+      <View style={{ flex: 1 }}>
+        <View style={{ flexShrink: 0 }}>
+          <Table.Body />
+        </View>
+      </View>
+      <View style={{ flexShrink: 0 }}>
+        <Selected />
+      </View>
+    </Table.Provider>
+  );
+}
+
+function Selected() {
+  const { data, idx, selectedFrom } = use(Table.Context);
+
+  if (selectedFrom == undefined)
+    return (
+      <View style={{ backgroundColor: "#ddd" }}>
+        <Text style={{ fontFamily: "mono" }}>No items selected</Text>
+      </View>
+    );
+
+  const from = Math.min(idx, selectedFrom);
+  const to = Math.max(idx, selectedFrom);
+  const selected = data.slice(from, to + 1) as Transaction[];
+  const count = selected.length;
+  const sum = selected.reduce((prev, curr) => prev + curr.amount, 0);
+
+  return (
+    <View style={{ backgroundColor: "#9f9" }}>
+      <Text style={{ fontFamily: "mono" }}>
+        {count} transaction{count == 1 ? "" : "s"} selected | $
+        {FORMAT.format(sum)}
+      </Text>
+    </View>
+  );
+}

packages/ui/src/useKeyboard.ts

@@ -0,0 +1,8 @@
+import { useKeyboard as useOpentuiKeyboard } from "@opentui/react";
+
+export function useKeyboard(
+  handler: Parameters<typeof useOpentuiKeyboard>[0],
+  _deps: any[] = [],
+) {
+  return useOpentuiKeyboard(handler);
+}

packages/ui/src/useKeyboard.web.ts

@@ -0,0 +1,47 @@
+import { useEffect } from "react";
+import type { KeyboardEvent } from "react";
+import type { KeyEvent } from "@opentui/core";
+
+function convertName(keyName: string): string {
+  const result = keyName.toLowerCase();
+  if (result == "arrowdown") return "down";
+  if (result == "arrowup") return "up";
+  return result;
+}
+
+export function useKeyboard(
+  handler: (key: KeyEvent) => void,
+  deps: any[] = [],
+) {
+  useEffect(() => {
+    const handlerWeb = (event: KeyboardEvent) => {
+      // @ts-ignore
+      handler({
+        name: convertName(event.key),
+        ctrl: event.ctrlKey,
+        meta: event.metaKey,
+        shift: event.shiftKey,
+        option: event.metaKey,
+        sequence: "",
+        number: false,
+        raw: "",
+        eventType: "press",
+        source: "raw",
+        code: event.code,
+        super: false,
+        hyper: false,
+        capsLock: false,
+        numLock: false,
+        baseCode: event.keyCode,
+        preventDefault: () => event.preventDefault(),
+      });
+    };
+
+    // @ts-ignore
+    window.addEventListener("keydown", handlerWeb);
+    return () => {
+      // @ts-ignore
+      window.removeEventListener("keydown", handlerWeb);
+    };
+  }, deps);
+}

packages/ui/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./*"]
+    },
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

pnpm-workspace.yaml

@@ -1,4 +1,4 @@
 nodeLinker: hoisted
 packages:
-  - 'api'
-  - 'shared'
+  - 'apps/*'
+  - 'packages/*'

process-compose.yaml

@@ -29,34 +29,39 @@ processes:
     command: "pnpm tsx ./scripts/set-machine-name.ts"
 
   expo:
-    command: "pnpm start"
+    command: "pnpm --filter=@money/expo start"
     depends_on:
       tailscale_machine_name:
         condition: process_completed_successfully
 
   api:
-    command: "pnpm run dev"
-    working_dir: ./api
+    command: "pnpm --filter=@money/api dev"
 
   migrate:
     command: |
       createdb -h localhost -p 5432 -U postgres money 2>/dev/null || true
 
-      psql -h localhost -p 5432 -U postgres -c "ALTER SYSTEM SET wal_level = 'logical';"
+      psql -h localhost -p 5432 -U postgres \
+        -c "ALTER SYSTEM SET wal_level = 'logical';" \
+        -c "ALTER SYSTEM SET timezone = 'UTC'" \
+        -c "SELECT pg_reload_conf();"
 
       echo "Migration and seeding complete!"
     depends_on:
       db:
         condition: process_healthy
   zero:
-    command: npx zero-cache-dev -p shared/src/schema.ts
+    command: npx zero-cache-dev -p packages/shared/src/schema.ts
     depends_on:
       migrate:
         condition: process_completed_successfully
 
   studio:
     command: npx drizzle-kit studio
-    working_dir: ./shared
+    working_dir: ./packages/shared
     depends_on:
       db:
         condition: process_healthy
+
+  tunnel:
+    command: cloudflared tunnel --config ~/.cloudflared/config.yml run

scripts/reset-project.js

@@ -91,7 +91,7 @@ const moveDirectories = async (userInput) => {
         userInput === "y"
           ? `\n3. Delete the /${exampleDir} directory when you're done referencing it.`
           : ""
-      }`
+      }`,
     );
   } catch (error) {
     console.error(`❌ Error during script execution: ${error.message}`);
@@ -108,5 +108,5 @@ rl.question(
       console.log("❌ Invalid input. Please enter 'Y' or 'N'.");
       rl.close();
     }
-  }
+  },
 );

scripts/set-machine-name.ts

@@ -33,4 +33,3 @@ try {
   console.error("Failed to update .env.dev:", err);
   process.exit(1);
 }
-

shared/package.json

@@ -1,18 +0,0 @@
-{
-  "name": "@money/shared",
-  "version": "0.0.0",
-  "type": "module",
-  "private": true,
-  "exports": {
-    ".": "./src/index.ts",
-    "./auth": "./src/auth.ts",
-    "./db": "./src/db/index.ts"
-  },
-  "dependencies": {
-    "drizzle-zero": "^0.15.1"
-  },
-  "scripts": {
-    "generate:zero": "drizzle-zero generate -s ./src/db/schema/public.ts -o ./src/zero-schema.gen.ts -f --disable-legacy-queries --disable-legacy-mutators",
-    "db:migrate": "drizzle-kit push"
-  }
-}

shared/src/auth.ts

@@ -1,25 +0,0 @@
-import { z } from "zod";
-
-export const sessionSchema = z.object({
-  id: z.string(),
-  userId: z.string(),
-  expiresAt: z.date(),
-});
-
-export const userSchema = z.object({
-  id: z.string(),
-  email: z.string(),
-  emailVerified: z.boolean(),
-  name: z.string(),
-  createdAt: z.date(),
-  updatedAt: z.date(),
-});
-
-export const authDataSchema = z.object({
-  session: sessionSchema,
-  user: userSchema,
-});
-
-export type Session = z.infer<typeof sessionSchema>;
-export type User = z.infer<typeof userSchema>;
-export type AuthData = z.infer<typeof authDataSchema>;

shared/src/mutators.ts

@@ -1,18 +0,0 @@
-import type { Transaction } from "@rocicorp/zero";
-import type { AuthData } from "./auth";
-import type { Schema } from ".";
-
-type Tx = Transaction<Schema>;
-
-export function createMutators(authData: AuthData | null) {
-  return {
-    link: {
-      async create() {},
-      async get(tx: Tx, { link_token }: { link_token: string }) {},
-      async updateTransactions() {},
-      async updateBalences() {},
-    }
-  } as const;
-}
-
-export type Mutators = ReturnType<typeof createMutators>;

shared/src/queries.ts

@@ -1,34 +0,0 @@
-import { syncedQueryWithContext } from "@rocicorp/zero";
-import { z } from "zod";
-import { builder } from ".";
-import { type AuthData } from "./auth";
-import { isLoggedIn } from "./zql";
-
-export const queries = {
-  me: syncedQueryWithContext('me', z.tuple([]), (authData: AuthData | null) => {
-    isLoggedIn(authData);
-    return builder.users
-      .where('id', '=', authData.user.id)
-      .one();
-  }),
-  allTransactions: syncedQueryWithContext('allTransactions', z.tuple([]), (authData: AuthData | null) => {
-    isLoggedIn(authData);
-    return builder.transaction
-      .where('user_id', '=', authData.user.id)
-      .orderBy('datetime', 'desc')
-      .limit(50)
-  }),
-  getPlaidLink: syncedQueryWithContext('getPlaidLink', z.tuple([]), (authData: AuthData | null) => {
-    isLoggedIn(authData);
-    return builder.plaidLink
-      .where('user_id', '=', authData.user.id)
-      .orderBy('createdAt', 'desc')
-      .one();
-  }),
-  getBalances: syncedQueryWithContext('getBalances', z.tuple([]), (authData: AuthData | null) => {
-    isLoggedIn(authData);
-    return builder.balance
-      .where('user_id', '=', authData.user.id)
-      .orderBy('name', 'asc');
-  })
-};

tsconfig.json

@@ -1,11 +1,4 @@
 {
-  "extends": "expo/tsconfig.base",
-  "compilerOptions": {
-    "strict": true,
-    "verbatimModuleSyntax": true,
-    "paths": {
-      "@/*": ["./*"]
-    }
-  },
-  "include": ["**/*.ts", "**/*.tsx", ".expo/types/**/*.ts", "expo-env.d.ts"]
+  "compilerOptions": {},
+  "extends": "expo/tsconfig.base"
 }