@fragno-dev/db 0.2.2 → 0.4.1

package/src/adapters/{drizzle/drizzle-adapter-pglite.test.ts → generic-sql/sql-adapter-pglite-queries.test.ts}

@@ -1,18 +1,21 @@
-import { PGlite } from "@electric-sql/pglite";
-import { KyselyPGlite } from "kysely-pglite";
-import { DrizzleAdapter } from "./drizzle-adapter";
 import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
-import { column, idColumn, referenceColumn, schema } from "../../schema/create";
+
+import { KyselyPGlite } from "kysely-pglite";
+
+import { PGlite } from "@electric-sql/pglite";
+
+import { internalSchema } from "../../fragments/internal-fragment";
 import { Cursor } from "../../query/cursor";
-import { PGLiteDriverConfig } from "../generic-sql/driver-config";
+import { column, idColumn, referenceColumn, schema } from "../../schema/create";
 import type { CompiledQuery } from "../../sql-driver/sql-driver";
-import { internalSchema } from "../../fragments/internal-fragment";
+import { PGLiteDriverConfig } from "./driver-config";
+import { SqlAdapter } from "./generic-sql-adapter";
 
-describe("DrizzleAdapter PGLite", () => {
+describe("SqlAdapter PGLite", () => {
   let pgliteDatabase: PGlite;
-  let adapter: DrizzleAdapter;
+  let adapter: SqlAdapter;
 
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
@@ -73,7 +76,7 @@ describe("DrizzleAdapter PGLite", () => {
       });
   });
 
-  const schema2 = schema((s) => {
+  const schema2 = schema("schema2", (s) => {
     return s
       .addTable("products", (t) => {
         return t
@@ -98,7 +101,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const { dialect } = new KyselyPGlite(pgliteDatabase);
 
-    adapter = new DrizzleAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new PGLiteDriverConfig(),
     });
@@ -321,7 +324,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [query] = queries;
     expect(query.sql).toMatchInlineSnapshot(
-      `"select "user"."name" as "user:name", "user"."id" as "user:id", "user"."age" as "user:age", "user"."_internalId" as "user:_internalId", "user"."_version" as "user:_version", "emails_namespace"."id" as "id", "emails_namespace"."user_id" as "user_id", "emails_namespace"."email" as "email", "emails_namespace"."is_primary" as "is_primary", "emails_namespace"."_internalId" as "_internalId", "emails_namespace"."_version" as "_version" from "emails_namespace" left join "users_namespace" as "user" on "emails_namespace"."user_id" = "user"."_internalId""`,
+      `"select "user"."name" as "user:name", "user"."id" as "user:id", "user"."age" as "user:age", "user"."_internalId" as "user:_internalId", "user"."_version" as "user:_version", "namespace"."emails"."id" as "id", "namespace"."emails"."user_id" as "user_id", "namespace"."emails"."email" as "email", "namespace"."emails"."is_primary" as "is_primary", "namespace"."emails"."_internalId" as "_internalId", "namespace"."emails"."_version" as "_version" from "namespace"."emails" left join "namespace"."users" as "user" on "namespace"."emails"."user_id" = "user"."_internalId""`,
     );
 
     expect(email).toMatchObject({
@@ -502,7 +505,7 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [query] = queries;
     expect(query.sql).toMatchInlineSnapshot(
-      `"select "post"."id" as "post:id", "post"."title" as "post:title", "post"."content" as "post:content", "post"."_internalId" as "post:_internalId", "post"."_version" as "post:_version", "post_author"."id" as "post:author:id", "post_author"."name" as "post:author:name", "post_author"."age" as "post:author:age", "post_author"."_internalId" as "post:author:_internalId", "post_author"."_version" as "post:author:_version", "commenter"."id" as "commenter:id", "commenter"."name" as "commenter:name", "commenter"."_internalId" as "commenter:_internalId", "commenter"."_version" as "commenter:_version", "comments_namespace"."id" as "id", "comments_namespace"."post_id" as "post_id", "comments_namespace"."user_id" as "user_id", "comments_namespace"."text" as "text", "comments_namespace"."_internalId" as "_internalId", "comments_namespace"."_version" as "_version" from "comments_namespace" left join "posts_namespace" as "post" on "comments_namespace"."post_id" = "post"."_internalId" left join "users_namespace" as "post_author" on "post"."user_id" = "post_author"."_internalId" left join "users_namespace" as "commenter" on "comments_namespace"."user_id" = "commenter"."_internalId""`,
+      `"select "post"."id" as "post:id", "post"."title" as "post:title", "post"."content" as "post:content", "post"."_internalId" as "post:_internalId", "post"."_version" as "post:_version", "post_author"."id" as "post:author:id", "post_author"."name" as "post:author:name", "post_author"."age" as "post:author:age", "post_author"."_internalId" as "post:author:_internalId", "post_author"."_version" as "post:author:_version", "commenter"."id" as "commenter:id", "commenter"."name" as "commenter:name", "commenter"."_internalId" as "commenter:_internalId", "commenter"."_version" as "commenter:_version", "namespace"."comments"."id" as "id", "namespace"."comments"."post_id" as "post_id", "namespace"."comments"."user_id" as "user_id", "namespace"."comments"."text" as "text", "namespace"."comments"."_internalId" as "_internalId", "namespace"."comments"."_version" as "_version" from "namespace"."comments" left join "namespace"."posts" as "post" on "namespace"."comments"."post_id" = "post"."_internalId" left join "namespace"."users" as "post_author" on "post"."user_id" = "post_author"."_internalId" left join "namespace"."users" as "commenter" on "namespace"."comments"."user_id" = "commenter"."_internalId""`,
     );
   });
 
@@ -614,11 +617,11 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [insertUserQuery, insertPostQuery] = queries;
     expect(insertUserQuery.sql).toMatchInlineSnapshot(
-      `"insert into "users_namespace" ("id", "name", "age") values ($1, $2, $3) returning "users_namespace"."id" as "id", "users_namespace"."name" as "name", "users_namespace"."age" as "age", "users_namespace"."_internalId" as "_internalId", "users_namespace"."_version" as "_version""`,
+      `"insert into "namespace"."users" ("id", "name", "age") values ($1, $2, $3) returning "namespace"."users"."id" as "id", "namespace"."users"."name" as "name", "namespace"."users"."age" as "age", "namespace"."users"."_internalId" as "_internalId", "namespace"."users"."_version" as "_version""`,
     );
     expect(insertUserQuery.parameters).toEqual([userId.externalId, "UOW Test User", 35]);
     expect(insertPostQuery.sql).toMatchInlineSnapshot(
-      `"insert into "posts_namespace" ("id", "user_id", "title", "content") values ($1, (select "_internalId" from "users_namespace" where "id" = $2 limit $3), $4, $5) returning "posts_namespace"."id" as "id", "posts_namespace"."user_id" as "user_id", "posts_namespace"."title" as "title", "posts_namespace"."content" as "content", "posts_namespace"."created_at" as "created_at", "posts_namespace"."_internalId" as "_internalId", "posts_namespace"."_version" as "_version""`,
+      `"insert into "namespace"."posts" ("id", "user_id", "title", "content") values ($1, (select "_internalId" from "namespace"."users" where "id" = $2 limit $3), $4, $5) returning "namespace"."posts"."id" as "id", "namespace"."posts"."user_id" as "user_id", "namespace"."posts"."title" as "title", "namespace"."posts"."content" as "content", "namespace"."posts"."created_at" as "created_at", "namespace"."posts"."_internalId" as "_internalId", "namespace"."posts"."_version" as "_version""`,
     );
     expect(insertPostQuery.parameters).toEqual([
       postId.externalId,

package/src/adapters/generic-sql/{test/generic-drizzle-adapter-sqlite3.test.ts → sql-adapter-sqlite3-driver.test.ts}

@@ -1,28 +1,32 @@
-import SQLite from "better-sqlite3";
 import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
-import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../../schema/create";
+
+import SQLite from "better-sqlite3";
+import { SqliteDialect } from "kysely";
+
+import { internalSchema } from "../../fragments/internal-fragment";
 import {
   Cursor,
   createServiceTxBuilder,
   createHandlerTxBuilder,
   ExponentialBackoffRetryPolicy,
   type DatabaseAdapter,
-} from "../../../mod";
-import { SqliteDialect } from "kysely";
-import { SqlDriverAdapter } from "../../../sql-driver/sql-driver-adapter";
-import { BetterSQLite3DriverConfig } from "../driver-config";
-import { GenericSQLAdapter } from "../generic-sql-adapter";
-import { internalSchema } from "../../../fragments/internal-fragment";
-
-describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
-  const testSchema = schema((s) => {
+} from "../../mod";
+import { createNamingResolver, suffixNamingStrategy } from "../../naming/sql-naming";
+import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
+import { SqlDriverAdapter } from "../../sql-driver/sql-driver-adapter";
+import { BetterSQLite3DriverConfig } from "./driver-config";
+import { SqlAdapter } from "./generic-sql-adapter";
+
+describe("SqlAdapter with better-sqlite3", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
           .addColumn("id", idColumn())
           .addColumn("name", column("string"))
           .addColumn("age", column("integer").nullable())
-          .createIndex("name_idx", ["name"]);
+          .createIndex("name_idx", ["name"])
+          .createIndex("name_id_idx", ["name", "id"]);
       })
       .addTable("emails", (t) => {
         return t
@@ -73,7 +77,7 @@ describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
   });
 
   // Second schema for multi-schema testing
-  const schema2 = schema((s) => {
+  const schema2 = schema("schema2", (s) => {
     return s
       .addTable("products", (t) => {
         return t
@@ -105,7 +109,7 @@ describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
     });
     const sqlAdapter = new SqlDriverAdapter(dialect);
     const driverConfig = new BetterSQLite3DriverConfig();
-    const genericAdapter = new GenericSQLAdapter({ dialect, driverConfig });
+    const genericAdapter = new SqlAdapter({ dialect, driverConfig });
 
     {
       const migrations = genericAdapter.prepareMigrations(internalSchema, "");
@@ -317,6 +321,47 @@ describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
     }
   });
 
+  it("should support composite cursor pagination", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+    const nameValue = "SqlAdapter SQLite Composite Cursor";
+
+    const createUow = queryEngine.createUnitOfWork("create-composite-cursor-users");
+    for (let i = 0; i < 5; i += 1) {
+      createUow.create("users", { name: nameValue, age: 70 + i });
+    }
+    await createUow.executeMutations();
+
+    const all = await queryEngine.find("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .orderByIndex("name_id_idx", "asc"),
+    );
+
+    const firstPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .orderByIndex("name_id_idx", "asc")
+        .pageSize(2),
+    );
+
+    const secondPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .after(firstPage.cursor!)
+        .orderByIndex("name_id_idx", "asc")
+        .pageSize(2),
+    );
+
+    const ids = (rows: { id: FragnoId }[]) => rows.map((row) => row.id.externalId);
+
+    expect(all.length).toBeGreaterThanOrEqual(5);
+    expect(firstPage.items).toHaveLength(2);
+    expect(firstPage.cursor).toBeInstanceOf(Cursor);
+    expect(firstPage.hasNextPage).toBe(true);
+    expect(ids(firstPage.items)).toEqual(ids(all).slice(0, 2));
+    expect(ids([...firstPage.items, ...secondPage.items])).toEqual(ids(all).slice(0, 4));
+  });
+
   it("should support joins", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
@@ -911,3 +956,226 @@ describe("GenericSQLAdapter with DrizzleAdapter better-sqlite3", () => {
     expect(conflictPosts).toHaveLength(0);
   });
 });
+
+describe("SQLite recreate-table foreign keys", () => {
+  it("keeps foreign keys pointing at the original table after recreation", async () => {
+    const database = new SQLite(":memory:");
+    const dialect = new SqliteDialect({ database });
+    const driver = new SqlDriverAdapter(dialect);
+    const adapter = new SqlAdapter({
+      dialect,
+      driverConfig: new BetterSQLite3DriverConfig(),
+    });
+
+    const fkSchema = schema("fk_test", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .addTable("sessions", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("userId", referenceColumn());
+        })
+        .addReference("sessionUser", {
+          type: "one",
+          from: { table: "sessions", column: "userId" },
+          to: { table: "users", column: "id" },
+        })
+        .alterTable("users", (t) => {
+          return t.alterColumn("name").nullable();
+        });
+    });
+
+    const namespace = "fk_test";
+    const resolver = createNamingResolver(fkSchema, namespace, suffixNamingStrategy);
+    const usersTable = resolver.getTableName("users");
+    const sessionsTable = resolver.getTableName("sessions");
+
+    const migrations = adapter.prepareMigrations(fkSchema, namespace);
+    const beforeRecreateVersion = fkSchema.version - 1;
+
+    try {
+      await migrations.executeWithDriver(driver, 0, beforeRecreateVersion, {
+        updateVersionInMigration: false,
+      });
+      await migrations.executeWithDriver(driver, beforeRecreateVersion, fkSchema.version, {
+        updateVersionInMigration: false,
+      });
+
+      const fkRows = database
+        .prepare(`PRAGMA foreign_key_list("${sessionsTable}")`)
+        .all() as Array<{ table: string }>;
+
+      expect(fkRows.length).toBeGreaterThan(0);
+      for (const row of fkRows) {
+        expect(row.table).toBe(usersTable);
+        expect(row.table).not.toContain("__fragno_tmp_");
+      }
+    } finally {
+      await driver.destroy();
+    }
+  });
+});
+
+describe("SQLite migration failure scenarios", () => {
+  const createAdapter = () => {
+    const database = new SQLite(":memory:");
+    const dialect = new SqliteDialect({ database });
+    const driver = new SqlDriverAdapter(dialect);
+    const adapter = new SqlAdapter({
+      dialect,
+      driverConfig: new BetterSQLite3DriverConfig(),
+    });
+
+    return { adapter, driver, database };
+  };
+
+  it("fails when adding a foreign key after tables already exist", async () => {
+    const { adapter, driver } = createAdapter();
+    const fkLaterSchema = schema("fk_later_runtime", (s) => {
+      return s
+        .addTable("users", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .addTable("posts", (t) => {
+          return t
+            .addColumn("id", idColumn())
+            .addColumn("title", column("string"))
+            .addColumn("authorId", referenceColumn());
+        })
+        .addReference("author", {
+          type: "one",
+          from: { table: "posts", column: "authorId" },
+          to: { table: "users", column: "id" },
+        });
+    });
+
+    const namespace = "fk_later_runtime";
+    const migrations = adapter.prepareMigrations(fkLaterSchema, namespace);
+    const beforeFkVersion = fkLaterSchema.version - 1;
+
+    try {
+      await migrations.executeWithDriver(driver, 0, beforeFkVersion, {
+        updateVersionInMigration: false,
+      });
+
+      await expect(
+        migrations.executeWithDriver(driver, beforeFkVersion, fkLaterSchema.version, {
+          updateVersionInMigration: false,
+        }),
+      ).rejects.toThrow(/foreign keys/i);
+    } finally {
+      await driver.destroy();
+    }
+  });
+
+  it("fails when adding a NOT NULL column without default to a table with data", async () => {
+    const { adapter, driver, database } = createAdapter();
+    const addNotNullSchema = schema("add_not_null", (s) => {
+      return s
+        .addTable("items", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .alterTable("items", (t) => {
+          return t.addColumn("status", column("string"));
+        });
+    });
+
+    const namespace = "add_not_null";
+    const resolver = createNamingResolver(addNotNullSchema, namespace, suffixNamingStrategy);
+    const itemsTable = resolver.getTableName("items");
+    const migrations = adapter.prepareMigrations(addNotNullSchema, namespace);
+    const beforeAddVersion = addNotNullSchema.version - 1;
+
+    try {
+      await migrations.executeWithDriver(driver, 0, beforeAddVersion, {
+        updateVersionInMigration: false,
+      });
+
+      database
+        .prepare(`insert into "${itemsTable}" ("id", "name") values (?, ?)`)
+        .run("item-1", "First");
+
+      await expect(
+        migrations.executeWithDriver(driver, beforeAddVersion, addNotNullSchema.version, {
+          updateVersionInMigration: false,
+        }),
+      ).rejects.toThrow(/not null/i);
+    } finally {
+      await driver.destroy();
+    }
+  });
+
+  it("fails when tightening a nullable column with existing NULL values", async () => {
+    const { adapter, driver, database } = createAdapter();
+    const tightenSchema = schema("tighten_nullable", (s) => {
+      return s
+        .addTable("items", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("note", column("string").nullable());
+        })
+        .alterTable("items", (t) => {
+          return t.alterColumn("note").nullable(false);
+        });
+    });
+
+    const namespace = "tighten_nullable";
+    const resolver = createNamingResolver(tightenSchema, namespace, suffixNamingStrategy);
+    const itemsTable = resolver.getTableName("items");
+    const migrations = adapter.prepareMigrations(tightenSchema, namespace);
+    const beforeTightenVersion = tightenSchema.version - 1;
+
+    try {
+      await migrations.executeWithDriver(driver, 0, beforeTightenVersion, {
+        updateVersionInMigration: false,
+      });
+
+      database
+        .prepare(`insert into "${itemsTable}" ("id", "note") values (?, ?)`)
+        .run("item-1", null);
+
+      await expect(
+        migrations.executeWithDriver(driver, beforeTightenVersion, tightenSchema.version, {
+          updateVersionInMigration: false,
+        }),
+      ).rejects.toThrow(/not null/i);
+    } finally {
+      await driver.destroy();
+    }
+  });
+
+  it("fails when adding a unique index with duplicate data", async () => {
+    const { adapter, driver, database } = createAdapter();
+    const uniqueIndexSchema = schema("unique_index", (s) => {
+      return s
+        .addTable("items", (t) => {
+          return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+        })
+        .alterTable("items", (t) => {
+          return t.createIndex("unique_name", ["name"], { unique: true });
+        });
+    });
+
+    const namespace = "unique_index";
+    const resolver = createNamingResolver(uniqueIndexSchema, namespace, suffixNamingStrategy);
+    const itemsTable = resolver.getTableName("items");
+    const migrations = adapter.prepareMigrations(uniqueIndexSchema, namespace);
+    const beforeIndexVersion = uniqueIndexSchema.version - 1;
+
+    try {
+      await migrations.executeWithDriver(driver, 0, beforeIndexVersion, {
+        updateVersionInMigration: false,
+      });
+
+      const insert = database.prepare(`insert into "${itemsTable}" ("id", "name") values (?, ?)`);
+      insert.run("item-1", "dup");
+      insert.run("item-2", "dup");
+
+      await expect(
+        migrations.executeWithDriver(driver, beforeIndexVersion, uniqueIndexSchema.version, {
+          updateVersionInMigration: false,
+        }),
+      ).rejects.toThrow(/unique/i);
+    } finally {
+      await driver.destroy();
+    }
+  });
+});

package/src/adapters/{drizzle/drizzle-adapter-sqlite3.test.ts → generic-sql/sql-adapter-sqlite3-uow.test.ts}

@@ -1,26 +1,31 @@
+import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
+
 import SQLite from "better-sqlite3";
 import { SqliteDialect } from "kysely";
-import { DrizzleAdapter } from "./drizzle-adapter";
-import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
-import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
+
+import { internalSchema } from "../../fragments/internal-fragment";
+import type { InternalFragmentInstance } from "../../fragments/internal-fragment";
+import { prepareHookMutations, type HooksMap } from "../../hooks/hooks";
 import { Cursor } from "../../query/cursor";
 import {
   createServiceTxBuilder,
   createHandlerTxBuilder,
 } from "../../query/unit-of-work/execute-unit-of-work";
 import { ExponentialBackoffRetryPolicy } from "../../query/unit-of-work/retry-policy";
-import { BetterSQLite3DriverConfig } from "../generic-sql/driver-config";
-import { internalSchema } from "../../fragments/internal-fragment";
+import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
+import { BetterSQLite3DriverConfig } from "./driver-config";
+import { SqlAdapter } from "./generic-sql-adapter";
 
-describe("DrizzleAdapter SQLite", () => {
-  const testSchema = schema((s) => {
+describe("SqlAdapter SQLite", () => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t
           .addColumn("id", idColumn())
           .addColumn("name", column("string"))
           .addColumn("age", column("integer").nullable())
-          .createIndex("name_idx", ["name"]);
+          .createIndex("name_idx", ["name"])
+          .createIndex("name_id_idx", ["name", "id"]);
       })
       .addTable("emails", (t) => {
         return t
@@ -39,6 +44,13 @@ describe("DrizzleAdapter SQLite", () => {
           .addColumn("content", column("string"))
           .createIndex("posts_user_idx", ["user_id"]);
       })
+      .addTable("optional_emails", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("user_id", referenceColumn().nullable())
+          .addColumn("email", column("string"))
+          .createIndex("optional_emails_user_idx", ["user_id"]);
+      })
       .addTable("comments", (t) => {
         return t
           .addColumn("id", idColumn())
@@ -58,6 +70,11 @@ describe("DrizzleAdapter SQLite", () => {
         from: { table: "posts", column: "user_id" },
         to: { table: "users", column: "id" },
       })
+      .addReference("user", {
+        type: "one",
+        from: { table: "optional_emails", column: "user_id" },
+        to: { table: "users", column: "id" },
+      })
       .addReference("post", {
         type: "one",
         from: { table: "comments", column: "post_id" },
@@ -71,7 +88,7 @@ describe("DrizzleAdapter SQLite", () => {
   });
 
   // Second schema for multi-schema testing
-  const schema2 = schema((s) => {
+  const schema2 = schema("schema2", (s) => {
     return s
       .addTable("products", (t) => {
         return t
@@ -94,7 +111,7 @@ describe("DrizzleAdapter SQLite", () => {
       });
   });
 
-  let adapter: DrizzleAdapter;
+  let adapter: SqlAdapter;
   let sqliteDatabase: InstanceType<typeof SQLite>;
 
   beforeAll(async () => {
@@ -104,7 +121,7 @@ describe("DrizzleAdapter SQLite", () => {
       database: sqliteDatabase,
     });
 
-    adapter = new DrizzleAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new BetterSQLite3DriverConfig(),
     });
@@ -149,7 +166,7 @@ describe("DrizzleAdapter SQLite", () => {
       Parameters<typeof createUow.find>[0]
     >();
     expectTypeOf<keyof typeof testSchema.tables>().toEqualTypeOf<
-      "users" | "emails" | "posts" | "comments"
+      "users" | "emails" | "posts" | "comments" | "optional_emails"
     >();
 
     const { success: createSuccess } = await createUow.executeMutations();
@@ -249,6 +266,45 @@ describe("DrizzleAdapter SQLite", () => {
     });
   });
 
+  it("should fail inserting duplicate triggered hook ids", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+    const hookId = "hook-duplicate-id";
+    const hooks: HooksMap = {
+      onTest: () => {},
+    };
+
+    const internalFragmentStub = {
+      $internal: { deps: { schema: internalSchema } },
+    } as InternalFragmentInstance;
+
+    const buildHookUow = (name: string) => {
+      const uow = queryEngine.createUnitOfWork(name).forSchema(testSchema, hooks);
+      uow.triggerHook("onTest", { data: name }, { id: hookId });
+      prepareHookMutations(
+        uow,
+        internalFragmentStub,
+        new ExponentialBackoffRetryPolicy({ maxRetries: 5 }),
+      );
+      return uow;
+    };
+
+    const firstUow = buildHookUow("hook-duplicate-first");
+    const { success } = await firstUow.executeMutations();
+    expect(success).toBe(true);
+
+    const secondUow = buildHookUow("hook-duplicate-second");
+    await expect(secondUow.executeMutations()).rejects.toThrow();
+
+    const verifyUow = queryEngine.createUnitOfWork("verify-duplicate-hook-id");
+    const internalUow = verifyUow.forSchema(internalSchema);
+    const findUow = internalUow.find("fragno_hooks", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", hookId)),
+    );
+    const [events] = await findUow.executeRetrieve();
+
+    expect(events).toHaveLength(1);
+  });
+
   it("should support count operations", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
@@ -380,6 +436,26 @@ describe("DrizzleAdapter SQLite", () => {
     });
   });
 
+  it("should return null for left-joined relation when foreign key is null", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+
+    const createUow = queryEngine.createUnitOfWork("create-optional-email");
+    createUow.create("optional_emails", {
+      user_id: null,
+      email: "optional@example.com",
+    });
+    await createUow.executeMutations();
+
+    const uow = queryEngine
+      .createUnitOfWork("join-optional-email")
+      .find("optional_emails", (b) => b.whereIndex("primary").join((jb) => jb.user()));
+
+    const [[email]] = await uow.executeRetrieve();
+
+    expect(email.email).toBe("optional@example.com");
+    expect(email.user).toBeNull();
+  });
+
   it("should support complex nested joins (comments -> post -> author)", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
 
@@ -796,6 +872,47 @@ describe("DrizzleAdapter SQLite", () => {
     expect(emptyPage.cursor).toBeUndefined();
   });
 
+  it("should support composite cursor pagination", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+    const nameValue = "SqlAdapter SQLite UOW Composite Cursor";
+
+    const createUow = queryEngine.createUnitOfWork("create-composite-cursor-users");
+    for (let i = 0; i < 5; i += 1) {
+      createUow.create("users", { name: nameValue, age: 60 + i });
+    }
+    await createUow.executeMutations();
+
+    const all = await queryEngine.find("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .orderByIndex("name_id_idx", "asc"),
+    );
+
+    const firstPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .orderByIndex("name_id_idx", "asc")
+        .pageSize(2),
+    );
+
+    const secondPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .after(firstPage.cursor!)
+        .orderByIndex("name_id_idx", "asc")
+        .pageSize(2),
+    );
+
+    const ids = (rows: { id: FragnoId }[]) => rows.map((row) => row.id.externalId);
+
+    expect(all.length).toBeGreaterThanOrEqual(5);
+    expect(firstPage.items).toHaveLength(2);
+    expect(firstPage.cursor).toBeInstanceOf(Cursor);
+    expect(firstPage.hasNextPage).toBe(true);
+    expect(ids(firstPage.items)).toEqual(ids(all).slice(0, 2));
+    expect(ids([...firstPage.items, ...secondPage.items])).toEqual(ids(all).slice(0, 4));
+  });
+
   it("should support handlerTx with retry logic", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");