@aprovan/chat-backend 0.1.0-dev.4d82df8

package/test/routes/proxy.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect, vi, beforeAll, beforeEach, afterEach } from "vitest";
+import { createChatApp } from "../../src/app";
+import { resetGatewaySessionCache } from "../../src/gateway-session";
+
+// ── Global fetch stub ─────────────────────────────────────────────────────────
+
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+
+// ── Middleware mocks ──────────────────────────────────────────────────────────
+
+vi.mock("aws-jwt-verify", () => {
+  const verify = vi.fn().mockResolvedValue({
+    sub: "user-123",
+    exp: Math.floor(Date.now() / 1000) + 3600,
+    token_use: "access",
+  });
+  return { CognitoJwtVerifier: { create: vi.fn(() => ({ verify })) } };
+});
+
+vi.mock("@aws-sdk/client-dynamodb", () => ({
+  DynamoDBClient: vi.fn(() => ({})),
+}));
+
+const mockSend = vi.fn();
+vi.mock("@aws-sdk/lib-dynamodb", () => ({
+  DynamoDBDocumentClient: { from: vi.fn(() => ({ send: mockSend })) },
+  QueryCommand: vi.fn((i) => i),
+  GetCommand: vi.fn((i) => i),
+}));
+
+// ── Environment + DDB setup ───────────────────────────────────────────────────
+
+beforeAll(() => {
+  process.env["COGNITO_USER_POOL_ID"] = "us-east-1_test";
+  process.env["COGNITO_CLIENT_ID"] = "test-client-id";
+  process.env["AWS_REGION"] = "us-east-1";
+  process.env["WORKSPACE_TABLE_NAME"] = "test-workspaces";
+  process.env["MEMBERSHIPS_TABLE_NAME"] = "test-memberships";
+  process.env["GATEWAY_URL"] = "https://gateway.test";
+  process.env["OPENROUTER_API_KEY"] = "test-key";
+});
+
+beforeEach(() => {
+  mockFetch.mockReset();
+  resetGatewaySessionCache();
+
+  mockSend.mockImplementation((cmd: { IndexName?: string }) => {
+    if (cmd.IndexName === "ByUserSub") {
+      return Promise.resolve({ Items: [{ workspaceId: "ws-test" }] });
+    }
+    return Promise.resolve({
+      Item: {
+        workspaceId: "ws-test",
+        plan: "pro",
+        limits: {},
+        features: {},
+        createdAt: "",
+        updatedAt: "",
+      },
+    });
+  });
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+  resetGatewaySessionCache();
+});
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("POST /api/proxy/:ns/:proc", () => {
+  it("forwards body and session token to the gateway and returns the response", async () => {
+    const app = createChatApp();
+    const expectedResult = { data: [{ id: "repo-1" }], meta: { requestId: "r1" } };
+
+    mockFetch
+      // POST /auth/sessions
+      .mockResolvedValueOnce(new Response(JSON.stringify({ workspace_id: "ws-test" }), { status: 200 }))
+      // POST /tools/github/repos.list
+      .mockResolvedValueOnce(new Response(JSON.stringify(expectedResult), { status: 200 }));
+
+    const res = await app.request("/api/proxy/github/repos.list", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer cognito-token",
+      },
+      body: JSON.stringify({ per_page: 10 }),
+    });
+
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual(expectedResult);
+
+    // Verify the gateway call used the session bearer and forwarded the body
+    const toolCall = mockFetch.mock.calls.find(
+      (c) => typeof c[0] === "string" && (c[0] as string).includes("/tools/github/repos.list"),
+    );
+    expect(toolCall).toBeDefined();
+    const toolCallOptions = toolCall![1] as RequestInit;
+    expect((toolCallOptions.headers as Record<string, string>)["Authorization"]).toBe(
+      "Bearer cognito-token",
+    );
+    expect(JSON.parse(toolCallOptions.body as string)).toEqual({ per_page: 10 });
+  });
+
+  it("returns 401 without Authorization header", async () => {
+    const app = createChatApp();
+    const res = await app.request("/api/proxy/github/repos.list", { method: "POST" });
+    expect(res.status).toBe(401);
+  });
+
+  it("forwards the gateway error status when gateway returns non-2xx", async () => {
+    const app = createChatApp();
+
+    mockFetch
+      .mockResolvedValueOnce(new Response(JSON.stringify({ workspace_id: "ws-test" }), { status: 200 }))
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify({ error: "Forbidden" }), { status: 403 }),
+      );
+
+    const res = await app.request("/api/proxy/github/repos.list", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer cognito-token",
+      },
+    });
+
+    expect(res.status).toBe(403);
+  });
+});

