@intx/hub-api 0.1.2

package/src/routes/wallets.ts

@@ -0,0 +1,370 @@
+import { eq, and } from "drizzle-orm";
+import { Hono } from "hono";
+import { describeRoute, resolver, validator } from "hono-openapi";
+
+import { wallet, transaction } from "@intx/db/schema";
+import { parseWalletRow, parseTransactionRow } from "@intx/db";
+import type { DB } from "@intx/db";
+import {
+  CreateWallet,
+  UpdateWallet,
+  WalletResponse,
+  TransactionResponse,
+  ErrorResponse,
+  paginatedSchema,
+} from "@intx/types";
+
+import type { TenantEnv } from "../context";
+import { first, ts } from "../format";
+import { generateId } from "@intx/hub-common";
+import { idResource } from "../middleware/grant";
+import type { RequireGrant } from "../middleware/grant";
+import {
+  parsePageParams,
+  cursorCondition,
+  pageOrder,
+  paginatedResponse,
+  pageParameters,
+} from "../pagination";
+
+function formatWallet(row: typeof wallet.$inferSelect) {
+  const parsed = parseWalletRow(row);
+  return {
+    id: parsed.id,
+    tenantId: parsed.tenantId,
+    name: parsed.name,
+    backendType: parsed.backendType,
+    currency: parsed.currency,
+    balance: parsed.balance,
+    config: parsed.config ?? undefined,
+    createdAt: ts(parsed.createdAt),
+    updatedAt: ts(parsed.updatedAt),
+  };
+}
+
+function formatTransaction(row: typeof transaction.$inferSelect) {
+  const parsed = parseTransactionRow(row);
+  return {
+    id: parsed.id,
+    walletId: parsed.walletId,
+    agentId: parsed.agentId ?? null,
+    direction: parsed.direction,
+    amount: parsed.amount,
+    currency: parsed.currency,
+    recipientId: parsed.recipientId ?? null,
+    senderId: parsed.senderId ?? null,
+    requestId: parsed.requestId ?? null,
+    status: parsed.status,
+    createdAt: ts(parsed.createdAt),
+  };
+}
+
+export type CreateWalletRoutesDeps = {
+  db: DB["db"];
+  requireGrant: RequireGrant;
+};
+
+export function createWalletRoutes({
+  db,
+  requireGrant,
+}: CreateWalletRoutesDeps): Hono<TenantEnv> {
+  const app = new Hono<TenantEnv>();
+
+  app.get(
+    "/",
+    requireGrant("wallet:*", "read"),
+    describeRoute({
+      tags: ["Wallets"],
+      summary: "List wallets in the tenant",
+      parameters: [...pageParameters],
+      responses: {
+        200: {
+          description: "List of wallets",
+          content: {
+            "application/json": {
+              schema: resolver(paginatedSchema(WalletResponse)),
+            },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      const tenantCtx = c.get("tenant");
+      const { limit, cursor } = parsePageParams({
+        cursor: c.req.query("cursor"),
+        limit: c.req.query("limit"),
+      });
+
+      const conditions = [eq(wallet.tenantId, tenantCtx.id)];
+      if (cursor) {
+        conditions.push(cursorCondition(wallet.createdAt, wallet.id, cursor));
+      }
+
+      const rows = await db.query.wallet.findMany({
+        where: and(...conditions),
+        orderBy: pageOrder(wallet.createdAt, wallet.id),
+        limit,
+      });
+
+      return c.json(paginatedResponse(rows.map(formatWallet), rows, limit));
+    },
+  );
+
+  app.post(
+    "/",
+    requireGrant("wallet:*", "create"),
+    describeRoute({
+      tags: ["Wallets"],
+      summary: "Create a wallet",
+      description:
+        "Creates a wallet with the specified payment backend and currency. Access for agents is managed through grants.",
+      responses: {
+        201: {
+          description: "Wallet created",
+          content: {
+            "application/json": { schema: resolver(WalletResponse) },
+          },
+        },
+        400: {
+          description: "Validation error",
+          content: {
+            "application/json": { schema: resolver(ErrorResponse) },
+          },
+        },
+      },
+    }),
+    validator("json", CreateWallet),
+    async (c) => {
+      const tenantCtx = c.get("tenant");
+      const body = c.req.valid("json");
+
+      const now = new Date();
+      const row = first(
+        await db
+          .insert(wallet)
+          .values({
+            id: generateId("wallet"),
+            tenantId: tenantCtx.id,
+            name: body.name,
+            backendType: body.backendType,
+            currency: body.currency,
+            balance: "0",
+            config: body.config ?? null,
+            createdAt: now,
+            updatedAt: now,
+          })
+          .returning(),
+      );
+
+      return c.json(formatWallet(row), 201);
+    },
+  );
+
+  app.get(
+    "/:walletId",
+    requireGrant(idResource("wallet", "walletId"), "read"),
+    describeRoute({
+      tags: ["Wallets"],
+      summary: "Get wallet details",
+      description: "Returns wallet details including current balance.",
+      responses: {
+        200: {
+          description: "Wallet details",
+          content: {
+            "application/json": { schema: resolver(WalletResponse) },
+          },
+        },
+        404: {
+          description: "Wallet not found",
+          content: {
+            "application/json": { schema: resolver(ErrorResponse) },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      const tenantCtx = c.get("tenant");
+      const walletId = c.req.param("walletId");
+
+      const row = await db.query.wallet.findFirst({
+        where: and(eq(wallet.id, walletId), eq(wallet.tenantId, tenantCtx.id)),
+      });
+
+      if (!row) {
+        return c.json(
+          { error: { code: "not_found", message: "Wallet not found" } },
+          404,
+        );
+      }
+
+      return c.json(formatWallet(row));
+    },
+  );
+
+  app.patch(
+    "/:walletId",
+    requireGrant(idResource("wallet", "walletId"), "manage"),
+    describeRoute({
+      tags: ["Wallets"],
+      summary: "Update wallet config",
+      responses: {
+        200: {
+          description: "Wallet updated",
+          content: {
+            "application/json": { schema: resolver(WalletResponse) },
+          },
+        },
+        404: {
+          description: "Wallet not found",
+          content: {
+            "application/json": { schema: resolver(ErrorResponse) },
+          },
+        },
+      },
+    }),
+    validator("json", UpdateWallet),
+    async (c) => {
+      const tenantCtx = c.get("tenant");
+      const walletId = c.req.param("walletId");
+      const body = c.req.valid("json");
+
+      const updates: Record<string, unknown> = { updatedAt: new Date() };
+      if (body.name !== undefined) updates["name"] = body.name;
+      if (body.config !== undefined) updates["config"] = body.config;
+
+      const [updated] = await db
+        .update(wallet)
+        .set(updates)
+        .where(and(eq(wallet.id, walletId), eq(wallet.tenantId, tenantCtx.id)))
+        .returning();
+
+      if (!updated) {
+        return c.json(
+          { error: { code: "not_found", message: "Wallet not found" } },
+          404,
+        );
+      }
+
+      return c.json(formatWallet(updated));
+    },
+  );
+
+  app.delete(
+    "/:walletId",
+    requireGrant(idResource("wallet", "walletId"), "manage"),
+    describeRoute({
+      tags: ["Wallets"],
+      summary: "Deactivate a wallet",
+      responses: {
+        204: {
+          description: "Wallet deactivated",
+        },
+        404: {
+          description: "Wallet not found",
+          content: {
+            "application/json": { schema: resolver(ErrorResponse) },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      const tenantCtx = c.get("tenant");
+      const walletId = c.req.param("walletId");
+
+      const deleted = await db
+        .delete(wallet)
+        .where(and(eq(wallet.id, walletId), eq(wallet.tenantId, tenantCtx.id)))
+        .returning();
+
+      if (deleted.length === 0) {
+        return c.json(
+          { error: { code: "not_found", message: "Wallet not found" } },
+          404,
+        );
+      }
+
+      return c.body(null, 204);
+    },
+  );
+
+  app.get(
+    "/:walletId/transactions",
+    requireGrant(idResource("wallet", "walletId"), "read"),
+    describeRoute({
+      tags: ["Wallets"],
+      summary: "List transactions",
+      description:
+        "Transaction history for a wallet. Filterable by agent, date range, and status.",
+      parameters: [
+        { name: "agentId", in: "query", schema: { type: "string" } },
+        { name: "startTime", in: "query", schema: { type: "string" } },
+        { name: "endTime", in: "query", schema: { type: "string" } },
+        {
+          name: "status",
+          in: "query",
+          schema: { type: "string", enum: ["pending", "completed", "failed"] },
+        },
+        ...pageParameters,
+      ],
+      responses: {
+        200: {
+          description: "List of transactions",
+          content: {
+            "application/json": {
+              schema: resolver(paginatedSchema(TransactionResponse)),
+            },
+          },
+        },
+      },
+    }),
+    async (c) => {
+      const tenantCtx = c.get("tenant");
+      const walletId = c.req.param("walletId");
+
+      const walletRow = await db.query.wallet.findFirst({
+        where: and(eq(wallet.id, walletId), eq(wallet.tenantId, tenantCtx.id)),
+      });
+
+      if (!walletRow) {
+        return c.json(
+          { error: { code: "not_found", message: "Wallet not found" } },
+          404,
+        );
+      }
+
+      const agentId = c.req.query("agentId");
+      const status = c.req.query("status");
+      const { limit, cursor } = parsePageParams({
+        cursor: c.req.query("cursor"),
+        limit: c.req.query("limit"),
+      });
+
+      const conditions = [eq(transaction.walletId, walletId)];
+      if (agentId) conditions.push(eq(transaction.agentId, agentId));
+      if (
+        status === "pending" ||
+        status === "completed" ||
+        status === "failed"
+      ) {
+        conditions.push(eq(transaction.status, status));
+      }
+      if (cursor) {
+        conditions.push(
+          cursorCondition(transaction.createdAt, transaction.id, cursor),
+        );
+      }
+
+      const rows = await db.query.transaction.findMany({
+        where: and(...conditions),
+        orderBy: pageOrder(transaction.createdAt, transaction.id),
+        limit,
+      });
+
+      return c.json(
+        paginatedResponse(rows.map(formatTransaction), rows, limit),
+      );
+    },
+  );
+
+  return app;
+}

package/src/session.ts

@@ -0,0 +1,44 @@
+// Hub-owned session contract.
+//
+// SessionUser and SessionInfo mirror the structural shape that better-auth
+// currently returns (see @better-auth/core/dist/db/schema/{user,session}),
+// but the hub does not reference Auth["$Infer"]. This breaks the type-level
+// dependency on better-auth so a third-party identity provider can be
+// plugged in by satisfying the GetSession contract.
+//
+// The shapes are kept intentionally hand-written: deriving with Pick<>
+// against the better-auth types would re-introduce the type dependency.
+// The trade-off is that a field added upstream in better-auth would not
+// surface here automatically.
+//
+// The optional `?: T | null | undefined` shape (rather than `?: T | null`)
+// is deliberate. Under exactOptionalPropertyTypes, the latter rejects an
+// explicit `undefined` assignment, but the inferred return of
+// z.string().nullish() in better-auth's user/session schemas is
+// `string | null | undefined`. Without the trailing `| undefined`, the
+// adapter in apps/hub cannot pass the result through structurally.
+
+export type SessionUser = {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  email: string;
+  emailVerified: boolean;
+  name: string;
+  image?: string | null | undefined;
+};
+
+export type SessionInfo = {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  userId: string;
+  expiresAt: Date;
+  token: string;
+  ipAddress?: string | null | undefined;
+  userAgent?: string | null | undefined;
+};
+
+export type GetSession = (
+  headers: Headers,
+) => Promise<{ user: SessionUser; session: SessionInfo } | null>;