@beignet/provider-db-drizzle 0.0.36 → 0.0.37

package/src/postgres/index.ts

@@ -41,6 +41,7 @@ import {
   type AnyProviderConfigSchema,
   createProvider,
   createProviderInstrumentation,
+  type ProviderInstrumentationTarget,
   type ServiceProvider,
 } from "@beignet/core/providers";
 import { type ExtractTablesWithRelations, type SQL, sql } from "drizzle-orm";
@@ -605,12 +606,24 @@ export type DrizzlePostgresProvider<
   Record<PortName, DbPort<TSchema>>
 >;
 
+/**
+ * Drizzle Postgres provider backed by an app-supplied pool.
+ */
+export type InjectedDrizzlePostgresProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+> = ServiceProvider<
+  unknown,
+  AnyProviderConfigSchema<void>,
+  Record<PortName, DbPort<TSchema>>
+>;
+
 /**
  * Options for creating a Drizzle Postgres provider.
  *
  * @template TSchema - The Drizzle schema type
  */
-export interface DrizzlePostgresProviderOptions<
+interface DrizzlePostgresProviderBaseOptions<
   TSchema extends Record<string, unknown>,
   PortName extends string = "db",
 > {
@@ -627,14 +640,34 @@ export interface DrizzlePostgresProviderOptions<
    * with its own env prefix instead.
    */
   portName?: PortName;
-
-  /**
-   * Optional node-postgres pool configuration merged into the pool created
-   * from `POSTGRES_DB_URL`, e.g. `max`, `ssl`, or timeouts.
-   */
-  pool?: Omit<PoolConfig, "connectionString">;
 }
 
+export type DrizzlePostgresProviderOptions<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+> = DrizzlePostgresProviderBaseOptions<TSchema, PortName> &
+  (
+    | {
+        /**
+         * Optional node-postgres pool configuration merged into the pool
+         * created from `POSTGRES_DB_URL`.
+         */
+        pool?: Omit<PoolConfig, "connectionString">;
+        client?: never;
+        closeOnStop?: never;
+      }
+    | {
+        /**
+         * App-supplied node-postgres pool. Injected pools do not require
+         * provider configuration and remain caller-owned by default.
+         */
+        client: Pool;
+        pool?: never;
+        /** Close the injected pool when the provider stops. @default false */
+        closeOnStop?: boolean;
+      }
+  );
+
 /**
  * Create a Drizzle Postgres provider factory.
  *
@@ -658,14 +691,90 @@ export interface DrizzlePostgresProviderOptions<
  * export const drizzlePostgresProvider = createDrizzlePostgresProvider({ schema });
  * ```
  */
