feat: better auth api handler

apps/api/package.json

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

apps/api/src/index.ts

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

apps/api/src/index_old.ts

@@ -0,0 +1,58 @@
+import { serve } from "@hono/node-server";
+import { authDataSchema } from "@money/shared/auth";
+import { BASE_URL } from "@money/shared";
+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`],
+    allowMethods: ["POST", "GET", "OPTIONS"],
+    allowHeaders: ["Content-Type", "Authorization"],
+    credentials: true,
+  }),
+);
+
+app.on(["GET", "POST"], "/api/auth/*", (c) => auth.handler(c.req.raw));
+
+app.use("*", async (c, next) => {
+  const authHeader = c.req.raw.headers.get("Authorization");
+  const cookie = authHeader?.split("Bearer ")[1];
+
+  const newHeaders = new Headers(c.req.raw.headers);
+
+  if (cookie) {
+    newHeaders.set("Cookie", cookie);
+  }
+
+  const session = await auth.api.getSession({ headers: newHeaders });
+
+  if (!session) {
+    c.set("auth", null);
+    return next();
+  }
+  c.set("auth", authDataSchema.parse(session));
+  return 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(
+  {
+    fetch: app.fetch,
+    port: process.env.PORT ? parseInt(process.env.PORT) : 3000,
+  },
+  (info) => {
+    console.log(`Server is running on ${info.address}:${info.port}`);
+  },
+);

apps/api/src/plaid/sync.ts

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

apps/api/src/plaid/tx.ts

@@ -1,23 +0,0 @@
-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/zero.ts

@@ -26,8 +26,6 @@ import {
   PlaidApi,
   PlaidEnvironments,
   Products,
-  SandboxItemFireWebhookRequestWebhookCodeEnum,
-  WebhookType,
 } from "plaid";
 import { randomUUID } from "crypto";
 import { db } from "./db";
@@ -37,16 +35,8 @@ import {
   plaidLink,
   transaction,
 } from "@money/shared/db";
-import {
+import { and, eq, inArray, sql, type InferInsertModel } from "drizzle-orm";
-  and,
-  eq,
-  inArray,
-  sql,
-  type InferInsertModel,
-  type InferSelectModel,
-} from "drizzle-orm";
 import { plaidClient } from "./plaid";
-import { transactionFromPlaid } from "./plaid/tx";
 
 const processor = new PushProcessor(
   new ZQLDatabase(
@@ -138,9 +128,9 @@ const createMutators = (authData: AuthData | null) => {
           throw Error("Plaid error");
         }
       },
-      async webhook() {
-        isLoggedIn(authData);
 
+      async updateTransactions() {
+        isLoggedIn(authData);
         const accounts = await db.query.plaidAccessTokens.findMany({
           where: eq(plaidAccessTokens.userId, authData.user.id),
         });
@@ -149,172 +139,85 @@ const createMutators = (authData: AuthData | null) => {
           return;
         }
 
-        const account = accounts.at(0)!;
+        for (const account of accounts) {
-
+          const { data } = await plaidClient.transactionsGet({
-        const { data } = await plaidClient.sandboxItemFireWebhook({
             access_token: account.token,
-          webhook_type: WebhookType.Transactions,
+            start_date: "2025-10-01",
-          webhook_code:
+            end_date: new Date().toISOString().split("T")[0],
-            SandboxItemFireWebhookRequestWebhookCodeEnum.DefaultUpdate,
           });
 
-        console.log(data);
+          const transactions = data.transactions.map(
-      },
+            (tx) =>
-      async sync() {
+              ({
-        isLoggedIn(authData);
+                id: randomUUID(),
-
+                user_id: authData.user.id,
-        const accounts = await db.query.plaidAccessTokens.findMany({
+                plaid_id: tx.transaction_id,
-          where: eq(plaidAccessTokens.userId, authData.user.id),
+                account_id: tx.account_id,
-        });
+                name: tx.name,
-        if (accounts.length == 0) {
+                amount: tx.amount as any,
-          console.error("No accounts");
+                datetime: tx.datetime
-          return;
+                  ? new Date(tx.datetime)
-        }
+                  : new Date(tx.date),
-
+                authorized_datetime: tx.authorized_datetime
-        const account = accounts.at(0)!;
+                  ? new Date(tx.authorized_datetime)
-
+                  : undefined,
-        const { data } = await plaidClient.transactionsSync({
+                json: JSON.stringify(tx),
-          access_token: account.token,
+              }) satisfies InferInsertModel<typeof transaction>,
-          cursor: account.syncCursor || undefined,
-        });
-
-        const added = data.added.map((tx) =>
-          transactionFromPlaid(authData.user.id, tx),
           );
 
-        const updated = data.modified.map((tx) =>
+          await db
-          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)
+            .values(transactions)
-              .onConflictDoUpdate({
+            .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: {
-                  name: sql.raw(`excluded.${transaction.name.name}`),
+                current: sql.raw(`excluded.${balance.current.name}`),
-                  amount: sql.raw(`excluded.${transaction.amount.name}`),
+                avaliable: sql.raw(`excluded.${balance.avaliable.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;
 };

