@spfn/core 0.3.0-beta.3 → 0.3.0-beta.31

package/dist/db/index.js

@@ -3,10 +3,11 @@ 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 { QueryError, ConnectionError, DeadlockError, TransactionError, ConstraintViolationError, DuplicateEntryError, SerializableError } from '@spfn/core/errors';
 import { parseNumber, parseBoolean } from '@spfn/core/env';
-import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
-import { join, dirname, basename } from 'path';
+import { existsSync, readdirSync, readFileSync, statSync, realpathSync, lstatSync } from 'fs';
+import { join, relative } from 'path';
+import mm from 'micromatch';
 import { sql, count as count$1, lt, gt, and, desc, asc, eq } from 'drizzle-orm';
 import { bigserial, timestamp, bigint, uuid as uuid$1, text, jsonb, pgSchema } from 'drizzle-orm/pg-core';
 import { createHash, randomUUID } from 'crypto';
@@ -1213,7 +1214,10 @@ var BARREL_FILE_PATTERNS = [
   "/config.js",
   "/config.mjs"
 ];
-var SUPPORTED_EXTENSIONS = [".ts", ".js", ".mjs"];
+var DEFAULT_ENTITY_GLOB = "./src/server/entities/**/*.ts";
+var SUPPORTED_EXTENSIONS = [".ts", ".mts", ".cts", ".tsx", ".js", ".mjs", ".cjs", ".jsx"];
+var DECLARATION_PATTERN = /\.d\.[mc]?ts$/;
+var SKIPPED_DIRECTORIES = /^(\.|node_modules$)/;
 function isBarrelFile(filePath) {
   const posixPath = toPosixPath(filePath);
   return BARREL_FILE_PATTERNS.some((pattern) => posixPath.endsWith(pattern));
@@ -1223,90 +1227,100 @@ function isAbsolutePath(path) {
   return !!path.match(/^[A-Za-z]:[\/\\]/);
 }
 function hasSupportedExtension(filePath) {
-  if (filePath.endsWith(".d.ts")) return false;
+  if (DECLARATION_PATTERN.test(filePath)) return false;
   return SUPPORTED_EXTENSIONS.some((ext) => filePath.endsWith(ext));
 }
 function filterBarrelFiles(files) {
   return files.filter((file) => !isBarrelFile(file));
 }
-function scanDirectoryRecursive(dir, extension) {
-  const files = [];
-  if (!existsSync(dir)) return files;
+function safeStat(path) {
   try {
-    const entries = readdirSync(dir);
-    for (const entry of entries) {
-      const fullPath = join(dir, entry);
-      try {
-        const stat = statSync(fullPath);
-        if (stat.isDirectory()) {
-          files.push(...scanDirectoryRecursive(fullPath, extension));
-        } else if (stat.isFile()) {
-          if ((!extension || fullPath.endsWith(extension)) && hasSupportedExtension(fullPath)) {
-            files.push(fullPath);
-          }
-        }
-      } catch (error) {
-      }
-    }
-  } catch (error) {
+    return statSync(path);
+  } catch {
+    return void 0;
   }
-  return files;
 }
-function scanDirectorySingleLevel(dir, filePattern) {
-  const files = [];
-  if (!existsSync(dir)) return files;
+function safeReaddir(dir) {
   try {
-    const entries = readdirSync(dir);
-    for (const entry of entries) {
-      const fullPath = join(dir, entry);
-      try {
-        const stat = statSync(fullPath);
-        if (stat.isFile()) {
-          if ((filePattern === "*" || filePattern.startsWith("*.") && entry.endsWith(filePattern.slice(1))) && hasSupportedExtension(fullPath)) {
-            files.push(fullPath);
-          }
-        }
-      } catch (error) {
-      }
-    }
-  } catch (error) {
+    return readdirSync(dir);
+  } catch {
+    return [];
   }
-  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 {
-    }
+function walkDirectory(dir, maxDepth, ancestors = /* @__PURE__ */ new Set()) {
+  const walk = { files: [], directories: [] };
+  if (maxDepth < 1 || !safeStat(dir)?.isDirectory()) return walk;
+  const realDir = realpathSafe(dir);
+  if (ancestors.has(realDir)) return walk;
+  const chain = new Set(ancestors).add(realDir);
+  for (const entry of safeReaddir(dir)) {
+    const path = join(dir, entry);
+    const stat = safeStat(path);
+    if (stat?.isFile() && hasSupportedExtension(path)) {
+      walk.files.push(path);
+    } else if (stat?.isDirectory() && !SKIPPED_DIRECTORIES.test(entry)) {
+      walk.directories.push(path);
+      const isLink = isSymlink(path);
+      const child = walkDirectory(path, isLink ? Math.min(maxDepth - 1, 1) : maxDepth - 1, chain);
+      for (const file of child.files) walk.files.push(file);
+      for (const sub of child.directories) walk.directories.push(sub);
+    }
+  }
+  return walk;
+}
+function isSymlink(path) {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
   }
-  return Array.from(schemas);
 }
-function expandGlobPattern(pattern) {
-  if (!pattern.includes("*")) {
-    return existsSync(pattern) ? [pattern] : [];
-  }
-  if (pattern.includes("**")) {
-    const [baseDir, ...rest] = pattern.split("**");
-    const extension = rest.join("").replace(/[\/\\]\*\./g, "").trim();
-    const dir2 = baseDir.trim() || ".";
-    return scanDirectoryRecursive(dir2, extension || void 0);
+function realpathSafe(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function scanDirectory(dir, maxDepth) {
+  return walkDirectory(dir, maxDepth).files;
+}
+function toRelativePattern(entry, cwd) {
+  return toPosixPath(isAbsolutePath(entry) ? relative(cwd, entry) : entry).replace(/^\.\//, "").replace(/[()]/g, "\\$&");
+}
+function expandGlob(pattern, cwd) {
+  const scan = mm.scan(pattern);
+  const depth = scan.isGlobstar || scan.glob.includes("**") ? Infinity : scan.glob.split("/").length;
+  const base = join(cwd, scan.base.replace(/\\([()])/g, "$1"));
+  const matches = mm.matcher(pattern);
+  const matched = (path) => matches(toPosixPath(relative(cwd, path)));
+  const walk = walkDirectory(base, depth);
+  return Array.from(/* @__PURE__ */ new Set([...walk.files.filter(matched), ...walk.directories.filter(matched).flatMap((dir) => scanDirectory(dir, 1))]));
+}
+function expandSchemaEntry(entry, cwd) {
+  const pattern = toRelativePattern(entry, cwd);
+  if (mm.scan(pattern).isGlob) {
+    return expandGlob(pattern, cwd);
+  }
+  const path = isAbsolutePath(entry) ? entry : join(cwd, entry);
+  const stat = safeStat(path);
+  if (!stat) return [];
+  return stat.isDirectory() ? scanDirectory(path, 1) : [path];
+}
+function selectDefaultSchema(cwd) {
+  const registry = env.DRIZZLE_SCHEMA_PATH;
+  const registryFile = isAbsolutePath(registry) ? registry : join(cwd, registry);
+  const registryExists = safeStat(registryFile)?.isFile() === true;
+  const scanned = filterBarrelFiles(expandSchemaEntry(DEFAULT_ENTITY_GLOB, cwd));
+  if (scanned.length === 0 && registryExists) {
+    return { schemas: [registry], source: `entity registry ${registry}` };
   }
-  const dir = dirname(pattern);
-  const filePattern = basename(pattern);
-  return scanDirectorySingleLevel(dir, filePattern);
+  return {
+    schemas: [DEFAULT_ENTITY_GLOB],
+    source: `${DEFAULT_ENTITY_GLOB} scan`,
+    files: scanned,
+    registry: registryExists ? registry : void 0
+  };
 }
 function discoverPackageSchemas(cwd) {
   const schemas = [];
@@ -1335,9 +1349,7 @@ function discoverPackageSchemas(cwd) {
         const packageSchemas = Array.isArray(pkgJson.spfn.schemas) ? pkgJson.spfn.schemas : [pkgJson.spfn.schemas];
         for (const schema of packageSchemas) {
           const absolutePath = join(pkgPath, schema);
-          const expandedFiles = expandGlobPattern(absolutePath);
-          const schemaFiles = filterBarrelFiles(expandedFiles);
-          schemas.push(...schemaFiles);
+          schemas.push(...filterBarrelFiles(expandSchemaEntry(absolutePath, pkgPath)));
         }
       }
     } catch (error) {
@@ -1396,6 +1408,8 @@ function getDrizzleConfig(options = {}) {
     const schema2 = filteredSchemas.length === 1 ? filteredSchemas[0] : filteredSchemas;
     return {
       schema: schema2,
+      schemaSource: `package ${options.packageFilter}`,
+      schemaRegistry: void 0,
       out,
       dialect,
       dbCredentials: getDbCredentials(dialect, databaseUrl),
@@ -1404,32 +1418,18 @@ function getDrizzleConfig(options = {}) {
       }
     };
   }
-  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) {
-    for (const schema2 of allSchemas) {
-      const absoluteSchema = isAbsolutePath(schema2) ? schema2 : join(cwd, schema2);
-      const expanded = expandGlobPattern(absoluteSchema);
-      const filtered = filterBarrelFiles(expanded);
-      expandedFiles.push(...filtered);
-    }
-    allSchemas = expandedFiles;
-  }
+  const selection = options.schema ? { schemas: Array.isArray(options.schema) ? options.schema : [options.schema], source: "schema option" } : selectDefaultSchema(cwd);
+  const schemaSource = selection.source;
+  const schemaRegistry = selection.registry;
+  const packageSchemas = options.disablePackageDiscovery ? [] : discoverPackageSchemas(cwd);
+  const allSchemas = options.expandGlobs ? [...selection.files ?? selection.schemas.flatMap((entry) => expandSchemaEntry(entry, cwd)), ...packageSchemas] : [...selection.schemas, ...packageSchemas];
   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);
-    }
-  }
+  const schemaFilter = dialect === "postgresql" ? options.schemaFilter : void 0;
   return {
     schema,
+    schemaSource,
+    schemaRegistry,
     out,
     dialect,
     dbCredentials: getDbCredentials(dialect, databaseUrl),
@@ -1451,9 +1451,7 @@ function getDbCredentials(dialect, url) {
       throw new Error(`Unsupported dialect: ${dialect}`);
   }
 }
-function generateDrizzleConfigFile(options = {}) {
-  const config = getDrizzleConfig(options);
-  const cwd = options.cwd ?? process.cwd();
+function renderDrizzleConfig(config, cwd = process.cwd()) {
   const normalizeSchemaPath = (schemaPath) => {
     if (isAbsolutePath(schemaPath)) {
       return schemaPath;
@@ -1477,6 +1475,9 @@ export default defineConfig({
 });
 `;
 }
+function generateDrizzleConfigFile(options = {}) {
+  return renderDrizzleConfig(getDrizzleConfig(options), options.cwd ?? process.cwd());
+}
 function id() {
   return bigserial("id", { mode: "number" }).primaryKey();
 }
@@ -1743,6 +1744,32 @@ function pendingMigrationsSummary(targets) {
   return `${pending} pending migration(s) in ${names}`;
 }
 var txLogger = logger.child("@spfn/core:transaction");
+var concurrentNestingReported = false;
+function reportConcurrentNesting() {
+  if (concurrentNestingReported) {
+    return;
+  }
+  concurrentNestingReported = true;
+  txLogger.warn("Concurrent nested transactions are serialized", {
+    reason: "sibling SAVEPOINTs share the outer transaction's connection, where one sibling's ROLLBACK TO would discard the other's writes",
+    hint: "await nested calls one at a time, or pass requiresNew: true to give a branch its own connection. A nested call whose callback awaits a sibling started after it deadlocks."
+  });
+}
+function createNestedFrameGate() {
+  let tail = Promise.resolve();
+  let pending = 0;
+  return {
+    run(frame) {
+      if (pending > 0) {
+        reportConcurrentNesting();
+      }
+      pending++;
+      const result = tail.then(frame);
+      tail = result.then(() => void pending--, () => void pending--);
+      return result;
+    }
+  };
+}
 var asyncContext = new AsyncLocalStorage();
 function getTransactionContext() {
   return asyncContext.getStore() ?? null;
@@ -1755,7 +1782,7 @@ function runWithTransaction(tx, txId, callback) {
   const existingContext = getTransactionContext();
   const newLevel = existingContext ? existingContext.level + 1 : 1;
   if (existingContext) {
-    txLogger.info("Nested transaction started (SAVEPOINT)", {
+    txLogger.debug("Nested transaction started (SAVEPOINT)", {
       outerTxId: existingContext.txId,
       innerTxId: txId,
       level: newLevel
@@ -1763,9 +1790,16 @@ function runWithTransaction(tx, txId, callback) {
   } else {
     txLogger.debug("Root transaction context set", { txId, level: newLevel });
   }
-  const afterCommitCallbacks = existingContext ? existingContext.afterCommitCallbacks : [];
   return asyncContext.run(
-    { tx, txId, level: newLevel, afterCommitCallbacks },
+    {
+      tx,
+      txId,
+      level: newLevel,
+      beforeCommitCallbacks: [],
+      afterCommitCallbacks: [],
+      afterRollbackCallbacks: [],
+      nestedFrames: createNestedFrameGate()
+    },
     callback
   );
 }
@@ -1781,14 +1815,79 @@ function onAfterCommit(callback) {
   }
   context.afterCommitCallbacks.push(callback);
 }
+function onBeforeCommit(callback) {
+  const context = getTransactionContext();
+  if (!context) {
+    txLogger.warn(
+      "beforeCommit callback ran immediately (no transaction): a throw cannot abort anything"
+    );
+    Promise.resolve().then(callback).catch((err) => {
+      txLogger.error("beforeCommit callback failed (no transaction)", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+    return;
+  }
+  context.beforeCommitCallbacks.push(callback);
+}
+function onAfterRollback(callback) {
+  const context = getTransactionContext();
+  if (!context) {
+    txLogger.warn("afterRollback callback ignored (no transaction)");
+    return;
+  }
+  context.afterRollbackCallbacks.push(callback);
+}
 var MAX_TIMEOUT_MS = 2147483647;
 var txLogger2 = logger.child("@spfn/core:transaction");
+function logSafely(emit) {
+  try {
+    emit();
+  } catch {
+  }
+}
+async function runBeforeCommitCallbacks(callbacks) {
+  for (const cb of [...callbacks]) {
+    await cb();
+  }
+}
+async function runAfterRollbackCallbacks(callbacks, txId, context, enableLogging) {
+  if (enableLogging) {
+    logSafely(() => txLogger2.debug("Executing afterRollback callbacks", {
+      txId,
+      context,
+      count: callbacks.length
+    }));
+  }
+  for (const cb of callbacks) {
+    await Promise.resolve().then(cb).catch((err) => logSafely(() => {
+      txLogger2.error("afterRollback callback failed", {
+        txId,
+        context,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }));
+  }
+}
+function promoteFrameHooks(frame, parent) {
+  parent.beforeCommitCallbacks.push(...frame.beforeCommitCallbacks);
+  parent.afterCommitCallbacks.push(...frame.afterCommitCallbacks);
+  parent.afterRollbackCallbacks.push(...frame.afterRollbackCallbacks);
+}
+async function discardFrameHooks(frame, parent, error, txId, context, enableLogging) {
+  await asyncContext.run(
+    { ...parent, nestedFrames: createNestedFrameGate() },
+    () => runAfterRollbackCallbacks(frame.afterRollbackCallbacks, txId, context, enableLogging)
+  ).catch(() => void 0);
+  throw error;
+}
 async function runInTransaction(callback, options = {}) {
   const defaultTimeout = env.TRANSACTION_TIMEOUT;
   const {
     slowThreshold = 1e3,
     enableLogging = true,
-    context = "transaction"
+    context = "transaction",
+    requiresNew = false
   } = options;
   const timeout = options.timeout ?? defaultTimeout;
   const idleTimeout = options.idleTimeout ?? env.TRANSACTION_IDLE_TIMEOUT;
@@ -1866,24 +1965,50 @@ async function runInTransaction(callback, options = {}) {
     }
     throw error;
   }
-  const existingContext = getTransactionContext();
-  const isNested = existingContext !== null;
-  if (isNested && timeout > 0 && enableLogging) {
+  const savepointOwner = requiresNew ? null : getTransactionContext();
+  const isNested = savepointOwner !== null;
+  if (isNested && options.timeout !== void 0 && options.timeout > 0 && enableLogging) {
     txLogger2.warn("Timeout ignored in nested transaction", {
       txId,
       context,
-      outerTxId: existingContext.txId,
+      outerTxId: savepointOwner.txId,
       requestedTimeout: `${timeout}ms`,
-      reason: "SET LOCAL statement_timeout affects the entire outer transaction"
+      reason: "the SAVEPOINT runs under the outer transaction's statement_timeout; SET LOCAL here would re-scope the whole outer transaction"
     });
   }
   if (enableLogging) {
     txLogger2.debug("Transaction started", { txId, context });
   }
   const startTime = Date.now();
+  let beforeCommitCallbacks = [];
   let afterCommitCallbacks = [];
+  let afterRollbackCallbacks = [];
+  const openTransaction = (body) => {
+    if (savepointOwner) {
+      return savepointOwner.nestedFrames.run(
+        () => savepointOwner.tx.transaction(body).then(
+          (result) => {
+            promoteFrameHooks({ beforeCommitCallbacks, afterCommitCallbacks, afterRollbackCallbacks }, savepointOwner);
+            return result;
+          },
+          (error) => discardFrameHooks(
+            { afterRollbackCallbacks },
+            savepointOwner,
+            error,
+            txId,
+            context,
+            enableLogging
+          )
+        )
+      );
+    }
+    if (requiresNew) {
+      return asyncContext.exit(() => writeDb.transaction(body));
+    }
+    return writeDb.transaction(body);
+  };
   try {
-    const result = await writeDb.transaction(async (tx) => {
+    const result = await openTransaction(async (tx) => {
       const transaction = tx;
       if (timeout > 0 && !isNested) {
         await transaction.execute(sql.raw(`SET LOCAL statement_timeout = ${timeout}`));
@@ -1892,81 +2017,115 @@ async function runInTransaction(callback, options = {}) {
         await transaction.execute(sql.raw(`SET LOCAL idle_in_transaction_session_timeout = ${idleTimeout}`));
       }
       return await runWithTransaction(transaction, txId, async () => {
+        const ctx = getTransactionContext();
+        if (ctx) {
+          beforeCommitCallbacks = ctx.beforeCommitCallbacks;
+          afterCommitCallbacks = ctx.afterCommitCallbacks;
+          afterRollbackCallbacks = ctx.afterRollbackCallbacks;
+        }
         const innerResult = await callback(transaction);
-        if (!isNested) {
-          const ctx = getTransactionContext();
-          if (ctx) {
-            afterCommitCallbacks = [...ctx.afterCommitCallbacks];
+        if (!isNested && beforeCommitCallbacks.length > 0) {
+          if (enableLogging) {
+            logSafely(() => txLogger2.debug("Executing beforeCommit callbacks", {
+              txId,
+              context,
+              count: beforeCommitCallbacks.length
+            }));
           }
+          await runBeforeCommitCallbacks(beforeCommitCallbacks);
         }
         return innerResult;
       });
     });
     const duration = Date.now() - startTime;
     if (enableLogging) {
-      if (duration >= slowThreshold) {
-        txLogger2.warn("Slow transaction committed", {
-          txId,
-          context,
-          duration: `${duration}ms`,
-          threshold: `${slowThreshold}ms`,
-          hint: "A transaction holds a pooled connection (and row locks) for its whole duration. If this is slow because of non-DB work (external API, etc.) inside the transaction, move that work out \u2014 it starves the connection pool."
-        });
-      } else {
-        txLogger2.debug("Transaction committed", {
-          txId,
-          context,
-          duration: `${duration}ms`
-        });
-      }
+      logSafely(() => {
+        if (duration >= slowThreshold) {
+          txLogger2.warn("Slow transaction committed", {
+            txId,
+            context,
+            duration: `${duration}ms`,
+            threshold: `${slowThreshold}ms`,
+            hint: "A transaction holds a pooled connection (and row locks) for its whole duration. If this is slow because of non-DB work (external API, etc.) inside the transaction, move that work out \u2014 it starves the connection pool."
+          });
+        } else {
+          txLogger2.debug("Transaction committed", {
+            txId,
+            context,
+            duration: `${duration}ms`
+          });
+        }
+      });
     }
     if (!isNested && afterCommitCallbacks.length > 0) {
       if (enableLogging) {
-        txLogger2.debug("Executing afterCommit callbacks", {
+        logSafely(() => txLogger2.debug("Executing afterCommit callbacks", {
           txId,
           context,
           count: afterCommitCallbacks.length
-        });
+        }));
       }
       for (const cb of afterCommitCallbacks) {
-        Promise.resolve().then(cb).catch((err) => {
+        Promise.resolve().then(cb).catch((err) => logSafely(() => {
           txLogger2.error("afterCommit callback failed", {
             txId,
             context,
             error: err instanceof Error ? err.message : String(err)
           });
-        });
+        }));
       }
     }
     return result;
   } catch (error) {
     const duration = Date.now() - startTime;
     if (enableLogging) {
-      if (duration >= slowThreshold) {
-        txLogger2.warn("Slow transaction rolled back", {
-          txId,
-          context,
-          duration: `${duration}ms`,
-          threshold: `${slowThreshold}ms`,
-          error: error instanceof Error ? error.message : String(error),
-          errorType: error instanceof Error ? error.name : "Unknown",
-          hint: "If the error is an idle-in-transaction timeout, the transaction held a pooled connection while awaiting non-DB work (external API, etc.). Move that work out of the transaction."
-        });
-      } else {
-        txLogger2.error("Transaction rolled back", {
-          txId,
-          context,
-          duration: `${duration}ms`,
-          error: error instanceof Error ? error.message : String(error),
-          errorType: error instanceof Error ? error.name : "Unknown"
-        });
-      }
+      logSafely(() => {
+        if (duration >= slowThreshold) {
+          txLogger2.warn("Slow transaction rolled back", {
+            txId,
+            context,
+            duration: `${duration}ms`,
+            threshold: `${slowThreshold}ms`,
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.name : "Unknown",
+            hint: "If the error is an idle-in-transaction timeout, the transaction held a pooled connection while awaiting non-DB work (external API, etc.). Move that work out of the transaction."
+          });
+        } else {
+          txLogger2.error("Transaction rolled back", {
+            txId,
+            context,
+            duration: `${duration}ms`,
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.name : "Unknown"
+          });
+        }
+      });
+    }
+    if (!isNested && afterRollbackCallbacks.length > 0) {
+      await runAfterRollbackCallbacks(afterRollbackCallbacks, txId, context, enableLogging).catch(() => void 0);
     }
     throw error;
   }
 }
 
 // src/db/transaction/middleware.ts
+var SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;
+function isDriverOriginError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const candidate = error;
+  if (typeof candidate.code !== "string") {
+    return false;
+  }
+  if (POSTGRES_JS_CONNECTION_CODES.has(candidate.code)) {
+    return true;
+  }
+  if (!SQLSTATE_PATTERN.test(candidate.code)) {
+    return false;
+  }
+  return typeof candidate.severity === "string" || typeof candidate.severity_local === "string";
+}
 function Transactional(options = {}) {
   return createMiddleware(async (c, next) => {
     const route = `${c.req.method} ${c.req.path}`;
@@ -1986,13 +2145,10 @@ function Transactional(options = {}) {
       );
     } catch (error) {
       reportDatabaseError(error);
-      if (error instanceof DatabaseError) {
-        throw error;
-      }
-      if (error instanceof TransactionError) {
+      if (error instanceof SerializableError) {
         throw error;
       }
-      if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
+      if (isDriverOriginError(error)) {
         throw fromPostgresError(error);
       }
       throw error;
@@ -2531,6 +2687,6 @@ var BaseRepository = class {
   }
 };
 
-export { BaseRepository, PROJECT_MIGRATIONS_TABLE, PROJECT_TARGET_NAME, RUN_MIGRATIONS_HINT, RepositoryError, Transactional, auditFields, checkConnection, closeDatabase, collectMigrationStatus, count, countPendingMigrations, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, discoverFunctionMigrations, enumText, filterPendingEntries, findMany, findOne, forceReconnectDatabase, foreignKey, formatPendingMigrations, fromPostgresError, functionMigrationsTable, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, getTransactionContext, hasMigrationTargets, id, initDatabase, isConnectionLevelError, migrationTargets, onAfterCommit, optionalForeignKey, packageNameToSchema, pendingMigrationTargets, pendingMigrationsSummary, projectMigrationsDir, publishingFields, readMigrationEntries, reportDatabaseError, resetConnectionErrorCounter, runInTransaction, runWithTransaction, setDatabase, setDatabaseProvider, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
+export { BaseRepository, PROJECT_MIGRATIONS_TABLE, PROJECT_TARGET_NAME, RUN_MIGRATIONS_HINT, RepositoryError, Transactional, auditFields, checkConnection, closeDatabase, collectMigrationStatus, count, countPendingMigrations, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, discoverFunctionMigrations, enumText, filterPendingEntries, findMany, findOne, forceReconnectDatabase, foreignKey, formatPendingMigrations, fromPostgresError, functionMigrationsTable, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, getTransactionContext, hasMigrationTargets, id, initDatabase, isConnectionLevelError, migrationTargets, onAfterCommit, onAfterRollback, onBeforeCommit, optionalForeignKey, packageNameToSchema, pendingMigrationTargets, pendingMigrationsSummary, projectMigrationsDir, publishingFields, readMigrationEntries, renderDrizzleConfig, reportDatabaseError, resetConnectionErrorCounter, runInTransaction, runWithTransaction, setDatabase, setDatabaseProvider, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map