package/test/routes/services.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect, vi, beforeAll, beforeEach, afterEach } from "vitest";
+import { createChatApp } from "../../src/app";
+import { resetGatewaySessionCache } from "../../src/gateway-session";
+
+// ── Global fetch stub ─────────────────────────────────────────────────────────
+
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+
+// ── Middleware mocks ──────────────────────────────────────────────────────────
+
+vi.mock("aws-jwt-verify", () => {
+  const verify = vi.fn().mockResolvedValue({
+    sub: "user-123",
+    exp: Math.floor(Date.now() / 1000) + 3600,
+    token_use: "access",
+  });
+  return { CognitoJwtVerifier: { create: vi.fn(() => ({ verify })) } };
+});
+
+vi.mock("@aws-sdk/client-dynamodb", () => ({
+  DynamoDBClient: vi.fn(() => ({})),
+}));
+
+const mockSend = vi.fn();
+vi.mock("@aws-sdk/lib-dynamodb", () => ({
+  DynamoDBDocumentClient: { from: vi.fn(() => ({ send: mockSend })) },
+  QueryCommand: vi.fn((i) => i),
+  GetCommand: vi.fn((i) => i),
+}));
+
+// ── Environment + DDB setup ───────────────────────────────────────────────────
+
+beforeAll(() => {
+  process.env["COGNITO_USER_POOL_ID"] = "us-east-1_test";
+  process.env["COGNITO_CLIENT_ID"] = "test-client-id";
+  process.env["AWS_REGION"] = "us-east-1";
+  process.env["WORKSPACE_TABLE_NAME"] = "test-workspaces";
+  process.env["MEMBERSHIPS_TABLE_NAME"] = "test-memberships";
+  process.env["GATEWAY_URL"] = "https://gateway.test";
+  process.env["OPENROUTER_API_KEY"] = "test-key";
+});
+
+beforeEach(() => {
+  mockFetch.mockReset();
+  resetGatewaySessionCache();
+
+  mockSend.mockImplementation((cmd: { IndexName?: string }) => {
+    if (cmd.IndexName === "ByUserSub") {
+      return Promise.resolve({ Items: [{ workspaceId: "ws-test" }] });
+    }
+    return Promise.resolve({
+      Item: {
+        workspaceId: "ws-test",
+        plan: "pro",
+        limits: {},
+        features: {},
+        createdAt: "",
+        updatedAt: "",
+      },
+    });
+  });
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+  resetGatewaySessionCache();
+});
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("GET /api/services", () => {
+  it("returns namespaces and services from the gateway", async () => {
+    const app = createChatApp();
+
+    mockFetch
+      // POST /auth/sessions
+      .mockResolvedValueOnce(new Response(JSON.stringify({ workspace_id: "ws-test" }), { status: 200 }))
+      // GET /tools
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            tools: [
+              {
+                provider: "github",
+                name: "github.repos_list",
+                operation: "repos_list",
+                description: "List repos",
+                inputSchema: { type: "object", properties: { per_page: { type: "number" } } },
+              },
+            ],
+            workspace_id: "ws-test",
+          }),
+          { status: 200 },
+        ),
+      );
+
+    const res = await app.request("/api/services", {
+      headers: { Authorization: "Bearer test-token" },
+    });
+
+    expect(res.status).toBe(200);
+    const body = await res.json() as { namespaces: string[]; services: unknown[] };
+    expect(body.namespaces).toContain("github");
+    expect(body.services).toHaveLength(1);
+    expect((body.services[0] as { namespace: string }).namespace).toBe("github");
+  });
+
+  it("returns 502 when gateway tools fetch fails", async () => {
+    const app = createChatApp();
+
+    mockFetch
+      .mockResolvedValueOnce(new Response(JSON.stringify({ workspace_id: "ws-test" }), { status: 200 }))
+      .mockResolvedValueOnce(new Response("Internal error", { status: 500 }));
+
+    const res = await app.request("/api/services", {
+      headers: { Authorization: "Bearer test-token" },
+    });
+
+    expect(res.status).toBe(502);
+  });
+
+  it("returns 401 without Authorization header", async () => {
+    const app = createChatApp();
+    const res = await app.request("/api/services");
+    expect(res.status).toBe(401);
+  });
+});