apps/expo/app.json

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

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

@@ -13,7 +13,7 @@ export default function Page() {
 
   useEffect(() => {
     const handler = () => {
-      const newRoute = window.location.pathname.slice(1) + "/";
+      const newRoute = window.location.pathname.slice(1);
       setRoute(newRoute);
     };
 

apps/expo/package.json

@@ -10,14 +10,14 @@
     "web": "expo start --web",
     "build": "expo export --platform web",
     "lint": "expo lint",
-    "db:migrate": "dotenv -- bun run --dir=shared db:migrate",
+    "db:migrate": "dotenv -- pnpm run --dir=shared db:migrate",
-    "db:gen": "dotenv -- bun run --dir=shared generate:zero"
+    "db:gen": "dotenv -- pnpm run --dir=shared generate:zero"
   },
   "dependencies": {
     "@better-auth/expo": "^1.3.27",
     "@expo/vector-icons": "^15.0.2",
-    "@money/shared": "*",
+    "@money/shared": "workspace:*",
-    "@money/ui": "*",
+    "@money/ui": "workspace:*",
     "@react-navigation/bottom-tabs": "^7.4.0",
     "@react-navigation/elements": "^2.6.3",
     "@react-navigation/native": "^7.1.8",
@@ -31,9 +31,7 @@
     "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/src/auth.ts

@@ -11,9 +11,9 @@ import {
 } 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";
+import { AuthSchema } from "@money/shared/auth";
 
 class AuthClientUnknownError extends Data.TaggedError(
   "AuthClientUnknownError",
@@ -129,7 +129,7 @@ const pollToken = ({ device_code }: { device_code: string }) =>
 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);
+  const auth = yield* Schema.decode(Schema.parseJson(AuthSchema))(content);
   if (auth.session.expiresAt < new Date())
     yield* Effect.fail(new AuthClientExpiredToken());
   return auth;
@@ -160,7 +160,7 @@ const requestAuth = Effect.gen(function* () {
   );
   if (sessionData == null) return yield* Effect.fail(new AuthClientNoData());
 
-  const result = yield* Schema.decodeUnknown(AuthState)(sessionData);
+  const result = yield* Schema.decodeUnknown(AuthSchema)(sessionData);
 
   const fs = yield* FileSystem.FileSystem;
   yield* fs.writeFileString(config.authPath, JSON.stringify(result));

apps/tui/src/index.tsx

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

apps/tui/src/schema.ts

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

package.json

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

packages/react-native-opentui/index.tsx

@@ -8,10 +8,9 @@ import type {
   StyleProp,
   ViewStyle,
   LinkingImpl,
-  TextInputProps,
 } from "react-native";
 import { useTerminalDimensions } from "@opentui/react";
-import { BorderSides, RGBA } from "@opentui/core";
+import { RGBA } from "@opentui/core";
 import { platform } from "node:os";
 import { exec } from "node:child_process";
 
@@ -66,27 +65,6 @@ export function View({ children, style }: ViewProps) {
       : undefined;
 
   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"),
@@ -96,48 +74,17 @@ export function View({ children, style }: ViewProps) {
     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={padding && Math.round(padding / RATIO_HEIGHT)}
-        (paddingTop && Math.round(paddingTop / RATIO_HEIGHT)) ||
+      paddingBottom={padding && Math.round(padding / RATIO_HEIGHT)}
-        (padding && Math.round(padding / RATIO_HEIGHT))
+      paddingLeft={padding && Math.round(padding / RATIO_WIDTH)}
-      }
+      paddingRight={padding && Math.round(padding / RATIO_WIDTH)}
-      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}
@@ -274,33 +221,6 @@ export function Modal({ children, visible }: ModalProps) {
   );
 }
 
-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",
 };

packages/shared/package.json

@@ -13,6 +13,6 @@
   },
   "scripts": {
     "db:gen": "drizzle-zero generate -s ./src/db/schema/public.ts -o ./src/zero-schema.gen.ts -f && sed -i 's/enableLegacyQueries: true,/enableLegacyQueries: false,/g' src/zero-schema.gen.ts && sed -i 's/enableLegacyMutators: true,/enableLegacyMutators: false,/g' src/zero-schema.gen.ts",
-    "db:push": "drizzle-kit push"
+    "db:migrate": "drizzle-kit push"
   }
 }

