@fragno-dev/db 0.1.11 → 0.1.13

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

@@ -10,7 +10,7 @@ import {
   type FragnoId,
   type FragnoReference,
 } from "../../schema/create";
-import { encodeCursor } from "../../query/cursor";
+import { Cursor } from "../../query/cursor";
 
 describe("KyselyAdapter PGLite", () => {
   const testSchema = schema((s) => {
@@ -396,10 +396,12 @@ describe("KyselyAdapter PGLite", () => {
 
     // Get cursor for pagination (using the last item from page 1)
     const lastItem = page1Results[page1Results.length - 1]!;
-    const cursor = encodeCursor({
+    const cursor = new Cursor({
+      indexName: "name_idx",
+      orderDirection: "asc",
+      pageSize: 2,
       indexValues: { name: lastItem.name },
-      direction: "forward",
-    });
+    }).encode();
 
     // Get page 2 using the cursor
     const page2 = queryEngine
@@ -784,4 +786,188 @@ describe("KyselyAdapter PGLite", () => {
       age: 60,
     });
   });
+
+  it("should handle timestamps and timezones correctly", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create a user
+    const userId = await queryEngine.create("users", {
+      name: "Timestamp Test User",
+      age: 28,
+    });
+
+    // Create a post
+    const postId = await queryEngine.create("posts", {
+      user_id: userId,
+      title: "Timestamp Test Post",
+      content: "Testing timestamp handling",
+    });
+
+    // Retrieve the post
+    const post = await queryEngine.findFirst("posts", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", postId)),
+    );
+
+    expect(post).toBeDefined();
+
+    // Test with a table that doesn't have timestamps
+    // Verify that Date handling works in general by checking basic Date operations
+    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 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");
+  });
+
+  it("should create user and post in same transaction using returned ID", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create UOW and create both user and post in same transaction
+    const uow = queryEngine.createUnitOfWork("create-user-and-post");
+
+    // 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 user = await queryEngine.findFirst("users", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", userId)),
+    );
+
+    expect(user?.name).toBe("UOW Test User");
+    expect(user?.age).toBe(35);
+
+    const post = await queryEngine.findFirst("posts", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", postId.externalId)),
+    );
+
+    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);
+  });
+
+  it("should support cursor-based pagination with findWithCursor()", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create multiple users for pagination testing with unique prefix
+    const prefix = "CursorPagTest";
+    const userIds: FragnoId[] = [];
+    for (let i = 1; i <= 25; i++) {
+      const userId = await queryEngine.create("users", {
+        name: `${prefix} ${i.toString().padStart(2, "0")}`,
+        age: 20 + i,
+      });
+      userIds.push(userId);
+    }
+
+    // Fetch first page with cursor (filter by prefix to avoid other test data)
+    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);
+
+    assert(firstPage.cursor instanceof 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);
+
+    // Verify no overlap - all names in second page should be different from first page
+    const firstPageNames = new Set(firstPage.items.map((u) => u.name));
+    const secondPageNames = secondPage.items.map((u) => u.name);
+
+    for (const name of secondPageNames) {
+      expect(firstPageNames.has(name)).toBe(false);
+    }
+
+    // Verify ordering - last item of first page should come before first item of second page
+    const firstPageLast = firstPage.items[firstPage.items.length - 1].name;
+    const secondPageFirst = secondPage.items[0].name;
+    expect(firstPageLast < secondPageFirst).toBe(true);
+
+    // Verify our test data is present
+    const testUsers = await queryEngine.find("users", (b) =>
+      b.whereIndex("name_idx").pageSize(100),
+    );
+    const testUserNames = testUsers.filter((u) => u.name.startsWith(prefix)).map((u) => u.name);
+    expect(testUserNames).toHaveLength(25);
+  });
+
+  it("should support findWithCursor() in Unit of Work", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create test users if not already present
+    const existingUsers = await queryEngine.find("users", (b) =>
+      b.whereIndex("name_idx").pageSize(1),
+    );
+
+    if (existingUsers.length === 0) {
+      for (let i = 1; i <= 5; i++) {
+        await queryEngine.create("users", {
+          name: `UOW Cursor User ${i}`,
+          age: 30 + i,
+        });
+      }
+    }
+
+    // Use findWithCursor in UOW
+    const uow = queryEngine
+      .createUnitOfWork("cursor-test")
+      .findWithCursor("users", (b) =>
+        b.whereIndex("name_idx").orderByIndex("name_idx", "asc").pageSize(3),
+      );
+
+    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.length).toBeGreaterThan(0);
+
+    if (result.items.length === 3) {
+      expect(result.cursor).toBeInstanceOf(Cursor);
+    }
+  });
 });

package/src/adapters/kysely/kysely-adapter.ts

@@ -10,7 +10,7 @@ import type { AnySchema } from "../../schema/create";
 import type { CustomOperation, MigrationOperation } from "../../migration-engine/shared";
 import { execute, preprocessOperations } from "./migration/execute";
 import type { AbstractQuery } from "../../query/query";
-import { fromKysely } from "./kysely-query";
+import { fromKysely, type KyselyUOWConfig } from "./kysely-query";
 import { createTableNameMapper } from "./kysely-shared";
 import { createHash } from "node:crypto";
 import { SETTINGS_TABLE_NAME } from "../../shared/settings-schema";
@@ -25,7 +25,7 @@ export interface KyselyConfig {
   provider: SQLProvider;
 }
 
-export class KyselyAdapter implements DatabaseAdapter {
+export class KyselyAdapter implements DatabaseAdapter<KyselyUOWConfig> {
   #connectionPool: ConnectionPool<KyselyAny>;
   #provider: SQLProvider;
 
@@ -46,7 +46,10 @@ export class KyselyAdapter implements DatabaseAdapter {
     await this.#connectionPool.close();
   }
 
-  createQueryEngine<T extends AnySchema>(schema: T, namespace: string): AbstractQuery<T> {
+  createQueryEngine<T extends AnySchema>(
+    schema: T,
+    namespace: string,
+  ): AbstractQuery<T, KyselyUOWConfig> {
     // Only create mapper if namespace is non-empty
     const mapper = namespace ? createTableNameMapper(namespace) : undefined;
     return fromKysely(schema, this.#connectionPool, this.#provider, mapper);