@fragno-dev/db 0.1.6 → 0.1.7

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