@fragno-dev/db 0.1.14 → 0.2.0

package/src/adapters/drizzle/{drizzle-adapter-sqlite.test.ts → drizzle-adapter-sqlite3.test.ts}

@@ -1,17 +1,13 @@
-import { drizzle } from "drizzle-orm/libsql";
-import { createClient } from "@libsql/client";
+import SQLite from "better-sqlite3";
+import { SqliteDialect } from "kysely";
 import { DrizzleAdapter } from "./drizzle-adapter";
-import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
+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 drizzle-kit for migrations
-const require = createRequire(import.meta.url);
-const { generateSQLiteDrizzleJson, generateSQLiteMigration } =
-  require("drizzle-kit/api") as typeof import("drizzle-kit/api");
+import { executeUnitOfWork } 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";
 
 describe("DrizzleAdapter SQLite", () => {
   const testSchema = schema((s) => {
@@ -96,56 +92,38 @@ describe("DrizzleAdapter SQLite", () => {
   });
 
   let adapter: DrizzleAdapter;
-  let db: DBType;
-  // let sqliteDb: Database.Database;
+  let sqliteDatabase: InstanceType<typeof SQLite>;
 
   beforeAll(async () => {
-    // Write schema to file and dynamically import it
-    const { schemaModule, cleanup } = await writeAndLoadSchema(
-      "drizzle-adapter-sqlite",
-      testSchema,
-      "sqlite",
-      "namespace",
-    );
+    sqliteDatabase = new SQLite(":memory:");
 
-    // 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",
+    const dialect = new SqliteDialect({
+      database: sqliteDatabase,
     });
 
-    // Merge both schema modules for the db
-    const mergedSchema = { ...schemaModule, ...schemaModule2 };
-
-    db = drizzle(client, {
-      schema: mergedSchema,
-    }) as unknown as DBType;
-
-    // Generate and run migrations for both schemas
-    const emptyJson = await generateSQLiteDrizzleJson({});
-    const targetJson = await generateSQLiteDrizzleJson(mergedSchema);
+    adapter = new DrizzleAdapter({
+      dialect,
+      driverConfig: new BetterSQLite3DriverConfig(),
+    });
 
-    const migrationStatements = await generateSQLiteMigration(emptyJson, targetJson);
+    // Create settings table first (needed for version tracking)
+    {
+      const migrations = adapter.prepareMigrations(internalSchema, "");
+      await migrations.executeWithDriver(adapter.driver, 0);
+    }
 
-    for (const statement of migrationStatements) {
-      await client.execute(statement);
+    {
+      const migrations = adapter.prepareMigrations(testSchema, "namespace");
+      await migrations.executeWithDriver(adapter.driver, 0);
     }
 
-    adapter = new DrizzleAdapter({
-      db,
-      provider: "sqlite",
-    });
+    {
+      const migrations = adapter.prepareMigrations(schema2, "namespace2");
+      await migrations.executeWithDriver(adapter.driver, 0);
+    }
 
     return async () => {
-      client.close();
-      await cleanup();
-      await cleanup2();
+      await adapter.close();
     };
   }, 12000);
 
@@ -271,7 +249,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 });
@@ -382,17 +359,17 @@ describe("DrizzleAdapter SQLite", () => {
     expect(email).toMatchObject({
       id: expect.objectContaining({
         externalId: expect.stringMatching(/^[a-z0-9]{20,}$/),
-        internalId: expect.any(Number),
+        internalId: expect.any(BigInt),
       }),
       user_id: expect.objectContaining({
-        internalId: expect.any(Number),
+        internalId: expect.any(BigInt),
       }),
       email: "test@example.com",
       is_primary: true,
       user: {
         id: expect.objectContaining({
           externalId: expect.stringMatching(/^[a-z0-9]{20,}$/),
-          internalId: expect.any(Number),
+          internalId: expect.any(BigInt),
         }),
         name: "Email User",
         age: 20,
@@ -475,7 +452,7 @@ describe("DrizzleAdapter SQLite", () => {
     expect(comment).toMatchObject({
       id: expect.objectContaining({
         externalId: expect.stringMatching(/^[a-z0-9]{20,}$/),
-        internalId: expect.any(Number),
+        internalId: expect.any(BigInt),
       }),
       text: "Great post!",
       // Post join (first level)
@@ -764,4 +741,159 @@ describe("DrizzleAdapter SQLite", () => {
       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.ts

@@ -1,103 +1,22 @@
 import type { DatabaseAdapter } from "../adapters";
 import { type AnySchema } from "../../schema/create";
-import type { AbstractQuery } from "../../query/query";
 import type { SchemaGenerator } from "../../schema-generator/schema-generator";
 import { generateSchema } from "./generate";
-import { fromDrizzle, type DrizzleUOWConfig } from "./drizzle-query";
-import { createTableNameMapper, type DBType, type DrizzleResult } from "./shared";
-import { createSettingsManager, settingsSchema } from "../../shared/settings-schema";
-import { sql } from "drizzle-orm";
-import {
-  fragnoDatabaseAdapterNameFakeSymbol,
-  fragnoDatabaseAdapterVersionFakeSymbol,
-} from "../adapters";
-import type { ConnectionPool } from "../../shared/connection-pool";
-import { createDrizzleConnectionPool } from "./drizzle-connection-pool";
-
-export interface DrizzleConfig {
-  db: unknown | (() => unknown | Promise<unknown>);
-  provider: "sqlite" | "mysql" | "postgresql";
-}
-
-export class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
-  #connectionPool: ConnectionPool<DBType>;
-  #provider: "sqlite" | "mysql" | "postgresql";
-  #schemaNamespaceMap = new WeakMap<AnySchema, string>();
-
-  constructor(config: DrizzleConfig) {
-    this.#connectionPool = createDrizzleConnectionPool(
-      config.db as DBType | (() => DBType | Promise<DBType>),
-    );
-    this.#provider = config.provider;
-  }
+import { createTableNameMapper } from "../shared/table-name-mapper";
 
-  get [fragnoDatabaseAdapterNameFakeSymbol](): string {
-    return "drizzle";
-  }
-
-  get [fragnoDatabaseAdapterVersionFakeSymbol](): number {
-    return 0;
-  }
-
-  async close(): Promise<void> {
-    await this.#connectionPool.close();
-  }
-
-  createTableNameMapper(namespace: string) {
-    return createTableNameMapper(namespace);
-  }
-
-  get provider(): "sqlite" | "mysql" | "postgresql" {
-    return this.#provider;
-  }
-
-  async isConnectionHealthy(): Promise<boolean> {
-    const conn = await this.#connectionPool.connect();
-    try {
-      const result = await conn.db.execute(sql`SELECT 1 as healthy`);
-
-      // Handle different result formats across providers
-      // PostgreSQL/MySQL: { rows: [...] }
-      // SQLite: array directly or { rows: [...] }
-      if (Array.isArray(result)) {
-        return result.length > 0 && result[0]["healthy"] === 1;
-      } else {
-        const drizzleResult = result as DrizzleResult;
-        return drizzleResult.rows[0]["healthy"] === 1;
-      }
-    } catch {
-      return false;
-    } finally {
-      await conn.release();
-    }
-  }
-
-  async getSchemaVersion(namespace: string): Promise<string | undefined> {
-    const queryEngine = this.createQueryEngine(settingsSchema, namespace);
-    const manager = createSettingsManager(queryEngine, namespace);
+import {
+  GenericSQLAdapter,
+  type GenericSQLOptions,
+  type UnitOfWorkConfig,
+} from "../generic-sql/generic-sql-adapter";
 
-    // Try to read the version key directly
-    const result = await manager.get("version");
-    return result?.value;
+export class DrizzleAdapter extends GenericSQLAdapter implements DatabaseAdapter<UnitOfWorkConfig> {
+  constructor(options: GenericSQLOptions) {
+    super(options);
   }
 
-  createQueryEngine<TSchema extends AnySchema>(
-    schema: TSchema,
-    namespace: string,
-  ): AbstractQuery<TSchema, DrizzleUOWConfig> {
-    // Register schema-namespace mapping
-    this.#schemaNamespaceMap.set(schema, namespace);
-
-    // Only create mapper if namespace is non-empty
-    const mapper = namespace ? createTableNameMapper(namespace) : undefined;
-    return fromDrizzle(
-      schema,
-      this.#connectionPool,
-      this.#provider,
-      mapper,
-      undefined,
-      this.#schemaNamespaceMap,
-    );
+  override createTableNameMapper(namespace: string) {
+    return createTableNameMapper(namespace, false);
   }
 
   createSchemaGenerator(
@@ -109,7 +28,9 @@ export class DrizzleAdapter implements DatabaseAdapter<DrizzleUOWConfig> {
         const path = genOptions?.path ?? options?.path ?? "fragno-schema.ts";
 
         return {
-          schema: generateSchema(fragments, this.#provider),
+          schema: generateSchema(fragments, this.driverConfig.databaseType, {
+            mapperFactory: (ns) => (ns ? this.createTableNameMapper(ns) : undefined),
+          }),
           path,
         };
       },