@fragno-dev/db 0.1.15 → 0.2.0

package/src/adapters/kysely/kysely-query-compiler.ts

@@ -1,127 +0,0 @@
-import type { CompiledQuery } from "kysely";
-import type { AnySchema, AnyTable } from "../../schema/create";
-import { buildCondition } from "../../query/condition-builder";
-import { buildFindOptions } from "../../query/orm/orm";
-import { createKyselyQueryBuilder } from "./kysely-query-builder";
-import type { ConditionBuilder, Condition } from "../../query/condition-builder";
-import { createKysely, type TableNameMapper } from "./kysely-shared";
-import type { SQLProvider } from "../../shared/providers";
-
-/**
- * Internal query compiler interface for Kysely
- * Used by the UOW compiler to generate compiled queries
- */
-export interface KyselyQueryCompiler {
-  count: (
-    name: string,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    options?: { where?: (eb: ConditionBuilder<any>) => any },
-  ) => CompiledQuery | null;
-  findFirst: (name: string, options: any) => CompiledQuery | null; // eslint-disable-line @typescript-eslint/no-explicit-any
-  findMany: (name: string, options?: any) => CompiledQuery | null; // eslint-disable-line @typescript-eslint/no-explicit-any
-  create: (name: string, values: any) => CompiledQuery; // eslint-disable-line @typescript-eslint/no-explicit-any
-  createMany: (name: string, values: any[]) => CompiledQuery; // eslint-disable-line @typescript-eslint/no-explicit-any
-  updateMany: (name: string, options: { set: any; where?: any }) => CompiledQuery | null; // eslint-disable-line @typescript-eslint/no-explicit-any
-  deleteMany: (name: string, options: { where?: any }) => CompiledQuery | null; // eslint-disable-line @typescript-eslint/no-explicit-any
-}
-
-export function createKyselyQueryCompiler<T extends AnySchema>(
-  schema: T,
-  provider: SQLProvider,
-  mapper?: TableNameMapper,
-): KyselyQueryCompiler {
-  // Get kysely instance for query building (compilation doesn't execute, just builds SQL)
-  const kysely = createKysely(provider);
-  const queryBuilder = createKyselyQueryBuilder(kysely, provider, mapper);
-
-  function toTable(name: unknown): AnyTable {
-    const table = schema.tables[name as string];
-    if (!table) {
-      throw new Error(`Invalid table name ${name}.`);
-    }
-    return table;
-  }
-
-  return {
-    count(name, { where } = {}) {
-      const table = toTable(name);
-      let conditions = where ? buildCondition(table.columns, where) : undefined;
-      if (conditions === true) {
-        conditions = undefined;
-      }
-      if (conditions === false) {
-        return null;
-      }
-
-      return queryBuilder.count(table, { where: conditions });
-    },
-
-    findFirst(name, options) {
-      const table = toTable(name);
-      // Safe cast: FindFirstOptions is structurally compatible with FindManyOptions
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const compiledOptions = buildFindOptions(table, options as any);
-      if (compiledOptions === false) {
-        return null;
-      }
-
-      return queryBuilder.findMany(table, {
-        ...compiledOptions,
-        limit: 1,
-      });
-    },
-
-    findMany(name, options = {}) {
-      const table = toTable(name);
-      // Safe cast: FindManyOptions from compiler matches FindManyOptions from buildFindOptions
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const compiledOptions = buildFindOptions(table, options as any);
-      if (compiledOptions === false) {
-        return null;
-      }
-
-      return queryBuilder.findMany(table, compiledOptions);
-    },
-
-    create(name, values) {
-      const table = toTable(name);
-      return queryBuilder.create(table, values);
-    },
-
-    createMany(name, values) {
-      const table = toTable(name);
-      return queryBuilder.createMany(table, values);
-    },
-
-    updateMany(name, { set, where }) {
-      const table = toTable(name);
-      let conditions = where ? buildCondition(table.columns, where) : undefined;
-      if (conditions === true) {
-        conditions = undefined;
-      }
-      if (conditions === false) {
-        return null;
-      }
-
-      // Safe: conditions is Condition | undefined after filtering out true/false
-      return queryBuilder.updateMany(table, {
-        set,
-        where: conditions as Condition | undefined,
-      });
-    },
-
-    deleteMany(name, { where }) {
-      const table = toTable(name);
-      let conditions = where ? buildCondition(table.columns, where) : undefined;
-      if (conditions === true) {
-        conditions = undefined;
-      }
-      if (conditions === false) {
-        return null;
-      }
-
-      // Safe: conditions is Condition | undefined after filtering out true/false
-      return queryBuilder.deleteMany(table, { where: conditions as Condition | undefined });
-    },
-  };
-}

