@cosmicdrift/kumiko-bundled-features 0.1.0

package/src/tenant/__tests__/multi-tenant.integration.ts

@@ -0,0 +1,278 @@
+import { buildServer, type JwtHelper } from "@cosmicdrift/kumiko-framework/api";
+import { createTenantDb, type DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import {
+  createRegistry,
+  defineFeature,
+  type SessionUser,
+  type TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { createEventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import { createJobRunner, type JobRunner } from "@cosmicdrift/kumiko-framework/jobs";
+import {
+  createEntityTable,
+  createTestDb,
+  createTestRedis,
+  createTestUser,
+  pushTables,
+  type TestDb,
+  type TestRedis,
+  TestUsers,
+  testTenantId,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { bridgeStub, sleep } from "@cosmicdrift/kumiko-framework/testing";
+import type { Hono } from "hono";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { createConfigFeature } from "../../config/feature";
+import { createConfigResolver } from "../../config/resolver";
+import { configValuesTable } from "../../config/table";
+import { TenantHandlers, TenantQueries } from "../constants";
+import { createTenantFeature } from "../feature";
+import { tenantMembershipsTable } from "../membership-table";
+import { tenantEntity } from "../schema/tenant";
+
+// --- Track job executions ---
+
+const jobExecutions: Array<{ name: string; tenantId: TenantId }> = [];
+
+// --- Feature with perTenant job ---
+
+const billingFeature = defineFeature("billing", (r) => {
+  r.job("monthlyReport", { trigger: { manual: true }, perTenant: true }, async (_payload, ctx) => {
+    const systemUser = ctx["systemUser"] as SessionUser;
+    jobExecutions.push({ name: "billing:job:monthly-report", tenantId: systemUser.tenantId });
+  });
+});
+
+// --- Setup ---
+
+let testDb: TestDb;
+let testRedis: TestRedis;
+let db: DbConnection;
+let app: Hono;
+let jwt: JwtHelper;
+let jobRunner: JobRunner;
+
+const systemAdmin = TestUsers.systemAdmin;
+const JWT_SECRET = "multi-tenant-test-secret-minimum-32-chars!!";
+
+beforeAll(async () => {
+  testDb = await createTestDb();
+  testRedis = await createTestRedis();
+  db = testDb.db;
+
+  await createEntityTable(db, tenantEntity);
+  await pushTables(db, { tenantMembershipsTable, configValuesTable });
+  await createEventsTable(db);
+
+  const configFeature = createConfigFeature();
+  const tenantFeature = createTenantFeature();
+  const registry = createRegistry([configFeature, tenantFeature, billingFeature]);
+  const resolver = createConfigResolver();
+
+  const redisUrl = `redis://${testRedis.redis.options.host}:${testRedis.redis.options.port}/${testRedis.redis.options.db}`;
+
+  jobRunner = createJobRunner({
+    registry,
+    context: { db, registry, configResolver: resolver },
+    redisUrl,
+    consumerLane: "worker",
+    queueNamePrefix: `kumiko-multi-tenant-test-${Date.now()}`,
+    getActiveTenantIds: async () => {
+      const handler = registry.getQueryHandler(TenantQueries.activeTenantIds);
+      if (!handler) return [];
+      const result = await handler.handler(
+        {
+          type: TenantQueries.activeTenantIds,
+          payload: {},
+          user: {
+            id: "00000000-0000-0000-0000-000000000000",
+            tenantId: "00000000-0000-4000-8000-000000000000",
+            roles: ["system"],
+          },
+        },
+        {
+          db: createTenantDb(db, "00000000-0000-4000-8000-000000000000", "system"),
+          registry,
+          ...bridgeStub(),
+        },
+      );
+      return result as number[];
+    },
+  });
+
+  const context = { db, registry, configResolver: resolver, jobRunner };
+  const server = buildServer({
+    registry,
+    context,
+    jwtSecret: JWT_SECRET,
+    auth: { membershipQuery: TenantQueries.memberships },
+  });
+  app = server.app;
+  jwt = server.jwt;
+
+  await jobRunner.start();
+});
+
+afterAll(async () => {
+  await jobRunner.stop();
+  await testDb.cleanup();
+  await testRedis.cleanup();
+});
+
+// --- Helpers ---
+
+async function writeApi(user: SessionUser, type: string, payload: unknown) {
+  const token = await jwt.sign(user);
+  const res = await app.request("/api/write", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+    body: JSON.stringify({ type, payload }),
+  });
+  return res.json();
+}
+
+async function queryApi(user: SessionUser, type: string, payload: unknown) {
+  const token = await jwt.sign(user);
+  const res = await app.request("/api/query", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+    body: JSON.stringify({ type, payload }),
+  });
+  return res.json();
+}
+
+async function getApi(user: SessionUser, path: string) {
+  const token = await jwt.sign(user);
+  return app.request(`/api${path}`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${token}` },
+  });
+}
+
+async function postApi(user: SessionUser, path: string, body: unknown) {
+  const token = await jwt.sign(user);
+  return app.request(`/api${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+    body: JSON.stringify(body),
+  });
+}
+
+// --- Scenario 1+2: Create tenants and memberships, then switch ---
+
+describe("multi-tenant user", () => {
+  test("setup: create two tenants", async () => {
+    // Explicit ids so later assertions (memberships, perTenant jobs) can
+    // match against the fixed testTenantId(1/2) values the test fixtures use.
+    const r1 = await writeApi(systemAdmin, TenantHandlers.create, {
+      id: testTenantId(1),
+      key: "acme",
+      name: "ACME",
+    });
+    expect(r1.isSuccess).toBe(true);
+
+    const r2 = await writeApi(systemAdmin, TenantHandlers.create, {
+      id: testTenantId(2),
+      key: "beta",
+      name: "Beta Inc",
+    });
+    expect(r2.isSuccess).toBe(true);
+  });
+
+  test("add user to both tenants with different roles", async () => {
+    const r1 = await writeApi(systemAdmin, TenantHandlers.addMember, {
+      userId: "11111111-0000-4000-8000-000000000010",
+      tenantId: testTenantId(1),
+      roles: ["Admin"],
+    });
+    expect(r1.isSuccess).toBe(true);
+
+    const r2 = await writeApi(systemAdmin, TenantHandlers.addMember, {
+      userId: "11111111-0000-4000-8000-000000000010",
+      tenantId: testTenantId(2),
+      roles: ["Viewer"],
+    });
+    expect(r2.isSuccess).toBe(true);
+  });
+
+  test("list tenants for user shows both", async () => {
+    const result = await queryApi(systemAdmin, TenantQueries.memberships, {
+      userId: "11111111-0000-4000-8000-000000000010",
+    });
+    const memberships = result.data;
+    expect(memberships.length).toBe(2);
+
+    const tenantIds = memberships.map((m: Record<string, unknown>) => m["tenantId"]);
+    expect(tenantIds).toContain(testTenantId(1));
+    expect(tenantIds).toContain(testTenantId(2));
+  });
+
+  test("user has different roles per tenant", async () => {
+    const result = await queryApi(systemAdmin, TenantQueries.memberships, {
+      userId: "11111111-0000-4000-8000-000000000010",
+    });
+    const memberships = result.data;
+
+    const acme = memberships.find(
+      (m: Record<string, unknown>) => m["tenantId"] === testTenantId(1),
+    );
+    const beta = memberships.find(
+      (m: Record<string, unknown>) => m["tenantId"] === testTenantId(2),
+    );
+
+    expect(acme["roles"]).toEqual(["Admin"]);
+    expect(beta["roles"]).toEqual(["Viewer"]);
+  });
+
+  test("GET /auth/tenants returns tenant list", async () => {
+    const user = createTestUser({ id: 10 });
+    const res = await getApi(user, "/auth/tenants");
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.tenants.length).toBe(2);
+    expect(body.activeTenantId).toBe(testTenantId(1));
+  });
+
+  test("POST /auth/switch-tenant issues new JWT with different tenant", async () => {
+    const user = createTestUser({ id: 10 });
+    const res = await postApi(user, "/auth/switch-tenant", { tenantId: testTenantId(2) });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.tenantId).toBe(testTenantId(2));
+    expect(body.roles).toEqual(["Viewer"]);
+    expect(body.token).toBeDefined();
+  });
+
+  test("switch to non-member tenant is rejected", async () => {
+    const user = createTestUser({ id: 10 });
+    const res = await postApi(user, "/auth/switch-tenant", { tenantId: testTenantId(999) });
+    expect(res.status).toBe(403);
+  });
+});
+
+// --- Scenario 4+5: perTenant jobs ---
+
+describe("perTenant jobs", () => {
+  test("perTenant job dispatches once per active tenant", async () => {
+    jobExecutions.length = 0;
+
+    await jobRunner.dispatch("billing:job:monthly-report", {});
+    // This dispatches _perTenant:billing.monthlyReport which fans out
+    // Wait for fan-out + processing
+    await sleep(2000);
+
+    // Should have run for each active tenant (we created 2)
+    expect(jobExecutions.length).toBe(2);
+    const tenantIds = jobExecutions.map((e) => e.tenantId);
+    expect(tenantIds).toContain(testTenantId(1));
+    expect(tenantIds).toContain(testTenantId(2));
+  });
+
+  test("each sub-job has the correct tenantId in systemUser", async () => {
+    for (const execution of jobExecutions) {
+      // UUID strings — just ensure a non-empty tenantId landed in the systemUser.
+      expect(typeof execution.tenantId).toBe("string");
+      expect(execution.tenantId.length).toBeGreaterThan(0);
+    }
+  });
+});