packages/shared/src/auth.ts

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

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

@@ -1,4 +1,3 @@
-import { relations } from "drizzle-orm";
 import {
   boolean,
   decimal,
@@ -7,7 +6,6 @@ import {
   timestamp,
   pgEnum,
   uniqueIndex,
-  numeric,
 } from "drizzle-orm/pg-core";
 
 export const users = pgTable(
@@ -65,41 +63,5 @@ 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,6 @@
 import type { Transaction } from "@rocicorp/zero";
-import { authDataSchema, type AuthData } from "./auth";
+import type { AuthData } from "./auth";
-import { type Category, type Schema } from "./zero-schema.gen";
+import { type Schema } from "./zero-schema.gen";
 import { isLoggedIn } from "./zql";
 
 type Tx = Transaction<Schema>;
@@ -10,10 +10,8 @@ export function createMutators(authData: AuthData | null) {
     link: {
       async create() {},
       async get(tx: Tx, { link_token }: { link_token: string }) {},
-      async webhook() {},
+      async updateTransactions() {},
-      async sync() {},
+      async updateBalences() {},
-      // async updateTransactions() {},
-      // async updateBalences() {},
       async deleteAccounts(tx: Tx, { accountIds }: { accountIds: string[] }) {
         isLoggedIn(authData);
         for (const id of accountIds) {
@@ -41,114 +39,6 @@ export function createMutators(authData: AuthData | null) {
         }
       },
     },
-    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

@@ -60,24 +60,4 @@ export const queries = {
         .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

@@ -112,190 +112,6 @@ 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: {
@@ -345,16 +161,6 @@ 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,
@@ -612,28 +418,7 @@ 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;
@@ -648,16 +433,6 @@ 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/ui/components/Button.tsx

@@ -1,14 +1,12 @@
-import { useEffect, type ReactNode } from "react";
+import { useKeyboard } from "../src/useKeyboard";
+import 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;
+  shortcut?: string;
 }
 
 const STYLES: Record<
@@ -23,9 +21,10 @@ const STYLES: Record<
 export function Button({ children, variant, onPress, shortcut }: ButtonProps) {
   const { backgroundColor, color } = STYLES[variant || "default"];
 
-  if (shortcut && onPress) {
+  useKeyboard((key) => {
-    useShortcut(shortcut, onPress);
+    if (!shortcut || !onPress) return;
-  }
+    if (key.name == shortcut) onPress();
+  });
 
   return (
     <Pressable onPress={onPress} style={{ backgroundColor }}>

packages/ui/components/Dialog.tsx

@@ -1,6 +1,6 @@
-import { createContext, use, type ReactNode } from "react";
+import { createContext, type ReactNode } from "react";
 import { Modal, View, Text } from "react-native";
-import { useShortcut } from "../lib/shortcuts";
+import { useKeyboard } from "../src/useKeyboard";
 
 export interface DialogState {
   close?: () => void;
@@ -15,13 +15,19 @@ interface ProviderProps {
   close?: () => void;
 }
 export function Provider({ children, visible, close }: ProviderProps) {
+  useKeyboard((key) => {
+    if (key.name == "escape") {
+      if (close) close();
+    }
+  }, []);
+
   return (
     <Context.Provider value={{ close }}>
       <Modal transparent visible={visible}>
         {/* <Pressable onPress={() => close && close()} style={{ justifyContent: 'center', alignItems: 'center', flex: 1, backgroundColor: 'rgba(0,0,0,0.2)',  }}> */}
         <View
           style={{
-            // justifyContent: "center",
+            justifyContent: "center",
             alignItems: "center",
             flex: 1,
             backgroundColor: "rgba(0,0,0,0.2)",
@@ -38,11 +44,10 @@ 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 }}>
+    <View
+      style={{ backgroundColor: "white", padding: 12, alignItems: "center" }}
+    >
       {children}
     </View>
   );

packages/ui/components/Table.tsx

@@ -1,15 +1,11 @@
-import { createContext, use, useEffect, useState, type ReactNode } from "react";
+import { createContext, use, useState, type ReactNode } from "react";
 import { View, Text } from "react-native";
-import { useShortcut } from "../lib/shortcuts/hooks";
+import { useKeyboard } from "../src/useKeyboard";
-import type { Key } from "../lib/shortcuts";
+import type { KeyEvent } from "@opentui/core";
 
 const HEADER_COLOR = "#7158e2";
-
+const TABLE_COLORS = ["#ddd", "#eee"];
-const COLORS = {
+const SELECTED_COLOR = "#f7b730";
-  focused: "#ddd",
-  selected: "#eaebf6",
-  focused_selected: "#d5d7ef",
-};
 
 const EXTRA = 5;
 
@@ -20,7 +16,7 @@ interface TableState {
   columns: Column[];
   columnMap: Map<string, number>;
   idx: number;
-  selectedIdx: Set<number>;
+  selectedFrom: number | undefined;
 }
 
 const INITAL_STATE = {
@@ -28,7 +24,7 @@ const INITAL_STATE = {
   columns: [],
   columnMap: new Map(),
   idx: 0,
-  selectedIdx: new Set(),
+  selectedFrom: undefined,
 } satisfies TableState;
 
 export const Context = createContext<TableState>(INITAL_STATE);
@@ -47,64 +43,48 @@ function renderCell(row: ValidRecord, column: Column): string {
   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>[];
+  onKey?: (event: KeyEvent, selected: T[]) => void;
 }
 export function Provider<T extends ValidRecord>({
   data,
   columns,
   children,
-  shortcuts,
+  onKey,
 }: ProviderProps<T>) {
   const [idx, setIdx] = useState(0);
-  const [selectedIdx, setSelectedIdx] = useState(new Set<number>());
+  const [selectedFrom, setSelectedFrom] = useState<number>();
 
-  useShortcut("j", () => {
+  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") {
-  useShortcut("down", () => {
+        if (key.shift && selectedFrom == undefined) {
-    setIdx((prev) => Math.min(prev + 1, data.length - 1));
+          setSelectedFrom(idx);
-  });
+        }
-  useShortcut("k", () => {
         setIdx((prev) => Math.max(prev - 1, 0));
-  });
+      } else if (key.name == "g" && key.shift) {
-  useShortcut("up", () => {
+        setIdx(data.length - 1);
-    setIdx((prev) => Math.max(prev - 1, 0));
+      } else if (key.name == "v") {
-  });
+        setSelectedFrom(idx);
-
+      } else if (key.name == "escape") {
-  useShortcut("escape", () => {
+        setSelectedFrom(undefined);
-    setSelectedIdx(new Set());
+      } else {
-  });
+        const from = selectedFrom ? Math.min(idx, selectedFrom) : idx;
-  useShortcut("x", () => {
+        const to = selectedFrom ? Math.max(idx, selectedFrom) : idx;
-    setSelectedIdx((last) => {
+        const selected = data.slice(from, to + 1);
-      const newSelected = new Set(last);
+        if (onKey) onKey(key, selected);
-      newSelected.add(idx);
+      }
-      return newSelected;
+    },
-    });
+    [data, idx, selectedFrom],
-  });
-
-  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) => {
@@ -119,14 +99,14 @@ export function Provider<T extends ValidRecord>({
   );
 
   return (
-    <Context.Provider value={{ data, columns, columnMap, idx, selectedIdx }}>
+    <Context.Provider value={{ data, columns, columnMap, idx, selectedFrom }}>
       {children}
     </Context.Provider>
   );
 }
 
 export function Body() {
-  const { columns, data, columnMap, idx, selectedIdx } = use(Context);
+  const { columns, data, columnMap, idx, selectedFrom } = use(Context);
   return (
     <View>
       <View style={{ backgroundColor: HEADER_COLOR, flexDirection: "row" }}>
@@ -143,21 +123,19 @@ export function Body() {
         ))}
       </View>
       {data.map((row, index) => {
-        const isSelected = selectedIdx.has(index);
+        const isSelected =
-        const isFocused = index == idx;
+          index == idx ||
+          (selectedFrom != undefined &&
+            ((selectedFrom <= index && index <= idx) ||
+              (idx <= index && index <= selectedFrom)));
 
         return (
           <View
             key={index}
             style={{
-              backgroundColor:
+              backgroundColor: isSelected
-                isSelected && isFocused
+                ? SELECTED_COLOR
-                  ? COLORS.focused_selected
+                : TABLE_COLORS[index % 2],
-                  : isFocused
-                    ? COLORS.focused
-                    : isSelected
-                      ? COLORS.selected
-                      : undefined,
             }}
           >
             <TableRow

packages/ui/lib/shortcuts/Debug.tsx

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

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

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

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

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

packages/ui/lib/shortcuts/store.ts

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

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

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

packages/ui/src/budget.tsx

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

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

@@ -1,107 +0,0 @@
-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,37 +1,24 @@
-import { createContext, use, type ReactNode } from "react";
+import { createContext, use } from "react";
 import { Transactions } from "./transactions";
-import { View } from "react-native";
+import { View, Text } 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",
   },
-  "/budget": {
-    screen: <Budget />,
-    key: "2",
-  },
   "/settings": {
     screen: <Settings />,
-    key: "3",
+    key: "2",
     children: {
       "/accounts": {},
       "/family": {},
     },
   },
-} satisfies Record<
+};
-  string,
-  { screen: ReactNode; key: KeyName; children?: Record<string, unknown> }
->;
 
 type Join<A extends string, B extends string> = `${A}${B}` extends `${infer X}`
   ? X
@@ -72,10 +59,7 @@ type AppProps = {
 export function App({ auth, route, setRoute }: AppProps) {
   return (
     <RouterContext.Provider value={{ auth, route, setRoute }}>
-      <ShortcutProvider>
-        <ShortcutDebug />
       <Main />
-      </ShortcutProvider>
     </RouterContext.Provider>
   );
 }
@@ -83,9 +67,17 @@ export function App({ auth, route, setRoute }: AppProps) {
 function Main() {
   const { route, setRoute } = use(RouterContext);
 
-  for (const [route, page] of Object.entries(PAGES)) {
+  useKeyboard((key) => {
-    useShortcut(page.key, () => setRoute(route as Route));
+    const screen = Object.entries(PAGES).find(
-  }
+      ([, screen]) => screen.key == key.name,
+    );
+
+    if (!screen) return;
+
+    const [route] = screen as [Route, never];
+
+    setRoute(route);
+  });
 
   const match =
     route in PAGES

packages/ui/src/settings.tsx

@@ -4,7 +4,8 @@ import { RouterContext, type Route } from ".";
 import { General } from "./settings/general";
 import { Accounts } from "./settings/accounts";
 import { Family } from "./settings/family";
-import { useShortcut } from "../lib/shortcuts";
+import { useKeyboard } from "./useKeyboard";
+import { Modal } from "react-native-opentui";
 
 type SettingsRoute = Extract<Route, `/settings${string}`>;
 
@@ -31,7 +32,9 @@ type Tab = keyof typeof TABS;
 export function Settings() {
   const { route, setRoute } = use(RouterContext);
 
-  useShortcut("h", () => {
+  useKeyboard(
+    (key) => {
+      if (key.name == "h") {
         const currentIdx = Object.entries(TABS).findIndex(
           ([tabRoute, _]) => tabRoute == route,
         );
@@ -39,8 +42,7 @@ export function Settings() {
         const last = routes[currentIdx - 1];
         if (!last) return;
         setRoute(last);
-  });
+      } else if (key.name == "l") {
-  useShortcut("l", () => {
         const currentIdx = Object.entries(TABS).findIndex(
           ([tabRoute, _]) => tabRoute == route,
         );
@@ -48,7 +50,10 @@ export function Settings() {
         const next = routes[currentIdx + 1];
         if (!next) return;
         setRoute(next);
-  });
+      }
+    },
+    [route],
+  );
 
   return (
     <View style={{ flexDirection: "row" }}>

packages/ui/src/settings/accounts.tsx

@@ -3,6 +3,7 @@ import { queries, type Mutators, type Schema } from "@money/shared";
 import { use, useEffect, useState } from "react";
 import { RouterContext } from "..";
 import { View, Text, Linking } from "react-native";
+import { useKeyboard } from "../useKeyboard";
 import { Button } from "../../components/Button";
 import * as Table from "../../components/Table";
 import * as Dialog from "../../components/Dialog";

packages/ui/src/transactions.tsx

@@ -40,9 +40,13 @@ export function Transactions() {
     <Table.Provider
       data={items}
       columns={COLUMNS}
-      shortcuts={[{ key: "r", handler: () => z.mutate.link.sync() }]}
+      onKey={(key) => {
+        if (key.name == "r" && key.shift) {
+          z.mutate.link.updateTransactions();
+        }
+      }}
     >
-      <View style={{ padding: 10, flex: 1 }}>
+      <View style={{ flex: 1 }}>
         <View style={{ flexShrink: 0 }}>
           <Table.Body />
         </View>
@@ -55,16 +59,18 @@ export function Transactions() {
 }
 
 function Selected() {
-  const { data, selectedIdx } = use(Table.Context);
+  const { data, idx, selectedFrom } = use(Table.Context);
 
-  if (selectedIdx.size == 0)
+  if (selectedFrom == undefined)
     return (
       <View style={{ backgroundColor: "#ddd" }}>
         <Text style={{ fontFamily: "mono" }}>No items selected</Text>
       </View>
     );
 
-  const selected = data.filter((_, i) => selectedIdx.has(i)) as Transaction[];
+  const from = Math.min(idx, selectedFrom);
+  const to = Math.max(idx, selectedFrom);
+  const selected = data.slice(from, to + 1) as Transaction[];
   const count = selected.length;
   const sum = selected.reduce((prev, curr) => prev + curr.amount, 0);
 

packages/ui/src/useKeyboard.ts

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

packages/ui/src/useKeyboard.web.ts

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

packages/ui/tsconfig.json

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

pnpm-workspace.yaml

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

process-compose.yaml

@@ -26,16 +26,16 @@ processes:
       period_seconds: 1
 
   tailscale_machine_name:
-    command: "bun tsx ./scripts/set-machine-name.ts"
+    command: "pnpm tsx ./scripts/set-machine-name.ts"
 
   expo:
-    command: "bun --filter=@money/expo start"
+    command: "pnpm --filter=@money/expo start"
     depends_on:
       tailscale_machine_name:
         condition: process_completed_successfully
 
   api:
-    command: "bun --filter=@money/api dev"
+    command: "pnpm --filter=@money/api dev"
 
   migrate:
     command: |
@@ -51,13 +51,13 @@ processes:
       db:
         condition: process_healthy
   zero:
-    command: bunx zero-cache-dev -p packages/shared/src/schema.ts
+    command: npx zero-cache-dev -p packages/shared/src/schema.ts
     depends_on:
       migrate:
         condition: process_completed_successfully
 
   studio:
-    command: bunx drizzle-kit studio
+    command: npx drizzle-kit studio
     working_dir: ./packages/shared
     depends_on:
       db: