@fragno-dev/db 0.1.6 → 0.1.8

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

@@ -0,0 +1,66 @@
+import type { ConnectionPool } from "../../shared/connection-pool";
+import type { DBType } from "./shared";
+
+/**
+ * Creates a Drizzle-specific connection pool.
+ * Drizzle doesn't have a standard destroy() method, as cleanup depends on the underlying driver.
+ */
+export function createDrizzleConnectionPool(
+  dbOrFactory: DBType | (() => DBType | Promise<DBType>),
+): ConnectionPool<DBType> {
+  let cachedDb: DBType | undefined;
+  let initPromise: Promise<DBType> | undefined;
+
+  const ensureInitialized = async (): Promise<DBType> => {
+    if (cachedDb) {
+      return cachedDb;
+    }
+
+    if (!initPromise) {
+      initPromise = (async () => {
+        const db =
+          typeof dbOrFactory === "function"
+            ? await (dbOrFactory as () => DBType | Promise<DBType>)()
+            : 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: () => Promise.resolve(),
+      };
+    },
+
+    getDatabaseSync() {
+      if (!cachedDb) {
+        throw new Error("Cannot get database synchronously: database not initialized.");
+      }
+      return cachedDb;
+    },
+
+    async close() {
+      // Drizzle doesn't have a standard destroy() method
+      // Cleanup depends on the underlying driver (e.g., PGlite, node-postgres, mysql2)
+      // For now, we just clear the cache
+      cachedDb = undefined;
+      initPromise = undefined;
+    },
+  };
+}

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

@@ -1,12 +1,12 @@
 import type { AbstractQuery } from "../../query/query";
 import type { AnySchema } from "../../schema/create";
-import type { DrizzleConfig } from "./drizzle-adapter";
 import type { CompiledMutation, UOWExecutor } from "../../query/unit-of-work";
 import { createDrizzleUOWCompiler, type DrizzleCompiledQuery } from "./drizzle-uow-compiler";
 import { executeDrizzleRetrievalPhase, executeDrizzleMutationPhase } from "./drizzle-uow-executor";
 import { UnitOfWork } from "../../query/unit-of-work";
-import { parseDrizzle, type DrizzleResult, type TableNameMapper } from "./shared";
+import { parseDrizzle, type DrizzleResult, type TableNameMapper, type DBType } from "./shared";
 import { createDrizzleUOWDecoder } from "./drizzle-uow-decoder";
+import type { ConnectionPool } from "../../shared/connection-pool";
 
 /**
  * Configuration options for creating a Drizzle Unit of Work
@@ -27,36 +27,53 @@ export interface DrizzleUOWConfig {
  * enabling features like SQL snapshot testing.
  *
  * @param schema - The database schema definition
- * @param config - Drizzle configuration containing the database instance and provider
+ * @param pool - Connection pool for acquiring database connections
+ * @param provider - SQL provider (sqlite, mysql, postgresql)
  * @param mapper - Optional table name mapper for namespace prefixing
  * @returns An AbstractQuery instance for performing database operations
  *
  * @example
  * ```ts
- * const queryEngine = fromDrizzle(mySchema, {
- *   db: drizzle,
- *   provider: 'postgresql'
- * });
+ * const pool = createSimpleConnectionPool(drizzle);
+ * const queryEngine = fromDrizzle(mySchema, pool, 'postgresql');
  *
  * const uow = queryEngine.createUnitOfWork('myOperation');
  * ```
  */
 export function fromDrizzle<T extends AnySchema>(
   schema: T,
-  config: DrizzleConfig,
+  pool: ConnectionPool<DBType>,
+  provider: "sqlite" | "mysql" | "postgresql",
   mapper?: TableNameMapper,
 ): AbstractQuery<T, DrizzleUOWConfig> {
-  const [db] = parseDrizzle(config.db);
-  const { provider } = config;
-
   function createUOW(name?: string, uowConfig?: DrizzleUOWConfig) {
-    const uowCompiler = createDrizzleUOWCompiler(schema, config, mapper, uowConfig?.onQuery);
+    const uowCompiler = createDrizzleUOWCompiler(
+      schema,
+      pool,
+      provider,
+      mapper,
+      uowConfig?.onQuery,
+    );
 
     const executor: UOWExecutor<DrizzleCompiledQuery, DrizzleResult> = {
-      executeRetrievalPhase: (retrievalBatch: DrizzleCompiledQuery[]) =>
-        executeDrizzleRetrievalPhase(db, retrievalBatch, provider),
-      executeMutationPhase: (mutationBatch: CompiledMutation<DrizzleCompiledQuery>[]) =>
-        executeDrizzleMutationPhase(db, mutationBatch, provider),
+      async executeRetrievalPhase(retrievalBatch: DrizzleCompiledQuery[]) {
+        const conn = await pool.connect();
+        try {
+          const db = parseDrizzle(conn.db)[0];
+          return await executeDrizzleRetrievalPhase(db, retrievalBatch, provider);
+        } finally {
+          await conn.release();
+        }
+      },
+      async executeMutationPhase(mutationBatch: CompiledMutation<DrizzleCompiledQuery>[]) {
+        const conn = await pool.connect();
+        try {
+          const db = parseDrizzle(conn.db)[0];
+          return await executeDrizzleMutationPhase(db, mutationBatch, provider);
+        } finally {
+          await conn.release();
+        }
+      },
     };
 
     const decoder = createDrizzleUOWDecoder(schema, provider);