package/src/tenant/__tests__/seed-testing.integration.ts

@@ -0,0 +1,229 @@
+// Test for the seedTenantMembership test-helper itself. Test-helpers that
+// other tests rely on for fixture setup should themselves have coverage —
+// otherwise a silent regression (e.g. the helper stops writing events but
+// keeps writing the projection) leaves every downstream test falsely
+// passing on bogus state.
+//
+// Four invariants matter:
+//   1. The projection row lands with the right (userId, tenantId, roles).
+//   2. A `tenantMembership.created` event lands on the aggregate stream.
+//   3. Duplicate call is a no-op (no second event, no crash).
+//   4. The `by`-user shows up as insertedById on the projection — so
+//      audit-queries that join events→users actually find the actor.
+
+import type { TenantId } from "@cosmicdrift/kumiko-framework/engine";
+import { createEventsTable, eventsTable } from "@cosmicdrift/kumiko-framework/event-store";
+import {
+  createEntityTable,
+  createTestUser,
+  pushTables,
+  setupTestStack,
+  type TestStack,
+  TestUsers,
+} from "@cosmicdrift/kumiko-framework/stack";
+import { and, eq } from "drizzle-orm";
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { createConfigFeature } from "../../config/feature";
+import { createConfigResolver } from "../../config/resolver";
+import { configValuesTable } from "../../config/table";
+import { createTenantFeature } from "../feature";
+import { tenantMembershipsTable } from "../membership-table";
+import { tenantEntity, tenantTable } from "../schema/tenant";
+import { seedTenant, seedTenantMembership } from "../seeding";
+
+let stack: TestStack;
+
+const ALICE_ID = "11111111-0000-4000-8000-000000000aaa";
+const TENANT_A: TenantId = "00000000-0000-4000-8000-000000000aaa" as TenantId;
+const TENANT_B: TenantId = "00000000-0000-4000-8000-000000000bbb" as TenantId;
+
+beforeAll(async () => {
+  const resolver = createConfigResolver();
+  stack = await setupTestStack({
+    features: [createConfigFeature(), createTenantFeature()],
+    extraContext: { configResolver: resolver },
+  });
+  await createEntityTable(stack.db, tenantEntity);
+  await pushTables(stack.db, { configValuesTable, tenantMembershipsTable });
+  await createEventsTable(stack.db);
+});
+
+afterAll(async () => {
+  await stack.cleanup();
+});
+
+beforeEach(async () => {
+  await stack.db.delete(tenantMembershipsTable);
+  await stack.db.delete(tenantTable);
+  // Events stay — the idempotency test below inspects how many .created
+  // events exist for the same aggregate-key pair across runs.
+  await stack.db.delete(eventsTable);
+});
+
+describe("seedTenant", () => {
+  test("schreibt Projection-Row mit id/key/name", async () => {
+    const id = await seedTenant(stack.db, {
+      id: TENANT_A,
+      key: "tenant-a",
+      name: "Tenant A",
+    });
+    expect(id).toBe(TENANT_A);
+
+    const rows = await stack.db.select().from(tenantTable).where(eq(tenantTable["id"], TENANT_A));
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.["id"]).toBe(TENANT_A);
+    expect(rows[0]?.["key"]).toBe("tenant-a");
+    expect(rows[0]?.["name"]).toBe("Tenant A");
+  });
+
+  test("emittiert tenant.created-Event auf den Aggregate-Stream", async () => {
+    await seedTenant(stack.db, { id: TENANT_A, key: "tenant-a", name: "Tenant A" });
+    const events = await stack.db
+      .select()
+      .from(eventsTable)
+      .where(eq(eventsTable.aggregateType, "tenant"));
+    const createdEvents = events.filter((e) => e.type === "tenant.created");
+    expect(createdEvents).toHaveLength(1);
+    // Aggregate-id steht im event-row (aggregateId), nicht im payload —
+    // payload trägt die Aggregat-Felder ohne PK.
+    expect(createdEvents[0]?.aggregateId).toBe(TENANT_A);
+    const payload = createdEvents[0]?.payload as { key: string; name: string };
+    expect(payload.key).toBe("tenant-a");
+    expect(payload.name).toBe("Tenant A");
+  });
+
+  test("zweiter Aufruf für dieselbe id: no-op (kein zweites Event, kein Crash)", async () => {
+    await seedTenant(stack.db, { id: TENANT_A, key: "tenant-a", name: "Tenant A" });
+    await seedTenant(stack.db, { id: TENANT_A, key: "tenant-a", name: "Tenant A v2" });
+
+    // Projection bleibt bei Original-name (zweiter Call wurde geskippt, kein update).
+    const rows = await stack.db.select().from(tenantTable).where(eq(tenantTable["id"], TENANT_A));
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.["name"]).toBe("Tenant A");
+
+    const events = await stack.db
+      .select()
+      .from(eventsTable)
+      .where(eq(eventsTable.aggregateType, "tenant"));
+    expect(events.filter((e) => e.type === "tenant.created")).toHaveLength(1);
+  });
+
+  test("zwei verschiedene Tenants in einem Test — beide in der Projection", async () => {
+    await seedTenant(stack.db, { id: TENANT_A, key: "a", name: "A" });
+    await seedTenant(stack.db, { id: TENANT_B, key: "b", name: "B" });
+    const rows = await stack.db.select().from(tenantTable);
+    expect(rows.map((r) => r["id"]).sort()).toEqual([TENANT_A, TENANT_B].sort());
+  });
+});
+
+describe("seedTenantMembership", () => {
+  test("writes the projection row with the given userId / tenantId / roles", async () => {
+    await seedTenantMembership(stack.db, {
+      userId: ALICE_ID,
+      tenantId: TENANT_A,
+      roles: ["Admin", "Billing"],
+    });
+
+    const rows = await stack.db
+      .select()
+      .from(tenantMembershipsTable)
+      .where(
+        and(
+          eq(tenantMembershipsTable.userId, ALICE_ID),
+          eq(tenantMembershipsTable.tenantId, TENANT_A),
+        ),
+      );
+    expect(rows).toHaveLength(1);
+    expect(rows[0]?.["userId"]).toBe(ALICE_ID);
+    expect(rows[0]?.["tenantId"]).toBe(TENANT_A);
+    expect(rows[0]?.["roles"]).toBe(JSON.stringify(["Admin", "Billing"]));
+  });
+
+  test("writes a tenantMembership.created event on the aggregate stream", async () => {
+    await seedTenantMembership(stack.db, {
+      userId: ALICE_ID,
+      tenantId: TENANT_A,
+      roles: ["User"],
+    });
+
+    const events = await stack.db
+      .select()
+      .from(eventsTable)
+      .where(eq(eventsTable.aggregateType, "tenant-membership"));
+    const createdEvents = events.filter((e) => e.type === "tenant-membership.created");
+    expect(createdEvents).toHaveLength(1);
+    // Payload should carry the seeded data — MSPs/audit rely on this.
+    const payload = createdEvents[0]?.payload as {
+      userId: string;
+      tenantId: string;
+      roles: string;
+    };
+    expect(payload.userId).toBe(ALICE_ID);
+    expect(payload.tenantId).toBe(TENANT_A);
+    expect(payload.roles).toBe(JSON.stringify(["User"]));
+  });
+
+  test("calling twice for the same (userId, tenantId) is idempotent — no second event, no crash", async () => {
+    // First call: creates both projection row + event.
+    await seedTenantMembership(stack.db, {
+      userId: ALICE_ID,
+      tenantId: TENANT_A,
+      roles: ["User"],
+    });
+    // Second call: helper detects existing row and no-ops. Would otherwise
+    // trip the (user_id, tenant_id) unique index AND would bump the event
+    // count — both are footguns for beforeEach-resets that only clear some
+    // tables.
+    await seedTenantMembership(stack.db, {
+      userId: ALICE_ID,
+      tenantId: TENANT_A,
+      roles: ["User"],
+    });
+
+    const projectionRows = await stack.db
+      .select()
+      .from(tenantMembershipsTable)
+      .where(eq(tenantMembershipsTable.userId, ALICE_ID));
+    expect(projectionRows).toHaveLength(1);
+
+    const events = await stack.db
+      .select()
+      .from(eventsTable)
+      .where(eq(eventsTable.aggregateType, "tenant-membership"));
+    expect(events.filter((e) => e.type === "tenant-membership.created")).toHaveLength(1);
+  });
+
+  test("records the `by` user as insertedById on the projection", async () => {
+    // Audit-queries that join events → users need a stable actor. Default
+    // `by` is TestUsers.systemAdmin; override to a custom test user and
+    // assert it propagates to the projection's inserted_by_id column.
+    const seedActor = createTestUser({ id: 99, tenantId: TENANT_A });
+    await seedTenantMembership(stack.db, {
+      userId: ALICE_ID,
+      tenantId: TENANT_A,
+      roles: ["User"],
+      by: seedActor,
+    });
+
+    const [row] = await stack.db
+      .select()
+      .from(tenantMembershipsTable)
+      .where(eq(tenantMembershipsTable.userId, ALICE_ID));
+    expect(row?.["insertedById"]).toBe(seedActor.id);
+  });
+
+  test("default `by` is TestUsers.systemAdmin", async () => {
+    // Documents the fallback — a regression that changed the default would
+    // silently skew audit queries across 18 call-sites.
+    await seedTenantMembership(stack.db, {
+      userId: ALICE_ID,
+      tenantId: TENANT_A,
+      roles: ["User"],
+    });
+    const [row] = await stack.db
+      .select()
+      .from(tenantMembershipsTable)
+      .where(eq(tenantMembershipsTable.userId, ALICE_ID));
+    expect(row?.["insertedById"]).toBe(TestUsers.systemAdmin.id);
+  });
+});