+export function createDrizzlePostgresProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(
+  options: DrizzlePostgresProviderBaseOptions<TSchema, PortName> & {
+    client: Pool;
+    pool?: never;
+    closeOnStop?: boolean;
+  },
+): InjectedDrizzlePostgresProvider<TSchema, PortName>;
+export function createDrizzlePostgresProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(
+  options: DrizzlePostgresProviderBaseOptions<TSchema, PortName> & {
+    pool?: Omit<PoolConfig, "connectionString">;
+    client?: never;
+    closeOnStop?: never;
+  },
+): DrizzlePostgresProvider<TSchema, PortName>;
 export function createDrizzlePostgresProvider<
   TSchema extends Record<string, unknown>,
   PortName extends string = "db",
 >(
   options: DrizzlePostgresProviderOptions<TSchema, PortName>,
-): DrizzlePostgresProvider<TSchema, PortName> {
+):
+  | DrizzlePostgresProvider<TSchema, PortName>
+  | InjectedDrizzlePostgresProvider<TSchema, PortName> {
+  return createDrizzlePostgresProviderImplementation(options);
+}
+
+function createDrizzlePostgresProviderImplementation<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(options: DrizzlePostgresProviderOptions<TSchema, PortName>) {
   const { schema, portName = "db" } = options;
 
+  const setupPool = (ports: unknown, pool: Pool, closeOnStop: boolean) => {
+    const instrumentation = createProviderInstrumentation(
+      ports as ProviderInstrumentationTarget,
+      {
+        providerName: "drizzle-postgres",
+        watcher: "db",
+      },
+    );
+    const logger = createDbQueryLogger(instrumentation, portName);
+    const db: NodePgDatabase<TSchema> = logger
+      ? drizzle(pool, { schema, logger })
+      : drizzle(pool, { schema });
+    const dbPort: DbPort<TSchema> = {
+      drizzle: db,
+      pool,
+      checkHealth: () => checkPostgresHealth(pool),
+    };
+
+    return {
+      ports: { [portName]: dbPort } as Record<PortName, DbPort<TSchema>>,
+      async stop() {
+        if (!closeOnStop) return;
+        try {
+          await pool.end();
+        } catch (error) {
+          console.error(
+            "[drizzlePostgresProvider] Error closing database connection:",
+            error,
+          );
+        }
+      },
+    };
+  };
+
+  if (options.client) {
+    return createProvider<
+      unknown,
+      AnyProviderConfigSchema<void>,
+      Record<PortName, DbPort<TSchema>>
+    >({
+      name: "drizzle-postgres",
+      setup({ ports }) {
+        return setupPool(ports, options.client, options.closeOnStop ?? false);
+      },
+    });
+  }
+
   return createProvider({
     name: "drizzle-postgres",
 
@@ -687,40 +796,7 @@ export function createDrizzlePostgresProvider<
         ...options.pool,
       });
 
-      const instrumentation = createProviderInstrumentation(ports, {
-        providerName: "drizzle-postgres",
-        watcher: "db",
-      });
-
-      const logger = createDbQueryLogger(instrumentation, portName);
-
-      // 2. Create typed Drizzle instance
-      const db: NodePgDatabase<TSchema> = logger
-        ? drizzle(pool, { schema, logger })
-        : drizzle(pool, { schema });
-
-      // 3. Build a typed DbPort
-      const dbPort: DbPort<TSchema> = {
-        drizzle: db,
-        pool,
-        checkHealth: () => checkPostgresHealth(pool),
-      };
-
-      return {
-        ports: { [portName]: dbPort } as Record<PortName, DbPort<TSchema>>,
-        async stop() {
-          // Gracefully close the connection pool
-          try {
-            await dbPort.pool.end();
-          } catch (error) {
-            // Log error but don't throw - we're shutting down anyway
-            console.error(
-              "[drizzlePostgresProvider] Error closing database connection:",
-              error,
-            );
-          }
-        },
-      };
+      return setupPool(ports, pool, true);
     },
   });
 }

package/src/sqlite/index.ts

@@ -43,6 +43,7 @@ import {
   type AnyProviderConfigSchema,
   createProvider,
   createProviderInstrumentation,
+  type ProviderInstrumentationTarget,
   type ServiceProvider,
 } from "@beignet/core/providers";
 import { type Client, createClient } from "@libsql/client";
@@ -625,12 +626,22 @@ export type DrizzleSqliteProvider<
   Record<PortName, DbPort<TSchema>>
 >;
 
+/** Drizzle SQLite provider backed by an app-supplied libSQL client. */
+export type InjectedDrizzleSqliteProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+> = ServiceProvider<
+  unknown,
+  AnyProviderConfigSchema<void>,
+  Record<PortName, DbPort<TSchema>>
+>;
+
 /**
  * Options for creating a Drizzle SQLite provider.
  *
  * @template TSchema - The Drizzle schema type
  */
-export interface DrizzleSqliteProviderOptions<
+interface DrizzleSqliteProviderBaseOptions<
   TSchema extends Record<string, unknown>,
   PortName extends string = "db",
 > {
@@ -649,6 +660,23 @@ export interface DrizzleSqliteProviderOptions<
   portName?: PortName;
 }
 
+export type DrizzleSqliteProviderOptions<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+> = DrizzleSqliteProviderBaseOptions<TSchema, PortName> &
+  (
+    | {
+        client?: never;
+        closeOnStop?: never;
+      }
+    | {
+        /** App-supplied libSQL client, caller-owned by default. */
+        client: Client;
+        /** Close the injected client when the provider stops. @default false */
+        closeOnStop?: boolean;
+      }
+  );
+
 /**
  * Create a Drizzle SQLite provider factory.
  *
@@ -671,14 +699,85 @@ export interface DrizzleSqliteProviderOptions<
  * export const drizzleSqliteProvider = createDrizzleSqliteProvider({ schema });
  * ```
  */
