import { describe, expect, it } from "@effect/vitest";import { Effect } from "effect";import { withQueryContext } from "@executor-js/fumadb/query"; import { collectTables } from "./executor";import { createSqliteTestFumaDb, type SqliteTestFumaDb } from "./sqlite-test-db"; // The subject table has no readers or writers yet (it is populated in a later// change), so this pins the two properties the schema alone is responsible// for: the boot bring-up actually creates it, and it is TENANT-scoped rather// than owner-scoped — any executor bound to the tenant may read it, which is// what a cross-subject view needs. Written against the real SQLite bring-up// (`createSqliteTestFumaDb` runs the same statements the local/self-host/D1// hosts boot with) instead of asserting on the table definition object. const TENANT = "t1";const OTHER_TENANT = "t2"; const withDb = <A>(body: (db: SqliteTestFumaDb) => Promise<A>): Promise<A> =>  Effect.runPromise(    Effect.acquireUseRelease(      Effect.promise(() => createSqliteTestFumaDb({ tables: collectTables() })),      (db) => Effect.promise(() => body(db)),      (db) => Effect.promise(() => db.close()),    ),  ); const insertSubject = (  db: SqliteTestFumaDb,  row: { readonly rowId: string; readonly tenant: string; readonly externalId: string },): Promise<unknown> =>  db.client.execute({    sql: `INSERT INTO subject (row_id, tenant, external_id, created_at, last_seen_at, status)      VALUES (?, ?, ?, ?, ?, ?)`,    args: [row.rowId, row.tenant, row.externalId, Date.now(), null, null],  }); describe("subject table", () => {  it.effect("is created by the runtime schema bring-up", () =>    Effect.promise(() =>      withDb(async (db) => {        const info = await db.client.execute("PRAGMA table_info('subject')");        const columns = info.rows.map((row) => String(row["name"]));        expect(columns).toEqual(          expect.arrayContaining([            "row_id",            "tenant",            "external_id",            "created_at",            "last_seen_at",            "status",          ]),        );      }),    ),  );   it.effect("keys one row per (tenant, external_id)", () =>    Effect.promise(() =>      withDb(async (db) => {        await insertSubject(db, { rowId: "s1", tenant: TENANT, externalId: "user_a" });         // The same principal id under a DIFFERENT tenant is a different row —        // external ids are only unique within their tenant.        await insertSubject(db, { rowId: "s2", tenant: OTHER_TENANT, externalId: "user_a" });         await expect(          insertSubject(db, { rowId: "s3", tenant: TENANT, externalId: "user_a" }),        ).rejects.toThrow();         const rows = await db.client.execute("SELECT row_id FROM subject ORDER BY row_id");        expect(rows.rows.map((row) => String(row["row_id"]))).toEqual(["s1", "s2"]);      }),    ),  );   it.effect("tolerates the host sentinel subject id", () =>    Effect.promise(() =>      withDb(async (db) => {        // Local/self-host bind every request to the literal subject "local";        // nothing may assume external ids are opaque provider identifiers.        await insertSubject(db, { rowId: "s1", tenant: TENANT, externalId: "local" });        const rows = await db.client.execute("SELECT external_id FROM subject");        expect(rows.rows.map((row) => String(row["external_id"]))).toEqual(["local"]);      }),    ),  );   it.effect("reads only within the bound tenant", () =>    Effect.promise(() =>      withDb(async (db) => {        await insertSubject(db, { rowId: "s1", tenant: TENANT, externalId: "user_a" });        await insertSubject(db, { rowId: "s2", tenant: OTHER_TENANT, externalId: "user_b" });         // No `subject` in the context: a pure-org executor still reads the        // table, which is the whole point of tenant scoping.        const scoped = withQueryContext(db.db, { tenant: TENANT, subject: null });        const visible = await scoped.findMany("subject", {});        expect(visible.map((row) => row.external_id)).toEqual(["user_a"]);      }),    ),  );});