refactor: move to bun

apps/api/package.json

@@ -8,7 +8,7 @@
   },
   "dependencies": {
     "@hono/node-server": "^1.19.5",
-    "@money/shared": "workspace:*",
+    "@money/shared": "*",
     "better-auth": "^1.3.27",
     "hono": "^4.9.12",
     "plaid": "^39.0.0",

apps/api/src/auth.ts

@@ -20,25 +20,25 @@ export const auth = betterAuth({
     "money://",
   ],
   advanced: {
-      crossSubDomainCookies: {
+    crossSubDomainCookies: {
-          enabled: process.env.NODE_ENV == 'production',
+      enabled: process.env.NODE_ENV == "production",
-          domain: "koon.us",
+      domain: "koon.us",
-      },
+    },
   },
   plugins: [
     expo(),
     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

@@ -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/plaid/sync.ts

@@ -0,0 +1,3 @@
+async function sync() {}
+
+sync();

apps/api/src/plaid/tx.ts

@@ -0,0 +1,23 @@
+import type { transaction } from "@money/shared/db";
+import type { Transaction } from "plaid";
+import { type InferInsertModel } from "drizzle-orm";
+import { randomUUID } from "crypto";
+
+export function transactionFromPlaid(
+  userId: string,
+  tx: Transaction,
+): InferInsertModel<typeof transaction> {
+  return {
+    id: randomUUID(),
+    user_id: userId,
+    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,
+    json: JSON.stringify(tx),
+  };
+}

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 { PostgresJSConnection } from "@rocicorp/zero/pg";
-import postgres from 'postgres';
+import postgres from "postgres";
 import {
   createMutators as createMutatorsShared,
   isLoggedIn,
@@ -20,24 +20,33 @@ 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,
+  SandboxItemFireWebhookRequestWebhookCodeEnum,
+  WebhookType,
+} from "plaid";
 import { randomUUID } from "crypto";
 import { db } from "./db";
-import { balance, plaidAccessTokens, plaidLink, transaction } from "@money/shared/db";
+import {
-import { eq, inArray, sql, type InferInsertModel } from "drizzle-orm";
+  balance,
-
+  plaidAccessTokens,
-
+  plaidLink,
-const configuration = new Configuration({
+  transaction,
-  basePath: process.env.PLAID_ENV == 'production' ? PlaidEnvironments.production : PlaidEnvironments.sandbox,
+} from "@money/shared/db";
-  baseOptions: {
+import {
-    headers: {
+  and,
-      'PLAID-CLIENT-ID': process.env.PLAID_CLIENT_ID,
+  eq,
-      'PLAID-SECRET': process.env.PLAID_SECRET,
+  inArray,
-    }
+  sql,
-  }
+  type InferInsertModel,
-});
+  type InferSelectModel,
-const plaidClient = new PlaidApi(configuration);
+} from "drizzle-orm";
-
+import { plaidClient } from "./plaid";
+import { transactionFromPlaid } from "./plaid/tx";
 
 const processor = new PushProcessor(
   new ZQLDatabase(
@@ -56,7 +65,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 +73,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,29 +91,56 @@ const createMutators = (authData: AuthData | null) => {
       async get(_, { link_token }) {
         isLoggedIn(authData);
 
-        const linkResp = await plaidClient.linkTokenGet({
+        try {
-          link_token,
+          const token = await db.query.plaidLink.findFirst({
-        });
+            where: and(
-        if (!linkResp) throw Error("No link respo");
+              eq(plaidLink.token, link_token),
-        console.log(JSON.stringify(linkResp.data, null, 4));
+              eq(plaidLink.user_id, authData.user.id),
-        const publicToken = linkResp.data.link_sessions?.at(0)?.results?.item_add_results.at(0)?.public_token;
+            ),
+          });
+          if (!token) throw Error("Link not found");
+          if (token.completeAt) return;
 
-        if (!publicToken) throw Error("No public token");
+          const linkResp = await plaidClient.linkTokenGet({
-        const { data } = await plaidClient.itemPublicTokenExchange({
+            link_token,
-          public_token: publicToken,
+          });
-        })
+          if (!linkResp) throw Error("No link respo");
 
-        await db.insert(plaidAccessTokens).values({
+          console.log(JSON.stringify(linkResp.data, null, 4));
-          id: randomUUID(),
+
-          userId: authData.user.id,
+          const item_add_result = linkResp.data.link_sessions
-          token: data.access_token,
+            ?.at(0)
-          logoUrl: "",
+            ?.results?.item_add_results.at(0);
-          name: ""
+
-        });
+          // We will assume its not done yet.
+          if (!item_add_result) return;
+
+          const { data } = await plaidClient.itemPublicTokenExchange({
+            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 webhook() {
-      async updateTransactions() {
         isLoggedIn(authData);
+
         const accounts = await db.query.plaidAccessTokens.findMany({
           where: eq(plaidAccessTokens.userId, authData.user.id),
         });
@@ -114,41 +149,20 @@ const createMutators = (authData: AuthData | null) => {
           return;
         }
 
-        for (const account of accounts) {
+        const account = accounts.at(0)!;
-          const { data } = await plaidClient.transactionsGet({
-            access_token: account.token,
-            start_date: "2025-10-01",
-            end_date: new Date().toISOString().split("T")[0],
-          });
 
-          const transactions = data.transactions.map(tx => ({
+        const { data } = await plaidClient.sandboxItemFireWebhook({
-            id: randomUUID(),
+          access_token: account.token,
-            user_id: authData.user.id,
+          webhook_type: WebhookType.Transactions,
-            plaid_id: tx.transaction_id,
+          webhook_code:
-            account_id: tx.account_id,
+            SandboxItemFireWebhookRequestWebhookCodeEnum.DefaultUpdate,
-            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,
-            json: JSON.stringify(tx),
-          } satisfies InferInsertModel<typeof transaction>));
 
-          await db.insert(transaction).values(transactions).onConflictDoNothing({
+        console.log(data);
-            target: transaction.plaid_id,
-          });
-
-          const txReplacingPendingIds = data.transactions
-            .filter(t => t.pending_transaction_id)
-            .map(t => t.pending_transaction_id!);
-
-          await db.delete(transaction)
-            .where(inArray(transaction.plaid_id, txReplacingPendingIds));
-
-        }
       },
-
+      async sync() {
-      async updateBalences() {
         isLoggedIn(authData);
+
         const accounts = await db.query.plaidAccessTokens.findMany({
           where: eq(plaidAccessTokens.userId, authData.user.id),
         });
@@ -157,27 +171,153 @@ const createMutators = (authData: AuthData | null) => {
           return;
         }
 
-        for (const account of accounts) {
+        const account = accounts.at(0)!;
-          const { data } = await plaidClient.accountsBalanceGet({
-            access_token: account.token
-          });
-          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({
-            target: balance.plaid_id,
-            set: { current: sql.raw(`excluded.${balance.current.name}`), avaliable: sql.raw(`excluded.${balance.avaliable.name}`) }
-          })
-        }
 
+        const { data } = await plaidClient.transactionsSync({
+          access_token: account.token,
+          cursor: account.syncCursor || undefined,
+        });
+
+        const added = data.added.map((tx) =>
+          transactionFromPlaid(authData.user.id, tx),
+        );
+
+        const updated = data.modified.map((tx) =>
+          transactionFromPlaid(authData.user.id, tx),
+        );
+
+        console.log("added", added.length);
+        console.log("updated", updated.length);
+        console.log("removed", data.removed.length);
+        console.log("next cursor", data.next_cursor);
+
+        await db.transaction(async (tx) => {
+          if (added.length) {
+            await tx.insert(transaction).values(added);
+          }
+
+          if (updated.length) {
+            await tx
+              .insert(transaction)
+              .values(updated)
+              .onConflictDoUpdate({
+                target: transaction.plaid_id,
+                set: {
+                  name: sql.raw(`excluded.${transaction.name.name}`),
+                  amount: sql.raw(`excluded.${transaction.amount.name}`),
+                  json: sql.raw(`excluded.${transaction.json.name}`),
+                },
+              });
+          }
+
+          if (data.removed.length) {
+            await tx.delete(transaction).where(
+              inArray(
+                transaction.id,
+                data.removed.map((tx) => tx.transaction_id),
+              ),
+            );
+          }
+
+          await tx
+            .update(plaidAccessTokens)
+            .set({ syncCursor: data.next_cursor })
+            .where(eq(plaidAccessTokens.id, account.id));
+        });
       },
-    }
+
+      // async updateTransactions() {
+      //   isLoggedIn(authData);
+      //   const accounts = await db.query.plaidAccessTokens.findMany({
+      //     where: eq(plaidAccessTokens.userId, authData.user.id),
+      //   });
+      //   if (accounts.length == 0) {
+      //     console.error("No accounts");
+      //     return;
+      //   }
+      //
+      //   for (const account of accounts) {
+      //     const { data } = await plaidClient.transactionsGet({
+      //       access_token: account.token,
+      //       start_date: "2025-10-01",
+      //       end_date: new Date().toISOString().split("T")[0],
+      //     });
+      //
+      //     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,
+      //           json: JSON.stringify(tx),
+      //         }) satisfies InferInsertModel<typeof transaction>,
+      //     );
+      //
+      //     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!);
+      //
+      //     await db
+      //       .delete(transaction)
+      //       .where(inArray(transaction.plaid_id, txReplacingPendingIds));
+      //   }
+      // },
+      //
+      // async updateBalences() {
+      //   isLoggedIn(authData);
+      //   const accounts = await db.query.plaidAccessTokens.findMany({
+      //     where: eq(plaidAccessTokens.userId, authData.user.id),
+      //   });
+      //   if (accounts.length == 0) {
+      //     console.error("No accounts");
+      //     return;
+      //   }
+      //
+      //   for (const account of accounts) {
+      //     const { data } = await plaidClient.accountsBalanceGet({
+      //       access_token: account.token,
+      //     });
+      //     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,
+      //           tokenId: account.id,
+      //         })),
+      //       )
+      //       .onConflictDoUpdate({
+      //         target: balance.plaid_id,
+      //         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/app.json

@@ -38,7 +38,8 @@
           }
         }
       ],
-      "expo-sqlite"
+      "expo-sqlite",
+      "expo-secure-store"
     ],
     "experiments": {
       "typedRoutes": true,

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

@@ -1,18 +1,19 @@
 import { useLocalSearchParams } from "expo-router";
-import { Text } from "react-native";
 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 [route, setRoute] = useState(
+    initalRoute ? "/" + initalRoute.join("/") : "/",
+  );
 
   const { data } = authClient.useSession();
 
   useEffect(() => {
     const handler = () => {
-      const newRoute = window.location.pathname.slice(1);
+      const newRoute = window.location.pathname.slice(1) + "/";
       setRoute(newRoute);
     };
 

apps/expo/app/_layout.tsx

@@ -1,17 +1,23 @@
-import { Stack } from 'expo-router';
+import { Stack } from "expo-router";
-import 'react-native-reanimated';
+import "react-native-reanimated";
 
-import { authClient } from '@/lib/auth-client';
+import { authClient } from "@/lib/auth-client";
-import { ZeroProvider } from '@rocicorp/zero/react';
+import { ZeroProvider } from "@rocicorp/zero/react";
-import { useMemo } from 'react';
+import { useMemo } from "react";
-import { authDataSchema } from '@money/shared/auth';
+import { authDataSchema } from "@money/shared/auth";
-import { Platform } from 'react-native';
+import { Platform } from "react-native";
-import type { ZeroOptions } from '@rocicorp/zero';
+import type { ZeroOptions } from "@rocicorp/zero";
-import { schema, type Schema, createMutators, type Mutators, BASE_URL } from '@money/shared';
+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),

apps/expo/app/approve.tsx

@@ -4,7 +4,7 @@ import { useEffect } from "react";
 import { Text } from "react-native";
 
 export default function Page() {
-  const { code } = useLocalSearchParams<{code: string }>();
+  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>;
@@ -13,11 +13,7 @@ export default function Page() {
     authClient.device.approve({
       userCode: code,
     });
-
   }, []);
 
-  return <Text>
+  return <Text>Approving: {code}</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

@@ -1,8 +1,14 @@
-import { authClient } from '@/lib/auth-client';
+import { authClient } from "@/lib/auth-client";
-import {  RefreshControl, ScrollView, StatusBar, Text, View } from 'react-native';
+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 { queries, type Mutators, type Schema } from "@money/shared";
-import { useState } from 'react';
+import { useState } from "react";
 
 export default function HomeScreen() {
   const { data: session } = authClient.useSession();
@@ -20,16 +26,43 @@ export default function HomeScreen() {
   return (
     <>
       <StatusBar barStyle="dark-content" />
-      <ScrollView contentContainerStyle={{ paddingTop: StatusBar.currentHeight, flexGrow: 1 }} refreshControl={<RefreshControl refreshing={refreshing} onRefresh={onRefresh} />} style={{ paddingHorizontal: 10 }}>
+      <ScrollView
-        {balances.map(balance => <Balance key={balance.id} balance={balance} />)}
+        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 } }) {
+function Balance({
-  return <View style={{ backgroundColor: "#eee", borderColor: "#ddd", borderWidth: 1, marginBottom: 10, borderRadius: 10 }}>
+  balance,
-    <Text style={{ fontSize: 15, textAlign: "center" }}>{balance.name}</Text>
+}: {
-    <Text style={{ fontSize: 30, textAlign: "center" }}>{balance.current}</Text>
+  balance: { name: string; current: number; avaliable: number };
-  </View>
+}) {
+  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/components/Header.tsx

@@ -1,70 +0,0 @@
-import { authClient } from "@/lib/auth-client";
-import { queries } from "@money/shared";
-import { useQuery } from "@rocicorp/zero/react";
-import { Link, usePathname, useRouter, type LinkProps } from "expo-router";
-import { useEffect } from "react";
-import { View, Text, Platform } from "react-native";
-
-type Page = { name: string, href: LinkProps['href'] };
-const PAGES: Page[] = [
-  {
-    name: "Home",
-    href: "/",
-  },
-  {
-    name: "Settings",
-    href: "/settings",
-  },
-];
-
-
-export default function Header() {
-  const router = useRouter();
-  const { data: session } = authClient.useSession();
-  const [user] = useQuery(queries.me(session));
-
-  useEffect(() => {
-    if (Platform.OS != 'web') return;
-    const handleKeyDown = (event: KeyboardEvent) => {
-      if (event.key === "1" && event.ctrlKey) {
-        router.push(PAGES.at(0)!.href);
-      } else if (event.key === "2" && event.ctrlKey) {
-        router.push(PAGES.at(1)!.href);
-      }
-    };
-
-    window.addEventListener("keydown", handleKeyDown);
-
-    return () => {
-      window.removeEventListener("keydown", handleKeyDown);
-    };
-  }, []);
-  
-
-  return (
-    <View style={{ flexDirection: "row", justifyContent: "space-between", backgroundColor: "#f7e2c8" }}>
-      <View style={{ flexDirection: "row" }}>
-        {PAGES.map(page => <Page
-          key={page.name}
-          name={page.name}
-          href={page.href}
-          />)}
-      </View>
-
-      <Link href={"#" as any}>
-        <Text style={{ fontFamily: 'mono' }}>{user?.name}  </Text>
-      </Link>
-    </View>
-  );
-}
-
-function Page({ name, href }: Page) {
-  const path = usePathname();
-
-  return (
-    <Link href={href }>
-      <Text style={{ fontFamily: 'mono' }}>{path == href ? `[ ${name} ]` : `  ${name}  `}</Text>
-    </Link>
-  )
-
-}

apps/expo/eslint.config.js

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

apps/expo/lib/auth-client.ts

@@ -1,11 +1,17 @@
 import { createAuthClient } from "better-auth/react";
-import { deviceAuthorizationClient, 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",
@@ -14,5 +20,5 @@ export const authClient = createAuthClient({
     }),
     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

@@ -10,14 +10,14 @@
     "web": "expo start --web",
     "build": "expo export --platform web",
     "lint": "expo lint",
-    "db:migrate": "dotenv -- pnpm run --dir=shared db:migrate",
+    "db:migrate": "dotenv -- bun run --dir=shared db:migrate",
-    "db:gen": "dotenv -- pnpm run --dir=shared generate:zero"
+    "db:gen": "dotenv -- bun run --dir=shared generate:zero"
   },
   "dependencies": {
     "@better-auth/expo": "^1.3.27",
     "@expo/vector-icons": "^15.0.2",
-    "@money/shared": "workspace:*",
+    "@money/shared": "*",
-    "@money/ui": "workspace:*",
+    "@money/ui": "*",
     "@react-navigation/bottom-tabs": "^7.4.0",
     "@react-navigation/elements": "^2.6.3",
     "@react-navigation/native": "^7.1.8",
@@ -31,7 +31,9 @@
     "expo-haptics": "~15.0.7",
     "expo-image": "~3.0.9",
     "expo-linking": "~8.0.8",
+    "expo-network": "~8.0.8",
     "expo-router": "~6.0.11",
+    "expo-secure-store": "~15.0.8",
     "expo-splash-screen": "~31.0.10",
     "expo-sqlite": "~16.0.8",
     "expo-status-bar": "~3.0.8",

apps/tui/build.ts

@@ -5,9 +5,12 @@ import path from "path";
 const aliasPlugin = {
   name: "alias-react-native",
   setup(build) {
-    build.onResolve({ filter: /^react-native$/ }, args => {
+    build.onResolve({ filter: /^react-native$/ }, (args) => {
       return {
-        path: path.resolve(__dirname, "../../packages/react-native-opentui/index.tsx"),
+        path: path.resolve(
+          __dirname,
+          "../../packages/react-native-opentui/index.tsx",
+        ),
       };
     });
   },
@@ -16,9 +19,9 @@ const aliasPlugin = {
 // Build configuration
 await esbuild.build({
   entryPoints: ["src/index.tsx"], // your app entry
-  bundle: true,                            // inline all dependencies (ui included)
+  bundle: true, // inline all dependencies (ui included)
-  platform: "node",                        // Node/Bun target
+  platform: "node", // Node/Bun target
-  format: "esm",                           // keep ESM for top-level await
+  format: "esm", // keep ESM for top-level await
   outfile: "dist/index.js",
   sourcemap: true,
   plugins: [aliasPlugin],
@@ -32,7 +35,13 @@ await esbuild.build({
     "@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",
   ],

apps/tui/lib/auth-client.ts

@@ -1,11 +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: "http://laptop:3000",
+  baseURL: config.apiUrl,
-  plugins: [
+  plugins: [deviceAuthorizationClient()],
-    deviceAuthorizationClient(),
-  ]
 });
-
-

apps/tui/package.json

@@ -13,8 +13,8 @@
     "@effect/platform-bun": "^0.83.0",
     "@money/shared": "workspace:*",
     "@money/ui": "workspace:*",
-    "@opentui/core": "^0.1.39",
+    "@opentui/core": "^0.1.47",
-    "@opentui/react": "^0.1.39",
+    "@opentui/react": "^0.1.47",
     "@types/qrcode": "^1.5.6",
     "effect": "^3.19.4",
     "qrcode": "^1.5.4",

apps/tui/src/auth.ts

@@ -1,49 +1,70 @@
-import { Context, Data, Effect, Layer, Schema, Console, Schedule, Match, Ref, Duration } from "effect";
+import {
+  Context,
+  Data,
+  Effect,
+  Layer,
+  Schema,
+  Console,
+  Schedule,
+  Ref,
+  Duration,
+} from "effect";
 import { FileSystem } from "@effect/platform";
 import { config } from "./config";
 import { AuthState } from "./schema";
 import { authClient } from "@/lib/auth-client";
 import type { BetterFetchResponse } from "@better-fetch/fetch";
 
-const CLIENT_ID = "koon-family";
+class AuthClientUnknownError extends Data.TaggedError(
-
+  "AuthClientUnknownError",
-const getFromFromDisk = Effect.gen(function* () {
+) {}
-  const fs = yield* FileSystem.FileSystem;
+class AuthClientExpiredToken extends Data.TaggedError(
-  const content = yield* fs.readFileString(config.authPath);
+  "AuthClientExpiredToken",
-  return yield* Schema.decode(Schema.parseJson(AuthState))(content);
+) {}
-});
+class AuthClientNoData extends Data.TaggedError("AuthClientNoData") {}
-
+class AuthClientFetchError extends Data.TaggedError("AuthClientFetchError")<{
-
+  message: string;
-class AuthClientErrorString extends Data.TaggedError("AuthClientErrorString")<{
+}> {}
-  errorString: string,
-}> {};
-
-
-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]; };
-
 class AuthClientError<T> extends Data.TaggedError("AuthClientError")<{
-  error: T,
+  error: T;
-}> {};
+}> {}
 
-export class AuthClient extends Context.Tag("AuthClient")<AuthClient, AuthClientImpl>() {};
+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>> | AuthClientErrorString, never>
+  ) => Effect.Effect<
+    T,
+    | AuthClientError<ErrorType<E>>
+    | AuthClientFetchError
+    | AuthClientUnknownError
+    | AuthClientNoData,
+    never
+  >;
 }
 
-
 export const make = () =>
   Effect.gen(function* () {
     return AuthClient.of({
@@ -51,86 +72,150 @@ export const make = () =>
         Effect.gen(function* () {
           const { data, error } = yield* Effect.tryPromise({
             try: () => fn(authClient),
-            catch: () => new AuthClientErrorString({ errorString: "Bad" }),
+            catch: (error) =>
+              error instanceof Error
+                ? new AuthClientFetchError({ message: error.message })
+                : new AuthClientUnknownError(),
           });
-          if (error != null) return yield* Effect.fail(new AuthClientError({ error }));
+          if (error != null)
-          if (data == null) return yield* Effect.fail(new AuthClientErrorString({  errorString: "No data" }));
+            return yield* Effect.fail(new AuthClientError({ error }));
+          if (data == null) return yield* Effect.fail(new AuthClientNoData());
           return data;
-        })
+        }),
-    })
+    });
-  })
+  });
 
-export const layer = () => Layer.scoped(AuthClient, make());
+export const AuthClientLayer = Layer.scoped(AuthClient, make());
 
-const pollToken = ({ device_code }: { device_code: string }) => Effect.gen(function* () {
+const pollToken = ({ device_code }: { device_code: string }) =>
-  const auth = yield* AuthClient;
+  Effect.gen(function* () {
-  const intervalRef = yield* Ref.make(5);
+    const auth = yield* AuthClient;
+    const intervalRef = yield* Ref.make(5);
 
-  const tokenEffect = auth.use(client => {
+    const tokenEffect = auth.use((client) => {
-    Console.debug("Fetching");
+      Console.debug("Fetching");
 
-    return client.device.token({
+      return client.device.token({
-      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-      device_code,
+        device_code,
-      client_id: CLIENT_ID,
+        client_id: config.authClientId,
-      fetchOptions: { headers: { "user-agent": "CLI" } },
+        fetchOptions: { headers: { "user-agent": config.authClientUserAgent } },
-    })
+      });
-  }
+    });
-  );
 
-  return yield* tokenEffect
+    return yield* tokenEffect.pipe(
-    .pipe(
+      Effect.tapError((error) =>
-      Effect.tapError(error =>
         error._tag == "AuthClientError" && error.error.error == "slow_down"
-          ? Ref.update(intervalRef, current => {
+          ? Ref.update(intervalRef, (current) => {
-            Console.debug("updating delay to ", current + 5);
+              Console.debug("updating delay to ", current + 5);
-            return current + 5
+              return current + 5;
-          })
+            })
-          : Effect.void
+          : Effect.void,
       ),
       Effect.retry({
         schedule: Schedule.addDelayEffect(
-          Schedule.recurWhile<Effect.Effect.Error<typeof tokenEffect>>(error =>
+          Schedule.recurWhile<Effect.Effect.Error<typeof tokenEffect>>(
-            error._tag == "AuthClientError" &&
+            (error) =>
-              (error.error.error == "authorization_pending" || error.error.error == "slow_down")
+              error._tag == "AuthClientError" &&
+              (error.error.error == "authorization_pending" ||
+                error.error.error == "slow_down"),
           ),
-          () => Ref.get(intervalRef).pipe(Effect.map(Duration.seconds))
+          () => 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(AuthState))(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({
+  const { device_code, user_code } = yield* auth.use((client) =>
-    client_id: CLIENT_ID,
+    client.device.code({
-    scope: "openid profile email",
+      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({
+  const sessionData = yield* auth.use((client) =>
-    fetchOptions: {
+    client.getSession({
-      auth: {
+      fetchOptions: {
-        type: "Bearer",
+        auth: {
-        token: access_token,
+          type: "Bearer",
-      }
+          token: access_token,
-    }
+        },
-  }));
+      },
-  if (sessionData == null) return yield* Effect.fail("Session was null");
+    }),
+  );
+  if (sessionData == null) return yield* Effect.fail(new AuthClientNoData());
+
+  const result = yield* Schema.decodeUnknown(AuthState)(sessionData);
 
   const fs = yield* FileSystem.FileSystem;
-  yield* fs.writeFileString(config.authPath, JSON.stringify(sessionData));
+  yield* fs.writeFileString(config.authPath, JSON.stringify(result));
 
-  return sessionData;
+  return result;
 });
 
 export const getAuth = Effect.gen(function* () {
   return yield* getFromFromDisk.pipe(
-    Effect.catchAll(() => requestAuth)
+    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

@@ -5,5 +5,10 @@ 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

@@ -1,38 +1,46 @@
 import { createCliRenderer } from "@opentui/core";
-import { createRoot } from "@opentui/react";
+import { createRoot, useKeyboard, useRenderer } from "@opentui/react";
 import { App, type Route } from "@money/ui";
 import { ZeroProvider } from "@rocicorp/zero/react";
-import { schema } from '@money/shared';
+import { schema, createMutators } from "@money/shared";
 import { useState } from "react";
-import { AuthClient, getAuth, layer } from "./auth";
+import { AuthClientLayer, getAuth } from "./auth";
-import { Effect, Layer } from "effect";
+import { Effect } from "effect";
 import { BunContext } from "@effect/platform-bun";
 import type { AuthData } from "./schema";
-
+import { kvStore } from "./store";
-const userID = "anon";
+import { config } from "./config";
-const server = "http://laptop:4848";
 
 function Main({ auth }: { auth: AuthData }) {
   const [route, setRoute] = useState<Route>("/");
+  const renderer = useRenderer();
 
-  return (
+  useKeyboard((key) => {
-    <ZeroProvider {...{ userID, auth: auth.session.token, server, schema }}>
+    if (key.name == "c" && key.ctrl) process.exit(0);
-      <App
+    if (key.name == "i" && key.meta) renderer.console.toggle();
-        auth={auth || null}
+  });
-        route={route}
+
-        setRoute={setRoute}
+  return <App auth={auth} route={route} setRoute={setRoute} />;
-      />
-    </ZeroProvider>
-  );
 }
 
-
-
 const auth = await Effect.runPromise(
   getAuth.pipe(
     Effect.provide(BunContext.layer),
-    Effect.provide(layer()),
+    Effect.provide(AuthClientLayer),
-  )
+  ),
+);
+const renderer = await createCliRenderer({ exitOnCtrlC: false });
+createRoot(renderer).render(
+  <ZeroProvider
+    {...{
+      userID: auth.user.id,
+      auth: auth.session.token,
+      server: config.zeroUrl,
+      schema,
+      mutators: createMutators(auth),
+      kvStore,
+    }}
+  >
+    <Main auth={auth} />
+  </ZeroProvider>,
 );
-const renderer = await createCliRenderer();
-createRoot(renderer).render(<Main auth={auth} />);

apps/tui/src/schema.ts

@@ -1,10 +1,15 @@
 import { Schema } from "effect";
 
+const DateFromDateOrString = Schema.Union(
+  Schema.DateFromString,
+  Schema.DateFromSelf,
+);
+
 const SessionSchema = Schema.Struct({
-  expiresAt: Schema.DateFromString,
+  expiresAt: DateFromDateOrString,
   token: Schema.String,
-  createdAt: Schema.DateFromString,
+  createdAt: DateFromDateOrString,
-  updatedAt: Schema.DateFromString,
+  updatedAt: DateFromDateOrString,
   ipAddress: Schema.optional(Schema.NullishOr(Schema.String)),
   userAgent: Schema.optional(Schema.NullishOr(Schema.String)),
   userId: Schema.String,
@@ -16,16 +21,14 @@ const UserSchema = Schema.Struct({
   email: Schema.String,
   emailVerified: Schema.Boolean,
   image: Schema.optional(Schema.NullishOr(Schema.String)),
-  createdAt: Schema.DateFromString,
+  createdAt: DateFromDateOrString,
-  updatedAt: Schema.DateFromString,
+  updatedAt: DateFromDateOrString,
   id: Schema.String,
 });
 
-
 export const AuthState = Schema.Struct({
   session: SessionSchema,
   user: UserSchema,
 });
 
 export type AuthData = typeof AuthState.Type;
-

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/util/qr.ts

@@ -22,5 +22,3 @@ export function QR(value: string): string {
   }
   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
+  }
+}

flake.nix

@@ -20,9 +20,11 @@
           corepack
           nodejs_22
           bun
+          biome
 
           postgresql
           process-compose
+          cloudflared
         ];
       };
     });

package.json

@@ -3,16 +3,14 @@
   "private": true,
   "scripts": {
     "dev": "process-compose up -p 0",
-    "tui": "bun run --hot apps/tui/src/index.tsx"
+    "tui": "bun --filter=@money/tui run build && bun --filter=@money/tui run start",
+    "db:gen": "bun --filter=@money/shared db:gen",
+    "db:push": "bun --filter=@money/shared db:push"
   },
-  "pnpm": {
+  "workspaces": ["apps/*", "packages/*"],
-    "onlyBuiltDependencies": [
+  "trustedDependencies": [
-      "@rocicorp/zero-sqlite3"
+    "@rocicorp/zero-sqlite3",
-    ],
+    "protobufjs",
-    "ignoredBuiltDependencies": [
+    "unrs-resolver"
-      "esbuild",
+  ]
-      "protobufjs",
-      "unrs-resolver"
-    ]
-  }
 }

packages/react-native-opentui/index.tsx

@@ -1,79 +1,323 @@
 import * as React from "react";
-import type { ViewProps, TextProps, PressableProps } from "react-native";
+import type {
+  ViewProps,
+  TextProps,
+  PressableProps,
+  ScrollViewProps,
+  ModalProps,
+  StyleProp,
+  ViewStyle,
+  LinkingImpl,
+  TextInputProps,
+} from "react-native";
+import { useTerminalDimensions } from "@opentui/react";
+import { BorderSides, 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 &&
+  const bg =
-    'backgroundColor' in style
+    style && "backgroundColor" in style
-    ? typeof style.backgroundColor == 'string'
+      ? typeof style.backgroundColor == "string"
-    ? style.backgroundColor
+        ? style.backgroundColor.startsWith("rgba(")
-    : undefined
+          ? (() => {
-    : undefined;
+              const parts = style.backgroundColor.split("(")[1].split(")")[0];
-  const flexDirection = style &&
+              const [r, g, b, a] = parts.split(",").map(parseFloat);
-    'flexDirection' in style
+              return RGBA.fromInts(r, g, b, a * 255);
-    ? typeof style.flexDirection == 'string'
+            })()
-    ? style.flexDirection
+          : style.backgroundColor
-    : undefined
+        : undefined
-    : undefined;
+      : undefined;
-  const flex = style &&
-    'flex' in style
-    ? typeof style.flex == 'number'
-    ? style.flex
-    : undefined
-    : undefined;
 
-  return <box backgroundColor={bg} flexDirection={flexDirection} flexGrow={flex}>{children}</box>
+  const padding = attr(style, "padding", "number");
+  const paddingTop = attr(style, "paddingTop", "number");
+  const paddingLeft = attr(style, "paddingLeft", "number");
+  const paddingBottom = attr(style, "paddingBottom", "number");
+  const paddingRight = attr(style, "paddingRight", "number");
+  const gap = attr(style, "gap", "number");
+
+  const borderBottomWidth = attr(style, "borderBottomWidth", "number");
+  const borderTopWidth = attr(style, "borderTopWidth", "number");
+  const borderLeftWidth = attr(style, "borderLeftWidth", "number");
+  const borderRightWidth = attr(style, "borderRightWidth", "number");
+
+  const borderBottomColor = attr(style, "borderBottomColor", "string");
+  const borderTopColor = attr(style, "borderTopColor", "string");
+  const borderLeftColor = attr(style, "borderLeftColor", "string");
+  const borderRightColor = attr(style, "borderRightColor", "string");
+
+  const borderColor = attr(style, "borderColor", "string");
+
+  const top = attr(style, "top", "number");
+
+  const width = attr(style, "width", "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"),
+    zIndex: attr(style, "zIndex", "number"),
+    left: attr(style, "left", "number"),
+    right: attr(style, "right", "number"),
+    bottom: attr(style, "bottom", "number"),
+    flexGrow:
+      attr(style, "flex", "number") || attr(style, "flexGrow", "number"),
+  };
+
+  const border = (() => {
+    const sides: BorderSides[] = [];
+    if (borderBottomWidth) sides.push("bottom");
+    if (borderTopWidth) sides.push("top");
+    if (borderLeftWidth) sides.push("left");
+    if (borderRightWidth) sides.push("right");
+    if (!sides.length) return undefined;
+    return sides;
+  })();
+
+  return (
+    <box
+      backgroundColor={bg}
+      paddingTop={
+        (paddingTop && Math.round(paddingTop / RATIO_HEIGHT)) ||
+        (padding && Math.round(padding / RATIO_HEIGHT))
+      }
+      paddingBottom={
+        (paddingBottom && Math.round(paddingBottom / RATIO_HEIGHT)) ||
+        (padding && Math.round(padding / RATIO_HEIGHT))
+      }
+      paddingLeft={
+        (paddingLeft && Math.round(paddingLeft / RATIO_WIDTH)) ||
+        (padding && Math.round(padding / RATIO_WIDTH))
+      }
+      paddingRight={
+        (paddingRight && Math.round(paddingRight / RATIO_WIDTH)) ||
+        (padding && Math.round(padding / RATIO_WIDTH))
+      }
+      gap={gap && Math.round(gap / RATIO_HEIGHT)}
+      border={border}
+      borderColor={borderColor}
+      width={width && Math.round(width / RATIO_WIDTH)}
+      top={top && Math.round(top / RATIO_HEIGHT)}
+      {...props}
+    >
+      {children}
+    </box>
+  );
 }
 
-export function Pressable({ children: childrenRaw, style, onPress }: PressableProps) {
+export function Pressable({
-  const bg = style &&
+  children: childrenRaw,
-    'backgroundColor' in style
+  style,
-    ? typeof style.backgroundColor == 'string'
+  onPress,
-    ? style.backgroundColor
+}: PressableProps) {
-    : undefined
+  const bg =
-    : undefined;
+    style && "backgroundColor" in style
-  const flexDirection = style &&
+      ? typeof style.backgroundColor == "string"
-    'flexDirection' in style
+        ? style.backgroundColor.startsWith("rgba(")
-    ? typeof style.flexDirection == 'string'
+          ? (() => {
-    ? style.flexDirection
+              const parts = style.backgroundColor.split("(")[1].split(")")[0];
-    : undefined
+              const [r, g, b, a] = parts.split(",").map(parseFloat);
-    : undefined;
+              return RGBA.fromInts(r, g, b, a * 255);
-  const flex = style &&
+            })()
-    'flex' in style
+          : style.backgroundColor
-    ? typeof style.flex == 'number'
+        : undefined
-    ? style.flex
+      : undefined;
-    : undefined
+  const flexDirection =
-    : undefined;
+    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 children = childrenRaw instanceof Function ? childrenRaw({ pressed: true }) : childrenRaw;
+  const padding =
+    style && "padding" in style
+      ? typeof style.padding == "number"
+        ? style.padding
+        : undefined
+      : undefined;
 
-  return <box
+  const children =
-    backgroundColor={bg}
+    childrenRaw instanceof Function
-    flexDirection={flexDirection}
+      ? childrenRaw({ pressed: true })
-    flexGrow={flex}
+      : childrenRaw;
-    onMouseDown={onPress ? ((_event) => {
+
-      // @ts-ignore
+  return (
-      onPress();
+    <box
-    }) : undefined}
+      onMouseDown={
-  >{children}</box>
+        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 &&
+  const fg =
-    'color' in style
+    style && "color" in style
-    ? typeof style.color == 'string'
+      ? typeof style.color == "string"
-    ? style.color
+        ? style.color
-    : undefined
+        : undefined
-    : undefined;
+      : undefined;
-  return <text fg={fg || "black"}>{children}</text>
+  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 function TextInput({
+  defaultValue,
+  onChangeText,
+  onKeyPress,
+}: TextInputProps) {
+  return (
+    <input
+      minWidth={20}
+      minHeight={1}
+      backgroundColor="white"
+      textColor="black"
+      focused={true}
+      cursorColor={"black"}
+      onInput={onChangeText}
+      onKeyDown={(key) =>
+        // @ts-ignore
+        onKeyPress({
+          nativeEvent: {
+            key: key.name == "return" ? "Enter" : key.name,
+          },
+        })
+      }
+      placeholder={defaultValue}
+    />
+  );
 }
 
 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/shared/package.json

@@ -12,7 +12,7 @@
     "drizzle-zero": "^0.14.3"
   },
   "scripts": {
-    "generate:zero": "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: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"
+    "db:push": "drizzle-kit push"
   }
 }

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/public.ts

@@ -1,4 +1,14 @@
-import { pgTable, text, boolean, timestamp, uniqueIndex, decimal } from "drizzle-orm/pg-core";
+import { relations } from "drizzle-orm";
+import {
+  boolean,
+  decimal,
+  pgTable,
+  text,
+  timestamp,
+  pgEnum,
+  uniqueIndex,
+  numeric,
+} from "drizzle-orm/pg-core";
 
 export const users = pgTable(
   "user",
@@ -33,6 +43,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(),
 });
 
@@ -43,6 +54,7 @@ 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(),
 });
@@ -53,5 +65,41 @@ export const plaidAccessTokens = pgTable("plaidAccessToken", {
   logoUrl: text("logoUrl").notNull(),
   userId: text("user_id").notNull(),
   token: text("token").notNull(),
+  syncCursor: text("sync_cursor"),
   createdAt: timestamp("created_at").notNull().defaultNow(),
 });
+
+export const budget = pgTable("budget", {
+  id: text("id").primaryKey(),
+  orgId: text("org_id").notNull(),
+  label: text("label").notNull(),
+  createdBy: text("created_by").notNull(),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});
+
+export const category = pgTable("category", {
+  id: text("id").primaryKey(),
+  budgetId: text("budget_id").notNull(),
+  amount: decimal("amount").notNull(),
+  every: text("every", { enum: ["year", "month", "week"] }).notNull(),
+  order: numeric("order").notNull(),
+  label: text("label").notNull(),
+  color: text("color").notNull(),
+  createdBy: text("created_by").notNull(),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+  removedBy: text("removed_by"),
+  removedAt: timestamp("removed_at"),
+});
+
+export const budgetRelations = relations(budget, ({ many }) => ({
+  categories: many(category),
+}));
+
+export const categoryRelations = relations(category, ({ one }) => ({
+  budget: one(budget, {
+    fields: [category.budgetId],
+    references: [budget.id],
+  }),
+}));

packages/shared/src/mutators.ts

@@ -1,6 +1,7 @@
 import type { Transaction } from "@rocicorp/zero";
-import type { AuthData } from "./auth";
+import { authDataSchema, type AuthData } from "./auth";
-import type { Schema } from ".";
+import { type Category, type Schema } from "./zero-schema.gen";
+import { isLoggedIn } from "./zql";
 
 type Tx = Transaction<Schema>;
 
@@ -9,9 +10,145 @@ export function createMutators(authData: AuthData | null) {
     link: {
       async create() {},
       async get(tx: Tx, { link_token }: { link_token: string }) {},
-      async updateTransactions() {},
+      async webhook() {},
-      async updateBalences() {},
+      async sync() {},
-    }
+      // 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 });
+            }
+          }
+        }
+      },
+    },
+    budget: {
+      async create(
+        tx: Tx,
+        { id, categoryId }: { id: string; categoryId: string },
+      ) {
+        isLoggedIn(authData);
+        await tx.mutate.budget.insert({
+          id,
+          orgId: authData.user.id,
+          label: "New Budget",
+          createdBy: authData.user.id,
+        });
+        await tx.mutate.category.insert({
+          id: categoryId,
+          budgetId: id,
+          amount: 0,
+          every: "week",
+          order: 1000,
+          label: "My category",
+          color: "#f06",
+          createdBy: authData.user.id,
+        });
+      },
+      async delete(tx: Tx, { id }: { id: string }) {
+        isLoggedIn(authData);
+        await tx.mutate.budget.delete({
+          id,
+        });
+      },
+      async createCategory(
+        tx: Tx,
+        {
+          id,
+          budgetId,
+          order,
+        }: { id: string; budgetId: string; order: number },
+      ) {
+        isLoggedIn(authData);
+
+        if (order != undefined) {
+          const after = await tx.query.category
+            .where("budgetId", "=", budgetId)
+            .where("order", ">", order);
+
+          after.forEach((item) => {
+            tx.mutate.category.update({
+              id: item.id,
+              order: item.order + 1,
+            });
+          });
+        }
+
+        tx.mutate.category.insert({
+          id,
+          budgetId,
+          amount: 0,
+          every: "week",
+          order: order + 1,
+          label: "My category",
+          color: "#f06",
+          createdBy: authData.user.id,
+        });
+      },
+      async deleteCategory(tx: Tx, { id }: { id: string }) {
+        isLoggedIn(authData);
+        const item = await tx.query.category.where("id", "=", id).one();
+        if (!item) throw Error("Item does not exist");
+        tx.mutate.category.update({
+          id,
+          removedAt: new Date().getTime(),
+          removedBy: authData.user.id,
+        });
+        const after = await tx.query.category
+          .where("budgetId", "=", item.budgetId)
+          .where("order", ">", item.order)
+          .run();
+        for (const item of after) {
+          tx.mutate.category.update({ id: item.id, order: item.order - 1 });
+        }
+        // after.forEach((item) => {
+        // });
+      },
+      async updateCategory(
+        tx: Tx,
+        {
+          id,
+          label,
+          order,
+          amount,
+          every,
+        }: {
+          id: string;
+          label?: string;
+          order?: number;
+          amount?: number;
+          every?: Category["every"];
+        },
+      ) {
+        isLoggedIn(authData);
+        tx.mutate.category.update({
+          id,
+          label,
+          order,
+          amount,
+          every,
+        });
+      },
+    },
   } as const;
 }
 

packages/shared/src/queries.ts

@@ -1,40 +1,83 @@
 import { syncedQueryWithContext } from "@rocicorp/zero";
 import { z } from "zod";
-import { builder } from ".";
+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) => {
+  me: syncedQueryWithContext("me", z.tuple([]), (authData: AuthData | null) => {
     isLoggedIn(authData);
-    return builder.users
+    return builder.users.where("id", "=", authData.user.id).one();
-      .where('id', '=', authData.user.id)
-      .one();
   }),
-  allTransactions: syncedQueryWithContext('allTransactions', z.tuple([]), (authData: AuthData | null) => {
+  allTransactions: syncedQueryWithContext(
-    isLoggedIn(authData);
+    "allTransactions",
-    return builder.transaction
+    z.tuple([]),
-      .where('user_id', '=', authData.user.id)
+    (authData: AuthData | null) => {
-      .orderBy('datetime', 'desc')
+      isLoggedIn(authData);
-      .limit(50)
+      return builder.transaction
-  }),
+        .where("user_id", "=", authData.user.id)
-  getPlaidLink: syncedQueryWithContext('getPlaidLink', z.tuple([]), (authData: AuthData | null) => {
+        .orderBy("datetime", "desc")
-    isLoggedIn(authData);
+        .limit(50);
-    return builder.plaidLink
+    },
-      .where('user_id', '=', authData.user.id)
+  ),
-      .orderBy('createdAt', 'desc')
+  getPlaidLink: syncedQueryWithContext(
-      .one();
+    "getPlaidLink",
-  }),
+    z.tuple([]),
-  getBalances: syncedQueryWithContext('getBalances', z.tuple([]), (authData: AuthData | null) => {
+    (authData: AuthData | null) => {
-    isLoggedIn(authData);
+      isLoggedIn(authData);
-    return builder.balance
+      return builder.plaidLink
-      .where('user_id', '=', authData.user.id)
+        .where(({ cmp, and, or }) =>
-      .orderBy('name', 'asc');
+          and(
-  }),
+            cmp("user_id", "=", authData.user.id),
-  getItems: syncedQueryWithContext('getItems', z.tuple([]), (authData: AuthData | null) => {
+            cmp("createdAt", ">", new Date().getTime() - 1000 * 60 * 60 * 4),
-    isLoggedIn(authData);
+            or(
-    return builder.plaidAccessTokens
+              cmp("completeAt", ">", new Date().getTime() - 1000 * 5),
-      .where('userId', '=', authData.user.id)
+              cmp("completeAt", "IS", null),
-      .orderBy('createdAt', 'desc');
+            ),
-  })
+          ),
+        )
+        .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");
+    },
+  ),
+  getBudgets: syncedQueryWithContext(
+    "getBudgets",
+    z.tuple([]),
+    (authData: AuthData | null) => {
+      isLoggedIn(authData);
+      return builder.budget
+        .related("categories", (q) =>
+          q.where("removedAt", "IS", null).orderBy("order", "asc"),
+        )
+        .limit(10);
+    },
+  ),
+  getBudgetCategories: syncedQueryWithContext(
+    "getBudgetCategories",
+    z.tuple([]),
+    (authData: AuthData | null) => {
+      isLoggedIn(authData);
+      return builder.category.orderBy("order", "desc");
+    },
+  ),
 };

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

@@ -80,6 +80,15 @@ export const schema = {
             "name"
           >,
         },
+        tokenId: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "balance",
+            "tokenId"
+          >,
+        },
         createdAt: {
           type: "number",
           optional: true,
@@ -103,6 +112,190 @@ export const schema = {
       },
       primaryKey: ["id"],
     },
+    budget: {
+      name: "budget",
+      columns: {
+        id: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "budget",
+            "id"
+          >,
+        },
+        orgId: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "budget",
+            "orgId"
+          >,
+          serverName: "org_id",
+        },
+        label: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "budget",
+            "label"
+          >,
+        },
+        createdBy: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "budget",
+            "createdBy"
+          >,
+          serverName: "created_by",
+        },
+        createdAt: {
+          type: "number",
+          optional: true,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "budget",
+            "createdAt"
+          >,
+          serverName: "created_at",
+        },
+        updatedAt: {
+          type: "number",
+          optional: true,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "budget",
+            "updatedAt"
+          >,
+          serverName: "updated_at",
+        },
+      },
+      primaryKey: ["id"],
+    },
+    category: {
+      name: "category",
+      columns: {
+        id: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "id"
+          >,
+        },
+        budgetId: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "budgetId"
+          >,
+          serverName: "budget_id",
+        },
+        amount: {
+          type: "number",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "amount"
+          >,
+        },
+        every: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "every"
+          >,
+        },
+        order: {
+          type: "number",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "order"
+          >,
+        },
+        label: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "label"
+          >,
+        },
+        color: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "color"
+          >,
+        },
+        createdBy: {
+          type: "string",
+          optional: false,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "createdBy"
+          >,
+          serverName: "created_by",
+        },
+        createdAt: {
+          type: "number",
+          optional: true,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "createdAt"
+          >,
+          serverName: "created_at",
+        },
+        updatedAt: {
+          type: "number",
+          optional: true,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "updatedAt"
+          >,
+          serverName: "updated_at",
+        },
+        removedBy: {
+          type: "string",
+          optional: true,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "removedBy"
+          >,
+          serverName: "removed_by",
+        },
+        removedAt: {
+          type: "number",
+          optional: true,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "category",
+            "removedAt"
+          >,
+          serverName: "removed_at",
+        },
+      },
+      primaryKey: ["id"],
+    },
     plaidAccessTokens: {
       name: "plaidAccessTokens",
       columns: {
@@ -152,6 +345,16 @@ export const schema = {
             "token"
           >,
         },
+        syncCursor: {
+          type: "string",
+          optional: true,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "plaidAccessTokens",
+            "syncCursor"
+          >,
+          serverName: "sync_cursor",
+        },
         createdAt: {
           type: "number",
           optional: true,
@@ -205,6 +408,16 @@ export const schema = {
             "token"
           >,
         },
+        completeAt: {
+          type: "number",
+          optional: true,
+          customType: null as unknown as ZeroCustomType<
+            ZeroSchema,
+            "plaidLink",
+            "completeAt"
+          >,
+          serverName: "complete_at",
+        },
         createdAt: {
           type: "number",
           optional: true,
@@ -399,7 +612,28 @@ export const schema = {
       serverName: "user",
     },
   },
-  relationships: {},
+  relationships: {
+    budget: {
+      categories: [
+        {
+          sourceField: ["id"],
+          destField: ["budgetId"],
+          destSchema: "category",
+          cardinality: "many",
+        },
+      ],
+    },
+    category: {
+      budget: [
+        {
+          sourceField: ["budgetId"],
+          destField: ["id"],
+          destSchema: "budget",
+          cardinality: "one",
+        },
+      ],
+    },
+  },
   enableLegacyQueries: false,
   enableLegacyMutators: false,
 } as const;
@@ -414,6 +648,16 @@ 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 "budget" table.
+ * This type is auto-generated from your Drizzle schema definition.
+ */
+export type Budget = Row<Schema["tables"]["budget"]>;
+/**
+ * Represents a row from the "category" table.
+ * This type is auto-generated from your Drizzle schema definition.
+ */
+export type Category = Row<Schema["tables"]["category"]>;
 /**
  * Represents a row from the "plaidAccessTokens" 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,39 @@
+import { useEffect, type ReactNode } from "react";
+import { Text, Pressable } from "react-native";
+import { useShortcut, type Key } from "../lib/shortcuts";
+
+type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
+
+export interface ButtonProps {
+  children: ReactNode;
+  onPress?: () => void;
+  variant?: "default" | "secondary" | "destructive";
+  shortcut?: Key;
+}
+
+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"];
+
+  if (shortcut && onPress) {
+    useShortcut(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,49 @@
+import { createContext, use, type ReactNode } from "react";
+import { Modal, View, Text } from "react-native";
+import { useShortcut } from "../lib/shortcuts";
+
+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) {
+  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) {
+  const { close } = use(Context);
+  useShortcut("escape", () => close?.(), "dialog");
+
+  return (
+    <View style={{ backgroundColor: "white", alignItems: "center", top: 120 }}>
+      {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,214 @@
+import { createContext, use, useEffect, useState, type ReactNode } from "react";
+import { View, Text } from "react-native";
+import { useShortcut } from "../lib/shortcuts/hooks";
+import type { Key } from "../lib/shortcuts";
+
+const HEADER_COLOR = "#7158e2";
+
+const COLORS = {
+  focused: "#ddd",
+  selected: "#eaebf6",
+  focused_selected: "#d5d7ef",
+};
+
+const EXTRA = 5;
+
+export type ValidRecord = Record<string, string | number | null>;
+
+interface TableState {
+  data: unknown[];
+  columns: Column[];
+  columnMap: Map<string, number>;
+  idx: number;
+  selectedIdx: Set<number>;
+}
+
+const INITAL_STATE = {
+  data: [],
+  columns: [],
+  columnMap: new Map(),
+  idx: 0,
+  selectedIdx: new Set(),
+} 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();
+}
+
+interface TableShortcut<T> {
+  key: Key;
+  handler: (params: { selected: T[]; index: number }) => void;
+}
+
+export interface ProviderProps<T> {
+  data: T[];
+  columns: Column[];
+  children: ReactNode;
+  shortcuts?: TableShortcut<T>[];
+}
+export function Provider<T extends ValidRecord>({
+  data,
+  columns,
+  children,
+  shortcuts,
+}: ProviderProps<T>) {
+  const [idx, setIdx] = useState(0);
+  const [selectedIdx, setSelectedIdx] = useState(new Set<number>());
+
+  useShortcut("j", () => {
+    setIdx((prev) => Math.min(prev + 1, data.length - 1));
+  });
+  useShortcut("down", () => {
+    setIdx((prev) => Math.min(prev + 1, data.length - 1));
+  });
+  useShortcut("k", () => {
+    setIdx((prev) => Math.max(prev - 1, 0));
+  });
+  useShortcut("up", () => {
+    setIdx((prev) => Math.max(prev - 1, 0));
+  });
+
+  useShortcut("escape", () => {
+    setSelectedIdx(new Set());
+  });
+  useShortcut("x", () => {
+    setSelectedIdx((last) => {
+      const newSelected = new Set(last);
+      newSelected.add(idx);
+      return newSelected;
+    });
+  });
+
+  useEffect(() => {
+    setIdx((prev) => Math.max(Math.min(prev, data.length - 1), 0));
+  }, [data]);
+
+  if (shortcuts) {
+    for (const shortcut of shortcuts) {
+      useShortcut(shortcut.key, () => {
+        const selected = data.filter(
+          (_, index) => idx == index || selectedIdx.has(index),
+        );
+        shortcut.handler({ selected, index: idx });
+      });
+    }
+  }
+
+  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, selectedIdx }}>
+      {children}
+    </Context.Provider>
+  );
+}
+
+export function Body() {
+  const { columns, data, columnMap, idx, selectedIdx } = 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 = selectedIdx.has(index);
+        const isFocused = index == idx;
+
+        return (
+          <View
+            key={index}
+            style={{
+              backgroundColor:
+                isSelected && isFocused
+                  ? COLORS.focused_selected
+                  : isFocused
+                    ? COLORS.focused
+                    : isSelected
+                      ? COLORS.selected
+                      : undefined,
+            }}
+          >
+            <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/lib/shortcuts/Debug.tsx

@@ -0,0 +1,41 @@
+import { useSyncExternalStore } from "react";
+import { View, Text } from "react-native";
+import { keysStore, type ScopeKeys } from "./store";
+
+export function ShortcutDebug() {
+  const entries = useSyncExternalStore(
+    keysStore.subscribe,
+    keysStore.getSnapshot,
+  );
+
+  return (
+    <View
+      style={{
+        position: "absolute",
+        zIndex: 100,
+        bottom: 0,
+        right: 0,
+        backgroundColor: "black",
+        padding: 10,
+      }}
+    >
+      <Text style={{ color: "red", fontFamily: "mono" }}>Scopes:</Text>
+      {entries.map(([scope, keys]) => (
+        <ScopeView key={scope} scope={scope} keys={keys} />
+      ))}
+    </View>
+  );
+}
+
+function ScopeView({ scope, keys }: { scope: string; keys: ScopeKeys }) {
+  return (
+    <Text style={{ color: "red", fontFamily: "mono", textAlign: "right" }}>
+      {scope}:
+      {keys
+        .entries()
+        .map(([key, _]) => key)
+        .toArray()
+        .join(",")}
+    </Text>
+  );
+}

packages/ui/lib/shortcuts/Provider.tsx

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+import { useKeyboard } from "@opentui/react";
+import { keysStore } from "./store";
+
+export function ShortcutProvider({ children }: { children: ReactNode }) {
+  useKeyboard((e) => {
+    const fn = keysStore.getHandler(e.name);
+    fn?.();
+  });
+
+  return children;
+}

packages/ui/lib/shortcuts/Provider.web.tsx

@@ -0,0 +1,26 @@
+import type { ReactNode } from "react";
+import { keysStore } from "./store";
+import type { KeyName } from "./types";
+
+const KEY_MAP: { [k: string]: KeyName } = {
+  Escape: "escape",
+  ArrowUp: "up",
+  ArrowDown: "down",
+  ArrowLeft: "left",
+  ArrowRight: "right",
+};
+
+if (typeof window !== "undefined") {
+  window.addEventListener("keydown", (e) => {
+    const key = Object.hasOwn(KEY_MAP, e.key) ? KEY_MAP[e.key]! : e.key;
+    const fn = keysStore.getHandler(key);
+    // console.log(e.key);
+    if (!fn) return;
+    e.preventDefault();
+    fn();
+  });
+}
+
+export function ShortcutProvider({ children }: { children: ReactNode }) {
+  return children;
+}

packages/ui/lib/shortcuts/hooks.ts

@@ -0,0 +1,22 @@
+import { useEffect, useRef } from "react";
+import { keysStore } from "./store";
+import type { Key } from "./types";
+import { enforceKeyOptions } from "./util";
+
+export const useShortcut = (
+  key: Key,
+  handler: () => void,
+  scope: string = "global",
+) => {
+  const keyOptions = enforceKeyOptions(key);
+  const keyName = keyOptions.name;
+  const ref = useRef(handler);
+  ref.current = handler;
+
+  useEffect(() => {
+    keysStore.register(keyName, ref, scope);
+    return () => {
+      keysStore.deregister(keyName, scope);
+    };
+  }, []);
+};

packages/ui/lib/shortcuts/index.ts

@@ -0,0 +1,4 @@
+export * from "./Debug";
+export * from "./Provider";
+export * from "./hooks";
+export * from "./types";

packages/ui/lib/shortcuts/store.ts

@@ -0,0 +1,58 @@
+import { type RefObject } from "react";
+
+export type ScopeKeys = Map<string, RefObject<() => void>>;
+
+// outer reactive container
+const scopes = new Map<string, ScopeKeys>();
+
+// stable snapshot for subscribers
+let snapshot: [string, ScopeKeys][] = [];
+
+const listeners = new Set<() => void>();
+
+function emit() {
+  // replace identity so subscribers re-render
+  snapshot = Array.from(scopes.entries());
+  for (const fn of listeners) fn();
+}
+
+export const keysStore = {
+  subscribe(fn: () => void) {
+    listeners.add(fn);
+    return () => listeners.delete(fn);
+  },
+
+  getSnapshot() {
+    return snapshot;
+  },
+
+  register(key: string, ref: RefObject<() => void>, scope: string) {
+    const prev = scopes.get(scope);
+    const next = new Map(prev); // <-- important: new identity
+    next.set(key, ref);
+
+    scopes.set(scope, next); // <-- outer identity also changes
+    emit();
+  },
+
+  deregister(key: string, scope: string) {
+    const prev = scopes.get(scope);
+    if (!prev) return;
+
+    const next = new Map(prev);
+    next.delete(key);
+
+    if (next.size === 0) {
+      scopes.delete(scope);
+    } else {
+      scopes.set(scope, next);
+    }
+    emit();
+  },
+
+  getHandler(key: string) {
+    // last scope wins — clarify this logic as needed
+    const last = Array.from(scopes.values()).at(-1);
+    return last?.get(key)?.current;
+  },
+};

packages/ui/lib/shortcuts/types.ts

@@ -0,0 +1,52 @@
+export type KeyName =
+  | "0"
+  | "1"
+  | "2"
+  | "3"
+  | "4"
+  | "5"
+  | "6"
+  | "7"
+  | "8"
+  | "9"
+  | "a"
+  | "b"
+  | "c"
+  | "d"
+  | "e"
+  | "f"
+  | "g"
+  | "h"
+  | "i"
+  | "j"
+  | "k"
+  | "l"
+  | "m"
+  | "n"
+  | "o"
+  | "p"
+  | "q"
+  | "r"
+  | "s"
+  | "t"
+  | "u"
+  | "v"
+  | "w"
+  | "x"
+  | "y"
+  | "z"
+  | ":"
+  | "up"
+  | "down"
+  | "left"
+  | "right"
+  | "return"
+  | "escape";
+
+export type Key = KeyName | KeyOptions;
+
+export interface KeyOptions {
+  name: KeyName;
+  ctrl?: boolean;
+  shift?: boolean;
+}

packages/ui/lib/shortcuts/util.ts

@@ -0,0 +1,9 @@
+import type { Key, KeyOptions } from "./types";
+
+export function enforceKeyOptions(key: Key): KeyOptions {
+  return typeof key == "string"
+    ? {
+        name: key,
+      }
+    : key;
+}

packages/ui/src/budget.tsx

@@ -0,0 +1,160 @@
+import { use, useRef, useState } from "react";
+import { View, Text, TextInput } from "react-native";
+import { RouterContext } from ".";
+import {
+  queries,
+  type Category,
+  type Mutators,
+  type Schema,
+} from "@money/shared";
+import { useQuery, useZero } from "@rocicorp/zero/react";
+import * as Table from "../components/Table";
+import { Button } from "../components/Button";
+import { RenameCategoryDialog } from "./budget/RenameCategoryDialog";
+import {
+  UpdateCategoryAmountDialog,
+  type CategoryWithComputed,
+  type Updating,
+} from "./budget/UpdateCategoryAmountDialog";
+
+const COLUMNS: Table.Column[] = [
+  { name: "label", label: "Name" },
+  { name: "week", label: "Week" },
+  { name: "month", label: "Month" },
+  { name: "year", label: "Year" },
+  { name: "order", label: "Order" },
+];
+
+export function Budget() {
+  const { auth } = use(RouterContext);
+  const [budgets] = useQuery(queries.getBudgets(auth));
+  const [renaming, setRenaming] = useState<Category>();
+  const [editCategoryAmount, setEditCategoryAmount] = useState<Updating>();
+
+  const z = useZero<Schema, Mutators>();
+
+  const newBudget = () => {
+    const id = new Date().getTime().toString();
+    const categoryId = new Date().getTime().toString();
+    z.mutate.budget.create({
+      id,
+      categoryId,
+    });
+  };
+
+  if (budgets.length == 0)
+    return (
+      <View
+        style={{
+          justifyContent: "center",
+          alignItems: "center",
+          flex: 1,
+          gap: 10,
+        }}
+      >
+        <Text style={{ fontFamily: "mono" }}>
+          No budgets, please create a new budget
+        </Text>
+        <Button onPress={newBudget} shortcut="n">
+          New budget
+        </Button>
+      </View>
+    );
+
+  const budget = budgets[0]!;
+
+  const data = budget.categories.slice().map((category) => {
+    const { amount } = category;
+    const week = amount / 4;
+    const month = amount;
+    const year = amount * 12;
+
+    return {
+      ...category,
+      ...{
+        week,
+        month,
+        year,
+      },
+    };
+  });
+
+  const newCategory = ({ index }: { index: number }) => {
+    const id = new Date().getTime().toString();
+    z.mutate.budget.createCategory({
+      id,
+      budgetId: budget.id,
+      order: index,
+    });
+  };
+
+  const deleteCategory = ({ selected }: { selected: { id: string }[] }) => {
+    for (const { id } of selected) {
+      z.mutate.budget.deleteCategory({ id });
+    }
+  };
+
+  const renameCategory = ({ selected }: { selected: Category[] }) => {
+    for (const category of selected) {
+      setRenaming(category);
+    }
+  };
+
+  const onEditCategoryYearly = ({
+    selected,
+  }: { selected: CategoryWithComputed[] }) => {
+    for (const category of selected) {
+      setEditCategoryAmount({ category, every: "year" });
+    }
+  };
+
+  const onEditCategoryMonthly = ({
+    selected,
+  }: { selected: CategoryWithComputed[] }) => {
+    for (const category of selected) {
+      setEditCategoryAmount({ category, every: "month" });
+    }
+  };
+
+  const onEditCategoryWeekly = ({
+    selected,
+  }: { selected: CategoryWithComputed[] }) => {
+    for (const category of selected) {
+      setEditCategoryAmount({ category, every: "week" });
+    }
+  };
+
+  return (
+    <>
+      <RenameCategoryDialog renaming={renaming} setRenaming={setRenaming} />
+      <UpdateCategoryAmountDialog
+        updating={editCategoryAmount}
+        setUpdating={setEditCategoryAmount}
+      />
+
+      <View style={{ alignItems: "flex-start" }}>
+        <Text style={{ fontFamily: "mono", textAlign: "left" }}>
+          Selected Budget: {budget.label}
+        </Text>
+      </View>
+      <Table.Provider
+        data={data}
+        columns={COLUMNS}
+        shortcuts={[
+          { key: "i", handler: newCategory },
+          { key: "d", handler: deleteCategory },
+          { key: "r", handler: renameCategory },
+          { key: "y", handler: onEditCategoryYearly },
+          { key: "m", handler: onEditCategoryMonthly },
+          { key: "w", handler: onEditCategoryWeekly },
+        ]}
+      >
+        <View style={{ flex: 1 }}>
+          <View style={{ flexShrink: 0 }}>
+            <Table.Body />
+          </View>
+        </View>
+      </Table.Provider>
+    </>
+  );
+}

packages/ui/src/budget/RenameCategoryDialog.tsx

@@ -0,0 +1,77 @@
+import { useRef, useState } from "react";
+import * as Dialog from "../../components/Dialog";
+import { View, Text, TextInput } from "react-native";
+import { type Category, type Mutators, type Schema } from "@money/shared";
+import { useZero } from "@rocicorp/zero/react";
+
+interface RenameCategoryDialogProps {
+  renaming: Category | undefined;
+  setRenaming: (v: Category | undefined) => void;
+}
+export function RenameCategoryDialog({
+  renaming,
+  setRenaming,
+}: RenameCategoryDialogProps) {
+  const refText = useRef("");
+  const [renamingText, setRenamingText] = useState("");
+
+  const z = useZero<Schema, Mutators>();
+
+  return (
+    <Dialog.Provider
+      visible={renaming != undefined}
+      close={() => setRenaming(undefined)}
+    >
+      <Dialog.Content>
+        <View style={{ width: 400 }}>
+          <View
+            style={{
+              borderBottomWidth: 1,
+              paddingTop: 12,
+              paddingLeft: 12,
+              paddingRight: 12,
+            }}
+          >
+            <TextInput
+              style={{
+                fontFamily: "mono",
+                // @ts-ignore
+                outline: "none",
+              }}
+              autoFocus
+              selectTextOnFocus
+              defaultValue={renaming?.label}
+              onChangeText={(t) => {
+                refText.current = t;
+                setRenamingText(t);
+              }}
+              onKeyPress={(e) => {
+                if (!renaming) return;
+                if (e.nativeEvent.key == "Enter") {
+                  if (refText.current.trim() == "")
+                    return setRenaming(undefined);
+                  z.mutate.budget.updateCategory({
+                    id: renaming.id,
+                    label: refText.current,
+                  });
+                  setRenaming(undefined);
+                } else if (e.nativeEvent.key == "Escape") {
+                  setRenaming(undefined);
+                }
+              }}
+            />
+          </View>
+
+          <View
+            style={{ paddingLeft: 12, paddingRight: 12, paddingBottom: 12 }}
+          >
+            <Text style={{ fontFamily: "mono" }}>
+              → Rename category to: {renamingText || renaming?.label}
+            </Text>
+            <Text style={{ fontFamily: "mono" }}>→ Cancel</Text>
+          </View>
+        </View>
+      </Dialog.Content>
+    </Dialog.Provider>
+  );
+}

packages/ui/src/budget/UpdateCategoryAmountDialog.tsx

@@ -0,0 +1,107 @@
+import { useRef, useState } from "react";
+import * as Dialog from "../../components/Dialog";
+import { View, Text, TextInput } from "react-native";
+import { type Category, type Mutators, type Schema } from "@money/shared";
+import { useZero } from "@rocicorp/zero/react";
+
+export type Updating = {
+  category: CategoryWithComputed;
+  every: Category["every"];
+};
+
+export type CategoryWithComputed = Category & {
+  month: number;
+  year: number;
+};
+
+interface UpdateCategoryAmountDialogProps {
+  updating: Updating | undefined;
+  setUpdating: (v: Updating | undefined) => void;
+}
+export function UpdateCategoryAmountDialog({
+  updating,
+  setUpdating,
+}: UpdateCategoryAmountDialogProps) {
+  const category = updating?.category;
+  const every = updating?.every;
+
+  const refText = useRef("");
+  const [amountText, setAmountText] = useState("");
+
+  const z = useZero<Schema, Mutators>();
+
+  return (
+    <Dialog.Provider
+      visible={category != undefined}
+      close={() => setUpdating(undefined)}
+    >
+      <Dialog.Content>
+        <View style={{ width: 400 }}>
+          <View
+            style={{
+              borderBottomWidth: 1,
+              paddingTop: 12,
+              paddingLeft: 12,
+              paddingRight: 12,
+            }}
+          >
+            <TextInput
+              style={{
+                fontFamily: "mono",
+                // @ts-ignore
+                outline: "none",
+              }}
+              autoFocus
+              selectTextOnFocus
+              defaultValue={category?.month.toString()}
+              onChangeText={(t) => {
+                refText.current = t;
+                setAmountText(t);
+              }}
+              onKeyPress={(e) => {
+                if (!category) return;
+                if (e.nativeEvent.key == "Enter") {
+                  if (refText.current.trim() == "")
+                    return setUpdating(undefined);
+
+                  try {
+                    const parsed = parseFloat(refText.current);
+
+                    const amount = (function () {
+                      switch (every) {
+                        case "year":
+                          return parsed / 12;
+                        case "month":
+                          return parsed;
+                        case "week":
+                          return parsed * 4;
+                      }
+                    })();
+
+                    z.mutate.budget.updateCategory({
+                      id: category.id,
+                      amount,
+                      every,
+                    });
+                    setUpdating(undefined);
+                  } catch (e) {}
+                } else if (e.nativeEvent.key == "Escape") {
+                  setUpdating(undefined);
+                }
+              }}
+            />
+          </View>
+
+          <View
+            style={{ paddingLeft: 12, paddingRight: 12, paddingBottom: 12 }}
+          >
+            <Text style={{ fontFamily: "mono" }}>
+              → Update monthly amount to: {amountText || category?.month}
+            </Text>
+            <Text style={{ fontFamily: "mono" }}>→ Cancel</Text>
+          </View>
+        </View>
+      </Dialog.Content>
+    </Dialog.Provider>
+  );
+}

packages/ui/src/index.tsx

@@ -1,43 +1,52 @@
-import { createContext, use, useState } from "react";
+import { createContext, use, type ReactNode } from "react";
 import { Transactions } from "./transactions";
-import { View, Text } from "react-native";
+import { View } from "react-native";
 import { Settings } from "./settings";
-import { useKeyboard } from "./useKeyboard";
 import type { AuthData } from "@money/shared/auth";
-
+import { Budget } from "./budget";
+import {
+  ShortcutProvider,
+  ShortcutDebug,
+  useShortcut,
+  type KeyName,
+} from "../lib/shortcuts";
 
 const PAGES = {
-  '/': {
+  "/": {
     screen: <Transactions />,
     key: "1",
   },
-  '/settings': {
+  "/budget": {
-    screen: <Settings />,
+    screen: <Budget />,
     key: "2",
+  },
+  "/settings": {
+    screen: <Settings />,
+    key: "3",
     children: {
       "/accounts": {},
       "/family": {},
-    }
+    },
   },
-};
+} satisfies Record<
+  string,
+  { screen: ReactNode; key: KeyName; children?: Record<string, unknown> }
+>;
 
-type Join<A extends string, B extends string> =
+type Join<A extends string, B extends string> = `${A}${B}` extends `${infer X}`
-  `${A}${B}` extends `${infer X}` ? X : never;
+  ? X
+  : never;
 
-type ChildRoutes<Parent extends string, Children> =
+type ChildRoutes<Parent extends string, Children> = {
-  {
+  [K in keyof Children & string]: K extends `/${string}`
-    [K in keyof Children & string]:
+    ? Join<Parent, K>
-      K extends `/${string}`
+    : never;
-        ? Join<Parent, K>
+}[keyof Children & string];
-        : never;
-  }[keyof Children & string];
 
 type Routes<T> = {
   [K in keyof T & string]:
     | K
-    | (T[K] extends { children: infer C }
+    | (T[K] extends { children: infer C } ? ChildRoutes<K, C> : never);
-        ? ChildRoutes<K, C>
-        : never)
 }[keyof T & string];
 
 export type Route = Routes<typeof PAGES>;
@@ -48,47 +57,46 @@ interface RouterContextType {
   setRoute: (route: Route) => void;
 }
 
-
 export const RouterContext = createContext<RouterContextType>({
   auth: null,
-  route: '/',
+  route: "/",
-  setRoute: () => {}
+  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 }}>
+  return (
-    <Main />
+    <RouterContext.Provider value={{ auth, route, setRoute }}>
-  </RouterContext.Provider>
+      <ShortcutProvider>
+        <ShortcutDebug />
+        <Main />
+      </ShortcutProvider>
+    </RouterContext.Provider>
+  );
 }
 
 function Main() {
   const { route, setRoute } = use(RouterContext);
 
-  useKeyboard((key) => {
+  for (const [route, page] of Object.entries(PAGES)) {
-    const screen = Object.entries(PAGES)
+    useShortcut(page.key, () => setRoute(route as Route));
-      .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
+      : (Object.keys(PAGES)
-          keyof typeof PAGES);
+          .sort((a, b) => b.length - a.length)
+          .find((p) => route.startsWith(p)) as keyof typeof PAGES);
 
-  return PAGES[match].screen;
+  return (
+    <View style={{ backgroundColor: "white", flex: 1 }}>
+      {PAGES[match].screen}
+    </View>
+  );
 }
-
-

packages/ui/src/list.tsx

@@ -1,30 +0,0 @@
-import { useState, type ReactNode } from "react";
-import { View, Text } from "react-native";
-import { useKeyboard } from "./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/src/settings.tsx

@@ -4,65 +4,79 @@ 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 { useShortcut } from "../lib/shortcuts";
 
 type SettingsRoute = Extract<Route, `/settings${string}`>;
 
 const TABS = {
   "/settings": {
-    label: "General",
+    label: "💽 General",
-    screen: <General />
+    screen: <General />,
   },
   "/settings/accounts": {
-    label: "Bank Accounts",
+    label: "🏦 Bank Accounts",
-    screen: <Accounts />
+    screen: <Accounts />,
   },
   "/settings/family": {
-    label: "Family",
+    label: "👑 Family",
-    screen: <Family />
+    screen: <Family />,
   },
-} as const satisfies Record<SettingsRoute, { label: string, screen: ReactNode }>;
+} as const satisfies Record<
+  SettingsRoute,
+  { label: string; screen: ReactNode }
+>;
 
 type Tab = keyof typeof TABS;
 
 export function Settings() {
   const { route, setRoute } = use(RouterContext);
 
-  useKeyboard((key) => {
+  useShortcut("h", () => {
-    if (key.name == 'h') {
+    const currentIdx = Object.entries(TABS).findIndex(
-      const currentIdx = Object.entries(TABS).findIndex(([tabRoute, _]) => tabRoute == route)
+      ([tabRoute, _]) => tabRoute == route,
-      const routes = Object.keys(TABS) as SettingsRoute[];
+    );
-      const last = routes[currentIdx - 1]
+    const routes = Object.keys(TABS) as SettingsRoute[];
-      if (!last) return;
+    const last = routes[currentIdx - 1];
-      setRoute(last);
+    if (!last) return;
-    } else if (key.name == 'l') {
+    setRoute(last);
-      const currentIdx = Object.entries(TABS).findIndex(([tabRoute, _]) => tabRoute == route)
+  });
-      const routes = Object.keys(TABS) as SettingsRoute[];
+  useShortcut("l", () => {
-      const next = routes[currentIdx + 1]
+    const currentIdx = Object.entries(TABS).findIndex(
-      if (!next) return;
+      ([tabRoute, _]) => tabRoute == route,
-      setRoute(next);
+    );
-    }
+    const routes = Object.keys(TABS) as SettingsRoute[];
-  }, [route]);
+    const next = routes[currentIdx + 1];
+    if (!next) return;
+    setRoute(next);
+  });
 
   return (
     <View style={{ flexDirection: "row" }}>
-
+      <View style={{ padding: 10 }}>
-      <View>
         {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)}>
+            <Pressable
-              <Text style={{ fontFamily: 'mono', color: isSelected ? 'white' : 'black' }}>{tab.label}</Text>
+              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>
+      <View>{TABS[route as Tab].screen}</View>
-        {TABS[route as Tab].screen}
-      </View>
     </View>
   );
 }
-

packages/ui/src/settings/accounts.tsx

@@ -1,23 +1,166 @@
-import { useQuery } from "@rocicorp/zero/react";
+import { useQuery, useZero } from "@rocicorp/zero/react";
-import { queries } from '@money/shared';
+import { queries, type Mutators, type Schema } from "@money/shared";
-import * as Table from "../table";
+import { use, useEffect, useState } from "react";
-import { use } from "react";
 import { RouterContext } from "..";
+import { View, Text, Linking } from "react-native";
+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: "name", label: "Name" },
-  { name: 'createdAt', label: 'Added At', render: (n) => new Date(n).toLocaleString() },
+  {
+    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 (
-    <Table.Provider columns={COLUMNS} data={items}>
+    <>
-      <Table.Body />
+      <Dialog.Provider
-    </Table.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

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

packages/ui/src/settings/general.tsx

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

packages/ui/src/table.tsx

@@ -1,134 +0,0 @@
-import { createContext, use, useState, type ReactNode } from "react";
-import { View, Text } from "react-native";
-import { useKeyboard } from "./useKeyboard";
-
-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;
-};
-export function Provider<T extends ValidRecord>({ data, columns, children }: 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);
-    }
-  }, [data, idx]);
-
-
-  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 { data, 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/src/transactions.tsx

@@ -1,11 +1,15 @@
-import * as Table from "./table";
+import * as Table from "../components/Table";
-import { useQuery } from "@rocicorp/zero/react";
+import { useQuery, useZero } from "@rocicorp/zero/react";
-import { queries, type Transaction } from '@money/shared';
+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,
@@ -14,52 +18,62 @@ const FORMAT = new Intl.NumberFormat("en-US", {
 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: "createdAt",
-  { name: 'name', label: 'Name' },
+    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} >
+      columns={COLUMNS}
-        <Table.Body />
+      shortcuts={[{ key: "r", handler: () => z.mutate.link.sync() }]}
-        {/* Spacer */}
+    >
-        <View style={{ flex: 1 }} />
+      <View style={{ padding: 10, flex: 1 }}>
-      <Selected />
+        <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);
+  const { data, selectedIdx } = use(Table.Context);
 
