@fragno-dev/db 0.1.13 → 0.1.15

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

@@ -1,6 +1,6 @@
 import { drizzle } from "drizzle-orm/pglite";
 import { DrizzleAdapter } from "./drizzle-adapter";
-import { assert, beforeAll, describe, expect, expectTypeOf, it } from "vitest";
+import { 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";
@@ -126,7 +126,12 @@ describe("DrizzleAdapter PGLite", () => {
       age: 25,
     });
 
-    expectTypeOf(createUow.find).parameter(0).toEqualTypeOf<keyof typeof testSchema.tables>();
+    expectTypeOf<keyof typeof testSchema.tables>().toEqualTypeOf<
+      Parameters<typeof createUow.find>[0]
+    >();
+    expectTypeOf<keyof typeof testSchema.tables>().toEqualTypeOf<
+      "users" | "emails" | "posts" | "comments"
+    >();
 
     const { success: createSuccess } = await createUow.executeMutations();
     expect(createSuccess).toBe(true);
@@ -735,46 +740,61 @@ describe("DrizzleAdapter PGLite", () => {
   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++) {
+    // Create exactly 15 users for precise pagination testing
+    const prefix = "CursorPagTest";
+
+    for (let i = 1; i <= 15; i++) {
       await queryEngine.create("users", {
-        name: `Cursor User ${i.toString().padStart(2, "0")}`,
+        name: `${prefix} ${i.toString().padStart(2, "0")}`,
         age: 20 + i,
       });
     }
 
-    // Fetch first page with cursor
+    // Fetch first page with cursor (pageSize=10, total=15 items)
     const firstPage = await queryEngine.findWithCursor("users", (b) =>
-      b.whereIndex("name_idx").orderByIndex("name_idx", "asc").pageSize(10),
+      b
+        .whereIndex("name_idx", (eb) => eb("name", "starts with", prefix))
+        .orderByIndex("name_idx", "asc")
+        .pageSize(10),
     );
 
-    // Check structure
+    // Check structure and hasNextPage
     expect(firstPage).toHaveProperty("items");
     expect(firstPage).toHaveProperty("cursor");
+    expect(firstPage).toHaveProperty("hasNextPage");
     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.hasNextPage).toBe(true);
     expect(firstPage.cursor).toBeInstanceOf(Cursor);
 
-    // Fetch second page using cursor
+    // Fetch second page using cursor (last page with 5 remaining items)
     const secondPage = await queryEngine.findWithCursor("users", (b) =>
       b
-        .whereIndex("name_idx")
+        .whereIndex("name_idx", (eb) => eb("name", "starts with", prefix))
         .after(firstPage.cursor!)
         .orderByIndex("name_idx", "asc")
         .pageSize(10),
     );
 
-    expect(secondPage.items.length).toBeGreaterThan(0);
-    expect(secondPage.items.length).toBeLessThanOrEqual(10);
+    expect(secondPage.items).toHaveLength(5);
+    expect(secondPage.hasNextPage).toBe(false);
+    expect(secondPage.cursor).toBeUndefined();
 
     // 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);
+
+    // Test empty results
+    const emptyPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_idx", (eb) => eb("name", "starts with", "NonExistentPrefix"))
+        .orderByIndex("name_idx", "asc")
+        .pageSize(10),
+    );
+    expect(emptyPage.items).toHaveLength(0);
+    expect(emptyPage.hasNextPage).toBe(false);
+    expect(emptyPage.cursor).toBeUndefined();
   });
 
   it("should support findWithCursor() in Unit of Work", async () => {
@@ -789,11 +809,60 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [result] = await uow.executeRetrieve();
 
-    // Verify result structure
+    // Verify result structure including hasNextPage
     expect(result).toHaveProperty("items");
     expect(result).toHaveProperty("cursor");
+    expect(result).toHaveProperty("hasNextPage");
     expect(Array.isArray(result.items)).toBe(true);
     expect(result.items).toHaveLength(5);
+    expect(typeof result.hasNextPage).toBe("boolean");
     expect(result.cursor).toBeInstanceOf(Cursor);
   });
