@spfn/core 0.1.0-alpha.88 → 0.2.0-beta.10

package/dist/db/index.js

@@ -1,944 +1,18 @@
 import { drizzle } from 'drizzle-orm/postgres-js';
-import { existsSync, mkdirSync, createWriteStream, statSync, readdirSync, renameSync, unlinkSync, accessSync, constants, writeFileSync, readFileSync } from 'fs';
-import { join, dirname, basename } from 'path';
-import { config } from 'dotenv';
+import { env } from '@spfn/core/config';
+import { logger } from '@spfn/core/logger';
 import postgres from 'postgres';
-import { bigserial, timestamp, pgSchema } from 'drizzle-orm/pg-core';
+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 { AsyncLocalStorage } from 'async_hooks';
-import { randomUUID } from 'crypto';
 import { createMiddleware } from 'hono/factory';
-import { eq, and } from 'drizzle-orm';
+import { randomUUID } from 'crypto';
+import { count as count$1, sql, eq, and } from 'drizzle-orm';
 
 // src/db/manager/factory.ts
-
-// src/logger/types.ts
-var LOG_LEVEL_PRIORITY = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  fatal: 4
-};
-
-// src/logger/formatters.ts
-var SENSITIVE_KEYS = [
-  "password",
-  "passwd",
-  "pwd",
-  "secret",
-  "token",
-  "apikey",
-  "api_key",
-  "accesstoken",
-  "access_token",
-  "refreshtoken",
-  "refresh_token",
-  "authorization",
-  "auth",
-  "cookie",
-  "session",
-  "sessionid",
-  "session_id",
-  "privatekey",
-  "private_key",
-  "creditcard",
-  "credit_card",
-  "cardnumber",
-  "card_number",
-  "cvv",
-  "ssn",
-  "pin"
-];
-var MASKED_VALUE = "***MASKED***";
-function isSensitiveKey(key) {
-  const lowerKey = key.toLowerCase();
-  return SENSITIVE_KEYS.some((sensitive) => lowerKey.includes(sensitive));
-}
-function maskSensitiveData(data) {
-  if (data === null || data === void 0) {
-    return data;
-  }
-  if (Array.isArray(data)) {
-    return data.map((item) => maskSensitiveData(item));
-  }
-  if (typeof data === "object") {
-    const masked = {};
-    for (const [key, value] of Object.entries(data)) {
-      if (isSensitiveKey(key)) {
-        masked[key] = MASKED_VALUE;
-      } else if (typeof value === "object" && value !== null) {
-        masked[key] = maskSensitiveData(value);
-      } else {
-        masked[key] = value;
-      }
-    }
-    return masked;
-  }
-  return data;
-}
-var COLORS = {
-  reset: "\x1B[0m",
-  bright: "\x1B[1m",
-  dim: "\x1B[2m",
-  // 로그 레벨 컬러
-  debug: "\x1B[36m",
-  // cyan
-  info: "\x1B[32m",
-  // green
-  warn: "\x1B[33m",
-  // yellow
-  error: "\x1B[31m",
-  // red
-  fatal: "\x1B[35m",
-  // magenta
-  // 추가 컬러
-  gray: "\x1B[90m"
-};
-function formatTimestamp(date) {
-  return date.toISOString();
-}
-function formatTimestampHuman(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
-  const ms = String(date.getMilliseconds()).padStart(3, "0");
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
-}
-function formatError(error) {
-  const lines = [];
-  lines.push(`${error.name}: ${error.message}`);
-  if (error.stack) {
-    const stackLines = error.stack.split("\n").slice(1);
-    lines.push(...stackLines);
-  }
-  return lines.join("\n");
-}
-function formatConsole(metadata, colorize = true) {
-  const parts = [];
-  const timestamp2 = formatTimestampHuman(metadata.timestamp);
-  if (colorize) {
-    parts.push(`${COLORS.gray}[${timestamp2}]${COLORS.reset}`);
-  } else {
-    parts.push(`[${timestamp2}]`);
-  }
-  if (metadata.module) {
-    if (colorize) {
-      parts.push(`${COLORS.dim}[module=${metadata.module}]${COLORS.reset}`);
-    } else {
-      parts.push(`[module=${metadata.module}]`);
-    }
-  }
-  if (metadata.context && Object.keys(metadata.context).length > 0) {
-    Object.entries(metadata.context).forEach(([key, value]) => {
-      let valueStr;
-      if (typeof value === "string") {
-        valueStr = value;
-      } else if (typeof value === "object" && value !== null) {
-        try {
-          valueStr = JSON.stringify(value);
-        } catch (error) {
-          valueStr = "[circular]";
-        }
-      } else {
-        valueStr = String(value);
-      }
-      if (colorize) {
-        parts.push(`${COLORS.dim}[${key}=${valueStr}]${COLORS.reset}`);
-      } else {
-        parts.push(`[${key}=${valueStr}]`);
-      }
-    });
-  }
-  const levelStr = metadata.level.toUpperCase();
-  if (colorize) {
-    const color = COLORS[metadata.level];
-    parts.push(`${color}(${levelStr})${COLORS.reset}:`);
-  } else {
-    parts.push(`(${levelStr}):`);
-  }
-  if (colorize) {
-    parts.push(`${COLORS.bright}${metadata.message}${COLORS.reset}`);
-  } else {
-    parts.push(metadata.message);
-  }
-  let output = parts.join(" ");
-  if (metadata.error) {
-    output += "\n" + formatError(metadata.error);
-  }
-  return output;
-}
-function formatJSON(metadata) {
-  const obj = {
-    timestamp: formatTimestamp(metadata.timestamp),
-    level: metadata.level,
-    message: metadata.message
-  };
-  if (metadata.module) {
-    obj.module = metadata.module;
-  }
-  if (metadata.context) {
-    obj.context = metadata.context;
-  }
-  if (metadata.error) {
-    obj.error = {
-      name: metadata.error.name,
-      message: metadata.error.message,
-      stack: metadata.error.stack
-    };
-  }
-  return JSON.stringify(obj);
-}
-
-// src/logger/logger.ts
-var Logger = class _Logger {
-  config;
-  module;
-  constructor(config) {
-    this.config = config;
-    this.module = config.module;
-  }
-  /**
-   * Get current log level
-   */
-  get level() {
-    return this.config.level;
-  }
-  /**
-   * Create child logger (per module)
-   */
-  child(module) {
-    return new _Logger({
-      ...this.config,
-      module
-    });
-  }
-  /**
-   * Debug log
-   */
-  debug(message, context) {
-    this.log("debug", message, void 0, context);
-  }
-  /**
-   * Info log
-   */
-  info(message, context) {
-    this.log("info", message, void 0, context);
-  }
-  warn(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.log("warn", message, errorOrContext, context);
-    } else {
-      this.log("warn", message, void 0, errorOrContext);
-    }
-  }
-  error(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.log("error", message, errorOrContext, context);
-    } else {
-      this.log("error", message, void 0, errorOrContext);
-    }
-  }
-  fatal(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.log("fatal", message, errorOrContext, context);
-    } else {
-      this.log("fatal", message, void 0, errorOrContext);
-    }
-  }
-  /**
-   * Log processing (internal)
-   */
-  log(level, message, error, context) {
-    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.config.level]) {
-      return;
-    }
-    const metadata = {
-      timestamp: /* @__PURE__ */ new Date(),
-      level,
-      message,
-      module: this.module,
-      error,
-      // Mask sensitive information in context to prevent credential leaks
-      context: context ? maskSensitiveData(context) : void 0
-    };
-    this.processTransports(metadata);
-  }
-  /**
-   * Process Transports
-   */
-  processTransports(metadata) {
-    const promises = this.config.transports.filter((transport) => transport.enabled).map((transport) => this.safeTransportLog(transport, metadata));
-    Promise.all(promises).catch((error) => {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[Logger] Transport error: ${errorMessage}
-`);
-    });
-  }
-  /**
-   * Transport log (error-safe)
-   */
-  async safeTransportLog(transport, metadata) {
-    try {
-      await transport.log(metadata);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[Logger] Transport "${transport.name}" failed: ${errorMessage}
-`);
-    }
-  }
-  /**
-   * Close all Transports
-   */
-  async close() {
-    const closePromises = this.config.transports.filter((transport) => transport.close).map((transport) => transport.close());
-    await Promise.all(closePromises);
-  }
-};
-
-// src/logger/transports/console.ts
-var ConsoleTransport = class {
-  name = "console";
-  level;
-  enabled;
-  colorize;
-  constructor(config) {
-    this.level = config.level;
-    this.enabled = config.enabled;
-    this.colorize = config.colorize ?? true;
-  }
-  async log(metadata) {
-    if (!this.enabled) {
-      return;
-    }
-    if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
-      return;
-    }
-    const message = formatConsole(metadata, this.colorize);
-    if (metadata.level === "warn" || metadata.level === "error" || metadata.level === "fatal") {
-      console.error(message);
-    } else {
-      console.log(message);
-    }
-  }
-};
-var FileTransport = class {
-  name = "file";
-  level;
-  enabled;
-  logDir;
-  maxFileSize;
-  maxFiles;
-  currentStream = null;
-  currentFilename = null;
-  constructor(config) {
-    this.level = config.level;
-    this.enabled = config.enabled;
-    this.logDir = config.logDir;
-    this.maxFileSize = config.maxFileSize ?? 10 * 1024 * 1024;
-    this.maxFiles = config.maxFiles ?? 10;
-    if (!existsSync(this.logDir)) {
-      mkdirSync(this.logDir, { recursive: true });
-    }
-  }
-  async log(metadata) {
-    if (!this.enabled) {
-      return;
-    }
-    if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
-      return;
-    }
-    const message = formatJSON(metadata);
-    const filename = this.getLogFilename(metadata.timestamp);
-    if (this.currentFilename !== filename) {
-      await this.rotateStream(filename);
-      await this.cleanOldFiles();
-    } else if (this.currentFilename) {
-      await this.checkAndRotateBySize();
-    }
-    if (this.currentStream) {
-      return new Promise((resolve, reject) => {
-        this.currentStream.write(message + "\n", "utf-8", (error) => {
-          if (error) {
-            process.stderr.write(`[FileTransport] Failed to write log: ${error.message}
-`);
-            reject(error);
-          } else {
-            resolve();
-          }
-        });
-      });
-    }
-  }
-  /**
-   * 스트림 교체 (날짜 변경 시)
-   */
-  async rotateStream(filename) {
-    if (this.currentStream) {
-      await this.closeStream();
-    }
-    const filepath = join(this.logDir, filename);
-    this.currentStream = createWriteStream(filepath, {
-      flags: "a",
-      // append mode
-      encoding: "utf-8"
-    });
-    this.currentFilename = filename;
-    this.currentStream.on("error", (error) => {
-      process.stderr.write(`[FileTransport] Stream error: ${error.message}
-`);
-      this.currentStream = null;
-      this.currentFilename = null;
-    });
-  }
-  /**
-   * 현재 스트림 닫기
-   */
-  async closeStream() {
-    if (!this.currentStream) {
-      return;
-    }
-    return new Promise((resolve, reject) => {
-      this.currentStream.end((error) => {
-        if (error) {
-          reject(error);
-        } else {
-          this.currentStream = null;
-          this.currentFilename = null;
-          resolve();
-        }
-      });
-    });
-  }
-  /**
-   * 파일 크기 체크 및 크기 기반 로테이션
-   */
-  async checkAndRotateBySize() {
-    if (!this.currentFilename) {
-      return;
-    }
-    const filepath = join(this.logDir, this.currentFilename);
-    if (!existsSync(filepath)) {
-      return;
-    }
-    try {
-      const stats = statSync(filepath);
-      if (stats.size >= this.maxFileSize) {
-        await this.rotateBySize();
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[FileTransport] Failed to check file size: ${errorMessage}
-`);
-    }
-  }
-  /**
-   * 크기 기반 로테이션 수행
-   * 예: 2025-01-01.log -> 2025-01-01.1.log, 2025-01-01.1.log -> 2025-01-01.2.log
-   */
-  async rotateBySize() {
-    if (!this.currentFilename) {
-      return;
-    }
-    await this.closeStream();
-    const baseName = this.currentFilename.replace(/\.log$/, "");
-    const files = readdirSync(this.logDir);
-    const relatedFiles = files.filter((file) => file.startsWith(baseName) && file.endsWith(".log")).sort().reverse();
-    for (const file of relatedFiles) {
-      const match = file.match(/\.(\d+)\.log$/);
-      if (match) {
-        const oldNum = parseInt(match[1], 10);
-        const newNum = oldNum + 1;
-        const oldPath = join(this.logDir, file);
-        const newPath2 = join(this.logDir, `${baseName}.${newNum}.log`);
-        try {
-          renameSync(oldPath, newPath2);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[FileTransport] Failed to rotate file: ${errorMessage}
-`);
-        }
-      }
-    }
-    const currentPath = join(this.logDir, this.currentFilename);
-    const newPath = join(this.logDir, `${baseName}.1.log`);
-    try {
-      if (existsSync(currentPath)) {
-        renameSync(currentPath, newPath);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[FileTransport] Failed to rotate current file: ${errorMessage}
-`);
-    }
-    await this.rotateStream(this.currentFilename);
-  }
-  /**
-   * 오래된 로그 파일 정리
-   * maxFiles 개수를 초과하는 로그 파일 삭제
-   */
-  async cleanOldFiles() {
-    try {
-      if (!existsSync(this.logDir)) {
-        return;
-      }
-      const files = readdirSync(this.logDir);
-      const logFiles = files.filter((file) => file.endsWith(".log")).map((file) => {
-        const filepath = join(this.logDir, file);
-        const stats = statSync(filepath);
-        return { file, mtime: stats.mtime };
-      }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-      if (logFiles.length > this.maxFiles) {
-        const filesToDelete = logFiles.slice(this.maxFiles);
-        for (const { file } of filesToDelete) {
-          const filepath = join(this.logDir, file);
-          try {
-            unlinkSync(filepath);
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            process.stderr.write(`[FileTransport] Failed to delete old file "${file}": ${errorMessage}
-`);
-          }
-        }
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[FileTransport] Failed to clean old files: ${errorMessage}
-`);
-    }
-  }
-  /**
-   * 날짜별 로그 파일명 생성
-   */
-  getLogFilename(date) {
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, "0");
-    const day = String(date.getDate()).padStart(2, "0");
-    return `${year}-${month}-${day}.log`;
-  }
-  async close() {
-    await this.closeStream();
-  }
-};
-function isFileLoggingEnabled() {
-  return process.env.LOGGER_FILE_ENABLED === "true";
-}
-function getDefaultLogLevel() {
-  const isProduction = process.env.NODE_ENV === "production";
-  const isDevelopment = process.env.NODE_ENV === "development";
-  if (isDevelopment) {
-    return "debug";
-  }
-  if (isProduction) {
-    return "info";
-  }
-  return "warn";
-}
-function getConsoleConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "debug",
-    enabled: true,
-    colorize: !isProduction
-    // Dev: colored output, Production: plain text
-  };
-}
-function getFileConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "info",
-    enabled: isProduction,
-    // File logging in production only
-    logDir: process.env.LOG_DIR || "./logs",
-    maxFileSize: 10 * 1024 * 1024,
-    // 10MB
-    maxFiles: 10
-  };
-}
-function validateDirectoryWritable(dirPath) {
-  if (!existsSync(dirPath)) {
-    try {
-      mkdirSync(dirPath, { recursive: true });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to create log directory "${dirPath}": ${errorMessage}`);
-    }
-  }
-  try {
-    accessSync(dirPath, constants.W_OK);
-  } catch {
-    throw new Error(`Log directory "${dirPath}" is not writable. Please check permissions.`);
-  }
-  const testFile = join(dirPath, ".logger-write-test");
-  try {
-    writeFileSync(testFile, "test", "utf-8");
-    unlinkSync(testFile);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Cannot write to log directory "${dirPath}": ${errorMessage}`);
-  }
-}
-function validateFileConfig() {
-  if (!isFileLoggingEnabled()) {
-    return;
-  }
-  const logDir = process.env.LOG_DIR;
-  if (!logDir) {
-    throw new Error(
-      "LOG_DIR environment variable is required when LOGGER_FILE_ENABLED=true. Example: LOG_DIR=/var/log/myapp"
-    );
-  }
-  validateDirectoryWritable(logDir);
-}
-function validateSlackConfig() {
-  const webhookUrl = process.env.SLACK_WEBHOOK_URL;
-  if (!webhookUrl) {
-    return;
-  }
-  if (!webhookUrl.startsWith("https://hooks.slack.com/")) {
-    throw new Error(
-      `Invalid SLACK_WEBHOOK_URL: "${webhookUrl}". Slack webhook URLs must start with "https://hooks.slack.com/"`
-    );
-  }
-}
-function validateEmailConfig() {
-  const smtpHost = process.env.SMTP_HOST;
-  const smtpPort = process.env.SMTP_PORT;
-  const emailFrom = process.env.EMAIL_FROM;
-  const emailTo = process.env.EMAIL_TO;
-  const hasAnyEmailConfig = smtpHost || smtpPort || emailFrom || emailTo;
-  if (!hasAnyEmailConfig) {
-    return;
-  }
-  const missingFields = [];
-  if (!smtpHost) missingFields.push("SMTP_HOST");
-  if (!smtpPort) missingFields.push("SMTP_PORT");
-  if (!emailFrom) missingFields.push("EMAIL_FROM");
-  if (!emailTo) missingFields.push("EMAIL_TO");
-  if (missingFields.length > 0) {
-    throw new Error(
-      `Email transport configuration incomplete. Missing: ${missingFields.join(", ")}. Either set all required fields or remove all email configuration.`
-    );
-  }
-  const port = parseInt(smtpPort, 10);
-  if (isNaN(port) || port < 1 || port > 65535) {
-    throw new Error(
-      `Invalid SMTP_PORT: "${smtpPort}". Must be a number between 1 and 65535.`
-    );
-  }
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  if (!emailRegex.test(emailFrom)) {
-    throw new Error(`Invalid EMAIL_FROM format: "${emailFrom}"`);
-  }
-  const recipients = emailTo.split(",").map((e) => e.trim());
-  for (const email of recipients) {
-    if (!emailRegex.test(email)) {
-      throw new Error(`Invalid email address in EMAIL_TO: "${email}"`);
-    }
-  }
-}
-function validateEnvironment() {
-  const nodeEnv = process.env.NODE_ENV;
-  if (!nodeEnv) {
-    process.stderr.write(
-      "[Logger] Warning: NODE_ENV is not set. Defaulting to test environment.\n"
-    );
-  }
-}
-function validateConfig() {
-  try {
-    validateEnvironment();
-    validateFileConfig();
-    validateSlackConfig();
-    validateEmailConfig();
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`[Logger] Configuration validation failed: ${error.message}`);
-    }
-    throw error;
-  }
-}
-
-// src/logger/factory.ts
-function initializeTransports() {
-  const transports = [];
-  const consoleConfig = getConsoleConfig();
-  transports.push(new ConsoleTransport(consoleConfig));
-  const fileConfig = getFileConfig();
-  if (fileConfig.enabled) {
-    transports.push(new FileTransport(fileConfig));
-  }
-  return transports;
-}
-function initializeLogger() {
-  validateConfig();
-  return new Logger({
-    level: getDefaultLogLevel(),
-    transports: initializeTransports()
-  });
-}
-var logger = initializeLogger();
-
-// src/env/config.ts
-var ENV_FILE_PRIORITY = [
-  ".env",
-  // Base configuration (lowest priority)
-  ".env.{NODE_ENV}",
-  // Environment-specific
-  ".env.local",
-  // Local overrides (excluded in test)
-  ".env.{NODE_ENV}.local"
-  // Local environment-specific (highest priority)
-];
-var TEST_ONLY_FILES = [
-  ".env.test",
-  ".env.test.local"
-];
-
-// src/env/loader.ts
-var envLogger = logger.child("environment");
-var environmentLoaded = false;
-var cachedLoadResult;
-function buildFileList(basePath, nodeEnv) {
-  const files = [];
-  if (!nodeEnv) {
-    files.push(join(basePath, ".env"));
-    files.push(join(basePath, ".env.local"));
-    return files;
-  }
-  for (const pattern of ENV_FILE_PRIORITY) {
-    const fileName = pattern.replace("{NODE_ENV}", nodeEnv);
-    if (nodeEnv === "test" && fileName === ".env.local") {
-      continue;
-    }
-    if (nodeEnv === "local" && pattern === ".env.local") {
-      continue;
-    }
-    if (nodeEnv !== "test" && TEST_ONLY_FILES.includes(fileName)) {
-      continue;
-    }
-    files.push(join(basePath, fileName));
-  }
-  return files;
-}
-function loadSingleFile(filePath, debug) {
-  if (!existsSync(filePath)) {
-    if (debug) {
-      envLogger.debug("Environment file not found (optional)", {
-        path: filePath
-      });
-    }
-    return { success: false, parsed: {}, error: "File not found" };
-  }
-  try {
-    const result = config({ path: filePath });
-    if (result.error) {
-      envLogger.warn("Failed to parse environment file", {
-        path: filePath,
-        error: result.error.message
-      });
-      return {
-        success: false,
-        parsed: {},
-        error: result.error.message
-      };
-    }
-    const parsed = result.parsed || {};
-    if (debug) {
-      envLogger.debug("Environment file loaded successfully", {
-        path: filePath,
-        variables: Object.keys(parsed),
-        count: Object.keys(parsed).length
-      });
-    }
-    return { success: true, parsed };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    envLogger.error("Error loading environment file", {
-      path: filePath,
-      error: message
-    });
-    return { success: false, parsed: {}, error: message };
-  }
-}
-function validateRequiredVars(required, debug) {
-  const missing = [];
-  for (const varName of required) {
-    if (!process.env[varName]) {
-      missing.push(varName);
-    }
-  }
-  if (missing.length > 0) {
-    const error = `Required environment variables missing: ${missing.join(", ")}`;
-    envLogger.error("Environment validation failed", {
-      missing,
-      required
-    });
-    throw new Error(error);
-  }
-  if (debug) {
-    envLogger.debug("Required environment variables validated", {
-      required,
-      allPresent: true
-    });
-  }
-}
-function loadEnvironment(options = {}) {
-  const {
-    basePath = process.cwd(),
-    customPaths = [],
-    debug = false,
-    nodeEnv = process.env.NODE_ENV || "",
-    required = [],
-    useCache = true
-  } = options;
-  if (useCache && environmentLoaded && cachedLoadResult) {
-    if (debug) {
-      envLogger.debug("Returning cached environment", {
-        loaded: cachedLoadResult.loaded.length,
-        variables: Object.keys(cachedLoadResult.parsed).length
-      });
-    }
-    return cachedLoadResult;
-  }
-  if (debug) {
-    envLogger.debug("Loading environment variables", {
-      basePath,
-      nodeEnv,
-      customPaths,
-      required
-    });
-  }
-  const result = {
-    success: true,
-    loaded: [],
-    failed: [],
-    parsed: {},
-    warnings: []
-  };
-  const standardFiles = buildFileList(basePath, nodeEnv);
-  const allFiles = [...standardFiles, ...customPaths];
-  if (debug) {
-    envLogger.debug("Environment files to load", {
-      standardFiles,
-      customPaths,
-      total: allFiles.length
-    });
-  }
-  const reversedFiles = [...allFiles].reverse();
-  for (const filePath of reversedFiles) {
-    const fileResult = loadSingleFile(filePath, debug);
-    if (fileResult.success) {
-      result.loaded.push(filePath);
-      Object.assign(result.parsed, fileResult.parsed);
-      if (fileResult.parsed["NODE_ENV"]) {
-        const fileName = filePath.split("/").pop() || filePath;
-        result.warnings.push(
-          `NODE_ENV found in ${fileName}. It's recommended to set NODE_ENV via CLI (e.g., 'spfn dev', 'spfn build') instead of .env files for consistent environment behavior.`
-        );
-      }
-    } else if (fileResult.error) {
-      result.failed.push({
-        path: filePath,
-        reason: fileResult.error
-      });
-    }
-  }
-  if (debug || result.loaded.length > 0) {
-    envLogger.info("Environment loading complete", {
-      loaded: result.loaded.length,
-      failed: result.failed.length,
-      variables: Object.keys(result.parsed).length,
-      files: result.loaded
-    });
-  }
-  if (required.length > 0) {
-    try {
-      validateRequiredVars(required, debug);
-    } catch (error) {
-      result.success = false;
-      result.errors = [
-        error instanceof Error ? error.message : "Validation failed"
-      ];
-      throw error;
-    }
-  }
-  if (result.warnings.length > 0) {
-    for (const warning of result.warnings) {
-      envLogger.warn(warning);
-    }
-  }
-  environmentLoaded = true;
-  cachedLoadResult = result;
-  return result;
-}
-
-// src/errors/database-errors.ts
-var DatabaseError = class extends Error {
-  statusCode;
-  details;
-  timestamp;
-  constructor(message, statusCode = 500, details) {
-    super(message);
-    this.name = "DatabaseError";
-    this.statusCode = statusCode;
-    this.details = details;
-    this.timestamp = /* @__PURE__ */ new Date();
-    Error.captureStackTrace(this, this.constructor);
-  }
-  /**
-   * Serialize error for API response
-   */
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      statusCode: this.statusCode,
-      details: this.details,
-      timestamp: this.timestamp.toISOString()
-    };
-  }
-};
-var ConnectionError = class extends DatabaseError {
-  constructor(message, details) {
-    super(message, 503, details);
-    this.name = "ConnectionError";
-  }
-};
-var QueryError = class extends DatabaseError {
-  constructor(message, statusCode = 500, details) {
-    super(message, statusCode, details);
-    this.name = "QueryError";
-  }
-};
-var ConstraintViolationError = class extends QueryError {
-  constructor(message, details) {
-    super(message, 400, details);
-    this.name = "ConstraintViolationError";
-  }
-};
-var TransactionError = class extends DatabaseError {
-  constructor(message, statusCode = 500, details) {
-    super(message, statusCode, details);
-    this.name = "TransactionError";
-  }
-};
-var DeadlockError = class extends TransactionError {
-  constructor(message, details) {
-    super(message, 409, details);
-    this.name = "DeadlockError";
-  }
-};
-var DuplicateEntryError = class extends QueryError {
-  constructor(field, value) {
-    super(`${field} '${value}' already exists`, 409, { field, value });
-    this.name = "DuplicateEntryError";
-  }
-};
-
-// src/db/postgres-errors.ts
 function parseUniqueViolation(message) {
   const patterns = [
     // Standard format: Key (field)=(value)
@@ -976,24 +50,24 @@ function fromPostgresError(error) {
     case "08007":
     // transaction_resolution_unknown
     case "08P01":
-      return new ConnectionError(message, { code });
+      return new ConnectionError({ message, details: { code } });
     // Class 23 — Integrity Constraint Violation
     case "23000":
     // integrity_constraint_violation
     case "23001":
-      return new ConstraintViolationError(message, { code, constraint: "integrity" });
+      return new ConstraintViolationError({ message, details: { code, constraint: "integrity" } });
     case "23502":
-      return new ConstraintViolationError(message, { code, constraint: "not_null" });
+      return new ConstraintViolationError({ message, details: { code, constraint: "not_null" } });
     case "23503":
-      return new ConstraintViolationError(message, { code, constraint: "foreign_key" });
+      return new ConstraintViolationError({ message, details: { code, constraint: "foreign_key" } });
     case "23505":
       const parsed = parseUniqueViolation(message);
       if (parsed) {
-        return new DuplicateEntryError(parsed.field, parsed.value);
+        return new DuplicateEntryError({ field: parsed.field, value: parsed.value });
       }
-      return new DuplicateEntryError("field", "value");
+      return new DuplicateEntryError({ field: "field", value: "value" });
     case "23514":
-      return new ConstraintViolationError(message, { code, constraint: "check" });
+      return new ConstraintViolationError({ message, details: { code, constraint: "check" } });
     // Class 40 — Transaction Rollback
     case "40000":
     // transaction_rollback
@@ -1002,9 +76,9 @@ function fromPostgresError(error) {
     case "40002":
     // transaction_integrity_constraint_violation
     case "40003":
-      return new TransactionError(message, 500, { code });
+      return new TransactionError({ message, statusCode: 500, details: { code } });
     case "40P01":
-      return new DeadlockError(message, { code });
+      return new DeadlockError({ message, details: { code } });
     // Class 42 — Syntax Error or Access Rule Violation
     case "42000":
     // syntax_error_or_access_rule_violation
@@ -1027,7 +101,7 @@ function fromPostgresError(error) {
     case "42P01":
     // undefined_table
     case "42P02":
-      return new QueryError(message, 400, { code });
+      return new QueryError({ message, statusCode: 400, details: { code } });
     // Class 53 — Insufficient Resources
     case "53000":
     // insufficient_resources
@@ -1036,7 +110,7 @@ function fromPostgresError(error) {
     case "53200":
     // out_of_memory
     case "53300":
-      return new ConnectionError(message, { code });
+      return new ConnectionError({ message, details: { code } });
     // Class 57 — Operator Intervention
     case "57000":
     // operator_intervention
@@ -1047,76 +121,209 @@ function fromPostgresError(error) {
     case "57P02":
     // crash_shutdown
     case "57P03":
-      return new ConnectionError(message, { code });
+      return new ConnectionError({ message, details: { code } });
     // Default: Unknown error
     default:
-      return new QueryError(message, 500, { code });
+      return new QueryError({ message, statusCode: 500, details: { code } });
   }
 }
 
 // src/db/manager/connection.ts
-var dbLogger = logger.child("database");
+var dbLogger = logger.child("@spfn/core:database");
+var DEFAULT_CONNECT_TIMEOUT = 10;
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function maskConnectionString(connectionString) {
+  try {
+    const url = new URL(connectionString);
+    if (url.password) {
+      return connectionString.replace(`:${url.password}@`, ":***@");
+    }
+    return connectionString;
+  } catch {
+    return connectionString.replace(/(:\/\/[^:/@]+:)([^@]+)(@)/, "$1***$3");
+  }
+}
+function isAuthenticationError(error) {
+  const message = error.message.toLowerCase();
+  return message.includes("password authentication failed") || message.includes("no password supplied") || message.includes("authentication failed") || message.includes("invalid authorization");
+}
+function isDatabaseNotFoundError(error) {
+  const message = error.message.toLowerCase();
+  return message.includes("database") && message.includes("does not exist");
+}
+function isSSLError(error) {
+  const message = error.message.toLowerCase();
+  return message.includes("ssl") || message.includes("tls") || message.includes("certificate") || message.includes("self signed certificate") || message.includes("unable to verify");
+}
+function isNonRetryableError(error) {
+  return isAuthenticationError(error) || isDatabaseNotFoundError(error) || isSSLError(error);
+}
+function validateRetryConfig(retryConfig) {
+  if (retryConfig.maxRetries < 0) {
+    throw new ConnectionError({ message: `maxRetries must be non-negative, got ${retryConfig.maxRetries}` });
+  }
+  if (retryConfig.initialDelay <= 0) {
+    throw new ConnectionError({ message: `initialDelay must be positive, got ${retryConfig.initialDelay}` });
+  }
+  if (retryConfig.factor <= 0) {
+    throw new ConnectionError({ message: `factor must be positive, got ${retryConfig.factor}` });
+  }
+  if (retryConfig.maxDelay <= 0) {
+    throw new ConnectionError({ message: `maxDelay must be positive, got ${retryConfig.maxDelay}` });
+  }
+}
+function validatePoolConfig(poolConfig) {
+  if (poolConfig.max <= 0) {
+    throw new ConnectionError({ message: `pool max must be positive, got ${poolConfig.max}` });
+  }
+}
 async function createDatabaseConnection(connectionString, poolConfig, retryConfig) {
+  if (!connectionString) {
+    throw new ConnectionError({ message: "Connection string must be a non-empty string" });
+  }
+  validateRetryConfig(retryConfig);
+  validatePoolConfig(poolConfig);
   let lastError;
+  let client;
   for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
     try {
-      const client = postgres(connectionString, {
+      client = postgres(connectionString, {
         max: poolConfig.max,
-        idle_timeout: poolConfig.idleTimeout
+        idle_timeout: poolConfig.idleTimeout,
+        connect_timeout: DEFAULT_CONNECT_TIMEOUT
       });
       await client`SELECT 1 as test`;
       if (attempt > 0) {
-        dbLogger.info(`Database connected successfully after ${attempt} retries`);
+        dbLogger.info(
+          "Database connected successfully",
+          { retriesNeeded: attempt }
+        );
       } else {
         dbLogger.info("Database connected successfully");
       }
       return client;
     } catch (error) {
+      if (client) {
+        try {
+          await client.end();
+        } catch {
+        }
+        client = void 0;
+      }
       lastError = fromPostgresError(error);
+      if (isNonRetryableError(lastError)) {
+        dbLogger.error(
+          "Cannot connect to database (non-retryable error)",
+          lastError,
+          {
+            connectionString: maskConnectionString(connectionString),
+            poolConfig: {
+              max: poolConfig.max,
+              idleTimeout: poolConfig.idleTimeout,
+              connectTimeout: DEFAULT_CONNECT_TIMEOUT
+            },
+            reason: isAuthenticationError(lastError) ? "authentication_failed" : isDatabaseNotFoundError(lastError) ? "database_not_found" : "ssl_error"
+          }
+        );
+        throw new ConnectionError({
+          message: `Cannot connect to database: ${lastError.message}`
+        });
+      }
       if (attempt < retryConfig.maxRetries) {
-        const delayMs = Math.min(
+        const baseDelay = Math.min(
           retryConfig.initialDelay * Math.pow(retryConfig.factor, attempt),
           retryConfig.maxDelay
         );
+        const jitter = 0.5 + Math.random() * 0.5;
+        const delayMs = Math.floor(baseDelay * jitter);
         dbLogger.warn(
-          `Connection failed (attempt ${attempt + 1}/${retryConfig.maxRetries + 1}), retrying in ${delayMs}ms...`,
+          "Database connection failed, retrying...",
           lastError,
           {
             attempt: attempt + 1,
-            maxRetries: retryConfig.maxRetries + 1,
-            delayMs
+            totalAttempts: retryConfig.maxRetries + 1,
+            nextRetryIn: delayMs,
+            connectionString: maskConnectionString(connectionString),
+            poolConfig: {
+              max: poolConfig.max,
+              idleTimeout: poolConfig.idleTimeout,
+              connectTimeout: DEFAULT_CONNECT_TIMEOUT
+            }
           }
         );
         await delay(delayMs);
       }
     }
   }
-  const errorMessage = `Failed to connect to database after ${retryConfig.maxRetries + 1} attempts: ${lastError?.message || "Unknown error"}`;
-  throw new ConnectionError(errorMessage);
+  if (!lastError) {
+    throw new ConnectionError({
+      message: "Unexpected error: no error recorded after failed connection attempts"
+    });
+  }
+  dbLogger.error(
+    "Failed to connect to database after all retries",
+    lastError,
+    {
+      totalAttempts: retryConfig.maxRetries + 1,
+      connectionString: maskConnectionString(connectionString),
+      poolConfig: {
+        max: poolConfig.max,
+        idleTimeout: poolConfig.idleTimeout,
+        connectTimeout: DEFAULT_CONNECT_TIMEOUT
+      },
+      retryConfig: {
+        maxRetries: retryConfig.maxRetries,
+        initialDelay: retryConfig.initialDelay,
+        factor: retryConfig.factor,
+        maxDelay: retryConfig.maxDelay
+      }
+    }
+  );
+  throw new ConnectionError({
+    message: `Failed to connect to database after ${retryConfig.maxRetries + 1} attempts: ${lastError.message}`
+  });
 }
 async function checkConnection(client) {
   try {
     await client`SELECT 1 as health_check`;
     return true;
   } catch (error) {
-    dbLogger.error("Database health check failed", error);
+    const errorObj = fromPostgresError(error);
+    dbLogger.error(
+      "Database health check failed",
+      errorObj,
+      { errorType: errorObj.name }
+    );
     return false;
   }
 }
-
-// src/db/manager/config.ts
 function parseEnvNumber(key, prodDefault, devDefault) {
   const isProduction = process.env.NODE_ENV === "production";
-  const envValue = parseInt(process.env[key] || "", 10);
-  return isNaN(envValue) ? isProduction ? prodDefault : devDefault : envValue;
+  const defaultValue = isProduction ? prodDefault : devDefault;
+  const value = process.env[key];
+  if (value === void 0) {
+    return defaultValue;
+  }
+  try {
+    return parseNumber(value, { min: 0, integer: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${key}: ${message}`);
+  }
 }
 function parseEnvBoolean(key, defaultValue) {
   const value = process.env[key];
-  if (value === void 0) return defaultValue;
-  return value.toLowerCase() === "true";
+  if (value === void 0) {
+    return defaultValue;
+  }
+  try {
+    return parseBoolean(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${key}: ${message}`);
+  }
 }
 function getPoolConfig(options) {
   return {
@@ -1151,48 +358,71 @@ function buildMonitoringConfig(options) {
 }
 
 // src/db/manager/factory.ts
-var dbLogger2 = logger.child("database");
+var dbLogger2 = logger.child("@spfn/core:database");
 function hasDatabaseConfig() {
-  return !!(process.env.DATABASE_URL || process.env.DATABASE_WRITE_URL || process.env.DATABASE_READ_URL);
+  return env.DATABASE_URL !== void 0 || env.DATABASE_WRITE_URL !== void 0 || env.DATABASE_READ_URL !== void 0;
 }
 function detectDatabasePattern() {
-  if (process.env.DATABASE_WRITE_URL && process.env.DATABASE_READ_URL) {
+  const DATABASE_WRITE_URL = env.DATABASE_WRITE_URL;
+  const DATABASE_READ_URL = env.DATABASE_READ_URL;
+  const DATABASE_URL = env.DATABASE_URL;
+  if (DATABASE_WRITE_URL && DATABASE_READ_URL) {
     return {
       type: "write-read",
-      write: process.env.DATABASE_WRITE_URL,
-      read: process.env.DATABASE_READ_URL
-    };
-  }
-  if (process.env.DATABASE_URL && process.env.DATABASE_REPLICA_URL) {
-    return {
-      type: "legacy",
-      primary: process.env.DATABASE_URL,
-      replica: process.env.DATABASE_REPLICA_URL
+      write: DATABASE_WRITE_URL,
+      read: DATABASE_READ_URL
     };
   }
-  if (process.env.DATABASE_URL) {
+  if (DATABASE_URL) {
     return {
       type: "single",
-      url: process.env.DATABASE_URL
+      url: DATABASE_URL
     };
   }
-  if (process.env.DATABASE_WRITE_URL) {
+  if (DATABASE_WRITE_URL) {
     return {
       type: "single",
-      url: process.env.DATABASE_WRITE_URL
+      url: DATABASE_WRITE_URL
     };
   }
   return { type: "none" };
 }
 async function createWriteReadClients(writeUrl, readUrl, poolConfig, retryConfig) {
-  const writeClient = await createDatabaseConnection(writeUrl, poolConfig, retryConfig);
-  const readClient = await createDatabaseConnection(readUrl, poolConfig, retryConfig);
-  return {
-    write: drizzle(writeClient),
-    read: drizzle(readClient),
-    writeClient,
-    readClient
-  };
+  let writeClient;
+  let readClient;
+  try {
+    writeClient = await createDatabaseConnection(writeUrl, poolConfig, retryConfig);
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    dbLogger2.error("Failed to connect to write database", errorObj);
+    throw new Error(`Write database connection failed: ${errorObj.message}`, { cause: error });
+  }
+  try {
+    readClient = await createDatabaseConnection(readUrl, poolConfig, retryConfig);
+    return {
+      write: drizzle(writeClient),
+      read: drizzle(readClient),
+      writeClient,
+      readClient
+    };
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    dbLogger2.warn(
+      "Failed to connect to read database (replica). Falling back to write database for read operations.",
+      {
+        error: errorObj.message,
+        readUrl: readUrl.replace(/:[^:@]+@/, ":***@"),
+        // Mask password in logs
+        fallbackBehavior: "Using write connection for both read and write operations"
+      }
+    );
+    return {
+      write: drizzle(writeClient),
+      read: drizzle(writeClient),
+      writeClient,
+      readClient: writeClient
+    };
+  }
 }
 async function createSingleClient(url, poolConfig, retryConfig) {
   const client = await createDatabaseConnection(url, poolConfig, retryConfig);
@@ -1206,25 +436,15 @@ async function createSingleClient(url, poolConfig, retryConfig) {
 }
 async function createDatabaseFromEnv(options) {
   if (!hasDatabaseConfig()) {
-    dbLogger2.debug("No DATABASE_URL found, loading environment variables");
-    const result = loadEnvironment({
-      debug: true
-    });
-    dbLogger2.debug("Environment variables loaded", {
-      success: result.success,
-      loaded: result.loaded.length,
-      hasDatabaseUrl: !!process.env.DATABASE_URL,
-      hasWriteUrl: !!process.env.DATABASE_WRITE_URL,
-      hasReadUrl: !!process.env.DATABASE_READ_URL
-    });
-  }
-  if (!hasDatabaseConfig()) {
-    dbLogger2.warn("No database configuration found", {
+    const error = new Error(
+      "No database configuration found. Please set DATABASE_URL, DATABASE_WRITE_URL, or DATABASE_READ_URL environment variable."
+    );
+    dbLogger2.error("No database configuration found", {
       cwd: process.cwd(),
-      nodeEnv: process.env.NODE_ENV,
+      nodeEnv: env.NODE_ENV,
       checkedVars: ["DATABASE_URL", "DATABASE_WRITE_URL", "DATABASE_READ_URL"]
     });
-    return { write: void 0, read: void 0 };
+    throw error;
   }
   try {
     const poolConfig = getPoolConfig(options?.pool);
@@ -1232,48 +452,30 @@ async function createDatabaseFromEnv(options) {
     const pattern = detectDatabasePattern();
     switch (pattern.type) {
       case "write-read":
-        dbLogger2.debug("Using write-read pattern", {
-          write: pattern.write.replace(/:[^:@]+@/, ":***@"),
-          read: pattern.read.replace(/:[^:@]+@/, ":***@")
-        });
         return await createWriteReadClients(
           pattern.write,
           pattern.read,
           poolConfig,
           retryConfig
         );
-      case "legacy":
-        dbLogger2.debug("Using legacy replica pattern", {
-          primary: pattern.primary.replace(/:[^:@]+@/, ":***@"),
-          replica: pattern.replica.replace(/:[^:@]+@/, ":***@")
-        });
-        return await createWriteReadClients(
-          pattern.primary,
-          pattern.replica,
-          poolConfig,
-          retryConfig
-        );
       case "single":
-        dbLogger2.debug("Using single database pattern", {
-          url: pattern.url.replace(/:[^:@]+@/, ":***@")
-        });
         return await createSingleClient(pattern.url, poolConfig, retryConfig);
-      case "none":
-        dbLogger2.warn("No database pattern detected");
-        return { write: void 0, read: void 0 };
     }
   } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    dbLogger2.error("Failed to create database connection", {
-      error: message,
-      stage: "initialization",
-      hasWriteUrl: !!process.env.DATABASE_WRITE_URL,
-      hasReadUrl: !!process.env.DATABASE_READ_URL,
-      hasUrl: !!process.env.DATABASE_URL,
-      hasReplicaUrl: !!process.env.DATABASE_REPLICA_URL
-    });
-    throw new Error(`Database connection failed: ${message}`, { cause: error });
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    dbLogger2.error(
+      "Failed to create database connection",
+      errorObj,
+      {
+        stage: "initialization",
+        hasWriteUrl: process.env.DATABASE_WRITE_URL !== void 0,
+        hasReadUrl: process.env.DATABASE_READ_URL !== void 0,
+        hasUrl: process.env.DATABASE_URL !== void 0
+      }
+    );
+    throw new Error(`Database connection failed: ${errorObj.message}`, { cause: error });
   }
+  throw new Error("No database pattern detected despite passing config check");
 }
 
 // src/db/manager/global-state.ts
@@ -1300,9 +502,36 @@ var setHealthCheckInterval = (interval) => {
 var setMonitoringConfig = (config) => {
   globalThis.__SPFN_DB_MONITORING__ = config;
 };
-
-// src/db/manager/health-check.ts
-var dbLogger3 = logger.child("database");
+var dbLogger3 = logger.child("@spfn/core:database");
+async function testDatabaseConnection(db) {
+  await db.execute("SELECT 1");
+}
+async function performHealthCheck(getDatabase2) {
+  const write = getDatabase2("write");
+  const read = getDatabase2("read");
+  await testDatabaseConnection(write);
+  if (read !== write) {
+    await testDatabaseConnection(read);
+  }
+}
+async function reconnectAndRestore(options, closeDatabase2) {
+  await closeDatabase2();
+  const result = await createDatabaseFromEnv(options);
+  if (!result.write) {
+    return false;
+  }
+  await testDatabaseConnection(result.write);
+  if (result.read && result.read !== result.write) {
+    await testDatabaseConnection(result.read);
+  }
+  setWriteInstance(result.write);
+  setReadInstance(result.read);
+  setWriteClient(result.writeClient);
+  setReadClient(result.readClient);
+  const monConfig = buildMonitoringConfig(options?.monitoring);
+  setMonitoringConfig(monConfig);
+  return true;
+}
 function startHealthCheck(config, options, getDatabase2, closeDatabase2) {
   const healthCheck = getHealthCheckInterval();
   if (healthCheck) {
@@ -1315,14 +544,7 @@ function startHealthCheck(config, options, getDatabase2, closeDatabase2) {
   });
   const interval = setInterval(async () => {
     try {
-      const write = getDatabase2("write");
-      const read = getDatabase2("read");
-      if (write) {
-        await write.execute("SELECT 1");
-      }
-      if (read && read !== write) {
-        await read.execute("SELECT 1");
-      }
+      await performHealthCheck(getDatabase2);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
       dbLogger3.error("Database health check failed", { error: message });
@@ -1341,17 +563,15 @@ async function attemptReconnection(config, options, closeDatabase2) {
   for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
     try {
       dbLogger3.debug(`Reconnection attempt ${attempt}/${config.maxRetries}`);
-      await closeDatabase2();
-      await new Promise((resolve) => setTimeout(resolve, config.retryInterval));
-      const result = await createDatabaseFromEnv(options);
-      if (result.write) {
-        await result.write.execute("SELECT 1");
-        setWriteInstance(result.write);
-        setReadInstance(result.read);
-        setWriteClient(result.writeClient);
-        setReadClient(result.readClient);
+      if (attempt > 1) {
+        await new Promise((resolve) => setTimeout(resolve, config.retryInterval));
+      }
+      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`);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -1360,9 +580,9 @@ async function attemptReconnection(config, options, closeDatabase2) {
         attempt,
         maxRetries: config.maxRetries
       });
-      if (attempt === config.maxRetries) {
-        dbLogger3.error("Max reconnection attempts reached, giving up");
-      }
+    }
+    if (attempt === config.maxRetries) {
+      dbLogger3.error("Max reconnection attempts reached, giving up");
     }
   }
 }
@@ -1376,16 +596,61 @@ function stopHealthCheck() {
 }
 
 // src/db/manager/manager.ts
-var dbLogger4 = logger.child("database");
+var dbLogger4 = logger.child("@spfn/core:database");
+var DB_CONNECTION_CLOSE_TIMEOUT = 5;
+var STACK_TRACE_SKIP_LINES = 3;
+var STACK_TRACE_PATTERNS = {
+  withParens: /\((.+):(\d+):(\d+)\)/,
+  withoutParens: /at (.+):(\d+):(\d+)/
+};
+var initPromise = null;
+var isClosing = false;
+async function cleanupDatabaseConnections(writeClient, readClient) {
+  const cleanupPromises = [];
+  if (writeClient) {
+    cleanupPromises.push(
+      writeClient.end({ timeout: DB_CONNECTION_CLOSE_TIMEOUT }).catch((err) => {
+        dbLogger4.debug("Write client cleanup failed", { error: err });
+      })
+    );
+  }
+  if (readClient && readClient !== writeClient) {
+    cleanupPromises.push(
+      readClient.end({ timeout: DB_CONNECTION_CLOSE_TIMEOUT }).catch((err) => {
+        dbLogger4.debug("Read client cleanup failed", { error: err });
+      })
+    );
+  }
+  await Promise.allSettled(cleanupPromises);
+}
+async function closeDatabaseClient(client, type) {
+  const typeName = type.charAt(0).toUpperCase() + type.slice(1);
+  dbLogger4.debug(`Closing ${type} connection...`);
+  try {
+    await client.end({ timeout: DB_CONNECTION_CLOSE_TIMEOUT });
+    dbLogger4.debug(`${typeName} connection closed`);
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    dbLogger4.error(`Error closing ${type} connection`, error);
+  }
+}
+async function testDatabaseConnections(write, read) {
+  if (write) {
+    await write.execute("SELECT 1");
+    if (read && read !== write) {
+      await read.execute("SELECT 1");
+    }
+  }
+}
 function getCallerInfo() {
   try {
     const stack = new Error().stack;
     if (!stack) return void 0;
     const lines = stack.split("\n");
-    for (let i = 3; i < lines.length; i++) {
+    for (let i = STACK_TRACE_SKIP_LINES; i < lines.length; i++) {
       const line = lines[i];
       if (!line.includes("node_modules") && !line.includes("/db/manager/")) {
-        const match = line.match(/\((.+):(\d+):(\d+)\)/) || line.match(/at (.+):(\d+):(\d+)/);
+        const match = line.match(STACK_TRACE_PATTERNS.withParens) || line.match(STACK_TRACE_PATTERNS.withoutParens);
         if (match) {
           const fullPath = match[1];
           const parts = fullPath.split("/");
@@ -1399,24 +664,39 @@ function getCallerInfo() {
         break;
       }
     }
-  } catch {
+  } catch (error) {
+    dbLogger4.debug("Failed to extract caller info from stack trace", {
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
   return void 0;
 }
+function createNotInitializedError(type) {
+  return new Error(
+    `Database not initialized (type: ${type}). Call initDatabase() first or set DATABASE_URL environment variable.`
+  );
+}
 function getDatabase(type) {
   const writeInst = getWriteInstance();
   const readInst = getReadInstance();
-  if (process.env.DB_DEBUG_TRACE === "true") {
+  if (env.DB_DEBUG_TRACE && env.NODE_ENV !== "production") {
     const caller = getCallerInfo();
     dbLogger4.debug("getDatabase() called", {
-      type: type || "write",
+      type: type ?? "write",
       hasWrite: !!writeInst,
       hasRead: !!readInst,
       caller
     });
   }
   if (type === "read") {
-    return readInst ?? writeInst;
+    const db = readInst ?? writeInst;
+    if (!db) {
+      throw createNotInitializedError("read");
+    }
+    return db;
+  }
+  if (!writeInst) {
+    throw createNotInitializedError("write");
   }
   return writeInst;
 }
@@ -1425,17 +705,32 @@ function setDatabase(write, read) {
   setReadInstance(read ?? write);
 }
 async function initDatabase(options) {
+  if (isClosing) {
+    throw new Error("Cannot initialize database while closing");
+  }
   const writeInst = getWriteInstance();
   if (writeInst) {
     dbLogger4.debug("Database already initialized");
     return { write: writeInst, read: getReadInstance() };
   }
-  const result = await createDatabaseFromEnv(options);
-  if (result.write) {
+  if (initPromise) {
+    dbLogger4.debug("Database initialization in progress, waiting...");
+    return await initPromise;
+  }
+  initPromise = (async () => {
     try {
-      await result.write.execute("SELECT 1");
-      if (result.read && result.read !== result.write) {
-        await result.read.execute("SELECT 1");
+      const result = await createDatabaseFromEnv(options);
+      try {
+        await testDatabaseConnections(result.write, result.read);
+      } catch (error) {
+        await cleanupDatabaseConnections(result.writeClient, result.readClient);
+        const message = error instanceof Error ? error.message : "Unknown error";
+        throw new Error(`Database connection test failed: ${message}`);
+      }
+      if (isClosing) {
+        dbLogger4.warn("Database closed during initialization, cleaning up...");
+        await cleanupDatabaseConnections(result.writeClient, result.readClient);
+        throw new Error("Database closed during initialization");
       }
       setWriteInstance(result.write);
       setReadInstance(result.read);
@@ -1457,53 +752,54 @@ async function initDatabase(options) {
           logQueries: monConfig.logQueries
         });
       }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger4.error("Database connection failed", { error: message });
-      await closeDatabase();
-      throw new Error(`Database connection test failed: ${message}`, { cause: error });
+      return { write: getWriteInstance(), read: getReadInstance() };
+    } finally {
+      initPromise = null;
     }
-  } else {
-    dbLogger4.warn("No database configuration found");
-    dbLogger4.warn("Set DATABASE_URL environment variable to enable database");
-  }
-  return { write: getWriteInstance(), read: getReadInstance() };
+  })();
+  return await initPromise;
 }
 async function closeDatabase() {
+  if (isClosing) {
+    dbLogger4.debug("Database close already in progress");
+    return;
+  }
+  isClosing = 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 writeInst = getWriteInstance();
   const readInst = getReadInstance();
   if (!writeInst && !readInst) {
     dbLogger4.debug("No database connections to close");
+    isClosing = false;
     return;
   }
-  stopHealthCheck();
   try {
+    stopHealthCheck();
     const closePromises = [];
     const writeC = getWriteClient();
     if (writeC) {
-      dbLogger4.debug("Closing write connection...");
-      closePromises.push(
-        writeC.end({ timeout: 5 }).then(() => dbLogger4.debug("Write connection closed")).catch((err) => dbLogger4.error("Error closing write connection", err))
-      );
+      closePromises.push(closeDatabaseClient(writeC, "write"));
     }
     const readC = getReadClient();
     if (readC && readC !== writeC) {
-      dbLogger4.debug("Closing read connection...");
-      closePromises.push(
-        readC.end({ timeout: 5 }).then(() => dbLogger4.debug("Read connection closed")).catch((err) => dbLogger4.error("Error closing read connection", err))
-      );
+      closePromises.push(closeDatabaseClient(readC, "read"));
     }
-    await Promise.all(closePromises);
+    await Promise.allSettled(closePromises);
     dbLogger4.info("All database connections closed");
-  } catch (error) {
-    dbLogger4.error("Error during database cleanup", error);
-    throw error;
   } finally {
     setWriteInstance(void 0);
     setReadInstance(void 0);
     setWriteClient(void 0);
     setReadClient(void 0);
     setMonitoringConfig(void 0);
+    isClosing = false;
   }
 }
 function getDatabaseInfo() {
@@ -1515,59 +811,110 @@ function getDatabaseInfo() {
     isReplica: !!(readInst && readInst !== writeInst)
   };
 }
-function expandGlobPattern(pattern) {
-  if (!pattern.includes("*")) {
-    return existsSync(pattern) ? [pattern] : [];
-  }
+var INDEX_FILE_PATTERNS = [
+  "/index",
+  "/index.ts",
+  "/index.js",
+  "/index.mjs",
+  "\\index",
+  "\\index.ts",
+  "\\index.js",
+  "\\index.mjs"
+];
+var SUPPORTED_EXTENSIONS = [".ts", ".js", ".mjs"];
+function isIndexFile(filePath) {
+  return INDEX_FILE_PATTERNS.some((pattern) => filePath.endsWith(pattern));
+}
+function isAbsolutePath(path) {
+  if (path.startsWith("/")) return true;
+  return !!path.match(/^[A-Za-z]:[\/\\]/);
+}
+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 scanDirectoryRecursive(dir, extension) {
   const files = [];
-  if (pattern.includes("**")) {
-    const [baseDir, ...rest] = pattern.split("**");
-    const extension = rest.join("").replace(/[\/\\]\*\./g, "").trim();
-    const scanRecursive = (dir) => {
-      if (!existsSync(dir)) return;
+  if (!existsSync(dir)) return files;
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
       try {
-        const entries = readdirSync(dir);
-        for (const entry of entries) {
-          const fullPath = join(dir, entry);
-          try {
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-              scanRecursive(fullPath);
-            } else if (stat.isFile()) {
-              if (!extension || fullPath.endsWith(extension)) {
-                files.push(fullPath);
-              }
-            }
-          } catch {
+        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 {
+      } catch (error) {
       }
-    };
-    scanRecursive(baseDir.trim() || ".");
-  } else if (pattern.includes("*")) {
-    const dir = dirname(pattern);
-    const filePattern = basename(pattern);
-    if (!existsSync(dir)) return [];
-    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))) {
-              files.push(fullPath);
-            }
+    }
+  } catch (error) {
+  }
+  return files;
+}
+function scanDirectorySingleLevel(dir, filePattern) {
+  const files = [];
+  if (!existsSync(dir)) return files;
+  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 {
         }
+      } catch (error) {
       }
-    } catch {
     }
+  } catch (error) {
   }
   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] : [];
+  }
+  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);
+  }
+  const dir = dirname(pattern);
+  const filePattern = basename(pattern);
+  return scanDirectorySingleLevel(dir, filePattern);
+}
 function discoverPackageSchemas(cwd) {
   const schemas = [];
   const nodeModulesPath = join(cwd, "node_modules");
@@ -1596,9 +943,7 @@ function discoverPackageSchemas(cwd) {
         for (const schema of packageSchemas) {
           const absolutePath = join(pkgPath, schema);
           const expandedFiles = expandGlobPattern(absolutePath);
-          const schemaFiles = expandedFiles.filter(
-            (file) => !file.endsWith("/index.js") && !file.endsWith("/index.ts") && !file.endsWith("/index.mjs") && !file.endsWith("\\index.js") && !file.endsWith("\\index.ts") && !file.endsWith("\\index.mjs")
-          );
+          const schemaFiles = filterIndexFiles(expandedFiles);
           schemas.push(...schemaFiles);
         }
       }
@@ -1637,7 +982,7 @@ function detectDialect(url) {
   );
 }
 function getDrizzleConfig(options = {}) {
-  const databaseUrl = options.databaseUrl ?? process.env.DATABASE_URL;
+  const databaseUrl = options.databaseUrl ?? env.DATABASE_URL;
   if (!databaseUrl) {
     throw new Error(
       "DATABASE_URL is required. Set it in .env or pass it to getDrizzleConfig()"
@@ -1666,13 +1011,33 @@ 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());
-  const allSchemas = [...userSchemas, ...packageSchemas];
+  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 = filterIndexFiles(expanded);
+      expandedFiles.push(...filtered);
+    }
+    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
   };
 }
 function getDbCredentials(dialect, url) {
@@ -1689,30 +1054,35 @@ function getDbCredentials(dialect, url) {
 }
 function generateDrizzleConfigFile(options = {}) {
   const config = getDrizzleConfig(options);
+  const cwd = options.cwd ?? process.cwd();
+  const normalizeSchemaPath = (schemaPath) => {
+    if (isAbsolutePath(schemaPath)) {
+      return schemaPath;
+    }
+    return join(cwd, schemaPath);
+  };
   const schemaValue = Array.isArray(config.schema) ? `[
-        ${config.schema.map((s) => `'${s}'`).join(",\n        ")}
-    ]` : `'${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)},` : "";
   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}
 });
 `;
 }
 function id() {
   return bigserial("id", { mode: "number" }).primaryKey();
 }
-function timestamps(options) {
-  const updatedAtColumn = timestamp("updated_at", { withTimezone: true, mode: "date" }).defaultNow().notNull();
-  if (options?.autoUpdate) {
-    updatedAtColumn.__autoUpdate = true;
-  }
+function timestamps() {
   return {
     createdAt: timestamp("created_at", { withTimezone: true, mode: "date" }).defaultNow().notNull(),
-    updatedAt: updatedAtColumn
+    updatedAt: timestamp("updated_at", { withTimezone: true, mode: "date" }).defaultNow().notNull()
   };
 }
 function foreignKey(name, reference, options) {
@@ -1721,12 +1091,51 @@ function foreignKey(name, reference, options) {
 function optionalForeignKey(name, reference, options) {
   return bigserial(`${name}_id`, { mode: "number" }).references(reference, { onDelete: options?.onDelete ?? "set null" });
 }
-function createFunctionSchema(packageName) {
+function uuid() {
+  return uuid$1("id").defaultRandom().primaryKey();
+}
+function auditFields() {
+  return {
+    createdBy: text("created_by"),
+    updatedBy: text("updated_by")
+  };
+}
+function publishingFields() {
+  return {
+    publishedAt: timestamp("published_at", { withTimezone: true, mode: "date" }),
+    publishedBy: text("published_by")
+  };
+}
+function verificationTimestamp(fieldName) {
+  const columnName = fieldName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "") + "_at";
+  return {
+    [fieldName + "At"]: timestamp(columnName, { withTimezone: true, mode: "date" })
+  };
+}
+function softDelete() {
+  return {
+    deletedAt: timestamp("deleted_at", { withTimezone: true, mode: "date" }),
+    deletedBy: text("deleted_by")
+  };
+}
+function utcTimestamp(fieldName, mode = "date") {
+  return timestamp(fieldName, {
+    withTimezone: true,
+    mode
+  });
+}
+function enumText(fieldName, values) {
+  return text(fieldName, { enum: values });
+}
+function typedJsonb(fieldName) {
+  return jsonb(fieldName).$type();
+}
+function createSchema(packageName) {
   const schemaName = packageNameToSchema(packageName);
   return pgSchema(schemaName);
 }
 function packageNameToSchema(packageName) {
-  return packageName.replace("@", "").replace("/", "_").replace(/-/g, "_");
+  return packageName.replace(/@/g, "").replace(/\//g, "_").replace(/-/g, "_");
 }
 function getSchemaInfo(packageName) {
   const isScoped = packageName.startsWith("@");
@@ -1738,7 +1147,7 @@ function getSchemaInfo(packageName) {
     scope
   };
 }
-var txLogger = logger.child("transaction");
+var txLogger = logger.child("@spfn/core:transaction");
 var asyncContext = new AsyncLocalStorage();
 function getTransactionContext() {
   return asyncContext.getStore() ?? null;
@@ -1761,103 +1170,187 @@ function runWithTransaction(tx, txId, callback) {
   }
   return asyncContext.run({ tx, txId, level: newLevel }, callback);
 }
-function Transactional(options = {}) {
-  const defaultTimeout = parseInt(process.env.TRANSACTION_TIMEOUT || "30000", 10);
+var MAX_TIMEOUT_MS = 2147483647;
+var txLogger2 = logger.child("@spfn/core:transaction");
+async function runInTransaction(callback, options = {}) {
+  const defaultTimeout = env.TRANSACTION_TIMEOUT;
   const {
     slowThreshold = 1e3,
     enableLogging = true,
-    timeout = defaultTimeout
+    context = "transaction"
   } = options;
-  const txLogger2 = logger.child("transaction");
-  return createMiddleware(async (c, next) => {
-    const txId = `tx_${randomUUID()}`;
-    const startTime = Date.now();
-    const route = `${c.req.method} ${c.req.path}`;
+  const timeout = options.timeout ?? defaultTimeout;
+  const txId = `tx_${randomUUID()}`;
+  const validateAndThrow = (condition, message, logMessage, metadata) => {
+    if (condition) {
+      const error = new TransactionError({ message, statusCode: 400, details: metadata });
+      if (enableLogging) {
+        txLogger2.error(logMessage, { ...metadata, error: error.message });
+      }
+      throw error;
+    }
+  };
+  validateAndThrow(
+    typeof callback !== "function",
+    "Callback must be a function",
+    "Invalid callback type",
+    { txId, context, callbackType: typeof callback }
+  );
+  validateAndThrow(
+    !Number.isInteger(slowThreshold) || slowThreshold < 0,
+    `Invalid slowThreshold value: ${slowThreshold}. Must be a non-negative integer.`,
+    "Invalid slowThreshold",
+    { txId, context, slowThreshold }
+  );
+  validateAndThrow(
+    !Number.isInteger(timeout),
+    `Invalid timeout value: ${timeout}. Must be an integer.`,
+    "Invalid timeout type",
+    { txId, context, timeout }
+  );
+  validateAndThrow(
+    timeout < 0,
+    `Invalid timeout value: ${timeout}. Timeout must be non-negative (0 to disable, or 1-${MAX_TIMEOUT_MS}ms).`,
+    "Invalid timeout range",
+    { txId, context, timeout }
+  );
+  validateAndThrow(
+    timeout > MAX_TIMEOUT_MS,
+    `Invalid timeout value: ${timeout}. Maximum timeout is ${MAX_TIMEOUT_MS}ms.`,
+    "Timeout exceeds maximum",
+    { txId, context, timeout, maxTimeout: MAX_TIMEOUT_MS }
+  );
+  const writeDb = getDatabase("write");
+  if (!writeDb) {
+    const error = new TransactionError({
+      message: "Database not initialized. Cannot start transaction.",
+      statusCode: 500,
+      details: { txId, context }
+    });
     if (enableLogging) {
-      txLogger2.debug("Transaction started", { txId, route });
+      txLogger2.error("Database not initialized", {
+        txId,
+        context,
+        error: error.message
+      });
     }
-    try {
-      const writeDb = getDatabase("write");
-      if (!writeDb) {
-        throw new TransactionError(
-          "Database not initialized. Cannot start transaction.",
-          500,
-          { txId, route }
-        );
+    throw error;
+  }
+  const existingContext = getTransactionContext();
+  const isNested = existingContext !== null;
+  if (isNested && timeout > 0 && enableLogging) {
+    txLogger2.warn("Timeout ignored in nested transaction", {
+      txId,
+      context,
+      outerTxId: existingContext.txId,
+      requestedTimeout: `${timeout}ms`,
+      reason: "SET LOCAL statement_timeout affects the entire outer transaction"
+    });
+  }
+  if (enableLogging) {
+    txLogger2.debug("Transaction started", { txId, context });
+  }
+  const startTime = Date.now();
+  try {
+    const result = await writeDb.transaction(async (tx) => {
+      if (timeout > 0 && !isNested) {
+        await tx.execute(sql.raw(`SET LOCAL statement_timeout = ${timeout}`));
       }
-      const transactionPromise = writeDb.transaction(async (tx) => {
-        await runWithTransaction(tx, txId, async () => {
-          await next();
-          const contextWithError = c;
-          if (contextWithError.error) {
-            throw contextWithError.error;
-          }
-        });
+      return await runWithTransaction(tx, txId, async () => {
+        return await callback(tx);
       });
-      if (timeout > 0) {
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(
-              new TransactionError(
-                `Transaction timeout after ${timeout}ms`,
-                500,
-                {
-                  txId,
-                  route,
-                  timeout: `${timeout}ms`
-                }
-              )
-            );
-          }, timeout);
+    });
+    const duration = Date.now() - startTime;
+    if (enableLogging) {
+      if (duration >= slowThreshold) {
+        txLogger2.warn("Slow transaction committed", {
+          txId,
+          context,
+          duration: `${duration}ms`,
+          threshold: `${slowThreshold}ms`
         });
-        await Promise.race([transactionPromise, timeoutPromise]);
       } else {
-        await transactionPromise;
-      }
-      const duration = Date.now() - startTime;
-      if (enableLogging) {
-        if (duration >= slowThreshold) {
-          txLogger2.warn("Slow transaction committed", {
-            txId,
-            route,
-            duration: `${duration}ms`,
-            threshold: `${slowThreshold}ms`
-          });
-        } else {
-          txLogger2.debug("Transaction committed", {
-            txId,
-            route,
-            duration: `${duration}ms`
-          });
-        }
+        txLogger2.debug("Transaction committed", {
+          txId,
+          context,
+          duration: `${duration}ms`
+        });
       }
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      const customError = error instanceof TransactionError ? error : fromPostgresError(error);
-      if (enableLogging) {
+    }
+    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"
+        });
+      } else {
         txLogger2.error("Transaction rolled back", {
           txId,
-          route,
+          context,
           duration: `${duration}ms`,
-          error: customError.message,
-          errorType: customError.name
+          error: error instanceof Error ? error.message : String(error),
+          errorType: error instanceof Error ? error.name : "Unknown"
         });
       }
-      throw customError;
+    }
+    throw error;
+  }
+}
+
+// src/db/transaction/middleware.ts
+function Transactional(options = {}) {
+  return createMiddleware(async (c, next) => {
+    const route = `${c.req.method} ${c.req.path}`;
+    try {
+      await runInTransaction(
+        async () => {
+          await next();
+          const contextWithError = c;
+          if (contextWithError.error) {
+            throw contextWithError.error;
+          }
+        },
+        {
+          context: route,
+          ...options
+        }
+      );
+    } catch (error) {
+      if (error instanceof DatabaseError) {
+        throw error;
+      }
+      if (error instanceof TransactionError) {
+        throw error;
+      }
+      if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
+        throw fromPostgresError(error);
+      }
+      throw error;
     }
   });
 }
 function isSQLWrapper(value) {
-  return value && typeof value === "object" && "queryChunks" in value;
+  return value !== null && typeof value === "object" && "queryChunks" in value;
 }
 function buildWhereFromObject(table, where) {
   const entries = Object.entries(where).filter(([_, value]) => value !== void 0);
-  if (entries.length === 0) return void 0;
+  if (entries.length === 0) {
+    return void 0;
+  }
   const conditions = entries.map(
     ([key, value]) => eq(table[key], value)
   );
   return conditions.length === 1 ? conditions[0] : and(...conditions);
 }
+
+// src/db/helpers.ts
 async function findOne(table, where) {
   const db = getDatabase("read");
   if (!db) {
@@ -1974,17 +1467,361 @@ async function count(table, where) {
   if (!db) {
     throw new Error("Database not initialized. Call initDatabase() first.");
   }
-  let query = db.select().from(table);
+  let query = db.select({ count: count$1() }).from(table);
   if (where) {
     const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
     if (whereClause) {
       query = query.where(whereClause);
     }
   }
-  const results = await query;
-  return results.length;
+  const [result] = await query;
+  return Number(result?.count ?? 0);
 }
+var RepositoryError = class extends Error {
+  constructor(message, repository, method, table, originalError) {
+    super(message);
+    this.repository = repository;
+    this.method = method;
+    this.table = table;
+    this.originalError = originalError;
+    this.name = "RepositoryError";
+    if (originalError?.stack) {
+      this.stack = originalError.stack;
+    }
+  }
+};
+var BaseRepository = class {
+  /**
+   * Write database instance
+   *
+   * Automatically resolves to:
+   * - Transaction DB if running within transaction context
+   * - Global write (primary) instance otherwise
+   *
+   * Use this for INSERT, UPDATE, DELETE operations.
+   *
+   * @example
+   * ```typescript
+   * async create(data: NewUser) {
+   *     return await this.db.insert(users).values(data).returning();
+   * }
+   * ```
+   */
+  get db() {
+    const txDb = getTransaction();
+    if (txDb) {
+      return txDb;
+    }
+    return getDatabase("write");
+  }
+  /**
+   * Read database instance
+   *
+   * Automatically resolves to:
+   * - Transaction DB if running within transaction context
+   * - Global read (replica) instance otherwise
+   *
+   * Use this for SELECT operations to leverage read replicas
+   * and reduce load on the primary database.
+   *
+   * @example
+   * ```typescript
+   * async findById(id: string) {
+   *     return await this.readDb
+   *         .select()
+   *         .from(users)
+   *         .where(eq(users.id, id));
+   * }
+   * ```
+   */
+  get readDb() {
+    const txDb = getTransaction();
+    if (txDb) {
+      return txDb;
+    }
+    return getDatabase("read");
+  }
+  /**
+   * Wrap query execution with repository context
+   *
+   * Enhances error messages with repository information to make debugging easier.
+   * When an error occurs, it will include:
+   * - Repository class name
+   * - Method name
+   * - Table name (if provided)
+   * - Original error details
+   *
+   * @param queryFn - Query function to execute
+   * @param context - Context information (operation name, table name, etc.)
+   * @returns Query result
+   * @throws RepositoryError with enhanced context
+   *
+   * @example
+   * ```typescript
+   * async findById(id: number) {
+   *     return await this.withContext(
+   *         () => this.readDb.select().from(users).where(eq(users.id, id)),
+   *         { method: 'findById', table: 'users' }
+   *     );
+   * }
+   * ```
+   */
+  async withContext(queryFn, context = {}) {
+    try {
+      return await queryFn();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      const repositoryName = this.constructor.name;
+      throw new RepositoryError(
+        err.message,
+        repositoryName,
+        context.method,
+        context.table,
+        err
+      );
+    }
+  }
+  // ============================================================================
+  // CRUD Methods
+  // ============================================================================
+  /**
+   * Find a single record
+   *
+   * @param table - Drizzle table schema
+   * @param where - Object or SQL condition
+   * @returns Single record or null
+   *
+   * @example
+   * ```typescript
+   * // Object-based
+   * const user = await this._findOne(users, { id: 1 });
+   *
+   * // SQL-based
+   * const user = await this._findOne(users, eq(users.id, 1));
+   * ```
+   */
+  async _findOne(table, where) {
+    const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+    if (!whereClause) {
+      throw new Error("findOne requires at least one where condition");
+    }
+    const results = await this.readDb.select().from(table).where(whereClause).limit(1);
+    return results[0] ?? null;
+  }
+  /**
+   * Find multiple records
+   *
+   * @param table - Drizzle table schema
+   * @param options - Query options
+   * @returns Array of records
+   *
+   * @example
+   * ```typescript
+   * const users = await this._findMany(users, {
+   *     where: { active: true },
+   *     orderBy: desc(users.createdAt),
+   *     limit: 10
+   * });
+   * ```
+   */
+  async _findMany(table, options) {
+    let query = this.readDb.select().from(table);
+    if (options?.where) {
+      const whereClause = isSQLWrapper(options.where) ? options.where : options.where ? buildWhereFromObject(table, options.where) : void 0;
+      if (whereClause) {
+        query = query.where(whereClause);
+      }
+    }
+    if (options?.orderBy) {
+      const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+      query = query.orderBy(...orderByArray);
+    }
+    if (options?.limit) {
+      query = query.limit(options.limit);
+    }
+    if (options?.offset) {
+      query = query.offset(options.offset);
+    }
+    return query;
+  }
+  /**
+   * Create a new record
+   *
+   * @param table - Drizzle table schema
+   * @param data - Insert data
+   * @returns Created record
+   *
+   * @example
+   * ```typescript
+   * const user = await this._create(users, {
+   *     email: 'test@example.com',
+   *     name: 'Test User'
+   * });
+   * ```
+   */
+  async _create(table, data) {
+    const [result] = await this.db.insert(table).values(data).returning();
+    return result;
+  }
+  /**
+   * Create multiple records
+   *
+   * @param table - Drizzle table schema
+   * @param data - Array of insert data
+   * @returns Array of created records
+   *
+   * @example
+   * ```typescript
+   * const users = await this._createMany(users, [
+   *     { email: 'user1@example.com', name: 'User 1' },
+   *     { email: 'user2@example.com', name: 'User 2' }
+   * ]);
+   * ```
+   */
+  async _createMany(table, data) {
+    const results = await this.db.insert(table).values(data).returning();
+    return results;
+  }
+  /**
+   * Upsert a record (INSERT or UPDATE on conflict)
+   *
+   * @param table - Drizzle table schema
+   * @param data - Insert data
+   * @param options - Conflict resolution options
+   * @returns Upserted record
+   *
+   * @example
+   * ```typescript
+   * const cache = await this._upsert(cache, {
+   *     key: 'config',
+   *     value: {...}
+   * }, {
+   *     target: [cache.key],
+   *     set: { value: data.value, updatedAt: new Date() }
+   * });
+   * ```
+   */
+  async _upsert(table, data, options) {
+    const [result] = await this.db.insert(table).values(data).onConflictDoUpdate({
+      target: options.target,
+      set: options.set || data
+    }).returning();
+    return result;
+  }
+  /**
+   * Update a single record
+   *
+   * @param table - Drizzle table schema
+   * @param where - Object or SQL condition
+   * @param data - Update data
+   * @returns Updated record or null
+   *
+   * @example
+   * ```typescript
+   * const user = await this._updateOne(users,
+   *     { id: 1 },
+   *     { name: 'Updated Name' }
+   * );
+   * ```
+   */
+  async _updateOne(table, where, data) {
+    const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+    if (!whereClause) {
+      throw new Error("updateOne requires at least one where condition");
+    }
+    const [result] = await this.db.update(table).set(data).where(whereClause).returning();
+    return result ?? null;
+  }
+  /**
+   * Update multiple records
+   *
+   * @param table - Drizzle table schema
+   * @param where - Object or SQL condition
+   * @param data - Update data
+   * @returns Array of updated records
+   *
+   * @example
+   * ```typescript
+   * const users = await this._updateMany(users,
+   *     { role: 'user' },
+   *     { verified: true }
+   * );
+   * ```
+   */
+  async _updateMany(table, where, data) {
+    const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+    if (!whereClause) {
+      throw new Error("updateMany requires at least one where condition");
+    }
+    const results = await this.db.update(table).set(data).where(whereClause).returning();
+    return results;
+  }
+  /**
+   * Delete a single record
+   *
+   * @param table - Drizzle table schema
+   * @param where - Object or SQL condition
+   * @returns Deleted record or null
+   *
+   * @example
+   * ```typescript
+   * const user = await this._deleteOne(users, { id: 1 });
+   * ```
+   */
+  async _deleteOne(table, where) {
+    const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+    if (!whereClause) {
+      throw new Error("deleteOne requires at least one where condition");
+    }
+    const [result] = await this.db.delete(table).where(whereClause).returning();
+    return result ?? null;
+  }
+  /**
+   * Delete multiple records
+   *
+   * @param table - Drizzle table schema
+   * @param where - Object or SQL condition
+   * @returns Array of deleted records
+   *
+   * @example
+   * ```typescript
+   * const users = await this._deleteMany(users, { verified: false });
+   * ```
+   */
+  async _deleteMany(table, where) {
+    const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+    if (!whereClause) {
+      throw new Error("deleteMany requires at least one where condition");
+    }
+    const results = await this.db.delete(table).where(whereClause).returning();
+    return results;
+  }
+  /**
+   * Count records
+   *
+   * @param table - Drizzle table schema
+   * @param where - Optional object or SQL condition
+   * @returns Number of records
+   *
+   * @example
+   * ```typescript
+   * const total = await this._count(users);
+   * const activeUsers = await this._count(users, { active: true });
+   * ```
+   */
+  async _count(table, where) {
+    let query = this.readDb.select({ count: count$1() }).from(table);
+    if (where) {
+      const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+      if (whereClause) {
+        query = query.where(whereClause);
+      }
+    }
+    const [result] = await query;
+    return Number(result?.count ?? 0);
+  }
+};
 
-export { Transactional, checkConnection, closeDatabase, count, create, createDatabaseConnection, createDatabaseFromEnv, createFunctionSchema, createMany, deleteMany, deleteOne, detectDialect, findMany, findOne, foreignKey, fromPostgresError, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, id, initDatabase, optionalForeignKey, packageNameToSchema, runWithTransaction, setDatabase, timestamps, updateMany, updateOne, upsert };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map