@aprovan/chat-backend 0.1.0-dev.99f9769 → 0.1.0-dev.9c336a0

package/src/routes/vfs.ts

@@ -0,0 +1,369 @@
+import { ConditionalCheckFailedException, DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import {
+  DynamoDBDocumentClient,
+  DeleteCommand,
+  GetCommand,
+  QueryCommand,
+  UpdateCommand,
+} from "@aws-sdk/lib-dynamodb";
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import { Hono } from "hono";
+import type { AppVariables } from "../types.js";
+
+export interface VfsChangeEntry {
+  path: string;
+  mtime: string;
+  version: number;
+  size: number;
+}
+
+interface VfsDdbItem {
+  PK: string;
+  SK: string;
+  s3Key: string;
+  size: number;
+  mtime: string;
+  etag?: string;
+  contentHash?: string;
+  version: number;
+}
+
+let ddbClient: DynamoDBDocumentClient | null = null;
+let s3Client: S3Client | null = null;
+
+function getDdb() {
+  if (!ddbClient) {
+    ddbClient = DynamoDBDocumentClient.from(
+      new DynamoDBClient({ region: process.env["AWS_REGION"] }),
+    );
+  }
+  return ddbClient;
+}
+
+function getS3() {
+  if (!s3Client) {
+    s3Client = new S3Client({ region: process.env["AWS_REGION"] });
+  }
+  return s3Client;
+}
+
+function vfsTableName(): string | undefined {
+  return process.env["VFS_TABLE_NAME"];
+}
+
+function vfsBucketName(): string | undefined {
+  return process.env["VFS_BUCKET_NAME"];
+}
+
+function pk(wsId: string) {
+  return `workspace#${wsId}`;
+}
+
+function sk(filePath: string) {
+  return `file#${filePath}`;
+}
+
+function s3Key(wsId: string, filePath: string) {
+  return `${wsId}/${filePath}`;
+}
+
+export const vfsRoute = new Hono<{ Variables: AppVariables }>();
+
+/** GET /vfs/config — parity endpoint; tells the client to use path-based addressing. */
+vfsRoute.get("/config", (c) => {
+  return c.json({ usePaths: true });
+});
+
+/**
+ * GET /vfs?since=<RFC3339>
+ *
+ * Returns a list of workspace files whose mtime is strictly after :since.
+ * The workspace is resolved from the caller's session — the URL carries no wsId.
+ *
+ * If VFS_TABLE_NAME is not set (infra not yet deployed) returns [] so the
+ * polling client degrades gracefully.
+ */
+vfsRoute.get("/", async (c) => {
+  const since = c.req.query("since");
+  if (!since) {
+    return c.json({ error: "since query parameter is required" }, 400);
+  }
+
+  const sinceDate = new Date(since);
+  if (isNaN(sinceDate.getTime())) {
+    return c.json({ error: "since must be a valid RFC3339 timestamp" }, 400);
+  }
+
+  const tableName = vfsTableName();
+  if (!tableName) {
+    return c.json([] as VfsChangeEntry[]);
+  }
+
+  const workspaceId = c.get("workspaceId");
+
+  const result = await getDdb().send(
+    new QueryCommand({
+      TableName: tableName,
+      KeyConditionExpression: "PK = :pk",
+      FilterExpression: "#mtime > :since",
+      ExpressionAttributeNames: { "#mtime": "mtime" },
+      ExpressionAttributeValues: {
+        ":pk": pk(workspaceId),
+        ":since": sinceDate.toISOString(),
+      },
+    }),
+  );
+
+  const items = (result.Items ?? []) as VfsDdbItem[];
+  const changes: VfsChangeEntry[] = items.map((item) => ({
+    path: item.SK.replace(/^file#/, ""),
+    mtime: item.mtime,
+    version: item.version ?? 0,
+    size: item.size ?? 0,
+  }));
+
+  return c.json(changes);
+});
+
+/**
+ * HEAD /vfs/:path — check existence. 200 if exists, 404 if not.
+ * GET  /vfs/:path — read file, stat, or readdir (query param selects behaviour).
+ *
+ * HEAD is merged into GET because Hono auto-routes HEAD to the matching GET
+ * handler before checking explicit HEAD registrations.
+ */
+vfsRoute.on(["GET", "HEAD"], "/:path{.+}", async (c) => {
+  const isHead = c.req.method === "HEAD";
+  const filePath = c.req.param("path");
+  const workspaceId = c.get("workspaceId");
+  const tableName = vfsTableName();
+  const bucketName = vfsBucketName();
+
+  // --- HEAD: existence check ---
+  if (isHead) {
+    if (!tableName) return c.body(null, 404);
+    const result = await getDdb().send(
+      new GetCommand({
+        TableName: tableName,
+        Key: { PK: pk(workspaceId), SK: sk(filePath) },
+        ProjectionExpression: "SK",
+      }),
+    );
+    return result.Item ? c.body(null, 200) : c.body(null, 404);
+  }
+
+  if (!tableName) {
+    return c.json({ error: "VFS not configured" }, 503);
+  }
+
+  // --- stat ---
+  if (c.req.query("stat") === "true") {
+    const result = await getDdb().send(
+      new GetCommand({
+        TableName: tableName,
+        Key: { PK: pk(workspaceId), SK: sk(filePath) },
+        ProjectionExpression: "#sz, #mt, version",
+        ExpressionAttributeNames: { "#sz": "size", "#mt": "mtime" },
+      }),
+    );
+    if (!result.Item) return c.json({ error: "ENOENT" }, 404);
+    const item = result.Item as Pick<VfsDdbItem, "size" | "mtime" | "version">;
+    return c.json({
+      size: item.size,
+      mtime: item.mtime,
+      isFile: true,
+      isDirectory: false,
+    });
+  }
+
+  // --- readdir ---
+  if (c.req.query("readdir") === "true") {
+    const prefix = filePath ? `file#${filePath}/` : "file#";
+    const result = await getDdb().send(
+      new QueryCommand({
+        TableName: tableName,
+        KeyConditionExpression: "PK = :pk AND begins_with(SK, :prefix)",
+        ExpressionAttributeValues: {
+          ":pk": pk(workspaceId),
+          ":prefix": prefix,
+        },
+        ProjectionExpression: "SK",
+      }),
+    );
+
+    const items = (result.Items ?? []) as Array<{ SK: string }>;
+    const seen = new Map<string, boolean>();
+
+    for (const item of items) {
+      const relativePath = item.SK.slice(prefix.length);
+      const slashIdx = relativePath.indexOf("/");
+      if (slashIdx === -1) {
+        seen.set(relativePath, false);
+      } else {
+        const dirName = relativePath.slice(0, slashIdx);
+        if (!seen.has(dirName)) {
+          seen.set(dirName, true);
+        }
+      }
+    }
+
+    const entries = Array.from(seen.entries()).map(([name, isDirectory]) => ({
+      name,
+      isDirectory,
+    }));
+
+    return c.json(entries);
+  }
+
+  // --- read file ---
+  if (!bucketName) {
+    return c.json({ error: "VFS storage not configured" }, 503);
+  }
+
+  const fileKey = s3Key(workspaceId, filePath);
+  try {
+    const obj = await getS3().send(
+      new GetObjectCommand({ Bucket: bucketName, Key: fileKey }),
+    );
+    const body = await obj.Body?.transformToString("utf-8");
+    if (body === undefined) return c.json({ error: "ENOENT" }, 404);
+    return c.text(body, 200);
+  } catch (err: unknown) {
+    const code = (err as { name?: string }).name;
+    if (code === "NoSuchKey" || code === "NotFound") {
+      return c.json({ error: "ENOENT" }, 404);
+    }
+    throw err;
+  }
+});
+
+/**
+ * PUT /vfs/:path — write file.
+ *
+ * Optionally accepts `X-Vfs-Expected-Version` header for optimistic concurrency.
+ * Returns {ok: true, version: <new>} or {ok: false, conflict: {serverVersion, serverEtag}}.
+ */
+vfsRoute.put("/:path{.+}", async (c) => {
+  const tableName = vfsTableName();
+  const bucketName = vfsBucketName();
+  if (!tableName || !bucketName) {
+    return c.json({ error: "VFS not configured" }, 503);
+  }
+
+  const filePath = c.req.param("path");
+  const workspaceId = c.get("workspaceId");
+  const content = await c.req.text();
+  const expectedVersionHeader = c.req.header("X-Vfs-Expected-Version");
+  const expectedVersion = expectedVersionHeader !== undefined
+    ? parseInt(expectedVersionHeader, 10)
+    : undefined;
+
+  const fileKey = s3Key(workspaceId, filePath);
+  const now = new Date().toISOString();
+  const byteSize = new TextEncoder().encode(content).length;
+
+  await getS3().send(
+    new PutObjectCommand({
+      Bucket: bucketName,
+      Key: fileKey,
+      Body: content,
+      ContentType: "text/plain; charset=utf-8",
+    }),
+  );
+
+  try {
+    const condExpr =
+      expectedVersion !== undefined
+        ? "attribute_not_exists(PK) OR version = :expected"
+        : undefined;
+
+    const exprAttrValues: Record<string, unknown> = {
+      ":mtime": now,
+      ":sz": byteSize,
+      ":s3Key": fileKey,
+      ":inc": 1,
+      ":zero": 0,
+    };
+    if (expectedVersion !== undefined) {
+      exprAttrValues[":expected"] = expectedVersion;
+    }
+
+    const result = await getDdb().send(
+      new UpdateCommand({
+        TableName: tableName,
+        Key: { PK: pk(workspaceId), SK: sk(filePath) },
+        UpdateExpression:
+          "SET #mt = :mtime, #sz = :sz, s3Key = :s3Key, version = if_not_exists(version, :zero) + :inc",
+        ExpressionAttributeNames: { "#mt": "mtime", "#sz": "size" },
+        ExpressionAttributeValues: exprAttrValues,
+        ...(condExpr ? { ConditionExpression: condExpr } : {}),
+        ReturnValues: "ALL_NEW",
+      }),
+    );
+
+    const newVersion = (result.Attributes as VfsDdbItem | undefined)?.version ?? 1;
+    return c.json({ ok: true, version: newVersion });
+  } catch (err: unknown) {
+    if (err instanceof ConditionalCheckFailedException) {
+      const metaResult = await getDdb().send(
+        new GetCommand({
+          TableName: tableName,
+          Key: { PK: pk(workspaceId), SK: sk(filePath) },
+          ProjectionExpression: "version, etag",
+        }),
+      );
+      const item = metaResult.Item as Pick<VfsDdbItem, "version" | "etag"> | undefined;
+      return c.json(
+        {
+          ok: false,
+          conflict: {
+            serverVersion: item?.version ?? 0,
+            serverEtag: item?.etag,
+          },
+        },
+        409,
+      );
+    }
+    throw err;
+  }
+});
+
+/** DELETE /vfs/:path — remove from S3 + DDB. */
+vfsRoute.delete("/:path{.+}", async (c) => {
+  const tableName = vfsTableName();
+  const bucketName = vfsBucketName();
+  if (!tableName || !bucketName) {
+    return c.json({ error: "VFS not configured" }, 503);
+  }
+
+  const filePath = c.req.param("path");
+  const workspaceId = c.get("workspaceId");
+  const fileKey = s3Key(workspaceId, filePath);
+
+  await Promise.all([
+    getDdb().send(
+      new DeleteCommand({
+        TableName: tableName,
+        Key: { PK: pk(workspaceId), SK: sk(filePath) },
+      }),
+    ),
+    getS3().send(
+      new DeleteObjectCommand({ Bucket: bucketName, Key: fileKey }),
+    ),
+  ]);
+
+  return c.body(null, 204);
+});
+
+/** POST /vfs/:path?mkdir=true — no-op (S3 is keyless). */
+vfsRoute.post("/:path{.+}", (c) => {
+  if (c.req.query("mkdir") === "true") {
+    return c.body(null, 204);
+  }
+  return c.json({ error: "unsupported operation" }, 400);
+});

package/src/routes/workspace.ts

@@ -0,0 +1,41 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, UpdateCommand } from "@aws-sdk/lib-dynamodb";
+import { Hono } from "hono";
+import { evictWorkspaceCache } from "../middleware/workspace.js";
+import type { AppVariables } from "../types.js";
+
+let ddbClient: DynamoDBDocumentClient | null = null;
+
+function getDdb() {
+  if (!ddbClient) {
+    ddbClient = DynamoDBDocumentClient.from(
+      new DynamoDBClient({ region: process.env["AWS_REGION"] }),
+    );
+  }
+  return ddbClient;
+}
+
+export const workspaceRoute = new Hono<{ Variables: AppVariables }>();
+
+/** POST /api/workspace — switch the caller's active workspace. */
+workspaceRoute.post("/", async (c) => {
+  const claims = c.get("claims");
+  const body = await c.req.json<{ workspaceId?: string }>();
+  const workspaceId = body?.workspaceId;
+  if (!workspaceId || typeof workspaceId !== "string") {
+    return c.json({ error: "workspaceId is required" }, 400);
+  }
+
+  await getDdb().send(
+    new UpdateCommand({
+      TableName: process.env["USERS_TABLE_NAME"]!,
+      Key: { sub: claims.sub },
+      UpdateExpression: "SET activeWorkspaceId = :ws",
+      ExpressionAttributeValues: { ":ws": workspaceId },
+    }),
+  );
+
+  evictWorkspaceCache(claims.sub);
+
+  return c.json({ activeWorkspaceId: workspaceId });
+});

package/src/routes/workspaces.ts

@@ -0,0 +1,89 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { BatchGetCommand, DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { listWorkspaceMemberships } from "../middleware/workspace.js";
+import { getSessionWorkspaceId, setSessionWorkspaceId } from "../session.js";
+import type { AppVariables, WorkspaceItem } from "../types.js";
+
+let ddbClient: DynamoDBDocumentClient | null = null;
+
+function getDdb() {
+  if (!ddbClient) {
+    ddbClient = DynamoDBDocumentClient.from(
+      new DynamoDBClient({ region: process.env["AWS_REGION"] }),
+    );
+  }
+  return ddbClient;
+}
+
+async function batchGetWorkspaces(
+  workspaceIds: string[],
+): Promise<WorkspaceItem[]> {
+  if (workspaceIds.length === 0) return [];
+  const tableName = process.env["WORKSPACE_TABLE_NAME"]!;
+  const result = await getDdb().send(
+    new BatchGetCommand({
+      RequestItems: {
+        [tableName]: { Keys: workspaceIds.map((id) => ({ workspaceId: id })) },
+      },
+    }),
+  );
+  return (result.Responses?.[tableName] ?? []) as WorkspaceItem[];
+}
+
+export const workspacesRoute = new Hono<{ Variables: AppVariables }>();
+
+workspacesRoute.get("/", async (c) => {
+  const claims = c.get("claims");
+  const userSub = claims.sub;
+
+  const [workspaceIds, activeWorkspaceId] = await Promise.all([
+    listWorkspaceMemberships(userSub),
+    getSessionWorkspaceId(userSub),
+  ]);
+
+  const workspaces = await batchGetWorkspaces(workspaceIds);
+
+  const effectiveActiveId =
+    activeWorkspaceId && workspaceIds.includes(activeWorkspaceId)
+      ? activeWorkspaceId
+      : (workspaceIds[0] ?? null);
+
+  const sorted = workspaceIds
+    .map((id) => workspaces.find((w) => w.workspaceId === id))
+    .filter((w): w is WorkspaceItem => w !== undefined);
+
+  return c.json({
+    workspaces: sorted.map((w) => ({
+      workspaceId: w.workspaceId,
+      name: w.name,
+      plan: w.plan,
+      active: w.workspaceId === effectiveActiveId,
+    })),
+    activeWorkspaceId: effectiveActiveId,
+  });
+});
+
+const setActiveSchema = z.object({
+  workspaceId: z.string().min(1),
+});
+
+workspacesRoute.put(
+  "/active",
+  zValidator("json", setActiveSchema),
+  async (c) => {
+    const claims = c.get("claims");
+    const userSub = claims.sub;
+    const { workspaceId } = c.req.valid("json");
+
+    const workspaceIds = await listWorkspaceMemberships(userSub);
+    if (!workspaceIds.includes(workspaceId)) {
+      return c.json({ error: "Not a member of this workspace" }, 403);
+    }
+
+    await setSessionWorkspaceId(userSub, workspaceId);
+    return c.json({ activeWorkspaceId: workspaceId });
+  },
+);

package/src/session.ts

@@ -0,0 +1,80 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import {
+  DynamoDBDocumentClient,
+  GetCommand,
+  PutCommand,
+} from "@aws-sdk/lib-dynamodb";
+
+const SESSION_CACHE_TTL_MS = 15_000;
+
+interface SessionCacheEntry {
+  activeWorkspaceId: string | null;
+  fetchedAt: number;
+}
+
+const sessionCache = new Map<string, SessionCacheEntry>();
+
+let ddbClient: DynamoDBDocumentClient | null = null;
+
+function getDdb() {
+  if (!ddbClient) {
+    ddbClient = DynamoDBDocumentClient.from(
+      new DynamoDBClient({ region: process.env["AWS_REGION"] }),
+    );
+  }
+  return ddbClient;
+}
+
+function tableName(): string {
+  return process.env["USER_SESSIONS_TABLE_NAME"]!;
+}
+
+export async function getSessionWorkspaceId(
+  userSub: string,
+): Promise<string | null> {
+  const now = Date.now();
+  const cached = sessionCache.get(userSub);
+  if (cached && now - cached.fetchedAt < SESSION_CACHE_TTL_MS) {
+    return cached.activeWorkspaceId;
+  }
+
+  const result = await getDdb().send(
+    new GetCommand({
+      TableName: tableName(),
+      Key: { userSub },
+    }),
+  );
+
+  const activeWorkspaceId =
+    (result.Item?.activeWorkspaceId as string | undefined) ?? null;
+  sessionCache.set(userSub, { activeWorkspaceId, fetchedAt: now });
+  return activeWorkspaceId;
+}
+
+export async function setSessionWorkspaceId(
+  userSub: string,
+  workspaceId: string,
+): Promise<void> {
+  await getDdb().send(
+    new PutCommand({
+      TableName: tableName(),
+      Item: {
+        userSub,
+        activeWorkspaceId: workspaceId,
+        updatedAt: new Date().toISOString(),
+      },
+    }),
+  );
+  sessionCache.set(userSub, {
+    activeWorkspaceId: workspaceId,
+    fetchedAt: Date.now(),
+  });
+}
+
+export function clearSessionCache(userSub: string): void {
+  sessionCache.delete(userSub);
+}
+
+export function resetSessionCache(): void {
+  sessionCache.clear();
+}

package/test/app.test.ts

@@ -20,6 +20,7 @@ vi.mock("@aws-sdk/lib-dynamodb", () => ({
   },
   QueryCommand: vi.fn((input) => input),
   GetCommand: vi.fn((input) => input),
+  UpdateCommand: vi.fn((input) => input),
 }));
 
 beforeAll(() => {
@@ -28,6 +29,7 @@ beforeAll(() => {
   process.env["AWS_REGION"] = "us-east-1";
   process.env["WORKSPACE_TABLE_NAME"] = "test-workspaces";
   process.env["MEMBERSHIPS_TABLE_NAME"] = "test-memberships";
+  process.env["USERS_TABLE_NAME"] = "test-users";
 });
 
 describe("chat app", () => {