package/test/routes/workspaces.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Hono } from "hono";
+import type { AppVariables } from "../../src/types";
+import type { CognitoAccessTokenPayload } from "aws-jwt-verify/jwt-model";
+
+vi.mock("@aws-sdk/client-dynamodb", () => ({
+  DynamoDBClient: vi.fn(() => ({})),
+}));
+
+const mockSend = vi.fn();
+vi.mock("@aws-sdk/lib-dynamodb", () => ({
+  DynamoDBDocumentClient: {
+    from: vi.fn(() => ({ send: mockSend })),
+  },
+  QueryCommand: vi.fn((input) => input),
+  GetCommand: vi.fn((input) => input),
+  PutCommand: vi.fn((input) => input),
+  BatchGetCommand: vi.fn((input) => input),
+}));
+
+const { workspacesRoute } = await import("../../src/routes/workspaces");
+const { resetMembershipCache } = await import("../../src/middleware/workspace");
+const { resetSessionCache } = await import("../../src/session");
+
+const MEMBERSHIPS_TABLE = "test-memberships";
+const WORKSPACE_TABLE = "test-workspaces";
+const SESSIONS_TABLE = "test-user-sessions";
+
+type MockCommand = { TableName?: string; RequestItems?: Record<string, unknown> };
+
+const fakeClaims = { sub: "user-ws-test" } as unknown as CognitoAccessTokenPayload;
+
+function buildApp() {
+  const app = new Hono<{ Variables: AppVariables }>();
+  app.use("/*", async (c, next) => {
+    c.set("claims", fakeClaims);
+    await next();
+  });
+  app.route("/workspaces", workspacesRoute);
+  return app;
+}
+
+describe("GET /workspaces", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetMembershipCache();
+    resetSessionCache();
+    process.env["MEMBERSHIPS_TABLE_NAME"] = MEMBERSHIPS_TABLE;
+    process.env["WORKSPACE_TABLE_NAME"] = WORKSPACE_TABLE;
+    process.env["USER_SESSIONS_TABLE_NAME"] = SESSIONS_TABLE;
+    process.env["AWS_REGION"] = "us-east-1";
+  });
+
+  it("returns workspace list with active flag", async () => {
+    mockSend.mockImplementation((cmd: MockCommand) => {
+      if (cmd.TableName === SESSIONS_TABLE) {
+        return Promise.resolve({ Item: { activeWorkspaceId: "ws-b" } });
+      }
+      if (cmd.TableName === MEMBERSHIPS_TABLE) {
+        return Promise.resolve({ Items: [{ workspaceId: "ws-a" }, { workspaceId: "ws-b" }] });
+      }
+      if (cmd.RequestItems?.[WORKSPACE_TABLE]) {
+        return Promise.resolve({
+          Responses: {
+            [WORKSPACE_TABLE]: [
+              { workspaceId: "ws-a", name: "Alpha", plan: "free" },
+              { workspaceId: "ws-b", name: "Beta", plan: "pro" },
+            ],
+          },
+        });
+      }
+      return Promise.resolve({});
+    });
+
+    const app = buildApp();
+    const res = await app.request("/workspaces");
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.activeWorkspaceId).toBe("ws-b");
+    const beta = body.workspaces.find((w: { workspaceId: string }) => w.workspaceId === "ws-b");
+    expect(beta?.active).toBe(true);
+  });
+
+  it("falls back to first membership when no session preference", async () => {
+    mockSend.mockImplementation((cmd: MockCommand) => {
+      if (cmd.TableName === SESSIONS_TABLE) {
+        return Promise.resolve({ Item: undefined });
+      }
+      if (cmd.TableName === MEMBERSHIPS_TABLE) {
+        return Promise.resolve({ Items: [{ workspaceId: "ws-a" }] });
+      }
+      if (cmd.RequestItems?.[WORKSPACE_TABLE]) {
+        return Promise.resolve({
+          Responses: { [WORKSPACE_TABLE]: [{ workspaceId: "ws-a", name: "Alpha", plan: "free" }] },
+        });
+      }
+      return Promise.resolve({});
+    });
+
+    const app = buildApp();
+    const res = await app.request("/workspaces");
+    const body = await res.json();
+    expect(body.activeWorkspaceId).toBe("ws-a");
+    expect(body.workspaces[0].active).toBe(true);
+  });
+});
+
+describe("PUT /workspaces/active", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetMembershipCache();
+    resetSessionCache();
+    process.env["MEMBERSHIPS_TABLE_NAME"] = MEMBERSHIPS_TABLE;
+    process.env["WORKSPACE_TABLE_NAME"] = WORKSPACE_TABLE;
+    process.env["USER_SESSIONS_TABLE_NAME"] = SESSIONS_TABLE;
+    process.env["AWS_REGION"] = "us-east-1";
+  });
+
+  it("sets active workspace and returns it", async () => {
+    mockSend.mockImplementation((cmd: MockCommand) => {
+      if (cmd.TableName === MEMBERSHIPS_TABLE) {
+        return Promise.resolve({ Items: [{ workspaceId: "ws-a" }, { workspaceId: "ws-b" }] });
+      }
+      return Promise.resolve({});
+    });
+
+    const app = buildApp();
+    const res = await app.request("/workspaces/active", {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ workspaceId: "ws-b" }),
+    });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.activeWorkspaceId).toBe("ws-b");
+  });
+
+  it("returns 403 when workspace is not in user memberships", async () => {
+    mockSend.mockImplementation((cmd: MockCommand) => {
+      if (cmd.TableName === MEMBERSHIPS_TABLE) {
+        return Promise.resolve({ Items: [{ workspaceId: "ws-a" }] });
+      }
+      return Promise.resolve({});
+    });
+
+    const app = buildApp();
+    const res = await app.request("/workspaces/active", {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ workspaceId: "ws-other" }),
+    });
+    expect(res.status).toBe(403);
+  });
+
+  it("returns 400 for invalid request body", async () => {
+    const app = buildApp();
+    const res = await app.request("/workspaces/active", {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ workspaceId: "" }),
+    });
+    expect(res.status).toBe(400);
+  });
+});