-  if (selectedFrom == undefined)
+  if (selectedIdx.size == 0)
-  return (
+    return (
-    <View style={{ backgroundColor: '#ddd' }}>
+      <View style={{ backgroundColor: "#ddd" }}>
-      <Text style={{ fontFamily: 'mono' }}>No items selected</Text>
+        <Text style={{ fontFamily: "mono" }}>No items selected</Text>
-    </View>
+      </View>
-  );
+    );
 
-  const from = Math.min(idx, selectedFrom);
+  const selected = data.filter((_, i) => selectedIdx.has(i)) as Transaction[];
-  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' }}>
+    <View style={{ backgroundColor: "#9f9" }}>
-      <Text style={{ fontFamily: 'mono' }}>{count} transaction{count == 1 ? "" : "s"} selected | ${FORMAT.format(sum)}</Text>
+      <Text style={{ fontFamily: "mono" }}>
+        {count} transaction{count == 1 ? "" : "s"} selected | $
+        {FORMAT.format(sum)}
+      </Text>
     </View>
   );
 }
-
-

packages/ui/src/useKeyboard.ts

@@ -1,5 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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,
-      });
-    };
-
-    // @ts-ignore
-    window.addEventListener("keydown", handlerWeb);
-    return () => {
-    // @ts-ignore
-window.removeEventListener("keydown", handlerWeb);
-    };
-  }, deps);
-}

packages/ui/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     // Environment setup & latest features
-    "lib": ["ESNext"],
+    "lib": ["ESNext", "DOM"],
     "target": "ESNext",
     "module": "ESNext",
     "moduleDetection": "force",

pnpm-workspace.yaml

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

process-compose.yaml

@@ -26,36 +26,42 @@ processes:
       period_seconds: 1
 
   tailscale_machine_name:
-    command: "pnpm tsx ./scripts/set-machine-name.ts"
+    command: "bun tsx ./scripts/set-machine-name.ts"
 
   expo:
-    command: "pnpm --filter=@money/expo start"
+    command: "bun --filter=@money/expo start"
     depends_on:
       tailscale_machine_name:
         condition: process_completed_successfully
 
   api:
-    command: "pnpm --filter=@money/api dev"
+    command: "bun --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 packages/shared/src/schema.ts
+    command: bunx zero-cache-dev -p packages/shared/src/schema.ts
     depends_on:
       migrate:
         condition: process_completed_successfully
 
   studio:
-    command: npx drizzle-kit studio
+    command: bunx drizzle-kit studio
     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);
 }
-