@spfn/core 0.2.0-beta.4 → 0.2.0-beta.42

package/dist/db/index.d.ts

@@ -376,6 +376,12 @@ interface DrizzleConfigOptions {
     packageFilter?: string;
     /** Expand glob patterns to actual file paths (useful for Drizzle Studio) */
     expandGlobs?: boolean;
+    /** PostgreSQL schema filter for push/introspect commands */
+    schemaFilter?: string[];
+    /** Auto-detect PostgreSQL schemas from entity files (requires expandGlobs: true) */
+    autoDetectSchemas?: boolean;
+    /** Migration prefix strategy (default: 'timestamp') */
+    migrationPrefix?: 'index' | 'timestamp' | 'unix' | 'none';
 }
 /**
  * Detect database dialect from connection URL
@@ -407,6 +413,21 @@ declare function getDrizzleConfig(options?: DrizzleConfigOptions): {
     dbCredentials: {
         url: string;
     };
+    migrations: {
+        prefix: "timestamp" | "none" | "index" | "unix";
+    };
+    schemaFilter?: undefined;
+} | {
+    schema: string | string[];
+    out: string;
+    dialect: "postgresql" | "mysql" | "sqlite";
+    dbCredentials: {
+        url: string;
+    };
+    schemaFilter: string[] | undefined;
+    migrations: {
+        prefix: "timestamp" | "none" | "index" | "unix";
+    };
 };
 /**
  * Generate drizzle.config.ts file content
@@ -462,7 +483,7 @@ declare function timestamps(): {
 /**
  * Foreign key reference to another table
  *
- * Creates a bigserial column with cascade delete.
+ * Creates a bigint column with cascade delete.
  * Type-safe: ensures the reference points to a valid PostgreSQL column.
  *
  * @param name - Column name (e.g., 'author' creates 'author_id')
@@ -482,7 +503,7 @@ declare function timestamps(): {
  */
 declare function foreignKey<T extends PgColumn>(name: string, reference: () => T, options?: {
     onDelete?: 'cascade' | 'set null' | 'restrict' | 'no action';
-}): drizzle_orm.NotNull<drizzle_orm_pg_core.PgBigSerial53BuilderInitial<`${string}_id`>>;
+}): drizzle_orm.NotNull<drizzle_orm_pg_core.PgBigInt53BuilderInitial<`${string}_id`>>;
 /**
  * Optional foreign key reference (nullable)
  *
@@ -502,7 +523,7 @@ declare function foreignKey<T extends PgColumn>(name: string, reference: () => T
  */
 declare function optionalForeignKey<T extends PgColumn>(name: string, reference: () => T, options?: {
     onDelete?: 'cascade' | 'set null' | 'restrict' | 'no action';
-}): drizzle_orm_pg_core.PgBigSerial53BuilderInitial<`${string}_id`>;
+}): drizzle_orm_pg_core.PgBigInt53BuilderInitial<`${string}_id`>;
 /**
  * UUID primary key
  *
@@ -833,6 +854,10 @@ declare function getSchemaInfo(packageName: string): {
  * Uses Record<string, unknown> to accept any schema shape
  */
 type TransactionDB = PostgresJsDatabase<Record<string, unknown>>;
+/**
+ * afterCommit callback type
+ */
+type AfterCommitCallback = () => void | Promise<void>;
 /**
  * Transaction context stored in AsyncLocalStorage
  */
@@ -842,6 +867,8 @@ type TransactionContext = {
     /** Unique transaction ID for logging and tracing */
     txId: string;
     level: number;
+    /** Callbacks to execute after root transaction commits */
+    afterCommitCallbacks: AfterCommitCallback[];
 };
 /**
  * Get current transaction from AsyncLocalStorage
@@ -862,6 +889,31 @@ declare function getTransaction(): TransactionDB | null;
  */
 declare function runWithTransaction<T>(tx: TransactionDB, txId: string, // Add txId parameter
 callback: () => Promise<T>): Promise<T>;