+export function createDrizzleSqliteProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(
+  options: DrizzleSqliteProviderBaseOptions<TSchema, PortName> & {
+    client: Client;
+    closeOnStop?: boolean;
+  },
+): InjectedDrizzleSqliteProvider<TSchema, PortName>;
+export function createDrizzleSqliteProvider<
+  TSchema extends Record<string, unknown>,
+  PortName extends string = "db",
+>(
+  options: DrizzleSqliteProviderBaseOptions<TSchema, PortName> & {
+    client?: never;
+    closeOnStop?: never;
+  },
+): DrizzleSqliteProvider<TSchema, PortName>;
 export function createDrizzleSqliteProvider<
   TSchema extends Record<string, unknown>,
   PortName extends string = "db",
 >(
   options: DrizzleSqliteProviderOptions<TSchema, PortName>,
-): DrizzleSqliteProvider<TSchema, PortName> {
+):
+  | DrizzleSqliteProvider<TSchema, PortName>
+  | InjectedDrizzleSqliteProvider<TSchema, PortName> {
   const { schema, portName = "db" } = options;
 
+  const setupClient = (
+    ports: unknown,
+    client: Client,
+    closeOnStop: boolean,
+  ) => {
+    const instrumentation = createProviderInstrumentation(
+      ports as ProviderInstrumentationTarget,
+      {
+        providerName: "drizzle-sqlite",
+        watcher: "db",
+      },
+    );
+    const logger = createDbQueryLogger(instrumentation, portName);
+    const db: LibSQLDatabase<TSchema> = logger
+      ? drizzle(client, { schema, logger })
+      : drizzle(client, { schema });
+    const dbPort: DbPort<TSchema> = {
+      drizzle: db,
+      client,
+      checkHealth: () => checkSqliteHealth(client),
+    };
+
+    return {
+      ports: { [portName]: dbPort } as Record<PortName, DbPort<TSchema>>,
+      async stop() {
+        if (!closeOnStop) return;
+        try {
+          await client.close();
+        } catch (error) {
+          console.error(
+            "[drizzleSqliteProvider] Error closing database connection:",
+            error,
+          );
+        }
+      },
+    };
+  };
+
+  if (options.client) {
+    return createProvider<
+      unknown,
+      AnyProviderConfigSchema<void>,
+      Record<PortName, DbPort<TSchema>>
+    >({
+      name: "drizzle-sqlite",
+      setup({ ports }) {
+        return setupClient(ports, options.client, options.closeOnStop ?? false);
+      },
+    });
+  }
+
   return createProvider({
     name: "drizzle-sqlite",
 
@@ -700,40 +799,7 @@ export function createDrizzleSqliteProvider<
         authToken: config.DB_AUTH_TOKEN,
       });
 
-      const instrumentation = createProviderInstrumentation(ports, {
-        providerName: "drizzle-sqlite",
-        watcher: "db",
-      });
-
-      const logger = createDbQueryLogger(instrumentation, portName);
-
-      // 2. Create typed Drizzle instance
-      const db: LibSQLDatabase<TSchema> = logger
-        ? drizzle(client, { schema, logger })
-        : drizzle(client, { schema });
-
-      // 3. Build a typed DbPort
-      const dbPort: DbPort<TSchema> = {
-        drizzle: db,
-        client,
-        checkHealth: () => checkSqliteHealth(client),
-      };
-
-      return {
-        ports: { [portName]: dbPort } as Record<PortName, DbPort<TSchema>>,
-        async stop() {
-          // Gracefully close the database connection
-          try {
-            await dbPort.client.close();
-          } catch (error) {
-            // Log error but don't throw - we're shutting down anyway
-            console.error(
-              "[drizzleSqliteProvider] Error closing database connection:",
-              error,
-            );
-          }
-        },
-      };
+      return setupClient(ports, client, true);
     },
   });
 }