@fragno-dev/db 0.1.14 → 0.2.0

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

@@ -0,0 +1,215 @@
+import { SQLocalKysely } from "sqlocal/kysely";
+import { beforeAll, describe, expect, it } from "vitest";
+import { KyselyAdapter } from "./kysely-adapter";
+import { column, idColumn, referenceColumn, schema } from "../../schema/create";
+import { SQLocalDriverConfig } from "../generic-sql/driver-config";
+
+describe("KyselyAdapter SQLite", () => {
+  const testSchema = schema((s) => {
+    return s
+      .addTable("accounts", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("userId", column("string"))
+          .addColumn("balance", column("integer"))
+          .createIndex("idx_user", ["userId"]);
+      })
+      .addTable("transactions", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("fromAccountId", referenceColumn())
+          .addColumn("toAccountId", referenceColumn())
+          .addColumn("amount", column("integer"));
+      })
+      .addReference("fromAccount", {
+        type: "one",
+        from: { table: "transactions", column: "fromAccountId" },
+        to: { table: "accounts", column: "id" },
+      })
+      .addReference("toAccount", {
+        type: "one",
+        from: { table: "transactions", column: "toAccountId" },
+        to: { table: "accounts", column: "id" },
+      });
+  });
+
+  let adapter: KyselyAdapter;
+
+  beforeAll(async () => {
+    const { dialect } = new SQLocalKysely(":memory:");
+    adapter = new KyselyAdapter({
+      dialect,
+      driverConfig: new SQLocalDriverConfig(),
+    });
+
+    // Run migrations
+    const preparedMigrations = adapter.prepareMigrations(testSchema, "test");
+    await preparedMigrations.execute(0, testSchema.version, { updateVersionInMigration: false });
+  });
+
+  it("should perform a balance transfer between accounts", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create two accounts with initial balances
+    const account1Id = await queryEngine.create("accounts", {
+      userId: "user1",
+      balance: 1000,
+    });
+
+    const account2Id = await queryEngine.create("accounts", {
+      userId: "user2",
+      balance: 500,
+    });
+
+    // Verify initial balances
+    const initialAccount1 = await queryEngine.findFirst("accounts", (b) => {
+      return b.whereIndex("primary", (eb) => eb("id", "=", account1Id));
+    });
+
+    const initialAccount2 = await queryEngine.findFirst("accounts", (b) => {
+      return b.whereIndex("primary", (eb) => eb("id", "=", account2Id));
+    });
+
+    expect(initialAccount1?.balance).toBe(1000);
+    expect(initialAccount2?.balance).toBe(500);
+
+    // Perform a balance transfer using Unit of Work
+    const transferAmount = 300;
+
+    // Read current balances - chain the calls to properly set generics
+    const uow = queryEngine
+      .createUnitOfWork("balance-transfer")
+      .find("accounts", (b) => {
+        return b.whereIndex("primary", (eb) => eb("id", "=", account1Id));
+      })
+      .find("accounts", (b) => {
+        return b.whereIndex("primary", (eb) => eb("id", "=", account2Id));
+      });
+
+    // Execute retrieval phase
+    const [[fromAccount], [toAccount]] = await uow.executeRetrieve();
+
+    expect(fromAccount).toBeDefined();
+    expect(toAccount).toBeDefined();
+
+    // Mutation phase: update balances and record transaction
+    uow.update("accounts", account1Id, (b) => {
+      return b.set({ balance: fromAccount!.balance - transferAmount }).check();
+    });
+
+    uow.update("accounts", account2Id, (b) => {
+      return b.set({ balance: toAccount!.balance + transferAmount }).check();
+    });
+
+    uow.create("transactions", {
+      fromAccountId: account1Id,
+      toAccountId: account2Id,
+      amount: transferAmount,
+    });
+
+    // Execute mutations
+    const { success } = await uow.executeMutations();
+    expect(success).toBe(true);
+
+    // Verify final balances
+    const finalAccount1 = await queryEngine.findFirst("accounts", (b) => {
+      return b.whereIndex("primary", (eb) => eb("id", "=", account1Id));
+    });
+
+    const finalAccount2 = await queryEngine.findFirst("accounts", (b) => {
+      return b.whereIndex("primary", (eb) => eb("id", "=", account2Id));
+    });
+
+    expect(finalAccount1?.balance).toBe(700); // 1000 - 300
+    expect(finalAccount2?.balance).toBe(800); // 500 + 300
+
+    // Verify versions were incremented
+    expect(finalAccount1?.id.version).toBe(1);
+    expect(finalAccount2?.id.version).toBe(1);
+
+    // Verify transaction was recorded
+    const transaction = await queryEngine.findFirst("transactions", (b) => {
+      return b.whereIndex("primary");
+    });
+
+    expect(transaction).toMatchObject({
+      fromAccountId: expect.objectContaining({
+        internalId: account1Id.internalId,
+      }),
+      toAccountId: expect.objectContaining({
+        internalId: account2Id.internalId,
+      }),
+      amount: transferAmount,
+    });
+  });
+
+  it("should execute Unit of Work with version checking", async () => {
+    // Use the same namespace as the first test (migrations already ran)
+    const queryEngine = adapter.createQueryEngine(testSchema, "test");
+
+    // Create initial account
+    const initialAccountId = await queryEngine.create("accounts", {
+      userId: "user3",
+      balance: 1000,
+    });
+
+    expect(initialAccountId.version).toBe(0);
+
+    // Build a UOW to update the account with optimistic locking
+    const uow = queryEngine
+      .createUnitOfWork("update-account-balance")
+      // Retrieval phase: find the account
+      .find("accounts", (b) => b.whereIndex("primary", (eb) => eb("id", "=", initialAccountId)));
+
+    // Execute retrieval and transition to mutation phase
+    const [accounts] = await uow.executeRetrieve();
+
+    // Mutation phase: update with version check
+    uow.update("accounts", initialAccountId, (b) => b.set({ balance: 1500 }).check());
+
+    // Execute mutations
+    const { success } = await uow.executeMutations();
+
+    // Should succeed
+    expect(success).toBe(true);
+    expect(accounts).toHaveLength(1);
+
+    // Verify the account was updated
+    const updatedAccount = await queryEngine.findFirst("accounts", (b) =>
+      b.whereIndex("primary", (eb) => eb("id", "=", initialAccountId)),
+    );
+
+    expect(updatedAccount).toMatchObject({
+      id: expect.objectContaining({
+        externalId: initialAccountId.externalId,
+        version: 1, // Version incremented
+      }),
+      userId: "user3",
+      balance: 1500,
+    });
+
+    // Try to update again with stale version (simulating concurrent update - should fail)
+    const uow2 = queryEngine.createUnitOfWork("update-account-stale");
+
+    // Use the old version (0) which is now stale
+    uow2.update("accounts", initialAccountId, (b) => b.set({ balance: 2000 }).check());
+
+    const { success: success2 } = await uow2.executeMutations();
+
+    // Should fail due to version conflict
+    expect(success2).toBe(false);
+
+    // Verify the account was NOT updated
+    const [[unchangedAccount]] = await queryEngine
+      .createUnitOfWork("verify-unchanged")
+      .find("accounts", (b) => b.whereIndex("primary", (eb) => eb("id", "=", initialAccountId)))
+      .executeRetrieve();
+
+    expect(unchangedAccount).toMatchObject({
+      id: expect.objectContaining({
+        version: 1, // Still version 1
+      }),
+      balance: 1500, // Still 1500, not 2000
+    });
+  });
+});

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