+
+  it("should fail check() when version changes", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+
+    // Create a user
+    const createUserUow = queryEngine.createUnitOfWork("create-user-for-version-conflict");
+    createUserUow.create("users", {
+      name: "Version Conflict User",
+      age: 40,
+    });
+    await createUserUow.executeMutations();
+
+    // Get the user
+    const [[user]] = await queryEngine
+      .createUnitOfWork("get-user-for-version-conflict")
+      .find("users", (b) =>
+        b.whereIndex("name_idx", (eb) => eb("name", "=", "Version Conflict User")),
+      )
+      .executeRetrieve();
+
+    // Update the user to increment their version
+    const updateUow = queryEngine.createUnitOfWork("update-user-version");
+    updateUow.update("users", user.id, (b) => b.set({ age: 41 }));
+    await updateUow.executeMutations();
+
+    // Try to check with the old version (should fail)
+    const uow = queryEngine.createUnitOfWork("check-stale-version");
+    uow.check("users", user.id); // This has version 0, but the user now has version 1
+    uow.create("posts", {
+      user_id: user.id,
+      title: "Should Not Be Created",
+      content: "Content",
+      created_at: new Date(),
+    });
+
+    const { success } = await uow.executeMutations();
+    expect(success).toBe(false);
+
+    // Verify the post was NOT created
+    const [posts] = await queryEngine
+      .createUnitOfWork("get-posts-for-version-conflict")
+      .find("posts", (b) => b.whereIndex("posts_user_idx", (eb) => eb("user_id", "=", user.id)))
+      .executeRetrieve();
+
+    const conflictPosts = posts.filter((p) => p.title === "Should Not Be Created");
+    expect(conflictPosts).toHaveLength(0);
+  });
 });

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

@@ -1,12 +1,14 @@
 import { drizzle } from "drizzle-orm/libsql";
 import { createClient } from "@libsql/client";
 import { DrizzleAdapter } from "./drizzle-adapter";
-import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
-import { column, idColumn, referenceColumn, schema } from "../../schema/create";
+import { beforeAll, describe, expect, expectTypeOf, it, assert } from "vitest";
+import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
 import type { DBType } from "./shared";
 import { createRequire } from "node:module";
 import { writeAndLoadSchema } from "./test-utils";
 import { Cursor } from "../../query/cursor";
+import { executeUnitOfWork } from "../../query/execute-unit-of-work";
+import { ExponentialBackoffRetryPolicy } from "../../query/retry-policy";
 
 // Import drizzle-kit for migrations
 const require = createRequire(import.meta.url);
@@ -71,6 +73,30 @@ describe("DrizzleAdapter SQLite", () => {
       });
   });
 
+  // Second schema for multi-schema testing
+  const schema2 = schema((s) => {
+    return s
+      .addTable("products", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("name", column("string"))
+          .addColumn("price", column("integer"))
+          .createIndex("name_idx", ["name"]);
+      })
+      .addTable("orders", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("product_id", referenceColumn())
+          .addColumn("quantity", column("integer"))
+          .createIndex("product_orders_idx", ["product_id"]);
+      })
+      .addReference("product", {
+        type: "one",
+        from: { table: "orders", column: "product_id" },
+        to: { table: "products", column: "id" },
+      });
+  });
+
   let adapter: DrizzleAdapter;
   let db: DBType;
   // let sqliteDb: Database.Database;
