@fragno-dev/db 0.1.11 → 0.1.13

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

@@ -1,10 +1,10 @@
 import { drizzle } from "drizzle-orm/pglite";
 import { DrizzleAdapter } from "./drizzle-adapter";
-import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
+import { assert, beforeAll, describe, expect, expectTypeOf, it } from "vitest";
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
 import type { DBType } from "./shared";
 import { createRequire } from "node:module";
-import { encodeCursor } from "../../query/cursor";
+import { Cursor } from "../../query/cursor";
 import type { DrizzleCompiledQuery } from "./drizzle-uow-compiler";
 import { writeAndLoadSchema } from "./test-utils";
 
@@ -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();
 
@@ -242,10 +245,12 @@ describe("DrizzleAdapter PGLite", () => {
 
     // Create cursor from last item of first page
     const lastItem = firstPage[firstPage.length - 1]!;
-    const cursor = encodeCursor({
+    const cursor = new Cursor({
+      indexName: "name_idx",
+      orderDirection: "asc",
+      pageSize: 2,
       indexValues: { name: lastItem.name },
-      direction: "forward",
-    });
+    }).encode();
 
     // Fetch next page using cursor
     const [secondPage] = await queryEngine
@@ -269,9 +274,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 +286,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 +335,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 +348,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 +388,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 +399,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 +411,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 +422,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 +567,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 +610,190 @@ 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",
+    ]);
+  });
+
+  it("should support cursor-based pagination with findWithCursor()", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+
+    // Create multiple users for pagination testing
+    for (let i = 1; i <= 25; i++) {
+      await queryEngine.create("users", {
+        name: `Cursor User ${i.toString().padStart(2, "0")}`,
+        age: 20 + i,
+      });
+    }
+
+    // Fetch first page with cursor
+    const firstPage = await queryEngine.findWithCursor("users", (b) =>
+      b.whereIndex("name_idx").orderByIndex("name_idx", "asc").pageSize(10),
+    );
+
+    // Check structure
+    expect(firstPage).toHaveProperty("items");
+    expect(firstPage).toHaveProperty("cursor");
+    expect(Array.isArray(firstPage.items)).toBe(true);
+    expect(firstPage.items.length).toBeGreaterThan(0);
+    expect(firstPage.items.length).toBeLessThanOrEqual(10);
+
+    assert(firstPage.cursor instanceof Cursor);
+    expect(firstPage.items).toHaveLength(10);
+    expect(firstPage.cursor).toBeInstanceOf(Cursor);
+
+    // Fetch second page using cursor
+    const secondPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_idx")
+        .after(firstPage.cursor!)
+        .orderByIndex("name_idx", "asc")
+        .pageSize(10),
+    );
+
+    expect(secondPage.items.length).toBeGreaterThan(0);
+    expect(secondPage.items.length).toBeLessThanOrEqual(10);
+
+    // Verify no overlap - first item of second page should come after last item of first page
+    const firstPageLastName = firstPage.items[firstPage.items.length - 1].name;
+    const secondPageFirstName = secondPage.items[0].name;
+    expect(secondPageFirstName > firstPageLastName).toBe(true);
+  });
+
+  it("should support findWithCursor() in Unit of Work", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+
+    // Use findWithCursor in UOW
+    const uow = queryEngine
+      .createUnitOfWork("cursor-test")
+      .findWithCursor("users", (b) =>
+        b.whereIndex("name_idx").orderByIndex("name_idx", "asc").pageSize(5),
+      );
+
+    const [result] = await uow.executeRetrieve();
+
+    // Verify result structure
+    expect(result).toHaveProperty("items");
+    expect(result).toHaveProperty("cursor");
+    expect(Array.isArray(result.items)).toBe(true);
+    expect(result.items).toHaveLength(5);
+    expect(result.cursor).toBeInstanceOf(Cursor);
+  });
 });

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

@@ -6,7 +6,7 @@ import { column, idColumn, referenceColumn, schema } from "../../schema/create";
 import type { DBType } from "./shared";
 import { createRequire } from "node:module";
 import { writeAndLoadSchema } from "./test-utils";
-import { encodeCursor } from "../../query/cursor";
+import { Cursor } from "../../query/cursor";
 
 // Import drizzle-kit for migrations
 const require = createRequire(import.meta.url);
@@ -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();
 
@@ -275,10 +272,12 @@ describe("DrizzleAdapter SQLite", () => {
 
     // Create cursor from last item of first page
     const lastItem = firstPage[firstPage.length - 1]!;
-    const cursor = encodeCursor({
+    const cursor = new Cursor({
+      indexName: "name_idx",
+      orderDirection: "asc",
+      pageSize: 2,
       indexValues: { name: lastItem.name },
-      direction: "forward",
-    });
+    }).encode();
 
     // Fetch next page using cursor
     const [secondPage] = await queryEngine
@@ -302,9 +301,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 +319,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 +363,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 +374,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 +389,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 +400,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 +579,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");
+  });
 });