@@ -1,21 +1,12 @@
-import { sql, type Kysely } from "kysely";
+import { type Kysely } from "kysely";
 import type { SQLProvider } from "../../shared/providers";
+import { type DatabaseAdapter } from "../adapters";
+import { createTableNameMapper } from "../shared/table-name-mapper";
 import {
-  fragnoDatabaseAdapterNameFakeSymbol,
-  fragnoDatabaseAdapterVersionFakeSymbol,
-  type DatabaseAdapter,
-} from "../adapters";
-import { createMigrator, type Migrator } from "../../migration-engine/create";
-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, type KyselyUOWConfig } from "./kysely-query";
-import { createTableNameMapper } from "./kysely-shared";
-import { createHash } from "node:crypto";
-import { SETTINGS_TABLE_NAME } from "../../shared/settings-schema";
-import type { ConnectionPool } from "../../shared/connection-pool";
-import { createKyselyConnectionPool } from "./kysely-connection-pool";
+  GenericSQLAdapter,
+  type GenericSQLOptions,
+  type UnitOfWorkConfig,
+} from "../generic-sql/generic-sql-adapter";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type KyselyAny = Kysely<any>;
@@ -25,235 +16,12 @@ export interface KyselyConfig {
   provider: SQLProvider;
 }
 
-export class KyselyAdapter implements DatabaseAdapter<KyselyUOWConfig> {
-  #connectionPool: ConnectionPool<KyselyAny>;
-  #provider: SQLProvider;
-  #schemaNamespaceMap = new WeakMap<AnySchema, string>();
-
-  constructor(config: KyselyConfig) {
-    this.#connectionPool = createKyselyConnectionPool(config.db);
-    this.#provider = config.provider;
-  }
-
-  get [fragnoDatabaseAdapterNameFakeSymbol](): string {
-    return "kysely";
-  }
-
-  get [fragnoDatabaseAdapterVersionFakeSymbol](): number {
-    return 0;
-  }
-
-  async close(): Promise<void> {
-    await this.#connectionPool.close();
+export class KyselyAdapter extends GenericSQLAdapter implements DatabaseAdapter<UnitOfWorkConfig> {
+  constructor(options: GenericSQLOptions) {
+    super(options);
   }
 
   createTableNameMapper(namespace: string) {
     return createTableNameMapper(namespace);
   }
-
-  createQueryEngine<T extends AnySchema>(
-    schema: T,
-    namespace: string,
-  ): AbstractQuery<T, KyselyUOWConfig> {
-    // Register schema-namespace mapping
-    this.#schemaNamespaceMap.set(schema, namespace);
-
-    // Only create mapper if namespace is non-empty
-    const mapper = namespace ? createTableNameMapper(namespace) : undefined;
-    return fromKysely(
-      schema,
-      this.#connectionPool,
-      this.#provider,
-      mapper,
-      undefined,
-      this.#schemaNamespaceMap,
-    );
-  }
-
-  async isConnectionHealthy(): Promise<boolean> {
-    const conn = await this.#connectionPool.connect();
-    try {
-      const result = await conn.db.executeQuery(sql`SELECT 1 as healthy`.compile(conn.db));
-      return (result.rows[0] as Record<string, unknown>)["healthy"] === 1;
-    } catch {
-      return false;
-    } finally {
-      await conn.release();
-    }
-  }
-
-  createMigrationEngine(schema: AnySchema, namespace: string): Migrator {
-    const mapper = namespace ? createTableNameMapper(namespace) : undefined;
-
-    const preprocessMigrationOperations = (operations: MigrationOperation[], db: KyselyAny) => {
-      // Preprocess operations using the provided db instance
-      const config: KyselyConfig = {
-        db,
-        provider: this.#provider,
-      };
-      let preprocessed = preprocessOperations(operations, config);
-
-      if (this.#provider === "mysql") {
-        preprocessed.unshift({ type: "custom", sql: "SET FOREIGN_KEY_CHECKS = 0" });
-        preprocessed.push({ type: "custom", sql: "SET FOREIGN_KEY_CHECKS = 1" });
-      }
-
-      return preprocessed;
-    };
-
-    // Convert operations to executable nodes bound to specific db instance
-    const toExecutableNodes = (operations: MigrationOperation[], db: KyselyAny) => {
-      const onCustomNode = (node: CustomOperation, db: KyselyAny) => {
-        const statement = sql.raw(node["sql"] as string);
-
-        return {
-          compile() {
-            return statement.compile(db);
-          },
-          execute() {
-            return statement.execute(db);
-          },
-        };
-      };
-
-      const config: KyselyConfig = { db, provider: this.#provider };
-      return operations.flatMap((op) =>
-        execute(op, config, (node) => onCustomNode(node, db), mapper),
-      );
-    };
-
-    const migrator = createMigrator({
-      schema,
-      executor: async (operations) => {
-        const conn = await this.#connectionPool.connect();
-        try {
-          // For SQLite, execute PRAGMA defer_foreign_keys BEFORE transaction
-          if (this.#provider === "sqlite") {
-            await sql.raw("PRAGMA defer_foreign_keys = ON").execute(conn.db);
-          }
-
-          await conn.db.transaction().execute(async (tx) => {
-            // Use the transaction instance for both preprocessing and execution
-            const preprocessed = preprocessMigrationOperations(operations, tx);
-            const nodes = toExecutableNodes(preprocessed, tx);
-            for (const node of nodes) {
-              try {
-                await node.execute();
-              } catch (e) {
-                console.error("failed at", node.compile(), e);
-                throw e;
-              }
-            }
-          });
-        } finally {
-          await conn.release();
-        }
-      },
-      sql: {
-        toSql: (operations) => {
-          const parts: string[] = [];
-
-          // Add SQLite PRAGMA at the beginning
-          if (this.#provider === "sqlite") {
-            parts.push("PRAGMA defer_foreign_keys = ON;");
-          }
-
-          // Use getDatabaseSync for SQL generation (doesn't execute, just builds SQL strings)
-          const db = this.#connectionPool.getDatabaseSync();
-          const preprocessed = preprocessMigrationOperations(operations, db);
-          const nodes = toExecutableNodes(preprocessed, db);
-          const compiled = nodes.map((node) => `${node.compile().sql};`);
-
-          parts.push(...compiled);
-
-          return parts.join("\n\n");
-        },
-      },
-
-      settings: {
-        getVersion: async () => {
-          const conn = await this.#connectionPool.connect();
-          try {
-            const manager = createSettingsManager(conn.db, namespace);
-            const v = await manager.get(`schema_version`);
-            return v ? parseInt(v) : 0;
-          } finally {
-            await conn.release();
-          }
-        },
-        updateSettingsInMigration: async (fromVersion, toVersion) => {
-          const conn = await this.#connectionPool.connect();
-          try {
-            const manager = createSettingsManager(conn.db, namespace);
-            return [
-              {
-                type: "custom",
-                sql:
-                  fromVersion === 0
-                    ? manager.insert(`schema_version`, toVersion.toString())
-                    : manager.update(`schema_version`, toVersion.toString()),
-              },
-            ];
-          } finally {
-            await conn.release();
-          }
-        },
-      },
-    });
-
-    return migrator;
-  }
-
-  async getSchemaVersion(namespace: string): Promise<string | undefined> {
-    const conn = await this.#connectionPool.connect();
-    try {
-      const manager = createSettingsManager(conn.db, namespace);
-      return await manager.get(`schema_version`);
-    } finally {
-      await conn.release();
-    }
-  }
-}
-
-function createSettingsManager(db: KyselyAny, namespace: string) {
-  // Settings table is never namespaced, but keys include namespace prefix
-  const tableName = SETTINGS_TABLE_NAME;
-
-  return {
-    async get(key: string): Promise<string | undefined> {
-      try {
-        const result = await db
-          .selectFrom(tableName)
-          .where("key", "=", sql.lit(`${namespace}.${key}`))
-          .select(["value"])
-          .executeTakeFirstOrThrow();
-        return result.value as string;
-      } catch {
-        return;
-      }
-    },
-
-    insert(key: string, value: string) {
-      return db
-        .insertInto(tableName)
-        .values({
-          id: sql.lit(
-            createHash("md5").update(`${namespace}.${key}`).digest("base64url").replace(/=/g, ""),
-          ),
-          key: sql.lit(`${namespace}.${key}`),
-          value: sql.lit(value),
-        })
-        .compile().sql;
-    },
-
-    update(key: string, value: string) {
-      return db
-        .updateTable(tableName)
-        .set({
-          value: sql.lit(value),
-        })
-        .where("key", "=", sql.lit(`${namespace}.${key}`))
-        .compile().sql;
-    },
-  };
 }