@@ -84,17 +110,28 @@ describe("DrizzleAdapter SQLite", () => {
       "namespace",
     );
 
+    // Write second schema to file and dynamically import it
+    const { schemaModule: schemaModule2, cleanup: cleanup2 } = await writeAndLoadSchema(
+      "drizzle-adapter-sqlite-schema2",
+      schema2,
+      "sqlite",
+      "namespace2",
+    );
+
     const client = createClient({
       url: "file::memory:?cache=shared",
     });
 
+    // Merge both schema modules for the db
+    const mergedSchema = { ...schemaModule, ...schemaModule2 };
+
     db = drizzle(client, {
-      schema: schemaModule,
+      schema: mergedSchema,
     }) as unknown as DBType;
 
-    // Generate and run migrations
+    // Generate and run migrations for both schemas
     const emptyJson = await generateSQLiteDrizzleJson({});
-    const targetJson = await generateSQLiteDrizzleJson(schemaModule);
+    const targetJson = await generateSQLiteDrizzleJson(mergedSchema);
 
     const migrationStatements = await generateSQLiteMigration(emptyJson, targetJson);
 
@@ -110,6 +147,7 @@ describe("DrizzleAdapter SQLite", () => {
     return async () => {
       client.close();
       await cleanup();
+      await cleanup2();
     };
   }, 12000);
 
@@ -128,7 +166,12 @@ describe("DrizzleAdapter SQLite", () => {
       age: 30,
     });
 
-    expectTypeOf(createUow.find).parameter(0).toEqualTypeOf<keyof typeof testSchema.tables>();
+    expectTypeOf<keyof typeof testSchema.tables>().toEqualTypeOf<
+      Parameters<typeof createUow.find>[0]
+    >();
+    expectTypeOf<keyof typeof testSchema.tables>().toEqualTypeOf<
+      "users" | "emails" | "posts" | "comments"
+    >();
 
     const { success: createSuccess } = await createUow.executeMutations();
     expect(createSuccess).toBe(true);
@@ -230,7 +273,6 @@ describe("DrizzleAdapter SQLite", () => {
   it("should support count operations", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
-    // Create some users
     const createUow = queryEngine.createUnitOfWork("create-users");
     createUow.create("users", { name: "User1", age: 20 });
     createUow.create("users", { name: "User2", age: 30 });
@@ -636,4 +678,246 @@ describe("DrizzleAdapter SQLite", () => {
     expect(localDate).toBeInstanceOf(Date);
     expect(typeof localDate.getTimezoneOffset()).toBe("number");
   });
+
+  it("should support forSchema for multi-schema queries", async () => {
+    const queryEngine1 = adapter.createQueryEngine(testSchema, "namespace");
+    const queryEngine2 = adapter.createQueryEngine(schema2, "namespace2");
+
+    // Create test data in schema1 (users)
+    const createUsersUow = queryEngine1.createUnitOfWork("create-users-for-multi-schema");
+    createUsersUow.create("users", { name: "Multi Schema User 1", age: 25 });
+    createUsersUow.create("users", { name: "Multi Schema User 2", age: 30 });
+    const { success: success1 } = await createUsersUow.executeMutations();
+    expect(success1).toBe(true);
+
+    // Create test data in schema2 (products)
+    const createProductsUow = queryEngine2.createUnitOfWork("create-products-for-multi-schema");
+    createProductsUow.create("products", { name: "Product A", price: 100 });
+    createProductsUow.create("products", { name: "Product B", price: 200 });
+    const { success: success2 } = await createProductsUow.executeMutations();
+    expect(success2).toBe(true);
+
+    // Now use forSchema to query from both schemas
+    const uow = queryEngine1.createUnitOfWork("multi-schema-query");
+
+    const view1 = uow
+      .forSchema(testSchema)
+      .find("users", (b) =>
+        b
+          .whereIndex("name_idx", (eb) => eb("name", "starts with", "Multi Schema User"))
+          .select(["id", "name"]),
+      )
+      .find("users", (b) =>
+        b
+          .whereIndex("name_idx", (eb) => eb("name", "starts with", "Multi Schema User"))
+          .select(["name", "age"]),
+      );
+
+    const view2 = uow
+      .forSchema(schema2)
+      .find("products", (b) => b.whereIndex("primary").select(["name", "price"]));
+
+    // Execute the retrieval phase once
+    await uow.executeRetrieve();
+
+    // Get results from view1
+    const [users1, users2] = await view1.retrievalPhase;
+    const [user1] = users1;
+    expectTypeOf(user1).toMatchObjectType<{ id: FragnoId; name: string }>();
+
+    const [user2] = users2;
+    expectTypeOf(user2).toMatchObjectType<{ name: string; age: number | null }>();
+
+    // Get results from view2
+    const [products] = await view2.retrievalPhase;
+    const [product1] = products;
+    expectTypeOf(product1).toMatchObjectType<{ name: string; price: number }>();
+
+    // Verify users from schema1
+    expect(users1).toHaveLength(2);
+    expect(users1[0]).toMatchObject({
+      id: expect.any(Object),
+      name: "Multi Schema User 1",
+    });
+    expect(users1[1]).toMatchObject({
+      id: expect.any(Object),
+      name: "Multi Schema User 2",
+    });
+
+    expect(users2).toHaveLength(2);
+    expect(users2[0]).toMatchObject({
+      name: "Multi Schema User 1",
+      age: 25,
+    });
+    expect(users2[1]).toMatchObject({
+      name: "Multi Schema User 2",
+      age: 30,
+    });
+
+    // Verify products from schema2
+    expect(products).toHaveLength(2);
+    expect(products[0]).toMatchObject({
+      name: "Product A",
+      price: 100,
+    });
+    expect(products[1]).toMatchObject({
+      name: "Product B",
+      price: 200,
+    });
+  });
+
+  it("should verify hasNextPage in cursor pagination", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+
+    // Create exactly 15 users for precise pagination testing
+    const prefix = "HasNextPageTest";
+
+    for (let i = 1; i <= 15; i++) {
+      await queryEngine.create("users", {
+        name: `${prefix} ${i.toString().padStart(2, "0")}`,
+        age: 20 + i,
+      });
+    }
+
+    // Test 1: First page with more results available (pageSize=10, total=15)
+    const firstPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_idx", (eb) => eb("name", "starts with", prefix))
+        .orderByIndex("name_idx", "asc")
+        .pageSize(10),
+    );
+
+    expect(firstPage.items).toHaveLength(10);
+    expect(firstPage.hasNextPage).toBe(true);
+    expect(firstPage.cursor).toBeInstanceOf(Cursor);
+
+    // Test 2: Second page (last page, partial results: 5 items remaining)
+    const secondPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_idx", (eb) => eb("name", "starts with", prefix))
+        .after(firstPage.cursor!)
+        .orderByIndex("name_idx", "asc")
+        .pageSize(10),
+    );
+
+    expect(secondPage.items).toHaveLength(5);
+    expect(secondPage.hasNextPage).toBe(false);
+    expect(secondPage.cursor).toBeUndefined();
+
+    // Test 3: Empty results
+    const emptyPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_idx", (eb) => eb("name", "starts with", "NonExistentPrefix"))
+        .orderByIndex("name_idx", "asc")
+        .pageSize(10),
+    );
+
+    expect(emptyPage.items).toHaveLength(0);
+    expect(emptyPage.hasNextPage).toBe(false);
+    expect(emptyPage.cursor).toBeUndefined();
+  });
+
+  it("should support executeUnitOfWork with retry logic", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+
+    // Create a test user
+    const createUow = queryEngine.createUnitOfWork("create-user-for-execute-uow");
+    createUow.create("users", { name: "Execute UOW User", age: 42 });
+    await createUow.executeMutations();
+
+    // Fetch the user to get their ID
+    const [[user]] = await queryEngine
+      .createUnitOfWork("get-user-for-execute-uow")
+      .find("users", (b) => b.whereIndex("name_idx", (eb) => eb("name", "=", "Execute UOW User")))
+      .executeRetrieve();
+
+    // Use executeUnitOfWork to increment age with optimistic locking
+    const result = await executeUnitOfWork(
+      {
+        retrieve: (uow) =>
+          uow.find("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", user.id))),
+        mutate: (uow, [users]) => {
+          const foundUser = users[0];
+          const newAge = foundUser.age! + 1;
+          uow.update("users", foundUser.id, (b) => b.set({ age: newAge }).check());
+          return { previousAge: foundUser.age, newAge };
+        },
+        onSuccess: ({ mutationResult }) => {
+          // Verify the age was incremented correctly
+          expect(mutationResult.newAge).toBe(mutationResult.previousAge! + 1);
+        },
+      },
+      {
+        createUnitOfWork: () => queryEngine.createUnitOfWork("execute-uow-update"),
+        retryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3, initialDelayMs: 1 }),
+      },
+    );
+
+    // Verify the operation succeeded
+    assert(result.success);
+    expect(result.mutationResult).toEqual({
+      previousAge: 42,
+      newAge: 43,
+    });
+
+    // Verify the user was actually updated in the database
+    const updatedUser = await queryEngine.findFirst("users", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", user.id)),
+    );
+
+    expect(updatedUser).toMatchObject({
+      id: expect.objectContaining({
+        externalId: user.id.externalId,
+        version: 1, // Version incremented due to check()
+      }),
+      name: "Execute UOW User",
+      age: 43,
+    });
+  });
+
+  it("should fail check() when version changes", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+
+    // Create a user
+    const createUserUow = queryEngine.createUnitOfWork("create-user-for-version-conflict");
+    createUserUow.create("users", {
+      name: "Version Conflict User SQLite",
+      age: 40,
+    });
+    await createUserUow.executeMutations();
+
+    // Get the user
+    const [[user]] = await queryEngine
+      .createUnitOfWork("get-user-for-version-conflict")
+      .find("users", (b) =>
+        b.whereIndex("name_idx", (eb) => eb("name", "=", "Version Conflict User SQLite")),
+      )
+      .executeRetrieve();
+
+    // Update the user to increment their version
+    const updateUow = queryEngine.createUnitOfWork("update-user-version");
+    updateUow.update("users", user.id, (b) => b.set({ age: 41 }));
+    await updateUow.executeMutations();
+
+    // Try to check with the old version (should fail)
+    const uow = queryEngine.createUnitOfWork("check-stale-version");
+    uow.check("users", user.id); // This has version 0, but the user now has version 1
+    uow.create("posts", {
+      user_id: user.id,
+      title: "Should Not Be Created SQLite",
+      content: "Content",
+    });
+
+    const { success } = await uow.executeMutations();
+    expect(success).toBe(false);
+
+    // Verify the post was NOT created
+    const [posts] = await queryEngine
+      .createUnitOfWork("get-posts-for-version-conflict")
+      .find("posts", (b) => b.whereIndex("posts_user_idx", (eb) => eb("user_id", "=", user.id)))
+      .executeRetrieve();
+
+    const conflictPosts = posts.filter((p) => p.title === "Should Not Be Created SQLite");
+    expect(conflictPosts).toHaveLength(0);
+  });
 });

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