+/**
+ * Register a callback to run after the current transaction commits
+ *
+ * - Inside a transaction: queued and executed after root transaction commits
+ * - Outside a transaction: executed immediately (already "committed")
+ * - Nested transactions: callbacks bubble up to root transaction
+ * - Callbacks run outside transaction context (new connection for DB access)
+ * - Errors are logged but never thrown (commit already succeeded)
+ *
+ * @example
+ * ```typescript
+ * import { onAfterCommit } from '@spfn/core/db/transaction';
+ *
+ * async function submit(spaceId: string, chatId: string)
+ * {
+ *     const publication = await publicationRepo.create({...});
+ *     await requestRepo.updateStatusAtomically(...);
+ *
+ *     onAfterCommit(() => generateArticle(spaceId, chatId, publication.id));
+ *
+ *     return publication;
+ * }
+ * ```
+ */
+declare function onAfterCommit(callback: AfterCommitCallback): void;
 
 /**
  * Transaction middleware options
@@ -942,6 +994,78 @@ interface TransactionalOptions {
  */
 declare function Transactional(options?: TransactionalOptions): hono_types.MiddlewareHandler<any, string, {}, Response>;
 
+/**
+ * Transaction runner options
+ */
+interface RunInTransactionOptions {
+    /**
+     * Slow transaction warning threshold in milliseconds
+     * @default 1000 (1 second)
+     */
+    slowThreshold?: number;
+    /**
+     * Enable transaction logging
+     * @default true
+     */
+    enableLogging?: boolean;
+    /**
+     * Transaction timeout in milliseconds
+     *
+     * Sets PostgreSQL `statement_timeout` to enforce database-level timeout.
+     * If transaction exceeds this duration, PostgreSQL will automatically cancel
+     * the query and rollback the transaction, ensuring data consistency.
+     *
+     * Behavior:
+     * - `timeout: 0` - Disables timeout (unlimited execution time)
+     * - `timeout: null` - Uses default (30s or TRANSACTION_TIMEOUT env var)
+     * - `timeout: undefined` - Uses default (30s or TRANSACTION_TIMEOUT env var)
+     * - `timeout: N` - Sets timeout to N milliseconds (1 to 2147483647)
+     *
+     * Note: Timeout is only applied to root transactions. Nested transactions
+     * (SAVEPOINTs) inherit the timeout from the outer transaction.
+     *
+     * @default 30000 (30 seconds) or TRANSACTION_TIMEOUT environment variable
+     *
+     * @example
+     * ```typescript
+     * // Use default timeout (30s)
+     * await runInTransaction(callback);
+     *
+     * // Disable timeout for long-running operations
+     * await runInTransaction(callback, { timeout: 0 });
+     *
+     * // Set custom timeout (60s)
+     * await runInTransaction(callback, { timeout: 60000 });
+     * ```
+     */
+    timeout?: number;
+    /**
+     * Context string for logging (e.g., 'migration:add-user', 'script:cleanup')
+     * @default 'transaction'
+     */
+    context?: string;
+}
+/**
+ * Run a callback function within a database transaction
+ *
+ * Automatically manages transaction lifecycle:
+ * - Commits on success
+ * - Rolls back on error
+ * - Tracks execution time
+ * - Warns about slow transactions
+ * - Enforces timeout if configured
+ *
+ * Errors are propagated to the caller without modification.
+ * Caller is responsible for error handling and conversion.
+ *
+ * @param callback - Function to execute within transaction
+ * @param options - Transaction options
+ * @returns Result of callback function
+ * @throws TransactionError if database not initialized or timeout exceeded
+ * @throws Any error thrown by callback function
+ */
+declare function runInTransaction<T>(callback: (tx: TransactionDB) => Promise<T>, options?: RunInTransactionOptions): Promise<T>;
+
 /**
  * PostgreSQL Error Conversion Utilities
  *
@@ -1550,4 +1674,4 @@ declare abstract class BaseRepository<TSchema extends Record<string, unknown> =
     protected _count<T extends PgTable>(table: T, where?: Record<string, any> | SQL | undefined): Promise<number>;
 }
 
-export { BaseRepository, type DatabaseClients, type DrizzleConfigOptions, type PoolConfig, RepositoryError, type RetryConfig, type TransactionContext, type TransactionDB, Transactional, type TransactionalOptions, auditFields, checkConnection, closeDatabase, count, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, enumText, findMany, findOne, foreignKey, fromPostgresError, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, id, initDatabase, optionalForeignKey, packageNameToSchema, publishingFields, runWithTransaction, setDatabase, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
+export { type AfterCommitCallback, BaseRepository, type DatabaseClients, type DrizzleConfigOptions, type PoolConfig, RepositoryError, type RetryConfig, type RunInTransactionOptions, type TransactionContext, type TransactionDB, Transactional, type TransactionalOptions, auditFields, checkConnection, closeDatabase, count, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, enumText, findMany, findOne, foreignKey, fromPostgresError, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, id, initDatabase, onAfterCommit, optionalForeignKey, packageNameToSchema, publishingFields, runInTransaction, runWithTransaction, setDatabase, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };

package/dist/db/index.js

@@ -1,16 +1,17 @@
 import { drizzle } from 'drizzle-orm/postgres-js';
 import { env } from '@spfn/core/config';
 import { logger } from '@spfn/core/logger';
+import net from 'net';
 import postgres from 'postgres';
 import { QueryError, ConnectionError, DeadlockError, TransactionError, ConstraintViolationError, DuplicateEntryError, DatabaseError } from '@spfn/core/errors';
 import { parseNumber, parseBoolean } from '@spfn/core/env';
 import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join, dirname, basename } from 'path';
-import { bigserial, timestamp, uuid as uuid$1, text, jsonb, pgSchema } from 'drizzle-orm/pg-core';
+import { bigserial, timestamp, bigint, uuid as uuid$1, text, jsonb, pgSchema } from 'drizzle-orm/pg-core';
 import { AsyncLocalStorage } from 'async_hooks';
 import { createMiddleware } from 'hono/factory';
 import { randomUUID } from 'crypto';
-import { count as count$1, sql, eq, and } from 'drizzle-orm';
+import { sql, count as count$1, eq, and } from 'drizzle-orm';
 
 // src/db/manager/factory.ts
 function parseUniqueViolation(message) {
@@ -129,6 +130,12 @@ function fromPostgresError(error) {
 }
 
 // src/db/manager/connection.ts
+function getSocketFamily() {
+  const family = process.env.DATABASE_SOCKET_FAMILY;
+  if (family === "4") return 4;
+  if (family === "6") return 6;
+  return void 0;
+}
 var dbLogger = logger.child("@spfn/core:database");
 var DEFAULT_CONNECT_TIMEOUT = 10;
 function delay(ms) {
@@ -189,10 +196,21 @@ async function createDatabaseConnection(connectionString, poolConfig, retryConfi
   let client;
   for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
     try {
+      const socketFamily = getSocketFamily();
       client = postgres(connectionString, {
         max: poolConfig.max,
         idle_timeout: poolConfig.idleTimeout,
-        connect_timeout: DEFAULT_CONNECT_TIMEOUT
+        connect_timeout: DEFAULT_CONNECT_TIMEOUT,
+        ...socketFamily && {
+          socket: ({ host, port }) => new Promise((resolve, reject) => {
+            const socket = new net.Socket();
+            socket.on("error", reject);
+            socket.connect(
+              { port: port[0], host: host[0], family: socketFamily },
+              () => resolve(socket)
+            );
+          })
+        }
       });
       await client`SELECT 1 as test`;
       if (attempt > 0) {
@@ -503,6 +521,8 @@ var setMonitoringConfig = (config) => {
   globalThis.__SPFN_DB_MONITORING__ = config;
 };
 var dbLogger3 = logger.child("@spfn/core:database");
+var CLIENT_CLOSE_TIMEOUT = 5;
+var isReconnecting = false;
 async function testDatabaseConnection(db) {
   await db.execute("SELECT 1");
 }
@@ -514,8 +534,13 @@ async function performHealthCheck(getDatabase2) {
     await testDatabaseConnection(read);
   }
 }
-async function reconnectAndRestore(options, closeDatabase2) {
-  await closeDatabase2();
+async function closeClient(client) {
+  try {
+    await client.end({ timeout: CLIENT_CLOSE_TIMEOUT });
+  } catch {
+  }
+}
+async function reconnectAndRestore(options) {
   const result = await createDatabaseFromEnv(options);
   if (!result.write) {
     return false;
@@ -524,15 +549,23 @@ async function reconnectAndRestore(options, closeDatabase2) {
   if (result.read && result.read !== result.write) {
     await testDatabaseConnection(result.read);
   }
+  const oldWriteClient = getWriteClient();
+  const oldReadClient = getReadClient();
   setWriteInstance(result.write);
   setReadInstance(result.read);
   setWriteClient(result.writeClient);
   setReadClient(result.readClient);
   const monConfig = buildMonitoringConfig(options?.monitoring);
   setMonitoringConfig(monConfig);
+  if (oldWriteClient) {
+    closeClient(oldWriteClient);
+  }
+  if (oldReadClient && oldReadClient !== oldWriteClient) {
+    closeClient(oldReadClient);
+  }
   return true;
 }
-function startHealthCheck(config, options, getDatabase2, closeDatabase2) {
+function startHealthCheck(config, options, getDatabase2) {
   const healthCheck = getHealthCheckInterval();
   if (healthCheck) {
     dbLogger3.debug("Health check already running");
@@ -543,47 +576,56 @@ function startHealthCheck(config, options, getDatabase2, closeDatabase2) {
     reconnect: config.reconnect
   });
   const interval = setInterval(async () => {
+    if (isReconnecting) {
+      dbLogger3.debug("Health check skipped: reconnection in progress");
+      return;
+    }
     try {
       await performHealthCheck(getDatabase2);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       dbLogger3.error("Database health check failed", { error: message });
       if (config.reconnect) {
-        await attemptReconnection(config, options, closeDatabase2);
+        await attemptReconnection(config, options);
       }
     }
   }, config.interval);
   setHealthCheckInterval(interval);
 }
-async function attemptReconnection(config, options, closeDatabase2) {
+async function attemptReconnection(config, options) {
+  isReconnecting = true;
   dbLogger3.warn("Attempting database reconnection", {
     maxRetries: config.maxRetries,
     retryInterval: `${config.retryInterval}ms`
   });
-  for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
-    try {
-      dbLogger3.debug(`Reconnection attempt ${attempt}/${config.maxRetries}`);
-      if (attempt > 1) {
-        await new Promise((resolve) => setTimeout(resolve, config.retryInterval));
+  try {
+    for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
+      try {
+        dbLogger3.debug(`Reconnection attempt ${attempt}/${config.maxRetries}`);
+        if (attempt > 1) {
+          await new Promise((resolve) => setTimeout(resolve, config.retryInterval));
+        }
+        const success = await reconnectAndRestore(options);
+        if (success) {
+          dbLogger3.info("Database reconnection successful", { attempt });
+          return;
+        } else {
+          dbLogger3.error(`Reconnection attempt ${attempt} failed: No write database instance created`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
+          error: message,
+          attempt,
+          maxRetries: config.maxRetries
+        });
       }
-      const success = await reconnectAndRestore(options, closeDatabase2);
-      if (success) {
-        dbLogger3.info("Database reconnection successful", { attempt });
-        return;
-      } else {
-        dbLogger3.error(`Reconnection attempt ${attempt} failed: No write database instance created`);
+      if (attempt === config.maxRetries) {
+        dbLogger3.error("Max reconnection attempts reached, will retry on next health check");
       }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
-        error: message,
-        attempt,
-        maxRetries: config.maxRetries
-      });
-    }
-    if (attempt === config.maxRetries) {
-      dbLogger3.error("Max reconnection attempts reached, giving up");
     }
+  } finally {
+    isReconnecting = false;
   }
 }
 function stopHealthCheck() {
@@ -593,6 +635,7 @@ function stopHealthCheck() {
     setHealthCheckInterval(void 0);
     dbLogger3.info("Database health check stopped");
   }
+  isReconnecting = false;
 }
 
 // src/db/manager/manager.ts
@@ -742,7 +785,7 @@ async function initDatabase(options) {
       );
       const healthCheckConfig = buildHealthCheckConfig(options?.healthCheck);
       if (healthCheckConfig.enabled) {
-        startHealthCheck(healthCheckConfig, options, getDatabase, closeDatabase);
+        startHealthCheck(healthCheckConfig, options, getDatabase);
       }
       const monConfig = buildMonitoringConfig(options?.monitoring);
       setMonitoringConfig(monConfig);
@@ -811,7 +854,7 @@ function getDatabaseInfo() {
     isReplica: !!(readInst && readInst !== writeInst)
   };
 }
-var INDEX_FILE_PATTERNS = [
+var BARREL_FILE_PATTERNS = [
   "/index",
   "/index.ts",
   "/index.js",
@@ -819,11 +862,14 @@ var INDEX_FILE_PATTERNS = [
   "\\index",
   "\\index.ts",
   "\\index.js",
-  "\\index.mjs"
+  "\\index.mjs",
+  "\\config.ts",
+  "\\config.js",
+  "\\config.mjs"
 ];
 var SUPPORTED_EXTENSIONS = [".ts", ".js", ".mjs"];
-function isIndexFile(filePath) {
-  return INDEX_FILE_PATTERNS.some((pattern) => filePath.endsWith(pattern));
+function isBarrelFile(filePath) {
+  return BARREL_FILE_PATTERNS.some((pattern) => filePath.endsWith(pattern));
 }
 function isAbsolutePath(path) {
   if (path.startsWith("/")) return true;
@@ -833,8 +879,8 @@ function hasSupportedExtension(filePath) {
   if (filePath.endsWith(".d.ts")) return false;
   return SUPPORTED_EXTENSIONS.some((ext) => filePath.endsWith(ext));
 }
-function filterIndexFiles(files) {
-  return files.filter((file) => !isIndexFile(file));
+function filterBarrelFiles(files) {
+  return files.filter((file) => !isBarrelFile(file));
 }
 function scanDirectoryRecursive(dir, extension) {
   const files = [];
@@ -880,6 +926,27 @@ function scanDirectorySingleLevel(dir, filePattern) {
   }
   return files;
 }
+function detectSchemasFromFiles(files) {
+  const schemas = /* @__PURE__ */ new Set(["public"]);
+  const pgSchemaPattern = /pgSchema\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  const createSchemaPattern = /createSchema\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const filePath of files) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      let match;
+      while ((match = pgSchemaPattern.exec(content)) !== null) {
+        schemas.add(match[1]);
+      }
+      while ((match = createSchemaPattern.exec(content)) !== null) {
+        const packageName = match[1];
+        const schemaName = packageName.replace(/@/g, "").replace(/\//g, "_").replace(/-/g, "_");
+        schemas.add(schemaName);
+      }
+    } catch {
+    }
+  }
+  return Array.from(schemas);
+}
 function expandGlobPattern(pattern) {
   if (!pattern.includes("*")) {
     return existsSync(pattern) ? [pattern] : [];
@@ -922,7 +989,7 @@ function discoverPackageSchemas(cwd) {
         for (const schema of packageSchemas) {
           const absolutePath = join(pkgPath, schema);
           const expandedFiles = expandGlobPattern(absolutePath);
-          const schemaFiles = filterIndexFiles(expandedFiles);
+          const schemaFiles = filterBarrelFiles(expandedFiles);
           schemas.push(...schemaFiles);
         }
       }
@@ -984,28 +1051,45 @@ function getDrizzleConfig(options = {}) {
       schema: schema2,
       out,
       dialect,
-      dbCredentials: getDbCredentials(dialect, databaseUrl)
+      dbCredentials: getDbCredentials(dialect, databaseUrl),
+      migrations: {
+        prefix: options.migrationPrefix ?? "timestamp"
+      }
     };
   }
   const userSchema = options.schema ?? "./src/server/entities/**/*.ts";
   const userSchemas = Array.isArray(userSchema) ? userSchema : [userSchema];
   const packageSchemas = options.disablePackageDiscovery ? [] : discoverPackageSchemas(options.cwd ?? process.cwd());
   let allSchemas = [...userSchemas, ...packageSchemas];
+  const cwd = options.cwd ?? process.cwd();
+  let expandedFiles = [];
   if (options.expandGlobs) {
-    const expandedSchemas = [];
     for (const schema2 of allSchemas) {
-      const expanded = expandGlobPattern(schema2);
-      const filtered = filterIndexFiles(expanded);
-      expandedSchemas.push(...filtered);
+      const absoluteSchema = isAbsolutePath(schema2) ? schema2 : join(cwd, schema2);
+      const expanded = expandGlobPattern(absoluteSchema);
+      const filtered = filterBarrelFiles(expanded);
+      expandedFiles.push(...filtered);
     }
-    allSchemas = expandedSchemas;
+    allSchemas = expandedFiles;
   }
   const schema = allSchemas.length === 1 ? allSchemas[0] : allSchemas;
+  let schemaFilter;
+  if (dialect === "postgresql") {
+    if (options.schemaFilter) {
+      schemaFilter = options.schemaFilter;
+    } else if (options.autoDetectSchemas && expandedFiles.length > 0) {
+      schemaFilter = detectSchemasFromFiles(expandedFiles);
+    }
+  }
   return {
     schema,
     out,
     dialect,
-    dbCredentials: getDbCredentials(dialect, databaseUrl)
+    dbCredentials: getDbCredentials(dialect, databaseUrl),
+    schemaFilter,
+    migrations: {
+      prefix: options.migrationPrefix ?? "timestamp"
+    }
   };
 }
 function getDbCredentials(dialect, url) {
@@ -1032,13 +1116,17 @@ function generateDrizzleConfigFile(options = {}) {
   const schemaValue = Array.isArray(config.schema) ? `[
         ${config.schema.map((s) => `'${normalizeSchemaPath(s)}'`).join(",\n        ")}
     ]` : `'${normalizeSchemaPath(config.schema)}'`;
+  const schemaFilterLine = config.schemaFilter && config.schemaFilter.length > 0 ? `
+    schemaFilter: ${JSON.stringify(config.schemaFilter)},` : "";
+  const migrationsLine = config.migrations ? `
+    migrations: ${JSON.stringify(config.migrations)},` : "";
   return `import { defineConfig } from 'drizzle-kit';
 
 export default defineConfig({
     schema: ${schemaValue},
     out: '${config.out}',
     dialect: '${config.dialect}',
-    dbCredentials: ${JSON.stringify(config.dbCredentials, null, 4)},
+    dbCredentials: ${JSON.stringify(config.dbCredentials, null, 4)},${schemaFilterLine}${migrationsLine}
 });
 `;
 }
@@ -1052,10 +1140,10 @@ function timestamps() {
   };
 }
 function foreignKey(name, reference, options) {
-  return bigserial(`${name}_id`, { mode: "number" }).notNull().references(reference, { onDelete: options?.onDelete ?? "cascade" });
+  return bigint(`${name}_id`, { mode: "number" }).notNull().references(reference, { onDelete: options?.onDelete ?? "cascade" });
 }
 function optionalForeignKey(name, reference, options) {
-  return bigserial(`${name}_id`, { mode: "number" }).references(reference, { onDelete: options?.onDelete ?? "set null" });
+  return bigint(`${name}_id`, { mode: "number" }).references(reference, { onDelete: options?.onDelete ?? "set null" });
 }
 function uuid() {
   return uuid$1("id").defaultRandom().primaryKey();
@@ -1134,7 +1222,20 @@ function runWithTransaction(tx, txId, callback) {
   } else {
     txLogger.debug("Root transaction context set", { txId, level: newLevel });
   }
-  return asyncContext.run({ tx, txId, level: newLevel }, callback);
+  const afterCommitCallbacks = existingContext ? existingContext.afterCommitCallbacks : [];
+  return asyncContext.run({ tx, txId, level: newLevel, afterCommitCallbacks }, callback);
+}
+function onAfterCommit(callback) {
+  const context = getTransactionContext();
+  if (!context) {
+    Promise.resolve().then(callback).catch((err) => {
+      txLogger.error("afterCommit callback failed (no transaction)", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+    return;
+  }
+  context.afterCommitCallbacks.push(callback);
 }
 var MAX_TIMEOUT_MS = 2147483647;
 var txLogger2 = logger.child("@spfn/core:transaction");
@@ -1217,13 +1318,21 @@ async function runInTransaction(callback, options = {}) {
     txLogger2.debug("Transaction started", { txId, context });
   }
   const startTime = Date.now();
+  let afterCommitCallbacks = [];
   try {
     const result = await writeDb.transaction(async (tx) => {
       if (timeout > 0 && !isNested) {
         await tx.execute(sql.raw(`SET LOCAL statement_timeout = ${timeout}`));
       }
       return await runWithTransaction(tx, txId, async () => {
-        return await callback(tx);
+        const innerResult = await callback(tx);
+        if (!isNested) {
+          const ctx = getTransactionContext();
+          if (ctx) {
+            afterCommitCallbacks = [...ctx.afterCommitCallbacks];
+          }
+        }
+        return innerResult;
       });
     });
     const duration = Date.now() - startTime;
@@ -1243,6 +1352,24 @@ async function runInTransaction(callback, options = {}) {
         });
       }
     }
+    if (!isNested && afterCommitCallbacks.length > 0) {
+      if (enableLogging) {
+        txLogger2.debug("Executing afterCommit callbacks", {
+          txId,
+          context,
+          count: afterCommitCallbacks.length
+        });
+      }
+      for (const cb of afterCommitCallbacks) {
+        Promise.resolve().then(cb).catch((err) => {
+          txLogger2.error("afterCommit callback failed", {
+            txId,
+            context,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        });
+      }
+    }
     return result;
   } catch (error) {
     const duration = Date.now() - startTime;
@@ -1788,6 +1915,6 @@ var BaseRepository = class {
   }
 };
 
-export { BaseRepository, RepositoryError, Transactional, auditFields, checkConnection, closeDatabase, count, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, enumText, findMany, findOne, foreignKey, fromPostgresError, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, id, initDatabase, optionalForeignKey, packageNameToSchema, publishingFields, 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, foreignKey, fromPostgresError, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, id, initDatabase, onAfterCommit, optionalForeignKey, packageNameToSchema, publishingFields, runInTransaction, runWithTransaction, setDatabase, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map