@spfn/core 0.2.0-beta.64 → 0.2.0-beta.66

package/dist/db/index.js

@@ -441,8 +441,8 @@ async function createWriteReadClients(writeUrl, readUrl, poolConfig, retryConfig
   try {
     readClient = await createDatabaseConnection(readUrl, readPoolConfig, retryConfig);
     return {
-      write: drizzle(writeClient),
-      read: drizzle(readClient),
+      write: drizzle({ client: writeClient }),
+      read: drizzle({ client: readClient }),
       writeClient,
       readClient
     };
@@ -458,8 +458,8 @@ async function createWriteReadClients(writeUrl, readUrl, poolConfig, retryConfig
       }
     );
     return {
-      write: drizzle(writeClient),
-      read: drizzle(writeClient),
+      write: drizzle({ client: writeClient }),
+      read: drizzle({ client: writeClient }),
       writeClient,
       readClient: writeClient
     };
@@ -467,7 +467,7 @@ async function createWriteReadClients(writeUrl, readUrl, poolConfig, retryConfig
 }
 async function createSingleClient(url, poolConfig, retryConfig) {
   const client = await createDatabaseConnection(url, poolConfig, retryConfig);
-  const db = drizzle(client);
+  const db = drizzle({ client });
   return {
     write: db,
     read: db,
@@ -528,6 +528,10 @@ var getReadInstance = () => globalThis.__SPFN_DB_READ__;
 var setReadInstance = (instance) => {
   globalThis.__SPFN_DB_READ__ = instance;
 };
+var getDatabaseProvider = () => globalThis.__SPFN_DB_PROVIDER__;
+var setDatabaseProviderInstance = (provider) => {
+  globalThis.__SPFN_DB_PROVIDER__ = provider;
+};
 var getWriteClient = () => globalThis.__SPFN_DB_WRITE_CLIENT__;
 var setWriteClient = (client) => {
   globalThis.__SPFN_DB_WRITE_CLIENT__ = client;
@@ -547,6 +551,18 @@ var getInitOptions = () => globalThis.__SPFN_DB_INIT_OPTIONS__;
 var setInitOptions = (options) => {
   globalThis.__SPFN_DB_INIT_OPTIONS__ = options;
 };
+var getInitPromise = () => globalThis.__SPFN_DB_INIT_PROMISE__;
+var setInitPromise = (promise) => {
+  globalThis.__SPFN_DB_INIT_PROMISE__ = promise;
+};
+var getInitProvider = () => globalThis.__SPFN_DB_INIT_PROVIDER__;
+var setInitProvider = (provider) => {
+  globalThis.__SPFN_DB_INIT_PROVIDER__ = provider;
+};
+var getClosePromise = () => globalThis.__SPFN_DB_CLOSE_PROMISE__;
+var setClosePromise = (promise) => {
+  globalThis.__SPFN_DB_CLOSE_PROMISE__ = promise;
+};
 var getIsClosing = () => globalThis.__SPFN_DB_CLOSING__ === true;
 var setIsClosing = (closing) => {
   globalThis.__SPFN_DB_CLOSING__ = closing;
@@ -641,6 +657,10 @@ function startHealthCheck(config, options, getDatabase2) {
   setHealthCheckInterval(interval);
 }
 async function triggerForceReconnect(reason) {
+  if (getDatabaseProvider()) {
+    dbLogger3.debug("Force reconnect skipped: database is externally provided", { reason });
+    return false;
+  }
   if (!getWriteInstance()) {
     dbLogger3.warn("Force reconnect skipped: database not initialized", { reason });
     return false;
@@ -655,6 +675,10 @@ async function triggerForceReconnect(reason) {
   return await attemptReconnection(config, options, reason);
 }
 async function attemptReconnection(config, options, reason) {
+  if (getDatabaseProvider()) {
+    dbLogger3.debug("Reconnection skipped: database is externally provided", { reason });
+    return false;
+  }
   if (isReconnecting) {
     dbLogger3.debug("Reconnection coalesced: attempt already in progress", { reason });
     return false;
@@ -714,7 +738,6 @@ var STACK_TRACE_PATTERNS = {
   withParens: /\((.+):(\d+):(\d+)\)/,
   withoutParens: /at (.+):(\d+):(\d+)/
 };
-var initPromise = null;
 async function cleanupDatabaseConnections(writeClient, readClient) {
   const cleanupPromises = [];
   if (writeClient) {
@@ -752,6 +775,33 @@ async function testDatabaseConnections(write, read) {
     }
   }
 }
+function validateDatabaseProvider(provider) {
+  if (typeof provider.kind !== "string" || !provider.kind.trim()) {
+    throw new Error("Database provider kind must be a non-empty string");
+  }
+}
+function registerDatabaseProvider(provider) {
+  setDatabaseProviderInstance(provider);
+  setWriteInstance(provider.write);
+  setReadInstance(provider.read ?? provider.write);
+  return {
+    write: provider.write,
+    read: provider.read ?? provider.write
+  };
+}
+async function closeDatabaseProvider(provider, context) {
+  if (!provider.close) {
+    return;
+  }
+  try {
+    await provider.close();
+  } catch (error) {
+    const closeError = error instanceof Error ? error : new Error(String(error));
+    dbLogger4.error(`Error closing ${provider.kind || "unknown"} database provider`, closeError, {
+      context
+    });
+  }
+}
 function getCallerInfo() {
   try {
     const stack = new Error().stack;
@@ -811,24 +861,107 @@ function getDatabase(type) {
   return writeInst;
 }
 function setDatabase(write, read) {
+  if (getIsClosing()) {
+    throw new Error("Cannot set database while closing");
+  }
+  if (getInitPromise()) {
+    throw new Error("Cannot set database while initialization is in progress");
+  }
+  if (getDatabaseProvider()) {
+    throw new Error(
+      "An external database provider is active. Call closeDatabase() before setting a database manually."
+    );
+  }
+  if (getWriteClient() || getReadClient()) {
+    throw new Error(
+      "Managed database connections are active. Call closeDatabase() before setting a database manually."
+    );
+  }
+  setDatabaseProviderInstance(void 0);
   setWriteInstance(write);
   setReadInstance(read ?? write);
 }
+function setDatabaseProvider(provider) {
+  validateDatabaseProvider(provider);
+  const activeProvider = getDatabaseProvider();
+  if (getIsClosing()) {
+    throw new Error("Cannot set database provider while closing");
+  }
+  if (getInitPromise()) {
+    throw new Error("Cannot set database provider while initialization is in progress");
+  }
+  if (activeProvider === provider) {
+    return {
+      write: provider.write,
+      read: provider.read ?? provider.write
+    };
+  }
+  if (getWriteInstance() || getReadInstance() || getWriteClient() || getReadClient() || activeProvider) {
+    throw new Error(
+      "Database already initialized. Call closeDatabase() before registering a different provider."
+    );
+  }
+  return registerDatabaseProvider(provider);
+}
 async function initDatabase(options) {
   if (getIsClosing()) {
     throw new Error("Cannot initialize database while closing");
   }
   const writeInst = getWriteInstance();
   if (writeInst) {
+    const activeProvider = getDatabaseProvider();
+    if (!activeProvider && !getWriteClient()) {
+      throw new Error(
+        "Database was registered manually. Use getDatabase() directly or call closeDatabase() before initDatabase()."
+      );
+    }
+    if (options?.provider !== activeProvider) {
+      const detail = options?.provider ? "a different provider was supplied" : "the active external provider was not supplied";
+      throw new Error(`Database already initialized: ${detail}`);
+    }
     dbLogger4.debug("Database already initialized");
-    return { write: writeInst, read: getReadInstance() };
+    return {
+      write: writeInst,
+      read: getReadInstance()
+    };
   }
-  if (initPromise) {
+  const activeInitPromise = getInitPromise();
+  if (activeInitPromise) {
+    if (options?.provider !== getInitProvider()) {
+      throw new Error("Database initialization already in progress with a different provider");
+    }
     dbLogger4.debug("Database initialization in progress, waiting...");
-    return await initPromise;
+    return await activeInitPromise;
   }
-  initPromise = (async () => {
+  setInitProvider(options?.provider);
+  const currentInit = (async () => {
     try {
+      if (options?.provider) {
+        const provider = options.provider;
+        try {
+          validateDatabaseProvider(provider);
+          await testDatabaseConnections(provider.write, provider.read);
+          if (getIsClosing()) {
+            throw new Error("Database closed during initialization");
+          }
+          const monConfig2 = buildMonitoringConfig(options.monitoring);
+          const result2 = registerDatabaseProvider(provider);
+          setInitOptions(options);
+          setMonitoringConfig(monConfig2);
+          dbLogger4.info("Database provider connected", {
+            kind: provider.kind,
+            hasReplica: !!(provider.read && provider.read !== provider.write)
+          });
+          return result2;
+        } catch (error) {
+          await closeDatabaseProvider(provider, "initialization_failed");
+          if (error instanceof Error && (error.message === "Database provider kind must be a non-empty string" || error.message === "Database closed during initialization")) {
+            throw error;
+          }
+          const message = error instanceof Error ? error.message : "Unknown error";
+          throw new Error(`Database connection test failed: ${message}`);
+        }
+      }
       const result = await createDatabaseFromEnv(options);
       try {
         await testDatabaseConnections(result.write, result.read);
@@ -865,56 +998,78 @@ async function initDatabase(options) {
       }
       return { write: getWriteInstance(), read: getReadInstance() };
     } finally {
-      initPromise = null;
+      setInitPromise(void 0);
+      setInitProvider(void 0);
     }
   })();
-  return await initPromise;
+  setInitPromise(currentInit);
+  return await currentInit;
 }
 async function closeDatabase() {
-  if (getIsClosing()) {
+  const activeClosePromise = getClosePromise();
+  if (activeClosePromise) {
     dbLogger4.debug("Database close already in progress");
-    return;
+    return await activeClosePromise;
   }
-  setIsClosing(true);
-  if (initPromise) {
-    dbLogger4.debug("Waiting for database initialization to complete before closing...");
-    try {
-      await initPromise;
-    } catch (_error) {
-      dbLogger4.debug("Initialization failed during close, proceeding with cleanup");
+  const currentClose = (async () => {
+    setIsClosing(true);
+    const activeInitPromise = getInitPromise();
+    if (activeInitPromise) {
+      dbLogger4.debug("Waiting for database initialization to complete before closing...");
+      try {
+        await activeInitPromise;
+      } catch (_error) {
+        dbLogger4.debug("Initialization failed during close, proceeding with cleanup");
+      }
     }
-  }
-  const writeInst = getWriteInstance();
-  const readInst = getReadInstance();
-  if (!writeInst && !readInst) {
-    dbLogger4.debug("No database connections to close");
-    setIsClosing(false);
-    return;
-  }
-  try {
-    stopHealthCheck();
-    const closePromises = [];
-    const writeC = getWriteClient();
-    if (writeC) {
-      closePromises.push(closeDatabaseClient(writeC, "write"));
+    const writeInst = getWriteInstance();
+    const readInst = getReadInstance();
+    const provider = getDatabaseProvider();
+    if (!writeInst && !readInst && !provider) {
+      dbLogger4.debug("No database connections to close");
+      return;
     }
-    const readC = getReadClient();
-    if (readC && readC !== writeC) {
-      closePromises.push(closeDatabaseClient(readC, "read"));
+    try {
+      stopHealthCheck();
+      const closePromises = [];
+      if (provider) {
+        closePromises.push(closeDatabaseProvider(provider, "shutdown"));
+      }
+      const writeC = getWriteClient();
+      if (writeC) {
+        closePromises.push(closeDatabaseClient(writeC, "write"));
+      }
+      const readC = getReadClient();
+      if (readC && readC !== writeC) {
+        closePromises.push(closeDatabaseClient(readC, "read"));
+      }
+      await Promise.allSettled(closePromises);
+      dbLogger4.info("All database connections closed");
+    } finally {
+      setWriteInstance(void 0);
+      setReadInstance(void 0);
+      setWriteClient(void 0);
+      setReadClient(void 0);
+      setDatabaseProviderInstance(void 0);
+      setMonitoringConfig(void 0);
+      setInitOptions(void 0);
     }
-    await Promise.allSettled(closePromises);
-    dbLogger4.info("All database connections closed");
+  })();
+  setClosePromise(currentClose);
+  try {
+    await currentClose;
   } finally {
-    setWriteInstance(void 0);
-    setReadInstance(void 0);
-    setWriteClient(void 0);
-    setReadClient(void 0);
-    setMonitoringConfig(void 0);
-    setInitOptions(void 0);
-    setIsClosing(false);
+    if (getClosePromise() === currentClose) {
+      setClosePromise(void 0);
+      setIsClosing(false);
+    }
   }
 }
 async function forceReconnectDatabase(reason = "manual") {
+  if (getDatabaseProvider()) {
+    dbLogger4.debug("Force reconnect skipped: database is externally provided", { reason });
+    return false;
+  }
   return await triggerForceReconnect(reason);
 }
 function getDatabaseInfo() {
@@ -923,7 +1078,8 @@ function getDatabaseInfo() {
   return {
     hasWrite: !!writeInst,
     hasRead: !!readInst,
-    isReplica: !!(readInst && readInst !== writeInst)
+    isReplica: !!(readInst && readInst !== writeInst),
+    providerKind: getDatabaseProvider()?.kind
   };
 }
 var dbLogger5 = logger.child("@spfn/core:database");
@@ -1411,7 +1567,10 @@ function runWithTransaction(tx, txId, callback) {
     txLogger.debug("Root transaction context set", { txId, level: newLevel });
   }
   const afterCommitCallbacks = existingContext ? existingContext.afterCommitCallbacks : [];
-  return asyncContext.run({ tx, txId, level: newLevel, afterCommitCallbacks }, callback);
+  return asyncContext.run(
+    { tx, txId, level: newLevel, afterCommitCallbacks },
+    callback
+  );
 }
 function onAfterCommit(callback) {
   const context = getTransactionContext();
@@ -1528,14 +1687,15 @@ async function runInTransaction(callback, options = {}) {
   let afterCommitCallbacks = [];
   try {
     const result = await writeDb.transaction(async (tx) => {
+      const transaction = tx;
       if (timeout > 0 && !isNested) {
-        await tx.execute(sql.raw(`SET LOCAL statement_timeout = ${timeout}`));
+        await transaction.execute(sql.raw(`SET LOCAL statement_timeout = ${timeout}`));
       }
       if (idleTimeout > 0 && !isNested) {
-        await tx.execute(sql.raw(`SET LOCAL idle_in_transaction_session_timeout = ${idleTimeout}`));
+        await transaction.execute(sql.raw(`SET LOCAL idle_in_transaction_session_timeout = ${idleTimeout}`));
       }
-      return await runWithTransaction(tx, txId, async () => {
-        const innerResult = await callback(tx);
+      return await runWithTransaction(transaction, txId, async () => {
+        const innerResult = await callback(transaction);
         if (!isNested) {
           const ctx = getTransactionContext();
           if (ctx) {
@@ -1698,7 +1858,8 @@ async function create(table, data) {
   if (!db) {
     throw new Error("Database not initialized. Call initDatabase() first.");
   }
-  const [result] = await db.insert(table).values(data).returning();
+  const results = await db.insert(table).values(data).returning();
+  const result = results[0];
   return result;
 }
 async function createMany(table, data) {
@@ -1714,10 +1875,11 @@ async function upsert(table, data, options) {
   if (!db) {
     throw new Error("Database not initialized. Call initDatabase() first.");
   }
-  const [result] = await db.insert(table).values(data).onConflictDoUpdate({
+  const results = await db.insert(table).values(data).onConflictDoUpdate({
     target: options.target,
     set: options.set || data
   }).returning();
+  const result = results[0];
   return result;
 }
 async function updateOne(table, where, data) {
@@ -1729,7 +1891,8 @@ async function updateOne(table, where, data) {
   if (!whereClause) {
     throw new Error("updateOne requires at least one where condition");
   }
-  const [result] = await db.update(table).set(data).where(whereClause).returning();
+  const results = await db.update(table).set(data).where(whereClause).returning();
+  const result = results[0];
   return result ?? null;
 }
 async function updateMany(table, where, data) {
@@ -1753,7 +1916,8 @@ async function deleteOne(table, where) {
   if (!whereClause) {
     throw new Error("deleteOne requires at least one where condition");
   }
-  const [result] = await db.delete(table).where(whereClause).returning();
+  const results = await db.delete(table).where(whereClause).returning();
+  const result = results[0];
   return result ?? null;
 }
 async function deleteMany(table, where) {
@@ -2004,7 +2168,8 @@ var BaseRepository = class {
    * ```
    */
   async _create(table, data) {
-    const [result] = await this.db.insert(table).values(data).returning();
+    const results = await this.db.insert(table).values(data).returning();
+    const result = results[0];
     return result;
   }
   /**
@@ -2046,10 +2211,11 @@ var BaseRepository = class {
    * ```
    */
   async _upsert(table, data, options) {
-    const [result] = await this.db.insert(table).values(data).onConflictDoUpdate({
+    const results = await this.db.insert(table).values(data).onConflictDoUpdate({
       target: options.target,
       set: options.set || data
     }).returning();
+    const result = results[0];
     return result;
   }
   /**
@@ -2073,7 +2239,8 @@ var BaseRepository = class {
     if (!whereClause) {
       throw new Error("updateOne requires at least one where condition");
     }
-    const [result] = await this.db.update(table).set(data).where(whereClause).returning();
+    const results = await this.db.update(table).set(data).where(whereClause).returning();
+    const result = results[0];
     return result ?? null;
   }
   /**
@@ -2117,7 +2284,8 @@ var BaseRepository = class {
     if (!whereClause) {
       throw new Error("deleteOne requires at least one where condition");
     }
-    const [result] = await this.db.delete(table).where(whereClause).returning();
+    const results = await this.db.delete(table).where(whereClause).returning();
+    const result = results[0];
     return result ?? null;
   }
   /**
@@ -2166,6 +2334,6 @@ var BaseRepository = class {
   }
 };
 
-export { BaseRepository, RepositoryError, Transactional, auditFields, checkConnection, closeDatabase, count, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, enumText, findMany, findOne, forceReconnectDatabase, foreignKey, fromPostgresError, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, getTransactionContext, id, initDatabase, isConnectionLevelError, onAfterCommit, optionalForeignKey, packageNameToSchema, publishingFields, reportDatabaseError, resetConnectionErrorCounter, runInTransaction, runWithTransaction, setDatabase, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
+export { BaseRepository, RepositoryError, Transactional, auditFields, checkConnection, closeDatabase, count, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, enumText, findMany, findOne, forceReconnectDatabase, foreignKey, fromPostgresError, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, getTransactionContext, id, initDatabase, isConnectionLevelError, onAfterCommit, optionalForeignKey, packageNameToSchema, publishingFields, reportDatabaseError, resetConnectionErrorCounter, runInTransaction, runWithTransaction, setDatabase, setDatabaseProvider, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map