package/test/session.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@aws-sdk/client-dynamodb", () => ({
+  DynamoDBClient: vi.fn(() => ({})),
+}));
+
+const mockSend = vi.fn();
+vi.mock("@aws-sdk/lib-dynamodb", () => ({
+  DynamoDBDocumentClient: {
+    from: vi.fn(() => ({ send: mockSend })),
+  },
+  GetCommand: vi.fn((input) => input),
+  PutCommand: vi.fn((input) => input),
+}));
+
+const { getSessionWorkspaceId, setSessionWorkspaceId, resetSessionCache } =
+  await import("../src/session");
+
+describe("session", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetSessionCache();
+    process.env["USER_SESSIONS_TABLE_NAME"] = "test-user-sessions";
+    process.env["AWS_REGION"] = "us-east-1";
+  });
+
+  it("returns null when no session record exists", async () => {
+    mockSend.mockResolvedValueOnce({ Item: undefined });
+    const result = await getSessionWorkspaceId("user-abc");
+    expect(result).toBeNull();
+  });
+
+  it("returns activeWorkspaceId from session record", async () => {
+    mockSend.mockResolvedValueOnce({ Item: { userSub: "user-abc", activeWorkspaceId: "ws-xyz" } });
+    const result = await getSessionWorkspaceId("user-abc");
+    expect(result).toBe("ws-xyz");
+  });
+
+  it("caches the result and skips DDB on second call", async () => {
+    mockSend.mockResolvedValueOnce({ Item: { activeWorkspaceId: "ws-cached" } });
+    await getSessionWorkspaceId("user-cached");
+    await getSessionWorkspaceId("user-cached");
+    expect(mockSend).toHaveBeenCalledTimes(1);
+  });
+
+  it("setSessionWorkspaceId writes to DDB and updates cache", async () => {
+    mockSend.mockResolvedValueOnce({});
+    await setSessionWorkspaceId("user-set", "ws-new");
+    expect(mockSend).toHaveBeenCalledTimes(1);
+
+    // Second read should come from cache, not DDB
+    const result = await getSessionWorkspaceId("user-set");
+    expect(result).toBe("ws-new");
+    expect(mockSend).toHaveBeenCalledTimes(1);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+}

package/tsup.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+    lambda: "src/lambda.ts",
+  },
+  format: ["esm"],
+  target: "node20",
+  platform: "node",
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  splitting: false,
+  minify: false,
+  shims: true,
+});