@fragno-dev/db 0.1.10 → 0.1.12

package/src/adapters/drizzle/drizzle-adapter-pglite.test.ts

@@ -38,6 +38,10 @@ describe("DrizzleAdapter PGLite", () => {
           .addColumn("user_id", referenceColumn())
           .addColumn("title", column("string"))
           .addColumn("content", column("string"))
+          .addColumn(
+            "created_at",
+            column("timestamp").defaultTo((b) => b.now()),
+          )
           .createIndex("posts_user_idx", ["user_id"]);
       })
       .addTable("comments", (t) => {
@@ -116,7 +120,8 @@ describe("DrizzleAdapter PGLite", () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     // Create initial user using UOW
-    const createUow = queryEngine.createUnitOfWork("create-user").create("users", {
+    const createUow = queryEngine.createUnitOfWork("create-user");
+    createUow.create("users", {
       name: "Alice",
       age: 25,
     });
@@ -201,12 +206,11 @@ describe("DrizzleAdapter PGLite", () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     // Create some users
-    await queryEngine
-      .createUnitOfWork("create-users")
-      .create("users", { name: "User1", age: 20 })
-      .create("users", { name: "User2", age: 30 })
-      .create("users", { name: "User3", age: 40 })
-      .executeMutations();
+    const createUow = queryEngine.createUnitOfWork("create-users");
+    createUow.create("users", { name: "User1", age: 20 });
+    createUow.create("users", { name: "User2", age: 30 });
+    createUow.create("users", { name: "User3", age: 40 });
+    await createUow.executeMutations();
 
     // Count all users
     const [totalCount] = await queryEngine
@@ -221,13 +225,12 @@ describe("DrizzleAdapter PGLite", () => {
   it("should support cursor-based pagination", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
-    const createUow = queryEngine
-      .createUnitOfWork("create-users")
-      .create("users", { name: "Page User A", age: 20 })
-      .create("users", { name: "Page User B", age: 30 })
-      .create("users", { name: "Page User C", age: 40 })
-      .create("users", { name: "Page User D", age: 50 })
-      .create("users", { name: "Page User E", age: 60 });
+    const createUow = queryEngine.createUnitOfWork("create-users");
+    createUow.create("users", { name: "Page User A", age: 20 });
+    createUow.create("users", { name: "Page User B", age: 30 });
+    createUow.create("users", { name: "Page User C", age: 40 });
+    createUow.create("users", { name: "Page User D", age: 50 });
+    createUow.create("users", { name: "Page User E", age: 60 });
 
     await createUow.executeMutations();
 
@@ -269,9 +272,8 @@ describe("DrizzleAdapter PGLite", () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
     const queries: DrizzleCompiledQuery[] = [];
 
-    const createUow = queryEngine
-      .createUnitOfWork("create-users")
-      .create("users", { name: "Email User", age: 20 });
+    const createUow = queryEngine.createUnitOfWork("create-users");
+    createUow.create("users", { name: "Email User", age: 20 });
 
     await createUow.executeMutations();
 
@@ -282,7 +284,8 @@ describe("DrizzleAdapter PGLite", () => {
       .executeRetrieve();
 
     // Create an email for testing joins
-    const createEmailUow = queryEngine.createUnitOfWork("create-test-email").create("emails", {
+    const createEmailUow = queryEngine.createUnitOfWork("create-test-email");
+    createEmailUow.create("emails", {
       user_id: existingUser.id,
       email: "test@example.com",
       is_primary: true,
@@ -330,9 +333,8 @@ describe("DrizzleAdapter PGLite", () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     // Create a user first
-    const createUserUow = queryEngine
-      .createUnitOfWork("create-user-for-external-id")
-      .create("users", { name: "External ID Test User", age: 35 });
+    const createUserUow = queryEngine.createUnitOfWork("create-user-for-external-id");
+    createUserUow.create("users", { name: "External ID Test User", age: 35 });
     await createUserUow.executeMutations();
 
     // Get the user
@@ -344,13 +346,12 @@ describe("DrizzleAdapter PGLite", () => {
       .executeRetrieve();
 
     // Create an email using just the external id string (not the full id object)
-    const createEmailUow = queryEngine
-      .createUnitOfWork("create-email-with-external-id")
-      .create("emails", {
-        user_id: user.id.externalId,
-        email: "external-id-test@example.com",
-        is_primary: false,
-      });
+    const createEmailUow = queryEngine.createUnitOfWork("create-email-with-external-id");
+    createEmailUow.create("emails", {
+      user_id: user.id.externalId,
+      email: "external-id-test@example.com",
+      is_primary: false,
+    });
 
     const { success } = await createEmailUow.executeMutations();
     expect(success).toBe(true);
@@ -385,9 +386,8 @@ describe("DrizzleAdapter PGLite", () => {
     const queries: DrizzleCompiledQuery[] = [];
 
     // Create a user (author)
-    const createAuthorUow = queryEngine
-      .createUnitOfWork("create-author")
-      .create("users", { name: "Blog Author", age: 30 });
+    const createAuthorUow = queryEngine.createUnitOfWork("create-author");
+    createAuthorUow.create("users", { name: "Blog Author", age: 30 });
     await createAuthorUow.executeMutations();
 
     // Get the author
@@ -397,7 +397,8 @@ describe("DrizzleAdapter PGLite", () => {
       .executeRetrieve();
 
     // Create a post by the author
-    const createPostUow = queryEngine.createUnitOfWork("create-post").create("posts", {
+    const createPostUow = queryEngine.createUnitOfWork("create-post");
+    createPostUow.create("posts", {
       user_id: author.id,
       title: "My First Post",
       content: "This is the content of my first post",
@@ -408,9 +409,8 @@ describe("DrizzleAdapter PGLite", () => {
     const [[post]] = await queryEngine.createUnitOfWork("get-post").find("posts").executeRetrieve();
 
     // Create a commenter
-    const createCommenterUow = queryEngine
-      .createUnitOfWork("create-commenter")
-      .create("users", { name: "Commenter User", age: 25 });
+    const createCommenterUow = queryEngine.createUnitOfWork("create-commenter");
+    createCommenterUow.create("users", { name: "Commenter User", age: 25 });
     await createCommenterUow.executeMutations();
 
     // Get the commenter
@@ -420,7 +420,8 @@ describe("DrizzleAdapter PGLite", () => {
       .executeRetrieve();
 
     // Create a comment on the post
-    const createCommentUow = queryEngine.createUnitOfWork("create-comment").create("comments", {
+    const createCommentUow = queryEngine.createUnitOfWork("create-comment");
+    createCommentUow.create("comments", {
       post_id: post.id,
       user_id: commenter.id,
       text: "Great post!",
@@ -564,24 +565,22 @@ describe("DrizzleAdapter PGLite", () => {
     const queryEngine = adapter.createQueryEngine(authSchema, "test-namespace");
 
     // Create a user
-    await queryEngine
-      .createUnitOfWork("create-user")
-      .create("user", {
-        email: "test@example.com",
-        passwordHash: "hash",
-      })
-      .executeMutations();
+    const createUserUow = queryEngine.createUnitOfWork("create-user");
+    createUserUow.create("user", {
+      email: "test@example.com",
+      passwordHash: "hash",
+    });
+    await createUserUow.executeMutations();
 
     // Create a session
     const [[user]] = await queryEngine.createUnitOfWork("get-user").find("user").executeRetrieve();
 
-    await queryEngine
-      .createUnitOfWork("create-session")
-      .create("session", {
-        userId: user.id,
-        expiresAt: new Date("2025-12-31"),
-      })
-      .executeMutations();
+    const createSessionUow = queryEngine.createUnitOfWork("create-session");
+    createSessionUow.create("session", {
+      userId: user.id,
+      expiresAt: new Date("2025-12-31"),
+    });
+    await createSessionUow.executeMutations();
 
     // Get session
     const [[session]] = await queryEngine
@@ -609,4 +608,125 @@ describe("DrizzleAdapter PGLite", () => {
 
     await cleanup();
   });
+
+  it("should handle timestamps and timezones correctly", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+
+    // Create a user
+    const createUserUow = queryEngine.createUnitOfWork("create-user-for-timestamp");
+    createUserUow.create("users", { name: "Timestamp User", age: 28 });
+    await createUserUow.executeMutations();
+
+    const [[user]] = await queryEngine
+      .createUnitOfWork("get-user-for-timestamp")
+      .find("users", (b) => b.whereIndex("name_idx", (eb) => eb("name", "=", "Timestamp User")))
+      .executeRetrieve();
+
+    // Create a post with database-generated timestamp (defaultTo(b => b.now()))
+    const createPostUow = queryEngine.createUnitOfWork("create-post-with-timestamp");
+    createPostUow.create("posts", {
+      user_id: user.id,
+      title: "Timestamp Test Post",
+      content: "Testing timestamp handling",
+    });
+    await createPostUow.executeMutations();
+
+    const createdPostIds = createPostUow.getCreatedIds();
+    expect(createdPostIds).toHaveLength(1);
+    const postId = createdPostIds[0];
+
+    // Retrieve the specific post we just created by its ID
+    const [[post]] = await queryEngine
+      .createUnitOfWork("get-post-with-timestamp")
+      .find("posts", (b) => b.whereIndex("primary", (eb) => eb("id", "=", postId)))
+      .executeRetrieve();
+
+    // Verify created_at is a Date
+    expect(post.created_at).toBeInstanceOf(Date);
+
+    // Verify the timestamp is a valid date (not too far in the past or future)
+    const now = Date.now();
+    const createdTime = post.created_at.getTime();
+    expect(createdTime).toBeGreaterThan(now - 24 * 60 * 60 * 1000); // Within last 24 hours
+    expect(createdTime).toBeLessThan(now + 24 * 60 * 60 * 1000); // Not more than 24 hours in future
+
+    // Verify we can compare timestamps
+    expect(post.created_at.getTime()).toBeGreaterThan(0);
+
+    // Test that the Date object has the correct methods
+    expect(typeof post.created_at.toISOString).toBe("function");
+    expect(typeof post.created_at.getTime).toBe("function");
+    expect(typeof post.created_at.getTimezoneOffset).toBe("function");
+
+    // Verify the date can be serialized and deserialized
+    const isoString = post.created_at.toISOString();
+    expect(typeof isoString).toBe("string");
+    expect(new Date(isoString).getTime()).toBe(post.created_at.getTime());
+  });
+
+  it("should create user and post in same transaction using returned ID", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+    const queries: DrizzleCompiledQuery[] = [];
+
+    // Create UOW and create both user and post in same transaction
+    const uow = queryEngine.createUnitOfWork("create-user-and-post", {
+      onQuery: (query) => queries.push(query),
+    });
+
+    // Create user and capture the returned ID
+    const userId = uow.create("users", {
+      name: "UOW Test User",
+      age: 35,
+    });
+
+    // Use the returned FragnoId directly to create a post in the same transaction
+    // The compiler will extract externalId and generate a subquery to lookup the internal ID
+    const postId = uow.create("posts", {
+      user_id: userId,
+      title: "UOW Test Post",
+      content: "This post was created in the same transaction as the user",
+    });
+
+    // Execute all mutations in a single transaction
+    const { success } = await uow.executeMutations();
+    expect(success).toBe(true);
+
+    // Verify both records were created
+    const userIdStr = userId.toString();
+    const postIdStr = postId.toString();
+
+    const [[user]] = await queryEngine
+      .createUnitOfWork("verify-user")
+      .find("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", userIdStr)))
+      .executeRetrieve();
+
+    expect(user.name).toBe("UOW Test User");
+    expect(user.age).toBe(35);
+
+    const [[post]] = await queryEngine
+      .createUnitOfWork("verify-post")
+      .find("posts", (b) => b.whereIndex("primary", (eb) => eb("id", "=", postIdStr)))
+      .executeRetrieve();
+
+    expect(post.title).toBe("UOW Test Post");
+    expect(post.content).toBe("This post was created in the same transaction as the user");
+
+    // Verify the foreign key relationship is correct
+    expect(post.user_id.internalId).toBe(user.id.internalId);
+
+    const [insertUserQuery, insertPostQuery] = queries;
+    expect(insertUserQuery.sql).toMatchInlineSnapshot(
+      `"insert into "users_namespace" ("id", "name", "age", "_internalId", "_version") values ($1, $2, $3, default, default)"`,
+    );
+    expect(insertUserQuery.params).toEqual([userId.externalId, "UOW Test User", 35]);
+    expect(insertPostQuery.sql).toMatchInlineSnapshot(
+      `"insert into "posts_namespace" ("id", "user_id", "title", "content", "created_at", "_internalId", "_version") values ($1, (select "_internalId" from "users_namespace" where "id" = $2 limit 1), $3, $4, default, default, default)"`,
+    );
+    expect(insertPostQuery.params).toEqual([
+      postId.externalId,
+      userId.externalId,
+      "UOW Test Post",
+      "This post was created in the same transaction as the user",
+    ]);
+  });
 });

package/src/adapters/drizzle/drizzle-adapter-sqlite.test.ts

@@ -118,16 +118,15 @@ describe("DrizzleAdapter SQLite", () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     // Create two users at once using UOW
-    const createUow = queryEngine
-      .createUnitOfWork("create-users")
-      .create("users", {
-        name: "Alice",
-        age: 25,
-      })
-      .create("users", {
-        name: "Bob",
-        age: 30,
-      });
+    const createUow = queryEngine.createUnitOfWork("create-users");
+    createUow.create("users", {
+      name: "Alice",
+      age: 25,
+    });
+    createUow.create("users", {
+      name: "Bob",
+      age: 30,
+    });
 
     expectTypeOf(createUow.find).parameter(0).toEqualTypeOf<keyof typeof testSchema.tables>();
 
@@ -232,12 +231,11 @@ describe("DrizzleAdapter SQLite", () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     // Create some users
-    await queryEngine
-      .createUnitOfWork("create-users")
-      .create("users", { name: "User1", age: 20 })
-      .create("users", { name: "User2", age: 30 })
-      .create("users", { name: "User3", age: 40 })
-      .executeMutations();
+    const createUow = queryEngine.createUnitOfWork("create-users");
+    createUow.create("users", { name: "User1", age: 20 });
+    createUow.create("users", { name: "User2", age: 30 });
+    createUow.create("users", { name: "User3", age: 40 });
+    await createUow.executeMutations();
 
     // Count all users
     const [totalCount] = await queryEngine
@@ -253,13 +251,12 @@ describe("DrizzleAdapter SQLite", () => {
   it("should support cursor-based pagination", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
-    const createUow = queryEngine
-      .createUnitOfWork("create-users")
-      .create("users", { name: "Page User A", age: 20 })
-      .create("users", { name: "Page User B", age: 30 })
-      .create("users", { name: "Page User C", age: 40 })
-      .create("users", { name: "Page User D", age: 50 })
-      .create("users", { name: "Page User E", age: 60 });
+    const createUow = queryEngine.createUnitOfWork("create-users");
+    createUow.create("users", { name: "Page User A", age: 20 });
+    createUow.create("users", { name: "Page User B", age: 30 });
+    createUow.create("users", { name: "Page User C", age: 40 });
+    createUow.create("users", { name: "Page User D", age: 50 });
+    createUow.create("users", { name: "Page User E", age: 60 });
 
     await createUow.executeMutations();
 
@@ -302,9 +299,8 @@ describe("DrizzleAdapter SQLite", () => {
   it("should support joins", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
-    const createUow = queryEngine
-      .createUnitOfWork("create-users")
-      .create("users", { name: "Email User", age: 20 });
+    const createUow = queryEngine.createUnitOfWork("create-users");
+    createUow.create("users", { name: "Email User", age: 20 });
 
     const { success } = await createUow.executeMutations();
     expect(success).toBe(true);
@@ -321,7 +317,8 @@ describe("DrizzleAdapter SQLite", () => {
     expect(createdUser.name).toBe("Email User");
 
     // Create an email for testing joins
-    const createEmailUow = queryEngine.createUnitOfWork("create-test-email").create("emails", {
+    const createEmailUow = queryEngine.createUnitOfWork("create-test-email");
+    createEmailUow.create("emails", {
       user_id: createdUser.id,
       email: "test@example.com",
       is_primary: true,
@@ -364,9 +361,8 @@ describe("DrizzleAdapter SQLite", () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
     // Create a user (author)
-    const createAuthorUow = queryEngine
-      .createUnitOfWork("create-author")
-      .create("users", { name: "Blog Author", age: 30 });
+    const createAuthorUow = queryEngine.createUnitOfWork("create-author");
+    createAuthorUow.create("users", { name: "Blog Author", age: 30 });
     await createAuthorUow.executeMutations();
 
     // Fetch the created author to get the proper ID
@@ -376,7 +372,8 @@ describe("DrizzleAdapter SQLite", () => {
       .executeRetrieve();
 
     // Create a post by the author
-    const createPostUow = queryEngine.createUnitOfWork("create-post").create("posts", {
+    const createPostUow = queryEngine.createUnitOfWork("create-post");
+    createPostUow.create("posts", {
       user_id: author.id,
       title: "My First Post",
       content: "This is the content of my first post",
@@ -390,9 +387,8 @@ describe("DrizzleAdapter SQLite", () => {
       .executeRetrieve();
 
     // Create a commenter
-    const createCommenterUow = queryEngine
-      .createUnitOfWork("create-commenter")
-      .create("users", { name: "Commenter User", age: 25 });
+    const createCommenterUow = queryEngine.createUnitOfWork("create-commenter");
+    createCommenterUow.create("users", { name: "Commenter User", age: 25 });
     await createCommenterUow.executeMutations();
 
     // Fetch the created commenter to get the proper ID
@@ -402,7 +398,8 @@ describe("DrizzleAdapter SQLite", () => {
       .executeRetrieve();
 
     // Create a comment on the post
-    const createCommentUow = queryEngine.createUnitOfWork("create-comment").create("comments", {
+    const createCommentUow = queryEngine.createUnitOfWork("create-comment");
+    createCommentUow.create("comments", {
       post_id: post.id,
       user_id: commenter.id,
       text: "Great post!",
@@ -580,4 +577,61 @@ describe("DrizzleAdapter SQLite", () => {
       age: 60,
     });
   });
+
+  it("should handle timestamps and timezones correctly", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+
+    // Create a user
+    const createUserUow = queryEngine.createUnitOfWork("create-user-for-timestamp");
+    createUserUow.create("users", { name: "Timestamp User", age: 28 });
+    await createUserUow.executeMutations();
+
+    const [[user]] = await queryEngine
+      .createUnitOfWork("get-user-for-timestamp")
+      .find("users", (b) => b.whereIndex("name_idx", (eb) => eb("name", "=", "Timestamp User")))
+      .executeRetrieve();
+
+    // Create a post (note: SQLite schema doesn't have created_at column)
+    const createPostUow = queryEngine.createUnitOfWork("create-post-for-timestamp");
+    createPostUow.create("posts", {
+      user_id: user.id,
+      title: "Timestamp Test Post",
+      content: "Testing timestamp handling",
+    });
+    await createPostUow.executeMutations();
+
+    // Retrieve the post
+    const [[post]] = await queryEngine
+      .createUnitOfWork("get-post-for-timestamp")
+      .find("posts", (b) => b.whereIndex("posts_user_idx", (eb) => eb("user_id", "=", user.id)))
+      .executeRetrieve();
+
+    expect(post).toBeDefined();
+    expect(post.title).toBe("Timestamp Test Post");
+
+    // Test general Date handling (SQLite stores timestamps as integers)
+    const now = new Date();
+    expect(now).toBeInstanceOf(Date);
+    expect(typeof now.getTime).toBe("function");
+    expect(typeof now.toISOString).toBe("function");
+
+    // Verify date serialization/deserialization works
+    const isoString = now.toISOString();
+    expect(typeof isoString).toBe("string");
+    expect(new Date(isoString).getTime()).toBe(now.getTime());
+
+    // Test timezone preservation
+    const specificDate = new Date("2024-06-15T14:30:00Z");
+    expect(specificDate.toISOString()).toBe("2024-06-15T14:30:00.000Z");
+
+    // Verify SQLite numeric timestamp conversion
+    const timestamp = Date.now();
+    const dateFromTimestamp = new Date(timestamp);
+    expect(dateFromTimestamp.getTime()).toBe(timestamp);
+
+    // Verify that dates from different timezones are handled correctly
+    const localDate = new Date("2024-06-15T14:30:00");
+    expect(localDate).toBeInstanceOf(Date);
+    expect(typeof localDate.getTimezoneOffset()).toBe("number");
+  });
 });

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

@@ -1,6 +1,6 @@
 import { drizzle } from "drizzle-orm/pglite";
-import { beforeAll, beforeEach, describe, expect, it } from "vitest";
-import { column, idColumn, referenceColumn, schema } from "../../schema/create";
+import { beforeAll, beforeEach, describe, expect, expectTypeOf, it } from "vitest";
+import { column, FragnoId, idColumn, referenceColumn, schema } from "../../schema/create";
 import type { DBType } from "./shared";
 import { writeAndLoadSchema } from "./test-utils";
 import { fromDrizzle } from "./drizzle-query";
@@ -134,10 +134,14 @@ describe("drizzle-query", () => {
     it("should find with select subset of columns", async () => {
       const someExternalId = "some-external-id";
 
-      await orm.findFirst("user", (b) =>
+      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;
       expect(query.sql).toMatchInlineSnapshot(
         `"select "id", "email", "_internalId", "_version" from "user" "user" where "user"."id" = $1 limit $2"`,
@@ -178,7 +182,7 @@ describe("drizzle-query", () => {
 
       const [query] = queries;
       expect(query.sql).toMatchInlineSnapshot(
-        `"select "id", "userId", "expiresAt", "createdAt", "_internalId", "_version" from "session" "session" where "session"."userId" = $1"`,
+        `"select "id", "userId", "expiresAt", "createdAt", "_internalId", "_version" from "session" "session" where "session"."userId" = (select "_internalId" from "user" where "id" = $1 limit 1)"`,
       );
       expect(query.params).toEqual([userId]);
     });
@@ -194,7 +198,7 @@ describe("drizzle-query", () => {
     });
 
     it("should find with select subset", async () => {
-      await orm.find("user", (b) => b.whereIndex("primary").select(["id", "email"]));
+      const _res = await orm.find("user", (b) => b.whereIndex("primary").select(["id", "email"]));
 
       const [query] = queries;
       expect(query.sql).toMatchInlineSnapshot(
@@ -331,6 +335,33 @@ describe("drizzle-query", () => {
       );
       expect(query.params).toEqual([newExpiresAt.toISOString(), 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.params).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", () => {
@@ -378,6 +409,25 @@ describe("drizzle-query", () => {
       expect(query.sql).toMatchInlineSnapshot(`"delete from "session" where "session"."id" = $1"`);
       expect(query.params).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.params).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", () => {
@@ -394,7 +444,7 @@ describe("drizzle-query", () => {
       // Verify the find query that's executed first
       const findQuery = queries[0];
       expect(findQuery.sql).toMatchInlineSnapshot(
-        `"select "id", "userId", "expiresAt", "createdAt", "_internalId", "_version" from "session" "session" where "session"."userId" = $1"`,
+        `"select "id", "userId", "expiresAt", "createdAt", "_internalId", "_version" from "session" "session" where "session"."userId" = (select "_internalId" from "user" where "id" = $1 limit 1)"`,
       );
       expect(findQuery.params).toEqual([userId]);