@fragno-dev/db 0.1.6 → 0.1.8

package/src/adapters/drizzle/drizzle-uow-compiler.ts

@@ -8,13 +8,19 @@ import type {
   UOWCompiler,
 } from "../../query/unit-of-work";
 import { buildCondition, type Condition } from "../../query/condition-builder";
-import type { DrizzleConfig } from "./drizzle-adapter";
-import { type ColumnType, type TableType, type TableNameMapper, parseDrizzle } from "./shared";
+import {
+  type ColumnType,
+  type TableType,
+  type TableNameMapper,
+  parseDrizzle,
+  type DBType,
+} from "./shared";
 import { encodeValues, ReferenceSubquery } from "../../query/result-transform";
 import { serialize } from "../../schema/serialize";
 import { decodeCursor, serializeCursorValues } from "../../query/cursor";
 import type { CompiledJoin } from "../../query/orm/orm";
 import { getOrderedJoinColumns } from "./join-column-utils";
+import type { ConnectionPool } from "../../shared/connection-pool";
 
 export type DrizzleCompiledQuery = {
   sql: string;
@@ -28,19 +34,23 @@ export type DrizzleCompiledQuery = {
  * that can be executed as a batch/transaction.
  *
  * @param schema - The database schema
- * @param config - Drizzle configuration
+ * @param pool - Connection pool for acquiring database connections
+ * @param provider - SQL provider (sqlite, mysql, postgresql)
  * @param mapper - Optional table name mapper for namespace prefixing
  * @param onQuery - Optional callback to receive compiled queries for logging/debugging
  * @returns A UOWCompiler instance for Drizzle
  */
 export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
   schema: TSchema,
-  config: DrizzleConfig,
+  pool: ConnectionPool<DBType>,
+  provider: "sqlite" | "mysql" | "postgresql",
   mapper?: TableNameMapper,
   onQuery?: (query: DrizzleCompiledQuery) => void,
 ): UOWCompiler<TSchema, DrizzleCompiledQuery> {
-  const [db, drizzleTables] = parseDrizzle(config.db);
-  const { provider } = config;
+  // Get db synchronously for compilation (doesn't execute, just builds SQL)
+  // TODO: We don't even need a Drizzle instance with a db client attached here. `drizzle({ schema })` is enough.
+  const dbRaw = pool.getDatabaseSync();
+  const [db, drizzleTables] = parseDrizzle(dbRaw);
 
   /**
    * Convert a Fragno table to a Drizzle table
@@ -175,16 +185,15 @@ export function createDrizzleUOWCompiler<TSchema extends AnySchema>(
         const externalId = value.externalIdValue;
         const internalIdCol = refTable.getInternalIdColumn();
         const idCol = refTable.getIdColumn();
-        const drizzleRefTable = toDrizzleTable(refTable);
-        const drizzleIdCol = toDrizzleColumn(idCol);
 
-        // Create a parameterized SQL subquery using Drizzle's query builder
+        // Map logical table name to physical table name using the mapper
+        const physicalTableName = mapper ? mapper.toPhysical(refTable.ormName) : refTable.ormName;
+
+        // Build a SQL subquery using Drizzle's sql template
+        // This creates a subquery: (SELECT _internalId FROM table WHERE id = ? LIMIT 1)
         // Safe cast: we're building a SQL subquery that returns a single bigint value
-        processed[key] = db
-          .select({ value: drizzleRefTable[internalIdCol.ormName] })
-          .from(drizzleRefTable)
-          .where(Drizzle.eq(drizzleIdCol, externalId))
-          .limit(1) as unknown;
+        processed[key] =
+          Drizzle.sql`(select ${Drizzle.sql.identifier(internalIdCol.name)} from ${Drizzle.sql.identifier(physicalTableName)} where ${Drizzle.sql.identifier(idCol.name)} = ${externalId} limit 1)`;
       } else {
         processed[key] = value;
       }

package/src/adapters/drizzle/drizzle-uow-executor.ts

@@ -85,6 +85,11 @@ function getAffectedRows(result: unknown): number {
   }
 
   if (result && typeof result === "object") {
+    // libsql uses rowsAffected
+    if ("rowsAffected" in result && typeof result["rowsAffected"] === "number") {
+      return result["rowsAffected"];
+    }
+
     if ("affectedRows" in result && typeof result["affectedRows"] === "number") {
       return result["affectedRows"];
     }
@@ -114,14 +119,20 @@ async function executeInTransaction(
   db: DBType,
   provider: "sqlite" | "mysql" | "postgresql",
   syncExecutor: (db: SyncSQLiteDB) => void,
-  asyncExecutor: (tx: { execute: (sql: SQL) => Promise<unknown> }) => Promise<void>,
+  asyncExecutor: (tx: {
+    execute?: (sql: SQL) => Promise<unknown>;
+    run?: (sql: SQL) => Promise<unknown>;
+  }) => Promise<void>,
 ): Promise<void> {
   if (provider === "sqlite" && isSyncSQLite(db)) {
     assertSyncSQLite(db);
     db.transaction(() => syncExecutor(db));
   } else {
     await db.transaction(
-      async (tx) => await asyncExecutor(tx as { execute: (sql: SQL) => Promise<unknown> }),
+      async (tx) =>
+        await asyncExecutor(
+          tx as { execute?: (sql: SQL) => Promise<unknown>; run?: (sql: SQL) => Promise<unknown> },
+        ),
     );
   }
 }
@@ -186,7 +197,13 @@ export async function executeDrizzleRetrievalPhase(
     },
     async (tx) => {
       for (const query of retrievalBatch) {
-        const result = (await tx.execute(toSQL(query, provider))) as DrizzleResult;
+        const sqlObj = toSQL(query, provider);
+        // Fallback to run when execute is not available (e.g., libsql)
+        const executeMethod = tx.execute ?? tx.run;
+        if (!executeMethod) {
+          throw new Error("Transaction object has neither execute nor run method");
+        }
+        const result = (await executeMethod.call(tx, sqlObj)) as DrizzleResult;
         retrievalResults.push(result);
       }
     },
@@ -232,7 +249,13 @@ export async function executeDrizzleMutationPhase(
       },
       async (tx) => {
         for (const { query, expectedAffectedRows } of mutationBatch) {
-          const result = await tx.execute(toSQL(query, provider));
+          const sqlObj = toSQL(query, provider);
+          // Fallback to run when execute is not available (e.g., libsql)
+          const executeMethod = tx.execute ?? tx.run;
+          if (!executeMethod) {
+            throw new Error("Transaction object has neither execute nor run method");
+          }
+          const result = await executeMethod.call(tx, sqlObj);
 
           if (expectedAffectedRows === null) {
             createdInternalIds.push(extractCreatedInternalId(result));

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

@@ -1,6 +1,10 @@
 import { sql, type Kysely } from "kysely";
 import type { SQLProvider } from "../../shared/providers";
-import type { DatabaseAdapter } from "../adapters";
+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";
@@ -10,56 +14,68 @@ import { fromKysely } 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";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type KyselyAny = Kysely<any>;
 
 export interface KyselyConfig {
-  db: KyselyAny | (() => KyselyAny);
+  db: KyselyAny | (() => KyselyAny | Promise<KyselyAny>);
   provider: SQLProvider;
 }
 
 export class KyselyAdapter implements DatabaseAdapter {
-  #kyselyConfig: KyselyConfig;
+  #connectionPool: ConnectionPool<KyselyAny>;
+  #provider: SQLProvider;
 
   constructor(config: KyselyConfig) {
-    this.#kyselyConfig = config;
+    this.#connectionPool = createKyselyConnectionPool(config.db);
+    this.#provider = config.provider;
   }
 
-  #getDb(): KyselyAny {
-    const db = this.#kyselyConfig.db;
-    return typeof db === "function" ? db() : db;
+  get [fragnoDatabaseAdapterNameFakeSymbol](): string {
+    return "kysely";
+  }
+
+  get [fragnoDatabaseAdapterVersionFakeSymbol](): number {
+    return 0;
+  }
+
+  async close(): Promise<void> {
+    await this.#connectionPool.close();
   }
 
   createQueryEngine<T extends AnySchema>(schema: T, namespace: string): AbstractQuery<T> {
     // Only create mapper if namespace is non-empty
     const mapper = namespace ? createTableNameMapper(namespace) : undefined;
-    // Resolve the db instance if it's a function
-    const resolvedConfig: KyselyConfig = {
-      db: this.#getDb(),
-      provider: this.#kyselyConfig.provider,
-    };
-    return fromKysely(schema, resolvedConfig, mapper);
+    return fromKysely(schema, this.#connectionPool, this.#provider, mapper);
   }
 
   async isConnectionHealthy(): Promise<boolean> {
+    const conn = await this.#connectionPool.connect();
     try {
-      const db = this.#getDb();
-      const result = await db.executeQuery(sql`SELECT 1 as healthy`.compile(db));
+      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 manager = createSettingsManager(this.#getDb(), namespace);
     const mapper = namespace ? createTableNameMapper(namespace) : undefined;
 
-    const preprocessMigrationOperations = (operations: MigrationOperation[]) => {
-      let preprocessed = preprocessOperations(operations, this.#kyselyConfig);
+    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.#kyselyConfig.provider === "mysql") {
+      if (this.#provider === "mysql") {
         preprocessed.unshift({ type: "custom", sql: "SET FOREIGN_KEY_CHECKS = 0" });
         preprocessed.push({ type: "custom", sql: "SET FOREIGN_KEY_CHECKS = 1" });
       }
@@ -82,45 +98,52 @@ export class KyselyAdapter implements DatabaseAdapter {
         };
       };
 
-      const dbConfig: KyselyConfig = { db, provider: this.#kyselyConfig.provider };
+      const config: KyselyConfig = { db, provider: this.#provider };
       return operations.flatMap((op) =>
-        execute(op, dbConfig, (node) => onCustomNode(node, db), mapper),
+        execute(op, config, (node) => onCustomNode(node, db), mapper),
       );
     };
 
     const migrator = createMigrator({
       schema,
       executor: async (operations) => {
-        const db = this.#getDb();
-        // For SQLite, execute PRAGMA defer_foreign_keys BEFORE transaction
-        if (this.#kyselyConfig.provider === "sqlite") {
-          await sql.raw("PRAGMA defer_foreign_keys = ON").execute(db);
-        }
+        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 db.transaction().execute(async (tx) => {
-          const preprocessed = preprocessMigrationOperations(operations);
-          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;
+          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.#kyselyConfig.provider === "sqlite") {
+          if (this.#provider === "sqlite") {
             parts.push("PRAGMA defer_foreign_keys = ON;");
           }
 
-          const preprocessed = preprocessMigrationOperations(operations);
-          const nodes = toExecutableNodes(preprocessed, this.#getDb());
+          // 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);
@@ -131,19 +154,31 @@ export class KyselyAdapter implements DatabaseAdapter {
 
       settings: {
         getVersion: async () => {
-          const v = await manager.get(`schema_version`);
-          return v ? parseInt(v) : 0;
+          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) => {
-          return [
-            {
-              type: "custom",
-              sql:
-                fromVersion === 0
-                  ? manager.insert(`schema_version`, toVersion.toString())
-                  : manager.update(`schema_version`, toVersion.toString()),
-            },
-          ];
+          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();
+          }
         },
       },
     });
@@ -151,10 +186,14 @@ export class KyselyAdapter implements DatabaseAdapter {
     return migrator;
   }
 
-  getSchemaVersion(namespace: string) {
-    const manager = createSettingsManager(this.#getDb(), namespace);
-
-    return manager.get(`schema_version`);
+  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();
+    }
   }
 }
 

package/src/adapters/kysely/kysely-connection-pool.ts

@@ -0,0 +1,70 @@
+import type { Kysely } from "kysely";
+import type { ConnectionPool } from "../../shared/connection-pool";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type KyselyAny = Kysely<any>;
+
+/**
+ * Creates a Kysely-specific connection pool with proper cleanup.
+ * Calls db.destroy() when the pool is closed to properly release database connections.
+ */
+export function createKyselyConnectionPool(
+  dbOrFactory: KyselyAny | (() => KyselyAny | Promise<KyselyAny>),
+): ConnectionPool<KyselyAny> {
+  let cachedDb: KyselyAny | undefined;
+  let initPromise: Promise<KyselyAny> | undefined;
+
+  const ensureInitialized = async (): Promise<KyselyAny> => {
+    if (cachedDb) {
+      return cachedDb;
+    }
+
+    if (!initPromise) {
+      initPromise = (async () => {
+        const db =
+          typeof dbOrFactory === "function"
+            ? await (dbOrFactory as () => KyselyAny | Promise<KyselyAny>)()
+            : dbOrFactory;
+        cachedDb = db;
+        return db;
+      })();
+    }
+
+    return initPromise;
+  };
+
+  // Eagerly start initialization if it's a factory function
+  if (typeof dbOrFactory === "function") {
+    void ensureInitialized();
+  } else {
+    // Direct instance - cache it immediately
+    cachedDb = dbOrFactory;
+  }
+
+  return {
+    async connect() {
+      const db = await ensureInitialized();
+
+      return {
+        db,
+        release: async () => {},
+      };
+    },
+
+    getDatabaseSync() {
+      if (!cachedDb) {
+        throw new Error("Cannot get database synchronously: database not initialized.");
+      }
+      return cachedDb;
+    },
+
+    async close() {
+      if (cachedDb) {
+        // Properly destroy Kysely instance to close all connections
+        await cachedDb.destroy();
+      }
+      cachedDb = undefined;
+      initPromise = undefined;
+    },
+  };
+}

package/src/adapters/kysely/kysely-query-compiler.ts

@@ -1,11 +1,15 @@
-import type { CompiledQuery } from "kysely";
+import type { CompiledQuery, Kysely } from "kysely";
 import type { AnySchema, AnyTable } from "../../schema/create";
 import { buildCondition } from "../../query/condition-builder";
 import { buildFindOptions } from "../../query/orm/orm";
-import type { KyselyConfig } from "./kysely-adapter";
 import { createKyselyQueryBuilder } from "./kysely-query-builder";
 import type { ConditionBuilder, Condition } from "../../query/condition-builder";
 import type { TableNameMapper } from "./kysely-shared";
+import type { ConnectionPool } from "../../shared/connection-pool";
+import type { SQLProvider } from "../../shared/providers";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type KyselyAny = Kysely<any>;
 
 /**
  * Internal query compiler interface for Kysely
@@ -27,12 +31,12 @@ export interface KyselyQueryCompiler {
 
 export function createKyselyQueryCompiler<T extends AnySchema>(
   schema: T,
-  config: KyselyConfig,
+  pool: ConnectionPool<KyselyAny>,
+  provider: SQLProvider,
   mapper?: TableNameMapper,
 ): KyselyQueryCompiler {
-  const { db, provider } = config;
-  // Resolve the db instance if it's a function
-  const kysely = typeof db === "function" ? db() : db;
+  // Get kysely instance for query building (compilation doesn't execute, just builds SQL)
+  const kysely = pool.getDatabaseSync();
   const queryBuilder = createKyselyQueryBuilder(kysely, provider, mapper);
 
   function toTable(name: unknown): AnyTable {

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

@@ -1,13 +1,17 @@
 import type { AbstractQuery } from "../../query/query";
 import type { AnySchema } from "../../schema/create";
-import type { KyselyConfig } from "./kysely-adapter";
 import type { CompiledMutation, UOWDecoder, UOWExecutor } from "../../query/unit-of-work";
 import { decodeResult } from "../../query/result-transform";
 import { createKyselyUOWCompiler } from "./kysely-uow-compiler";
 import { executeKyselyRetrievalPhase, executeKyselyMutationPhase } from "./kysely-uow-executor";
 import { UnitOfWork } from "../../query/unit-of-work";
-import type { CompiledQuery } from "kysely";
+import type { CompiledQuery, Kysely } from "kysely";
 import type { TableNameMapper } from "./kysely-shared";
+import type { ConnectionPool } from "../../shared/connection-pool";
+import type { SQLProvider } from "../../shared/providers";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type KyselyAny = Kysely<any>;
 
 /**
  * Creates a Kysely-based query engine for the given schema.
@@ -17,16 +21,15 @@ import type { TableNameMapper } from "./kysely-shared";
  * enabling features like SQL snapshot testing.
  *
  * @param schema - The database schema definition
- * @param config - Kysely configuration containing the database instance and provider
+ * @param pool - Connection pool for acquiring database connections
+ * @param provider - SQL provider (postgresql, mysql, sqlite, etc.)
  * @param mapper - Optional table name mapper for namespace prefixing
  * @returns An AbstractQuery instance for performing database operations
  *
  * @example
  * ```ts
- * const queryEngine = fromKysely(mySchema, {
- *   db: kysely,
- *   provider: 'postgresql'
- * });
+ * const pool = createSimpleConnectionPool(kysely);
+ * const queryEngine = fromKysely(mySchema, pool, 'postgresql');
  *
  * const users = await queryEngine.findMany('users', {
  *   where: (b) => b('age', '>', 18),
@@ -36,20 +39,30 @@ import type { TableNameMapper } from "./kysely-shared";
  */
 export function fromKysely<T extends AnySchema>(
   schema: T,
-  config: KyselyConfig,
+  pool: ConnectionPool<KyselyAny>,
+  provider: SQLProvider,
   mapper?: TableNameMapper,
 ): AbstractQuery<T> {
-  const { db, provider } = config;
-  // Resolve the db instance if it's a function
-  const kysely = typeof db === "function" ? db() : db;
-  const uowCompiler = createKyselyUOWCompiler(schema, config, mapper);
-
   function createUOW(name?: string): UnitOfWork<T, []> {
+    const uowCompiler = createKyselyUOWCompiler(schema, pool, provider, mapper);
+
     const executor: UOWExecutor<CompiledQuery, unknown> = {
-      executeRetrievalPhase: (retrievalBatch: CompiledQuery[]) =>
-        executeKyselyRetrievalPhase(kysely, retrievalBatch),
-      executeMutationPhase: (mutationBatch: CompiledMutation<CompiledQuery>[]) =>
-        executeKyselyMutationPhase(kysely, mutationBatch),
+      async executeRetrievalPhase(retrievalBatch: CompiledQuery[]) {
+        const conn = await pool.connect();
+        try {
+          return await executeKyselyRetrievalPhase(conn.db, retrievalBatch);
+        } finally {
+          await conn.release();
+        }
+      },
+      async executeMutationPhase(mutationBatch: CompiledMutation<CompiledQuery>[]) {
+        const conn = await pool.connect();
+        try {
+          return await executeKyselyMutationPhase(conn.db, mutationBatch);
+        } finally {
+          await conn.release();
+        }
+      },
     };
 
     // Create a decoder function to transform raw results into application format