@@ -20,25 +20,9 @@ describe("DrizzleAdapter", () => {
 
     expect(result.path).toBe("schema.ts");
     expect(result.schema).toMatchInlineSnapshot(`
-      "import { pgTable, varchar, text, bigserial, integer, uniqueIndex } from "drizzle-orm/pg-core"
+      "import { pgTable, varchar, text, bigserial, integer } from "drizzle-orm/pg-core"
       import { createId } from "@fragno-dev/db/id"
 
-      // ============================================================================
-      // Settings Table (shared across all fragments)
-      // ============================================================================
-
-      export const fragno_db_settings = pgTable("fragno_db_settings", {
-        id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
-        key: text("key").notNull(),
-        value: text("value").notNull(),
-        _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
-        _version: integer("_version").notNull().default(0)
-      }, (table) => [
-        uniqueIndex("unique_key").on(table.key)
-      ])
-
-      export const fragnoDbSettingSchemaVersion = 1;
-
       // ============================================================================
       // Fragment: test
       // ============================================================================
@@ -69,25 +53,9 @@ describe("DrizzleAdapter", () => {
 
     expect(result.path).toBe("schema.ts");
     expect(result.schema).toMatchInlineSnapshot(`
-      "import { sqliteTable, text, integer, uniqueIndex } from "drizzle-orm/sqlite-core"
+      "import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core"
       import { createId } from "@fragno-dev/db/id"
 
-      // ============================================================================
-      // Settings Table (shared across all fragments)
-      // ============================================================================
-
-      export const fragno_db_settings = sqliteTable("fragno_db_settings", {
-        id: text("id").notNull().$defaultFn(() => createId()),
-        key: text("key").notNull(),
-        value: text("value").notNull(),
-        _internalId: integer("_internalId").primaryKey({ autoIncrement: true }).notNull(),
-        _version: integer("_version").notNull().default(0)
-      }, (table) => [
-        uniqueIndex("unique_key").on(table.key)
-      ])
-
-      export const fragnoDbSettingSchemaVersion = 1;
-
       // ============================================================================
       // Fragment: test
       // ============================================================================
@@ -130,25 +98,9 @@ describe("DrizzleAdapter", () => {
 
     // Original table should still be there
     expect(result.schema).toMatchInlineSnapshot(`
-      "import { pgTable, varchar, text, bigserial, integer, uniqueIndex } from "drizzle-orm/pg-core"
+      "import { pgTable, varchar, text, bigserial, integer } from "drizzle-orm/pg-core"
       import { createId } from "@fragno-dev/db/id"
 
-      // ============================================================================
-      // Settings Table (shared across all fragments)
-      // ============================================================================
-
-      export const fragno_db_settings = pgTable("fragno_db_settings", {
-        id: varchar("id", { length: 30 }).notNull().$defaultFn(() => createId()),
-        key: text("key").notNull(),
-        value: text("value").notNull(),
-        _internalId: bigserial("_internalId", { mode: "number" }).primaryKey().notNull(),
-        _version: integer("_version").notNull().default(0)
-      }, (table) => [
-        uniqueIndex("unique_key").on(table.key)
-      ])
-
-      export const fragnoDbSettingSchemaVersion = 1;
-
       // ============================================================================
       // Fragment: test
       // ============================================================================