package/src/adapters/kysely/kysely-query.test.ts

@@ -1,498 +0,0 @@
-import { Kysely } from "kysely";
-import { KyselyPGlite } from "kysely-pglite";
-import { assert, beforeAll, beforeEach, describe, expect, expectTypeOf, it } from "vitest";
-import { column, FragnoId, idColumn, referenceColumn, schema } from "../../schema/create";
-import { fromKysely } from "./kysely-query";
-import { createKyselyConnectionPool } from "./kysely-connection-pool";
-import type { ConnectionPool } from "../../shared/connection-pool";
-import type { CompiledQuery } from "kysely";
-
-describe("kysely-query", () => {
-  const authSchema = schema((s) => {
-    return s
-      .addTable("user", (t) => {
-        return t
-          .addColumn("id", idColumn())
-          .addColumn("email", column("string"))
-          .addColumn("passwordHash", column("string"))
-          .addColumn(
-            "createdAt",
-            column("timestamp").defaultTo$((b) => b.now()),
-          )
-          .createIndex("idx_user_email", ["email"]);
-      })
-      .addTable("session", (t) => {
-        return t
-          .addColumn("id", idColumn())
-          .addColumn("userId", referenceColumn())
-          .addColumn("expiresAt", column("timestamp"))
-          .addColumn(
-            "createdAt",
-            column("timestamp").defaultTo$((b) => b.now()),
-          )
-          .createIndex("idx_session_user", ["userId"]);
-      })
-      .addReference("sessionOwner", {
-        from: {
-          table: "session",
-          column: "userId",
-        },
-        to: {
-          table: "user",
-          column: "id",
-        },
-        type: "one",
-      });
-  });
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let kysely: Kysely<any>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let pool: ConnectionPool<Kysely<any>>;
-  let orm: ReturnType<typeof fromKysely<typeof authSchema>>;
-
-  const queries: CompiledQuery[] = [];
-
-  beforeAll(async () => {
-    // Create Kysely instance with PGLite (in-memory Postgres)
-    const { dialect } = await KyselyPGlite.create();
-    kysely = new Kysely({
-      dialect,
-    });
-
-    // Wrap in connection pool
-    pool = createKyselyConnectionPool(kysely);
-    orm = fromKysely(authSchema, pool, "postgresql", undefined, {
-      onQuery: (query) => {
-        queries.push(query);
-      },
-      dryRun: true,
-    });
-  });
-
-  beforeEach(() => {
-    queries.splice(0, queries.length);
-  });
-
-  describe("findFirst", () => {
-    it("should find session with user join", async () => {
-      const someExternalId = "some-external-id";
-
-      // Find the session with user join
-      await orm.findFirst("session", (b) =>
-        b
-          .whereIndex("primary", (eb) => eb("id", "=", someExternalId))
-          .join((j) => j.sessionOwner((b) => b.select(["id", "email"]))),
-      );
-
-      const [query] = queries;
-      assert(query?.sql);
-      expect(query?.sql).toMatchInlineSnapshot(
-        `"select "sessionOwner"."id" as "sessionOwner:id", "sessionOwner"."email" as "sessionOwner:email", "sessionOwner"."_internalId" as "sessionOwner:_internalId", "sessionOwner"."_version" as "sessionOwner:_version", "session"."id" as "id", "session"."userId" as "userId", "session"."expiresAt" as "expiresAt", "session"."createdAt" as "createdAt", "session"."_internalId" as "_internalId", "session"."_version" as "_version" from "session" left join "user" as "sessionOwner" on "session"."userId" = "sessionOwner"."_internalId" where "session"."id" = $1 limit $2"`,
-      );
-      expect(query?.parameters).toEqual([someExternalId, 1]);
-    });
-
-    it("should find session without join", async () => {
-      const someExternalId = "some-external-id";
-
-      await orm.findFirst("session", (b) =>
-        b.whereIndex("primary", (eb) => eb("id", "=", someExternalId)),
-      );
-
-      const [query] = queries;
-      assert(query?.sql);
-      expect(query?.sql).toMatchInlineSnapshot(
-        `"select "session"."id" as "id", "session"."userId" as "userId", "session"."expiresAt" as "expiresAt", "session"."createdAt" as "createdAt", "session"."_internalId" as "_internalId", "session"."_version" as "_version" from "session" where "session"."id" = $1 limit $2"`,
-      );
-      expect(query?.parameters).toEqual([someExternalId, 1]);
-    });
-
-    it("should find user by email using custom index", async () => {
-      const email = "test@example.com";
-
-      await orm.findFirst("user", (b) =>
-        b.whereIndex("idx_user_email", (eb) => eb("email", "=", email)),
-      );
-
-      const [query] = queries;
-      assert(query?.sql);
-      expect(query?.sql).toMatchInlineSnapshot(
-        `"select "user"."id" as "id", "user"."email" as "email", "user"."passwordHash" as "passwordHash", "user"."createdAt" as "createdAt", "user"."_internalId" as "_internalId", "user"."_version" as "_version" from "user" where "user"."email" = $1 limit $2"`,
-      );
-      expect(query?.parameters).toEqual([email, 1]);
-    });
-
-    it("should find with select subset of columns", async () => {
-      const someExternalId = "some-external-id";
-
-      const res = await orm.findFirst("user", (b) =>
-        b.whereIndex("primary", (eb) => eb("id", "=", someExternalId)).select(["id", "email"]),
-      );
-
-      if (res) {
-        expectTypeOf(res.email).toEqualTypeOf<string>();
-      }
-
-      const [query] = queries;
-      assert(query?.sql);
-      expect(query?.sql).toMatchInlineSnapshot(
-        `"select "user"."id" as "id", "user"."email" as "email", "user"."_internalId" as "_internalId", "user"."_version" as "_version" from "user" where "user"."id" = $1 limit $2"`,
-      );
-      expect(query?.parameters).toEqual([someExternalId, 1]);
-    });
-  });
-
-  describe("find", () => {
-    it("should find all sessions using primary index", async () => {
-      await orm.find("session", (b) => b.whereIndex("primary"));
-
-      const [query] = queries;
-      assert(query?.sql);
-      expect(query?.sql).toMatchInlineSnapshot(
-        `"select "session"."id" as "id", "session"."userId" as "userId", "session"."expiresAt" as "expiresAt", "session"."createdAt" as "createdAt", "session"."_internalId" as "_internalId", "session"."_version" as "_version" from "session""`,
-      );
-      expect(query?.parameters).toEqual([]);
-    });
-
-    it("should find sessions with user join", async () => {
-      await orm.find("session", (b) =>
-        b.whereIndex("primary").join((j) => j.sessionOwner((b) => b.select(["id", "email"]))),
-      );
-
-      const [query] = queries;
-      assert(query?.sql);
-      expect(query?.sql).toMatchInlineSnapshot(
-        `"select "sessionOwner"."id" as "sessionOwner:id", "sessionOwner"."email" as "sessionOwner:email", "sessionOwner"."_internalId" as "sessionOwner:_internalId", "sessionOwner"."_version" as "sessionOwner:_version", "session"."id" as "id", "session"."userId" as "userId", "session"."expiresAt" as "expiresAt", "session"."createdAt" as "createdAt", "session"."_internalId" as "_internalId", "session"."_version" as "_version" from "session" left join "user" as "sessionOwner" on "session"."userId" = "sessionOwner"."_internalId""`,
-      );
-      expect(query?.parameters).toEqual([]);
-    });
-
-    it("should find sessions with where clause using custom index", async () => {
-      const userId = "user-123";
-
-      await orm.find("session", (b) =>
-        b.whereIndex("idx_session_user", (eb) => eb("userId", "=", userId)),
-      );
-
-      const [query] = queries;
-      assert(query?.sql);
-      expect(query?.sql).toMatchInlineSnapshot(
-        `"select "session"."id" as "id", "session"."userId" as "userId", "session"."expiresAt" as "expiresAt", "session"."createdAt" as "createdAt", "session"."_internalId" as "_internalId", "session"."_version" as "_version" from "session" where "session"."userId" = (select "_internalId" from "user" where "id" = $1 limit $2)"`,
-      );
-      expect(query?.parameters).toEqual([userId, 1]);
-    });
-
-    it("should find with pageSize", async () => {
-      await orm.find("user", (b) => b.whereIndex("primary").pageSize(10));
-
-      const [query] = queries;
-      assert(query?.sql);
-      expect(query?.sql).toMatchInlineSnapshot(
-        `"select "user"."id" as "id", "user"."email" as "email", "user"."passwordHash" as "passwordHash", "user"."createdAt" as "createdAt", "user"."_internalId" as "_internalId", "user"."_version" as "_version" from "user" limit $1"`,
-      );
-      expect(query?.parameters).toEqual([10]);
-    });
-
-    it("should find with select subset", async () => {
-      const _res = await orm.find("user", (b) => b.whereIndex("primary").select(["id", "email"]));
-
-      const [query] = queries;
-      assert(query?.sql);
-      expect(query?.sql).toMatchInlineSnapshot(
-        `"select "user"."id" as "id", "user"."email" as "email", "user"."_internalId" as "_internalId", "user"."_version" as "_version" from "user""`,
-      );
-      expect(query?.parameters).toEqual([]);
-    });
-  });
-
-  describe("create", () => {
-    it("should create a new user", async () => {
-      const createdId = await orm.create("user", {
-        id: "user-123",
-        email: "test@example.com",
-        passwordHash: "hashed-password",
-      });
-
-      // Verify the operation succeeded by getting the created ID (FragnoId object)
-      expect(createdId).toBeDefined();
-      expect(typeof createdId).toBe("object");
-
-      // Verify the SQL query was captured
-      const [query] = queries;
-      expect(query.sql).toMatchInlineSnapshot(
-        `"insert into "user" ("id", "email", "passwordHash", "createdAt") values ($1, $2, $3, $4) returning "user"."id" as "id", "user"."email" as "email", "user"."passwordHash" as "passwordHash", "user"."createdAt" as "createdAt", "user"."_internalId" as "_internalId", "user"."_version" as "_version""`,
-      );
-      expect(query.parameters[0]).toEqual("user-123");
-      expect(query.parameters[1]).toEqual("test@example.com");
-      expect(query.parameters[2]).toEqual("hashed-password");
-      expect(query.parameters[3]).toBeInstanceOf(Date); // createdAt timestamp
-    });
-
-    it("should create a new session", async () => {
-      const expiresAt = new Date("2025-12-31T23:59:59Z");
-
-      const createdId = await orm.create("session", {
-        id: "session-456",
-        userId: "user-123",
-        expiresAt,
-      });
-
-      // Verify the operation succeeded by getting the created ID (FragnoId object)
-      expect(createdId).toBeDefined();
-      expect(typeof createdId).toBe("object");
-
-      // Verify the SQL query was captured
-      const [query] = queries;
-      expect(query.sql).toMatchInlineSnapshot(
-        `"insert into "session" ("id", "userId", "expiresAt", "createdAt") values ($1, (select "_internalId" from "user" where "id" = $2 limit $3), $4, $5) returning "session"."id" as "id", "session"."userId" as "userId", "session"."expiresAt" as "expiresAt", "session"."createdAt" as "createdAt", "session"."_internalId" as "_internalId", "session"."_version" as "_version""`,
-      );
-      expect(query.parameters[0]).toEqual("session-456");
-      expect(query.parameters[1]).toEqual("user-123"); // userId is resolved via subquery
-      expect(query.parameters[2]).toEqual(1); // Limit for subquery
-      expect(query.parameters[3]).toEqual(expiresAt);
-      expect(query.parameters[4]).toBeInstanceOf(Date); // createdAt timestamp
-    });
-  });
-
-  describe("createMany", () => {
-    it("should create multiple users", async () => {
-      const createdIds = await orm.createMany("user", [
-        {
-          id: "user-1",
-          email: "user1@example.com",
-          passwordHash: "hash1",
-        },
-        {
-          id: "user-2",
-          email: "user2@example.com",
-          passwordHash: "hash2",
-        },
-      ]);
-
-      // Verify the operation succeeded by checking we got IDs back (FragnoId objects)
-      expect(createdIds).toHaveLength(2);
-      expect(typeof createdIds[0]).toBe("object");
-      expect(typeof createdIds[1]).toBe("object");
-
-      // Verify the SQL queries were captured
-      // createMany should generate one insert per record
-      expect(queries).toHaveLength(2);
-
-      // Check the first user insert
-      expect(queries[0].sql).toMatchInlineSnapshot(
-        `"insert into "user" ("id", "email", "passwordHash", "createdAt") values ($1, $2, $3, $4) returning "user"."id" as "id", "user"."email" as "email", "user"."passwordHash" as "passwordHash", "user"."createdAt" as "createdAt", "user"."_internalId" as "_internalId", "user"."_version" as "_version""`,
-      );
-      expect(queries[0].parameters[0]).toEqual("user-1");
-      expect(queries[0].parameters[1]).toEqual("user1@example.com");
-      expect(queries[0].parameters[2]).toEqual("hash1");
-
-      // Check the second user insert
-      expect(queries[1].sql).toMatchInlineSnapshot(
-        `"insert into "user" ("id", "email", "passwordHash", "createdAt") values ($1, $2, $3, $4) returning "user"."id" as "id", "user"."email" as "email", "user"."passwordHash" as "passwordHash", "user"."createdAt" as "createdAt", "user"."_internalId" as "_internalId", "user"."_version" as "_version""`,
-      );
-      expect(queries[1].parameters[0]).toEqual("user-2");
-      expect(queries[1].parameters[1]).toEqual("user2@example.com");
-      expect(queries[1].parameters[2]).toEqual("hash2");
-    });
-  });
-
-  describe("update", () => {
-    it("should update user by id", async () => {
-      const userId = "user-123";
-
-      await orm.update("user", userId, (b) =>
-        b.set({
-          email: "newemail@example.com",
-        }),
-      );
-
-      // Verify the SQL query was captured
-      const [query] = queries;
-      expect(query.sql).toMatchInlineSnapshot(
-        `"update "user" set "email" = $1, "_version" = COALESCE(_version, 0) + 1 where "user"."id" = $2"`,
-      );
-      expect(query.parameters).toEqual(["newemail@example.com", userId]);
-    });
-
-    it("should update session expiration", async () => {
-      const sessionId = "session-456";
-      const newExpiresAt = new Date("2026-01-01T00:00:00Z");
-
-      await orm.update("session", sessionId, (b) =>
-        b.set({
-          expiresAt: newExpiresAt,
-        }),
-      );
-
-      // Verify the SQL query was captured
-      const [query] = queries;
-      expect(query.sql).toMatchInlineSnapshot(
-        `"update "session" set "expiresAt" = $1, "_version" = COALESCE(_version, 0) + 1 where "session"."id" = $2"`,
-      );
-      expect(query.parameters).toEqual([newExpiresAt, sessionId]);
-    });
-
-    it("should update with version check using FragnoId", async () => {
-      const userId = FragnoId.fromExternal("user-123", 5);
-
-      await orm.update("user", userId, (b) =>
-        b
-          .set({
-            email: "checked@example.com",
-          })
-          .check(),
-      );
-
-      // Verify the SQL query includes version check in WHERE clause
-      const [query] = queries;
-      expect(query.sql).toMatchInlineSnapshot(
-        `"update "user" set "email" = $1, "_version" = COALESCE(_version, 0) + 1 where ("user"."id" = $2 and "user"."_version" = $3)"`,
-      );
-      expect(query.parameters).toEqual(["checked@example.com", "user-123", 5]);
-    });
-
-    it("should throw when trying to check() with string ID", async () => {
-      await expect(
-        orm.update("user", "user-123", (b) => b.set({ email: "test@example.com" }).check()),
-      ).rejects.toThrow(
-        'Cannot use check() with a string ID on table "user". Version checking requires a FragnoId with version information.',
-      );
-    });
-  });
-
-  describe("updateMany", () => {
-    it("should update multiple users by index", async () => {
-      await orm.updateMany("user", (b) =>
-        b
-          .whereIndex("idx_user_email", (eb) => eb("email", "=", "old@example.com"))
-          .set({ email: "new@example.com" }),
-      );
-
-      // updateMany first finds matching records, then updates them
-      expect(queries.length).toBeGreaterThan(0);
-
-      // Verify the find query that's executed first
-      const findQuery = queries[0];
-      assert(findQuery?.sql);
-      expect(findQuery?.sql).toMatchInlineSnapshot(
-        `"select "user"."id" as "id", "user"."email" as "email", "user"."passwordHash" as "passwordHash", "user"."createdAt" as "createdAt", "user"."_internalId" as "_internalId", "user"."_version" as "_version" from "user" where "user"."email" = $1"`,
-      );
-      expect(findQuery?.parameters).toEqual(["old@example.com"]);
-
-      // Note: In dryRun mode, no actual records are found, so no update queries are generated
-      // This is expected behavior - updateMany only generates update queries for found records
-    });
-  });
-
-  describe("delete", () => {
-    it("should delete user by id", async () => {
-      const userId = "user-123";
-
-      await orm.delete("user", userId);
-
-      // Verify the SQL query was captured
-      const [query] = queries;
-      expect(query.sql).toMatchInlineSnapshot(`"delete from "user" where "user"."id" = $1"`);
-      expect(query.parameters).toEqual([userId]);
-    });
-
-    it("should delete session by id", async () => {
-      const sessionId = "session-456";
-
-      await orm.delete("session", sessionId);
-
-      // Verify the SQL query was captured
-      const [query] = queries;
-      expect(query.sql).toMatchInlineSnapshot(`"delete from "session" where "session"."id" = $1"`);
-      expect(query.parameters).toEqual([sessionId]);
-    });
-
-    it("should delete with version check using FragnoId", async () => {
-      const userId = FragnoId.fromExternal("user-789", 3);
-
-      await orm.delete("user", userId, (b) => b.check());
-
-      // Verify the SQL query includes version check in WHERE clause
-      const [query] = queries;
-      expect(query.sql).toMatchInlineSnapshot(
-        `"delete from "user" where ("user"."id" = $1 and "user"."_version" = $2)"`,
-      );
-      expect(query.parameters).toEqual(["user-789", 3]);
-    });
-
-    it("should throw when trying to check() with string ID on delete", async () => {
-      await expect(orm.delete("user", "user-123", (b) => b.check())).rejects.toThrow(
-        'Cannot use check() with a string ID on table "user". Version checking requires a FragnoId with version information.',
-      );
-    });
-  });
-
-  describe("deleteMany", () => {
-    it("should delete sessions by userId using index", async () => {
-      const userId = "user-123";
-
-      await orm.deleteMany("session", (b) =>
-        b.whereIndex("idx_session_user", (eb) => eb("userId", "=", userId)),
-      );
-
-      // deleteMany first finds matching records, then deletes them
-      expect(queries.length).toBeGreaterThan(0);
-
-      // Verify the find query that's executed first
-      const findQuery = queries[0];
-      assert(findQuery?.sql);
-      expect(findQuery?.sql).toMatchInlineSnapshot(
-        `"select "session"."id" as "id", "session"."userId" as "userId", "session"."expiresAt" as "expiresAt", "session"."createdAt" as "createdAt", "session"."_internalId" as "_internalId", "session"."_version" as "_version" from "session" where "session"."userId" = (select "_internalId" from "user" where "id" = $1 limit $2)"`,
-      );
-      expect(findQuery?.parameters).toEqual([userId, 1]);
-
-      // Note: In dryRun mode, no actual records are found, so no delete queries are generated
-      // This is expected behavior - deleteMany only generates delete queries for found records
-    });
-  });
-
-  describe("FragnoId support", () => {
-    it("should accept FragnoId in delete", async () => {
-      // Create a user first to get a FragnoId
-      const createdId = await orm.create("user", {
-        id: "fragno-user-123",
-        email: "fragno@example.com",
-        passwordHash: "hash",
-      });
-
-      // Clear queries from create
-      queries.splice(0, queries.length);
-
-      // Now delete using the FragnoId
-      await orm.delete("user", createdId);
-
-      // Verify the SQL query was captured with the external ID
-      const [query] = queries;
-      expect(query.sql).toMatchInlineSnapshot(`"delete from "user" where "user"."id" = $1"`);
-      expect(query.parameters).toEqual(["fragno-user-123"]);
-    });
-
-    it("should accept FragnoId in update", async () => {
-      // Create a user first to get a FragnoId
-      const createdId = await orm.create("user", {
-        id: "fragno-user-456",
-        email: "update@example.com",
-        passwordHash: "hash",
-      });
-
-      // Clear queries from create
-      queries.splice(0, queries.length);
-
-      // Now update using the FragnoId
-      await orm.update("user", createdId, (b) => b.set({ email: "updated@example.com" }));
-
-      // Verify the SQL query was captured with the external ID
-      const [query] = queries;
-      expect(query.sql).toMatchInlineSnapshot(
-        `"update "user" set "email" = $1, "_version" = COALESCE(_version, 0) + 1 where "user"."id" = $2"`,
-      );
-      expect(query.parameters).toEqual(["updated@example.com", "fragno-user-456"]);
-    });
-  });
-});