@spfn/core 0.1.0-alpha.8 → 0.1.0-alpha.82

package/dist/db/index.js

@@ -1,56 +1,45 @@
-import { config } from 'dotenv';
 import { drizzle } from 'drizzle-orm/postgres-js';
-import postgres from 'postgres';
 import pino from 'pino';
-import { existsSync, mkdirSync, createWriteStream } from 'fs';
-import { join } from 'path';
+import { existsSync, mkdirSync, accessSync, constants, writeFileSync, unlinkSync, createWriteStream, statSync, readdirSync, renameSync, readFileSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { config } from 'dotenv';
+import postgres from 'postgres';
+import { bigserial, timestamp, pgSchema } from 'drizzle-orm/pg-core';
 import { AsyncLocalStorage } from 'async_hooks';
+import { randomUUID } from 'crypto';
 import { createMiddleware } from 'hono/factory';
-import { and, desc, asc, sql, isNull, isNotNull, notInArray, inArray, like, lte, lt, gte, gt, ne, eq } from 'drizzle-orm';
-import { bigserial, timestamp } from 'drizzle-orm/pg-core';
+import { eq, and } from 'drizzle-orm';
 
 // src/db/manager/factory.ts
 var PinoAdapter = class _PinoAdapter {
   logger;
-  constructor(config2) {
-    const isProduction = process.env.NODE_ENV === "production";
+  constructor(config) {
     const isDevelopment = process.env.NODE_ENV === "development";
-    const fileLoggingEnabled = process.env.LOGGER_FILE_ENABLED === "true";
-    const targets = [];
-    if (!isProduction && isDevelopment) {
-      targets.push({
-        target: "pino-pretty",
-        level: "debug",
-        options: {
-          colorize: true,
-          translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l",
-          ignore: "pid,hostname"
-        }
+    const transport = isDevelopment ? {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "HH:MM:ss.l",
+        ignore: "pid,hostname",
+        singleLine: false,
+        messageFormat: "{module} {msg}",
+        errorLikeObjectKeys: ["err", "error"]
+      }
+    } : void 0;
+    try {
+      this.logger = pino({
+        level: config.level,
+        // 기본 필드
+        base: config.module ? { module: config.module } : void 0,
+        // Transport (pretty print in development if available)
+        transport
       });
-    }
-    if (fileLoggingEnabled && isProduction) {
-      const logDir = process.env.LOG_DIR || "./logs";
-      const maxFileSize = process.env.LOG_MAX_FILE_SIZE || "10M";
-      const maxFiles = parseInt(process.env.LOG_MAX_FILES || "10", 10);
-      targets.push({
-        target: "pino-roll",
-        level: "info",
-        options: {
-          file: `${logDir}/app.log`,
-          frequency: "daily",
-          size: maxFileSize,
-          limit: { count: maxFiles },
-          mkdir: true
-        }
+    } catch (error) {
+      this.logger = pino({
+        level: config.level,
+        base: config.module ? { module: config.module } : void 0
       });
     }
-    this.logger = pino({
-      level: config2.level,
-      // Transport 설정 (targets가 있으면 사용, 없으면 기본 stdout)
-      transport: targets.length > 0 ? { targets } : void 0,
-      // 기본 필드
-      base: config2.module ? { module: config2.module } : void 0
-    });
   }
   child(module) {
     const childLogger = new _PinoAdapter({ level: this.logger.level, module });
@@ -88,13 +77,183 @@ var PinoAdapter = class _PinoAdapter {
   }
 };
 
+// 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]) => {
+      const valueStr = typeof value === "string" ? value : 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(config2) {
-    this.config = config2;
-    this.module = config2.module;
+  constructor(config) {
+    this.config = config;
+    this.module = config.module;
   }
   /**
    * Get current log level
@@ -148,13 +307,17 @@ var Logger = class _Logger {
    * 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,
-      context
+      // Mask sensitive information in context to prevent credential leaks
+      context: context ? maskSensitiveData(context) : void 0
     };
     this.processTransports(metadata);
   }
@@ -190,130 +353,16 @@ var Logger = class _Logger {
   }
 };
 
-// src/logger/types.ts
-var LOG_LEVEL_PRIORITY = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  fatal: 4
-};
-
-// src/logger/formatters.ts
-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 colorizeLevel(level) {
-  const color = COLORS[level];
-  const levelStr = level.toUpperCase().padEnd(5);
-  return `${color}${levelStr}${COLORS.reset}`;
-}
-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 formatContext(context) {
-  try {
-    return JSON.stringify(context, null, 2);
-  } catch (error) {
-    return "[Context serialization failed]";
-  }
-}
-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 (colorize) {
-    parts.push(colorizeLevel(metadata.level));
-  } else {
-    parts.push(metadata.level.toUpperCase().padEnd(5));
-  }
-  if (metadata.module) {
-    if (colorize) {
-      parts.push(`${COLORS.dim}[${metadata.module}]${COLORS.reset}`);
-    } else {
-      parts.push(`[${metadata.module}]`);
-    }
-  }
-  parts.push(metadata.message);
-  let output = parts.join(" ");
-  if (metadata.context && Object.keys(metadata.context).length > 0) {
-    output += "\n" + formatContext(metadata.context);
-  }
-  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/transports/console.ts
 var ConsoleTransport = class {
   name = "console";
   level;
   enabled;
   colorize;
-  constructor(config2) {
-    this.level = config2.level;
-    this.enabled = config2.enabled;
-    this.colorize = config2.colorize ?? true;
+  constructor(config) {
+    this.level = config.level;
+    this.enabled = config.enabled;
+    this.colorize = config.colorize ?? true;
   }
   async log(metadata) {
     if (!this.enabled) {
@@ -335,12 +384,16 @@ var FileTransport = class {
   level;
   enabled;
   logDir;
+  maxFileSize;
+  maxFiles;
   currentStream = null;
   currentFilename = null;
-  constructor(config2) {
-    this.level = config2.level;
-    this.enabled = config2.enabled;
-    this.logDir = config2.logDir;
+  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 });
     }
@@ -356,6 +409,9 @@ var FileTransport = class {
     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) => {
@@ -412,25 +468,123 @@ var FileTransport = class {
     });
   }
   /**
-   * 날짜별 로그 파일명 생성
+   * 파일 크기 체크 및 크기 기반 로테이션
    */
-  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 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}
+`);
+    }
   }
-  async close() {
+  /**
+   * 크기 기반 로테이션 수행
+   * 예: 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);
   }
-};
-
-// src/logger/config.ts
-function getDefaultLogLevel() {
-  const isProduction = process.env.NODE_ENV === "production";
-  const isDevelopment = process.env.NODE_ENV === "development";
-  if (isDevelopment) {
-    return "debug";
+  /**
+   * 오래된 로그 파일 정리
+   * 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";
@@ -458,6 +612,109 @@ function getFileConfig() {
     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/adapters/custom.ts
 function initializeTransports() {
@@ -472,10 +729,10 @@ function initializeTransports() {
 }
 var CustomAdapter = class _CustomAdapter {
   logger;
-  constructor(config2) {
+  constructor(config) {
     this.logger = new Logger({
-      level: config2.level,
-      module: config2.module,
+      level: config.level,
+      module: config.module,
       transports: initializeTransports()
     });
   }
@@ -535,7 +792,205 @@ function getAdapterType() {
   }
   return "pino";
 }
-var logger = createAdapter(getAdapterType());
+function initializeLogger() {
+  validateConfig();
+  return createAdapter(getAdapterType());
+}
+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 {
@@ -575,10 +1030,10 @@ var QueryError = class extends DatabaseError {
     this.name = "QueryError";
   }
 };
-var ValidationError = class extends QueryError {
+var ConstraintViolationError = class extends QueryError {
   constructor(message, details) {
     super(message, 400, details);
-    this.name = "ValidationError";
+    this.name = "ConstraintViolationError";
   }
 };
 var TransactionError = class extends DatabaseError {
@@ -643,11 +1098,11 @@ function fromPostgresError(error) {
     case "23000":
     // integrity_constraint_violation
     case "23001":
-      return new ValidationError(message, { code, constraint: "integrity" });
+      return new ConstraintViolationError(message, { code, constraint: "integrity" });
     case "23502":
-      return new ValidationError(message, { code, constraint: "not_null" });
+      return new ConstraintViolationError(message, { code, constraint: "not_null" });
     case "23503":
-      return new ValidationError(message, { code, constraint: "foreign_key" });
+      return new ConstraintViolationError(message, { code, constraint: "foreign_key" });
     case "23505":
       const parsed = parseUniqueViolation(message);
       if (parsed) {
@@ -655,7 +1110,7 @@ function fromPostgresError(error) {
       }
       return new DuplicateEntryError("field", "value");
     case "23514":
-      return new ValidationError(message, { code, constraint: "check" });
+      return new ConstraintViolationError(message, { code, constraint: "check" });
     // Class 40 — Transaction Rollback
     case "40000":
     // transaction_rollback
@@ -770,23 +1225,45 @@ async function checkConnection(client) {
 }
 
 // src/db/manager/config.ts
-function getPoolConfig(options) {
+function parseEnvNumber(key, prodDefault, devDefault) {
   const isProduction = process.env.NODE_ENV === "production";
-  const max = options?.max ?? (parseInt(process.env.DB_POOL_MAX || "", 10) || (isProduction ? 20 : 10));
-  const idleTimeout = options?.idleTimeout ?? (parseInt(process.env.DB_POOL_IDLE_TIMEOUT || "", 10) || (isProduction ? 30 : 20));
-  return { max, idleTimeout };
+  const envValue = parseInt(process.env[key] || "", 10);
+  return isNaN(envValue) ? isProduction ? prodDefault : devDefault : envValue;
+}
+function parseEnvBoolean(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0) return defaultValue;
+  return value.toLowerCase() === "true";
+}
+function getPoolConfig(options) {
+  return {
+    max: options?.max ?? parseEnvNumber("DB_POOL_MAX", 20, 10),
+    idleTimeout: options?.idleTimeout ?? parseEnvNumber("DB_POOL_IDLE_TIMEOUT", 30, 20)
+  };
 }
 function getRetryConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
   return {
-    maxRetries: isProduction ? 5 : 3,
-    // 프로덕션: 5회, 개발: 3회
-    initialDelay: 1e3,
-    // 1초
-    maxDelay: 16e3,
-    // 16초
-    factor: 2
-    // 2배씩 증가 (1s → 2s → 4s → 8s → 16s)
+    maxRetries: parseEnvNumber("DB_RETRY_MAX", 5, 3),
+    initialDelay: parseEnvNumber("DB_RETRY_INITIAL_DELAY", 100, 50),
+    maxDelay: parseEnvNumber("DB_RETRY_MAX_DELAY", 1e4, 5e3),
+    factor: parseEnvNumber("DB_RETRY_FACTOR", 2, 2)
+  };
+}
+function buildHealthCheckConfig(options) {
+  return {
+    enabled: options?.enabled ?? parseEnvBoolean("DB_HEALTH_CHECK_ENABLED", true),
+    interval: options?.interval ?? parseEnvNumber("DB_HEALTH_CHECK_INTERVAL", 6e4, 6e4),
+    reconnect: options?.reconnect ?? parseEnvBoolean("DB_HEALTH_CHECK_RECONNECT", true),
+    maxRetries: options?.maxRetries ?? parseEnvNumber("DB_HEALTH_CHECK_MAX_RETRIES", 3, 3),
+    retryInterval: options?.retryInterval ?? parseEnvNumber("DB_HEALTH_CHECK_RETRY_INTERVAL", 5e3, 5e3)
+  };
+}
+function buildMonitoringConfig(options) {
+  const isDevelopment = process.env.NODE_ENV !== "production";
+  return {
+    enabled: options?.enabled ?? parseEnvBoolean("DB_MONITORING_ENABLED", isDevelopment),
+    slowThreshold: options?.slowThreshold ?? parseEnvNumber("DB_MONITORING_SLOW_THRESHOLD", 1e3, 1e3),
+    logQueries: options?.logQueries ?? parseEnvBoolean("DB_MONITORING_LOG_QUERIES", false)
   };
 }
 
@@ -795,81 +1272,113 @@ var dbLogger2 = logger.child("database");
 function hasDatabaseConfig() {
   return !!(process.env.DATABASE_URL || process.env.DATABASE_WRITE_URL || process.env.DATABASE_READ_URL);
 }
+function detectDatabasePattern() {
+  if (process.env.DATABASE_WRITE_URL && process.env.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
+    };
+  }
+  if (process.env.DATABASE_URL) {
+    return {
+      type: "single",
+      url: process.env.DATABASE_URL
+    };
+  }
+  if (process.env.DATABASE_WRITE_URL) {
+    return {
+      type: "single",
+      url: process.env.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
+  };
+}
+async function createSingleClient(url, poolConfig, retryConfig) {
+  const client = await createDatabaseConnection(url, poolConfig, retryConfig);
+  const db = drizzle(client);
+  return {
+    write: db,
+    read: db,
+    writeClient: client,
+    readClient: client
+  };
+}
 async function createDatabaseFromEnv(options) {
   if (!hasDatabaseConfig()) {
-    config({ path: ".env.local" });
+    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", {
+      cwd: process.cwd(),
+      nodeEnv: process.env.NODE_ENV,
+      checkedVars: ["DATABASE_URL", "DATABASE_WRITE_URL", "DATABASE_READ_URL"]
+    });
     return { write: void 0, read: void 0 };
   }
   try {
     const poolConfig = getPoolConfig(options?.pool);
     const retryConfig = getRetryConfig();
-    if (process.env.DATABASE_WRITE_URL && process.env.DATABASE_READ_URL) {
-      const writeClient2 = await createDatabaseConnection(
-        process.env.DATABASE_WRITE_URL,
-        poolConfig,
-        retryConfig
-      );
-      const readClient2 = await createDatabaseConnection(
-        process.env.DATABASE_READ_URL,
-        poolConfig,
-        retryConfig
-      );
-      return {
-        write: drizzle(writeClient2),
-        read: drizzle(readClient2),
-        writeClient: writeClient2,
-        readClient: readClient2
-      };
-    }
-    if (process.env.DATABASE_URL && process.env.DATABASE_REPLICA_URL) {
-      const writeClient2 = await createDatabaseConnection(
-        process.env.DATABASE_URL,
-        poolConfig,
-        retryConfig
-      );
-      const readClient2 = await createDatabaseConnection(
-        process.env.DATABASE_REPLICA_URL,
-        poolConfig,
-        retryConfig
-      );
-      return {
-        write: drizzle(writeClient2),
-        read: drizzle(readClient2),
-        writeClient: writeClient2,
-        readClient: readClient2
-      };
-    }
-    if (process.env.DATABASE_URL) {
-      const client = await createDatabaseConnection(
-        process.env.DATABASE_URL,
-        poolConfig,
-        retryConfig
-      );
-      const db2 = drizzle(client);
-      return {
-        write: db2,
-        read: db2,
-        writeClient: client,
-        readClient: client
-      };
-    }
-    if (process.env.DATABASE_WRITE_URL) {
-      const client = await createDatabaseConnection(
-        process.env.DATABASE_WRITE_URL,
-        poolConfig,
-        retryConfig
-      );
-      const db2 = drizzle(client);
-      return {
-        write: db2,
-        read: db2,
-        writeClient: client,
-        readClient: client
-      };
+    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 };
     }
-    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", {
@@ -880,57 +1389,129 @@ async function createDatabaseFromEnv(options) {
       hasUrl: !!process.env.DATABASE_URL,
       hasReplicaUrl: !!process.env.DATABASE_REPLICA_URL
     });
-    return { write: void 0, read: void 0 };
+    throw new Error(`Database connection failed: ${message}`, { cause: error });
   }
 }
 
-// src/db/manager/manager.ts
+// src/db/manager/global-state.ts
+var getWriteInstance = () => globalThis.__SPFN_DB_WRITE__;
+var setWriteInstance = (instance) => {
+  globalThis.__SPFN_DB_WRITE__ = instance;
+};
+var getReadInstance = () => globalThis.__SPFN_DB_READ__;
+var setReadInstance = (instance) => {
+  globalThis.__SPFN_DB_READ__ = instance;
+};
+var getWriteClient = () => globalThis.__SPFN_DB_WRITE_CLIENT__;
+var setWriteClient = (client) => {
+  globalThis.__SPFN_DB_WRITE_CLIENT__ = client;
+};
+var getReadClient = () => globalThis.__SPFN_DB_READ_CLIENT__;
+var setReadClient = (client) => {
+  globalThis.__SPFN_DB_READ_CLIENT__ = client;
+};
+var getHealthCheckInterval = () => globalThis.__SPFN_DB_HEALTH_CHECK__;
+var setHealthCheckInterval = (interval) => {
+  globalThis.__SPFN_DB_HEALTH_CHECK__ = interval;
+};
+var setMonitoringConfig = (config) => {
+  globalThis.__SPFN_DB_MONITORING__ = config;
+};
+
+// src/db/manager/health-check.ts
 var dbLogger3 = logger.child("database");
-var writeInstance;
-var readInstance;
-var writeClient;
-var readClient;
-var healthCheckInterval;
-var monitoringConfig;
+function startHealthCheck(config, options, getDatabase2, closeDatabase2) {
+  const healthCheck = getHealthCheckInterval();
+  if (healthCheck) {
+    dbLogger3.debug("Health check already running");
+    return;
+  }
+  dbLogger3.info("Starting database health check", {
+    interval: `${config.interval}ms`,
+    reconnect: config.reconnect
+  });
+  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");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      dbLogger3.error("Database health check failed", { error: message });
+      if (config.reconnect) {
+        await attemptReconnection(config, options, closeDatabase2);
+      }
+    }
+  }, config.interval);
+  setHealthCheckInterval(interval);
+}
+async function attemptReconnection(config, options, closeDatabase2) {
+  dbLogger3.warn("Attempting database reconnection", {
+    maxRetries: config.maxRetries,
+    retryInterval: `${config.retryInterval}ms`
+  });
+  for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
+    try {
+      dbLogger3.debug(`Reconnection attempt ${attempt}/${config.maxRetries}`);
+      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);
+        dbLogger3.info("Database reconnection successful", { attempt });
+        return;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
+        error: message,
+        attempt,
+        maxRetries: config.maxRetries
+      });
+      if (attempt === config.maxRetries) {
+        dbLogger3.error("Max reconnection attempts reached, giving up");
+      }
+    }
+  }
+}
+function stopHealthCheck() {
+  const healthCheck = getHealthCheckInterval();
+  if (healthCheck) {
+    clearInterval(healthCheck);
+    setHealthCheckInterval(void 0);
+    dbLogger3.info("Database health check stopped");
+  }
+}
+
+// src/db/manager/manager.ts
+var dbLogger4 = logger.child("database");
 function getDatabase(type) {
+  const writeInst = getWriteInstance();
+  const readInst = getReadInstance();
+  dbLogger4.debug(`getDatabase() called with type=${type}, writeInstance=${!!writeInst}, readInstance=${!!readInst}`);
   if (type === "read") {
-    return readInstance ?? writeInstance;
+    return readInst ?? writeInst;
   }
-  return writeInstance;
+  return writeInst;
 }
 function setDatabase(write, read) {
-  writeInstance = write;
-  readInstance = read ?? write;
-}
-function getHealthCheckConfig(options) {
-  const parseBoolean = (value, defaultValue) => {
-    if (value === void 0) return defaultValue;
-    return value.toLowerCase() === "true";
-  };
-  return {
-    enabled: options?.enabled ?? parseBoolean(process.env.DB_HEALTH_CHECK_ENABLED, true),
-    interval: options?.interval ?? (parseInt(process.env.DB_HEALTH_CHECK_INTERVAL || "", 10) || 6e4),
-    reconnect: options?.reconnect ?? parseBoolean(process.env.DB_HEALTH_CHECK_RECONNECT, true),
-    maxRetries: options?.maxRetries ?? (parseInt(process.env.DB_HEALTH_CHECK_MAX_RETRIES || "", 10) || 3),
-    retryInterval: options?.retryInterval ?? (parseInt(process.env.DB_HEALTH_CHECK_RETRY_INTERVAL || "", 10) || 5e3)
-  };
-}
-function getMonitoringConfig(options) {
-  const isDevelopment = process.env.NODE_ENV !== "production";
-  const parseBoolean = (value, defaultValue) => {
-    if (value === void 0) return defaultValue;
-    return value.toLowerCase() === "true";
-  };
-  return {
-    enabled: options?.enabled ?? parseBoolean(process.env.DB_MONITORING_ENABLED, isDevelopment),
-    slowThreshold: options?.slowThreshold ?? (parseInt(process.env.DB_MONITORING_SLOW_THRESHOLD || "", 10) || 1e3),
-    logQueries: options?.logQueries ?? parseBoolean(process.env.DB_MONITORING_LOG_QUERIES, false)
-  };
+  setWriteInstance(write);
+  setReadInstance(read ?? write);
 }
 async function initDatabase(options) {
-  if (writeInstance) {
-    dbLogger3.debug("Database already initialized");
-    return { write: writeInstance, read: readInstance };
+  const writeInst = getWriteInstance();
+  if (writeInst) {
+    dbLogger4.debug("Database already initialized");
+    return { write: writeInst, read: getReadInstance() };
   }
   const result = await createDatabaseFromEnv(options);
   if (result.write) {
@@ -939,178 +1520,329 @@ async function initDatabase(options) {
       if (result.read && result.read !== result.write) {
         await result.read.execute("SELECT 1");
       }
-      writeInstance = result.write;
-      readInstance = result.read;
-      writeClient = result.writeClient;
-      readClient = result.readClient;
+      setWriteInstance(result.write);
+      setReadInstance(result.read);
+      setWriteClient(result.writeClient);
+      setReadClient(result.readClient);
       const hasReplica = result.read && result.read !== result.write;
-      dbLogger3.info(
+      dbLogger4.info(
         hasReplica ? "Database connected (Primary + Replica)" : "Database connected"
       );
-      const healthCheckConfig = getHealthCheckConfig(options?.healthCheck);
+      const healthCheckConfig = buildHealthCheckConfig(options?.healthCheck);
       if (healthCheckConfig.enabled) {
-        startHealthCheck(healthCheckConfig);
+        startHealthCheck(healthCheckConfig, options, getDatabase, closeDatabase);
       }
-      monitoringConfig = getMonitoringConfig(options?.monitoring);
-      if (monitoringConfig.enabled) {
-        dbLogger3.info("Database query monitoring enabled", {
-          slowThreshold: `${monitoringConfig.slowThreshold}ms`,
-          logQueries: monitoringConfig.logQueries
+      const monConfig = buildMonitoringConfig(options?.monitoring);
+      setMonitoringConfig(monConfig);
+      if (monConfig.enabled) {
+        dbLogger4.info("Database query monitoring enabled", {
+          slowThreshold: `${monConfig.slowThreshold}ms`,
+          logQueries: monConfig.logQueries
         });
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error("Database connection failed", { error: message });
+      dbLogger4.error("Database connection failed", { error: message });
       await closeDatabase();
-      return { write: void 0, read: void 0 };
+      throw new Error(`Database connection test failed: ${message}`, { cause: error });
     }
   } else {
-    dbLogger3.warn("No database configuration found");
-    dbLogger3.warn("Set DATABASE_URL environment variable to enable database");
+    dbLogger4.warn("No database configuration found");
+    dbLogger4.warn("Set DATABASE_URL environment variable to enable database");
   }
-  return { write: writeInstance, read: readInstance };
+  return { write: getWriteInstance(), read: getReadInstance() };
 }
 async function closeDatabase() {
-  if (!writeInstance && !readInstance) {
-    dbLogger3.debug("No database connections to close");
+  const writeInst = getWriteInstance();
+  const readInst = getReadInstance();
+  if (!writeInst && !readInst) {
+    dbLogger4.debug("No database connections to close");
     return;
   }
   stopHealthCheck();
   try {
     const closePromises = [];
-    if (writeClient) {
-      dbLogger3.debug("Closing write connection...");
+    const writeC = getWriteClient();
+    if (writeC) {
+      dbLogger4.debug("Closing write connection...");
       closePromises.push(
-        writeClient.end({ timeout: 5 }).then(() => dbLogger3.debug("Write connection closed")).catch((err) => dbLogger3.error("Error closing write connection", err))
+        writeC.end({ timeout: 5 }).then(() => dbLogger4.debug("Write connection closed")).catch((err) => dbLogger4.error("Error closing write connection", err))
       );
     }
-    if (readClient && readClient !== writeClient) {
-      dbLogger3.debug("Closing read connection...");
+    const readC = getReadClient();
+    if (readC && readC !== writeC) {
+      dbLogger4.debug("Closing read connection...");
       closePromises.push(
-        readClient.end({ timeout: 5 }).then(() => dbLogger3.debug("Read connection closed")).catch((err) => dbLogger3.error("Error closing read connection", err))
+        readC.end({ timeout: 5 }).then(() => dbLogger4.debug("Read connection closed")).catch((err) => dbLogger4.error("Error closing read connection", err))
       );
     }
     await Promise.all(closePromises);
-    dbLogger3.info("All database connections closed");
+    dbLogger4.info("All database connections closed");
   } catch (error) {
-    dbLogger3.error("Error during database cleanup", error);
+    dbLogger4.error("Error during database cleanup", error);
     throw error;
   } finally {
-    writeInstance = void 0;
-    readInstance = void 0;
-    writeClient = void 0;
-    readClient = void 0;
-    monitoringConfig = void 0;
+    setWriteInstance(void 0);
+    setReadInstance(void 0);
+    setWriteClient(void 0);
+    setReadClient(void 0);
+    setMonitoringConfig(void 0);
   }
 }
 function getDatabaseInfo() {
+  const writeInst = getWriteInstance();
+  const readInst = getReadInstance();
   return {
-    hasWrite: !!writeInstance,
-    hasRead: !!readInstance,
-    isReplica: !!(readInstance && readInstance !== writeInstance)
+    hasWrite: !!writeInst,
+    hasRead: !!readInst,
+    isReplica: !!(readInst && readInst !== writeInst)
   };
 }
-function startHealthCheck(config2) {
-  if (healthCheckInterval) {
-    dbLogger3.debug("Health check already running");
-    return;
-  }
-  dbLogger3.info("Starting database health check", {
-    interval: `${config2.interval}ms`,
-    reconnect: config2.reconnect
-  });
-  healthCheckInterval = setInterval(async () => {
-    try {
-      const write = getDatabase("write");
-      const read = getDatabase("read");
-      if (write) {
-        await write.execute("SELECT 1");
-      }
-      if (read && read !== write) {
-        await read.execute("SELECT 1");
+function expandGlobPattern(pattern) {
+  if (!pattern.includes("*")) {
+    return existsSync(pattern) ? [pattern] : [];
+  }
+  const files = [];
+  if (pattern.includes("**")) {
+    const [baseDir, ...rest] = pattern.split("**");
+    const extension = rest.join("").replace(/[\/\\]\*\./g, "").trim();
+    const scanRecursive = (dir) => {
+      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.isDirectory()) {
+              scanRecursive(fullPath);
+            } else if (stat.isFile()) {
+              if (!extension || fullPath.endsWith(extension)) {
+                files.push(fullPath);
+              }
+            }
+          } catch {
+          }
+        }
+      } catch {
       }
-      dbLogger3.debug("Database health check passed");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error("Database health check failed", { error: message });
-      if (config2.reconnect) {
-        await attemptReconnection(config2);
+    };
+    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 {
+        }
       }
+    } catch {
     }
-  }, config2.interval);
+  }
+  return files;
 }
-async function attemptReconnection(config2) {
-  dbLogger3.warn("Attempting database reconnection", {
-    maxRetries: config2.maxRetries,
-    retryInterval: `${config2.retryInterval}ms`
-  });
-  for (let attempt = 1; attempt <= config2.maxRetries; attempt++) {
+function discoverPackageSchemas(cwd) {
+  const schemas = [];
+  const nodeModulesPath = join(cwd, "node_modules");
+  if (!existsSync(nodeModulesPath)) {
+    return schemas;
+  }
+  const projectPkgPath = join(cwd, "package.json");
+  let directDeps = /* @__PURE__ */ new Set();
+  if (existsSync(projectPkgPath)) {
     try {
-      dbLogger3.debug(`Reconnection attempt ${attempt}/${config2.maxRetries}`);
-      await closeDatabase();
-      await new Promise((resolve) => setTimeout(resolve, config2.retryInterval));
-      const result = await createDatabaseFromEnv();
-      if (result.write) {
-        await result.write.execute("SELECT 1");
-        writeInstance = result.write;
-        readInstance = result.read;
-        writeClient = result.writeClient;
-        readClient = result.readClient;
-        dbLogger3.info("Database reconnection successful", { attempt });
-        return;
+      const projectPkg = JSON.parse(readFileSync(projectPkgPath, "utf-8"));
+      directDeps = /* @__PURE__ */ new Set([
+        ...Object.keys(projectPkg.dependencies || {}),
+        ...Object.keys(projectPkg.devDependencies || {})
+      ]);
+    } catch (error) {
+    }
+  }
+  const checkPackage = (_pkgName, pkgPath) => {
+    const pkgJsonPath = join(pkgPath, "package.json");
+    if (!existsSync(pkgJsonPath)) return;
+    try {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      if (pkgJson.spfn?.schemas) {
+        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 = 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")
+          );
+          schemas.push(...schemaFiles);
+        }
       }
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
-        error: message,
-        attempt,
-        maxRetries: config2.maxRetries
-      });
-      if (attempt === config2.maxRetries) {
-        dbLogger3.error("Max reconnection attempts reached, giving up");
+    }
+  };
+  const spfnDir = join(nodeModulesPath, "@spfn");
+  if (existsSync(spfnDir)) {
+    try {
+      const spfnPackages = readdirSync(spfnDir);
+      for (const pkg of spfnPackages) {
+        checkPackage(`@spfn/${pkg}`, join(spfnDir, pkg));
       }
+    } catch (error) {
     }
   }
-}
-function stopHealthCheck() {
-  if (healthCheckInterval) {
-    clearInterval(healthCheckInterval);
-    healthCheckInterval = void 0;
-    dbLogger3.info("Database health check stopped");
+  for (const depName of directDeps) {
+    if (depName.startsWith("@spfn/")) continue;
+    const pkgPath = depName.startsWith("@") ? join(nodeModulesPath, ...depName.split("/")) : join(nodeModulesPath, depName);
+    checkPackage(depName, pkgPath);
   }
+  return schemas;
 }
-function getDatabaseMonitoringConfig() {
-  return monitoringConfig;
+function detectDialect(url) {
+  if (url.startsWith("postgres://") || url.startsWith("postgresql://")) {
+    return "postgresql";
+  }
+  if (url.startsWith("mysql://")) {
+    return "mysql";
+  }
+  if (url.startsWith("sqlite://") || url.includes(".db") || url.includes(".sqlite")) {
+    return "sqlite";
+  }
+  throw new Error(
+    `Unsupported database URL format: ${url}. Supported: postgresql://, mysql://, sqlite://`
+  );
 }
-
-// src/db/manager/instance.ts
-var db = new Proxy({}, {
-  get(_target, prop) {
-    const instance = getDatabase("write");
-    if (!instance) {
+function getDrizzleConfig(options = {}) {
+  const databaseUrl = options.databaseUrl ?? process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    throw new Error(
+      "DATABASE_URL is required. Set it in .env or pass it to getDrizzleConfig()"
+    );
+  }
+  const dialect = options.dialect ?? detectDialect(databaseUrl);
+  const out = options.out ?? "./src/server/drizzle";
+  if (options.packageFilter) {
+    const packageSchemas2 = options.disablePackageDiscovery ? [] : discoverPackageSchemas(options.cwd ?? process.cwd());
+    const filteredSchemas = packageSchemas2.filter(
+      (schemaPath) => schemaPath.includes(`node_modules/${options.packageFilter}/`)
+    );
+    if (filteredSchemas.length === 0) {
       throw new Error(
-        "Database not initialized. Set DATABASE_URL environment variable or call initDatabase() first."
+        `No schemas found for package ${options.packageFilter}. Make sure the package is installed and has "spfn.schemas" in package.json.`
       );
     }
-    return instance[prop];
+    const schema2 = filteredSchemas.length === 1 ? filteredSchemas[0] : filteredSchemas;
+    return {
+      schema: schema2,
+      out,
+      dialect,
+      dbCredentials: getDbCredentials(dialect, databaseUrl)
+    };
   }
+  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];
+  const schema = allSchemas.length === 1 ? allSchemas[0] : allSchemas;
+  return {
+    schema,
+    out,
+    dialect,
+    dbCredentials: getDbCredentials(dialect, databaseUrl)
+  };
+}
+function getDbCredentials(dialect, url) {
+  switch (dialect) {
+    case "postgresql":
+    case "mysql":
+      return { url };
+    case "sqlite":
+      const dbPath = url.replace("sqlite://", "").replace("sqlite:", "");
+      return { url: dbPath };
+    default:
+      throw new Error(`Unsupported dialect: ${dialect}`);
+  }
+}
+function generateDrizzleConfigFile(options = {}) {
+  const config = getDrizzleConfig(options);
+  const schemaValue = Array.isArray(config.schema) ? `[
+        ${config.schema.map((s) => `'${s}'`).join(",\n        ")}
+    ]` : `'${config.schema}'`;
+  return `import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+    schema: ${schemaValue},
+    out: '${config.out}',
+    dialect: '${config.dialect}',
+    dbCredentials: ${JSON.stringify(config.dbCredentials, null, 4)},
 });
-function getRawDb(type = "write") {
-  const instance = getDatabase(type);
-  if (!instance) {
-    throw new Error(
-      "Database not initialized. Set DATABASE_URL environment variable or call initDatabase() first."
-    );
+`;
+}
+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;
   }
-  return instance;
+  return {
+    createdAt: timestamp("created_at", { withTimezone: true, mode: "date" }).defaultNow().notNull(),
+    updatedAt: updatedAtColumn
+  };
+}
+function foreignKey(name, reference, options) {
+  return bigserial(`${name}_id`, { mode: "number" }).notNull().references(reference, { onDelete: options?.onDelete ?? "cascade" });
+}
+function optionalForeignKey(name, reference, options) {
+  return bigserial(`${name}_id`, { mode: "number" }).references(reference, { onDelete: options?.onDelete ?? "set null" });
+}
+function createFunctionSchema(packageName) {
+  const schemaName = packageNameToSchema(packageName);
+  return pgSchema(schemaName);
 }
+function packageNameToSchema(packageName) {
+  return packageName.replace("@", "").replace("/", "_").replace(/-/g, "_");
+}
+function getSchemaInfo(packageName) {
+  const isScoped = packageName.startsWith("@");
+  const scope = isScoped ? packageName.split("/")[0].substring(1) : null;
+  const schemaName = packageNameToSchema(packageName);
+  return {
+    schemaName,
+    isScoped,
+    scope
+  };
+}
+var txLogger = logger.child("transaction");
 var asyncContext = new AsyncLocalStorage();
+function getTransactionContext() {
+  return asyncContext.getStore() ?? null;
+}
 function getTransaction() {
-  const context = asyncContext.getStore();
+  const context = getTransactionContext();
   return context?.tx ?? null;
 }
-function runWithTransaction(tx, callback) {
-  return asyncContext.run({ tx }, callback);
+function runWithTransaction(tx, txId, callback) {
+  const existingContext = getTransactionContext();
+  const newLevel = existingContext ? existingContext.level + 1 : 1;
+  if (existingContext) {
+    txLogger.info("Nested transaction started (SAVEPOINT)", {
+      outerTxId: existingContext.txId,
+      innerTxId: txId,
+      level: newLevel
+    });
+  } else {
+    txLogger.debug("Root transaction context set", { txId, level: newLevel });
+  }
+  return asyncContext.run({ tx, txId, level: newLevel }, callback);
 }
 function Transactional(options = {}) {
   const defaultTimeout = parseInt(process.env.TRANSACTION_TIMEOUT || "30000", 10);
@@ -1119,17 +1851,25 @@ function Transactional(options = {}) {
     enableLogging = true,
     timeout = defaultTimeout
   } = options;
-  const txLogger = logger.child("transaction");
+  const txLogger2 = logger.child("transaction");
   return createMiddleware(async (c, next) => {
-    const txId = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const txId = `tx_${randomUUID()}`;
     const startTime = Date.now();
     const route = `${c.req.method} ${c.req.path}`;
     if (enableLogging) {
-      txLogger.debug("Transaction started", { txId, route });
+      txLogger2.debug("Transaction started", { txId, route });
     }
     try {
-      const transactionPromise = db.transaction(async (tx) => {
-        await runWithTransaction(tx, async () => {
+      const writeDb = getDatabase("write");
+      if (!writeDb) {
+        throw new TransactionError(
+          "Database not initialized. Cannot start transaction.",
+          500,
+          { txId, route }
+        );
+      }
+      const transactionPromise = writeDb.transaction(async (tx) => {
+        await runWithTransaction(tx, txId, async () => {
           await next();
           const contextWithError = c;
           if (contextWithError.error) {
@@ -1160,14 +1900,14 @@ function Transactional(options = {}) {
       const duration = Date.now() - startTime;
       if (enableLogging) {
         if (duration >= slowThreshold) {
-          txLogger.warn("Slow transaction committed", {
+          txLogger2.warn("Slow transaction committed", {
             txId,
             route,
             duration: `${duration}ms`,
             threshold: `${slowThreshold}ms`
           });
         } else {
-          txLogger.debug("Transaction committed", {
+          txLogger2.debug("Transaction committed", {
             txId,
             route,
             duration: `${duration}ms`
@@ -1178,7 +1918,7 @@ function Transactional(options = {}) {
       const duration = Date.now() - startTime;
       const customError = error instanceof TransactionError ? error : fromPostgresError(error);
       if (enableLogging) {
-        txLogger.error("Transaction rolled back", {
+        txLogger2.error("Transaction rolled back", {
           txId,
           route,
           duration: `${duration}ms`,
@@ -1190,910 +1930,144 @@ function Transactional(options = {}) {
     }
   });
 }
-function buildFilters(filters, table) {
-  const conditions = [];
-  for (const [field, filterCondition] of Object.entries(filters)) {
-    const column = table[field];
-    if (!column) {
-      console.warn(`[buildFilters] Unknown field: ${field}`);
-      continue;
-    }
-    for (const [operator, value] of Object.entries(filterCondition)) {
-      const condition = buildCondition(column, operator, value);
-      if (condition) {
-        conditions.push(condition);
-      }
-    }
-  }
-  return conditions.length > 0 ? and(...conditions) : void 0;
-}
-function buildCondition(column, operator, value) {
-  switch (operator) {
-    case "eq":
-      return eq(column, value);
-    case "ne":
-      return ne(column, value);
-    case "gt":
-      return gt(column, value);
-    case "gte":
-      return gte(column, value);
-    case "lt":
-      return lt(column, value);
-    case "lte":
-      return lte(column, value);
-    case "like":
-      return like(column, `%${value}%`);
-    case "in":
-      if (Array.isArray(value)) {
-        return inArray(column, value);
-      }
-      console.warn(`[buildCondition] 'in' operator requires array value`);
-      return void 0;
-    case "nin":
-      if (Array.isArray(value)) {
-        return notInArray(column, value);
-      }
-      console.warn(`[buildCondition] 'nin' operator requires array value`);
-      return void 0;
-    case "is":
-      if (value === "null") return isNull(column);
-      if (value === "notnull") return isNotNull(column);
-      console.warn(`[buildCondition] 'is' operator requires 'null' or 'notnull'`);
-      return void 0;
-    default:
-      console.warn(`[buildCondition] Unknown operator: ${operator}`);
-      return void 0;
-  }
-}
-function buildSort(sortConditions, table) {
-  const orderByClauses = [];
-  for (const { field, direction } of sortConditions) {
-    const column = table[field];
-    if (!column) {
-      console.warn(`[buildSort] Unknown field: ${field}`);
-      continue;
-    }
-    const clause = direction === "desc" ? desc(column) : asc(column);
-    orderByClauses.push(clause);
-  }
-  return orderByClauses;
-}
-function applyPagination(pagination) {
-  const { page, limit } = pagination;
-  const offset = (page - 1) * limit;
-  return { offset, limit };
-}
-function createPaginationMeta(pagination, total) {
-  const { page, limit } = pagination;
-  const totalPages = Math.ceil(total / limit);
-  return {
-    page,
-    limit,
-    total,
-    totalPages,
-    hasNext: page < totalPages,
-    hasPrev: page > 1
-  };
+function isSQLWrapper(value) {
+  return value && typeof value === "object" && "queryChunks" in value;
 }
-async function countTotal(db2, table, whereCondition) {
-  const query = db2.select({ count: sql`count(*)::int` }).from(table);
-  if (whereCondition) {
-    query.where(whereCondition);
-  }
-  const [result] = await query;
-  return result?.count || 0;
+function buildWhereFromObject(table, where) {
+  const entries = Object.entries(where).filter(([_, value]) => value !== 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/repository/query-builder.ts
-var QueryBuilder = class {
-  db;
-  table;
-  filterConditions = [];
-  sortConditions = [];
-  limitValue;
-  offsetValue;
-  constructor(db2, table) {
-    this.db = db2;
-    this.table = table;
-  }
-  /**
-   * Add WHERE conditions
-   *
-   * Multiple where() calls are combined with AND logic.
-   *
-   * @param filters - Filter conditions
-   * @returns QueryBuilder for chaining
-   *
-   * @example
-   * ```typescript
-   * query
-   *     .where({ status: 'active' })
-   *     .where({ role: 'admin' })  // AND condition
-   * ```
-   */
-  where(filters) {
-    this.filterConditions.push(filters);
-    return this;
-  }
-  /**
-   * Add ORDER BY clause
-   *
-   * Multiple orderBy() calls create multi-column sorting.
-   *
-   * @param field - Field name to sort by
-   * @param direction - Sort direction ('asc' or 'desc')
-   * @returns QueryBuilder for chaining
-   *
-   * @example
-   * ```typescript
-   * query
-   *     .orderBy('isPremium', 'desc')
-   *     .orderBy('createdAt', 'desc')
-   * ```
-   */
-  orderBy(field, direction = "asc") {
-    this.sortConditions.push({ field, direction });
-    return this;
-  }
-  /**
-   * Set LIMIT clause
-   *
-   * @param limit - Maximum number of records to return
-   * @returns QueryBuilder for chaining
-   *
-   * @example
-   * ```typescript
-   * query.limit(10)
-   * ```
-   */
-  limit(limit) {
-    this.limitValue = limit;
-    return this;
-  }
-  /**
-   * Set OFFSET clause
-   *
-   * @param offset - Number of records to skip
-   * @returns QueryBuilder for chaining
-   *
-   * @example
-   * ```typescript
-   * query.offset(20)
-   * ```
-   */
-  offset(offset) {
-    this.offsetValue = offset;
-    return this;
-  }
-  /**
-   * Execute query and return multiple records
-   *
-   * @returns Array of records
-   *
-   * @example
-   * ```typescript
-   * const users = await query
-   *     .where({ status: 'active' })
-   *     .orderBy('createdAt', 'desc')
-   *     .limit(10)
-   *     .findMany();
-   * ```
-   */
-  async findMany() {
-    const mergedFilters = this.mergeFilters();
-    const whereCondition = buildFilters(mergedFilters, this.table);
-    const orderBy = buildSort(this.sortConditions, this.table);
-    let query = this.db.select().from(this.table).where(whereCondition).orderBy(...orderBy);
-    if (this.limitValue !== void 0) {
-      query = query.limit(this.limitValue);
-    }
-    if (this.offsetValue !== void 0) {
-      query = query.offset(this.offsetValue);
-    }
-    return query;
+async function findOne(table, where) {
+  const db = getDatabase("read");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-  /**
-   * Execute query and return first record
-   *
-   * @returns First matching record or null
-   *
-   * @example
-   * ```typescript
-   * const user = await query
-   *     .where({ email: 'john@example.com' })
-   *     .findOne();
-   * ```
-   */
-  async findOne() {
-    const results = await this.limit(1).findMany();
-    return results[0] ?? null;
+  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+  if (!whereClause) {
+    throw new Error("findOne requires at least one where condition");
   }
-  /**
-   * Execute query and return count
-   *
-   * @returns Number of matching records
-   *
-   * @example
-   * ```typescript
-   * const count = await query
-   *     .where({ status: 'active' })
-   *     .count();
-   * ```
-   */
-  async count() {
-    const mergedFilters = this.mergeFilters();
-    const whereCondition = buildFilters(mergedFilters, this.table);
-    const { count } = await import('drizzle-orm');
-    const result = await this.db.select({ count: count() }).from(this.table).where(whereCondition);
-    return Number(result[0]?.count ?? 0);
-  }
-  /**
-   * Merge multiple filter conditions into single object
-   *
-   * Combines all where() calls into one filter object.
-   */
-  mergeFilters() {
-    if (this.filterConditions.length === 0) {
-      return {};
-    }
-    return this.filterConditions.reduce((merged, current) => {
-      return { ...merged, ...current };
-    }, {});
-  }
-};
-
-// src/db/repository/repository.ts
-var Repository = class {
-  db;
-  table;
-  useReplica;
-  explicitDb;
-  // Track if db was explicitly provided
-  autoUpdateField;
-  // Field name to auto-update (e.g., 'updatedAt', 'modifiedAt')
-  constructor(dbOrTable, tableOrUseReplica, useReplica = true) {
-    if ("name" in dbOrTable && typeof dbOrTable.name === "string") {
-      this.db = getRawDb("write");
-      this.table = dbOrTable;
-      this.useReplica = typeof tableOrUseReplica === "boolean" ? tableOrUseReplica : true;
-      this.explicitDb = void 0;
-    } else {
-      this.db = dbOrTable;
-      this.table = tableOrUseReplica;
-      this.useReplica = useReplica;
-      this.explicitDb = this.db;
-    }
-    this.autoUpdateField = this.detectAutoUpdateField();
-  }
-  /**
-   * Detect which field (if any) should be auto-updated
-   *
-   * Checks all table columns for __autoUpdate metadata flag.
-   * Set by autoUpdateTimestamp() or timestamps({ autoUpdate: true }) helpers.
-   *
-   * @returns Field name to auto-update, or undefined if none found
-   */
-  detectAutoUpdateField() {
-    if (!this.table || typeof this.table !== "object") {
-      return void 0;
-    }
-    const tableColumns = this.table;
-    for (const [fieldName, column] of Object.entries(tableColumns)) {
-      if (fieldName.startsWith("_") || fieldName.startsWith("$")) {
-        continue;
-      }
-      if (column && typeof column === "object" && column.__autoUpdate === true) {
-        return fieldName;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Inject auto-update timestamp if configured
-   *
-   * Only injects if:
-   * 1. Table has an auto-update field configured (via autoUpdateTimestamp() or timestamps({ autoUpdate: true }))
-   * 2. The field is not already explicitly provided in the data
-   *
-   * @param data - Update data object
-   * @returns Data with auto-update timestamp injected (if applicable)
-   */
-  injectAutoUpdateTimestamp(data) {
-    if (!this.autoUpdateField) {
-      return data;
-    }
-    if (data && this.autoUpdateField in data) {
-      return data;
-    }
-    return {
-      ...data,
-      [this.autoUpdateField]: /* @__PURE__ */ new Date()
-    };
-  }
-  /**
-   * Get id column from table
-   *
-   * Helper method to reduce code duplication across methods that need id column.
-   *
-   * @returns The id column object
-   * @throws {QueryError} If table does not have an id column
-   */
-  getIdColumn() {
-    const idColumn = this.table.id;
-    if (!idColumn) {
-      throw new QueryError("Table does not have an id column");
-    }
-    return idColumn;
-  }
-  /**
-   * Get read-only DB
-   *
-   * Automatically detects and uses transaction context if available.
-   * When in transaction, uses transaction DB to ensure read consistency.
-   * Priority: explicitDb > transaction > replica/primary DB
-   */
-  getReadDb() {
-    if (this.explicitDb) {
-      return this.explicitDb;
-    }
-    const tx = getTransaction();
-    if (tx) {
-      return tx;
-    }
-    return this.useReplica ? getRawDb("read") : this.db;
-  }
-  /**
-   * Get write-only DB
-   *
-   * Automatically detects and uses transaction context if available.
-   * Priority: explicitDb > transaction > primary DB
-   */
-  getWriteDb() {
-    if (this.explicitDb) {
-      return this.explicitDb;
-    }
-    const tx = getTransaction();
-    if (tx) {
-      return tx;
-    }
-    return getRawDb("write");
-  }
-  /**
-   * Execute operation with performance monitoring
-   *
-   * Wraps database operations with timing and logging for slow queries.
-   * Only logs if monitoring is enabled and query exceeds threshold.
-   *
-   * @param operation - Name of the operation (for logging)
-   * @param fn - Async function to execute
-   * @returns Result of the operation
-   */
-  async executeWithMonitoring(operation, fn) {
-    const config2 = getDatabaseMonitoringConfig();
-    if (!config2?.enabled) {
-      return fn();
-    }
-    const startTime = performance.now();
-    try {
-      const result = await fn();
-      const duration = performance.now() - startTime;
-      if (duration >= config2.slowThreshold) {
-        const dbLogger4 = logger.child("database");
-        const logData = {
-          operation,
-          table: this.table._.name,
-          duration: `${duration.toFixed(2)}ms`,
-          threshold: `${config2.slowThreshold}ms`
-        };
-        dbLogger4.warn("Slow query detected", logData);
-      }
-      return result;
-    } catch (error) {
-      const duration = performance.now() - startTime;
-      const dbLogger4 = logger.child("database");
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger4.error("Query failed", {
-        operation,
-        table: this.table._.name,
-        duration: `${duration.toFixed(2)}ms`,
-        error: message
-      });
-      throw error;
+  const results = await db.select().from(table).where(whereClause).limit(1);
+  return results[0] ?? null;
+}
+async function findMany(table, options) {
+  const db = getDatabase("read");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
+  }
+  let query = db.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);
     }
   }
-  /**
-   * Find all records (uses Replica)
-   *
-   * @example
-   * const users = await userRepo.findAll();
-   */
-  async findAll() {
-    return this.executeWithMonitoring("findAll", async () => {
-      const readDb = this.getReadDb();
-      return readDb.select().from(this.table);
-    });
-  }
-  /**
-   * Find with pagination (uses Replica)
-   *
-   * @example
-   * const result = await userRepo.findPage({
-   *   filters: { email: { like: 'john' } },
-   *   sort: [{ field: 'createdAt', direction: 'desc' }],
-   *   pagination: { page: 1, limit: 20 }
-   * });
-   */
-  async findPage(pageable) {
-    return this.executeWithMonitoring("findPage", async () => {
-      const { filters = {}, sort = [], pagination = { page: 1, limit: 20 } } = pageable;
-      const whereCondition = buildFilters(filters, this.table);
-      const orderBy = buildSort(sort, this.table);
-      const { offset, limit } = applyPagination(pagination);
-      const readDb = this.getReadDb();
-      const data = await readDb.select().from(this.table).where(whereCondition).orderBy(...orderBy).limit(limit).offset(offset);
-      const total = await countTotal(readDb, this.table, whereCondition);
-      const meta = createPaginationMeta(pagination, total);
-      return { data, meta };
-    });
-  }
-  /**
-   * Find one record by ID (uses Replica)
-   *
-   * @example
-   * const user = await userRepo.findById(1);
-   */
-  async findById(id2) {
-    return this.executeWithMonitoring("findById", async () => {
-      const idColumn = this.getIdColumn();
-      const { eq: eq2 } = await import('drizzle-orm');
-      const readDb = this.getReadDb();
-      const [result] = await readDb.select().from(this.table).where(eq2(idColumn, id2));
-      return result ?? null;
-    });
-  }
-  /**
-   * Find one record by condition (uses Replica)
-   *
-   * @example
-   * const user = await userRepo.findOne(eq(users.email, 'john@example.com'));
-   */
-  async findOne(where) {
-    return this.executeWithMonitoring("findOne", async () => {
-      const readDb = this.getReadDb();
-      const [result] = await readDb.select().from(this.table).where(where);
-      return result ?? null;
-    });
-  }
-  /**
-   * Create a new record (uses Primary)
-   *
-   * @example
-   * const user = await userRepo.save({ email: 'john@example.com', name: 'John' });
-   */
-  async save(data) {
-    return this.executeWithMonitoring("save", async () => {
-      const writeDb = this.getWriteDb();
-      const [result] = await writeDb.insert(this.table).values(data).returning();
-      return result;
-    });
-  }
-  /**
-   * Update a record (uses Primary)
-   *
-   * Automatically injects current timestamp if table has auto-update field configured.
-   *
-   * @example
-   * const user = await userRepo.update(1, { name: 'Jane' });
-   */
-  async update(id2, data) {
-    return this.executeWithMonitoring("update", async () => {
-      const idColumn = this.getIdColumn();
-      const updateData = this.injectAutoUpdateTimestamp(data);
-      const { eq: eq2 } = await import('drizzle-orm');
-      const writeDb = this.getWriteDb();
-      const [result] = await writeDb.update(this.table).set(updateData).where(eq2(idColumn, id2)).returning();
-      return result ?? null;
-    });
-  }
-  /**
-   * Delete a record (uses Primary)
-   *
-   * @example
-   * const deleted = await userRepo.delete(1);
-   */
-  async delete(id2) {
-    return this.executeWithMonitoring("delete", async () => {
-      const idColumn = this.getIdColumn();
-      const { eq: eq2 } = await import('drizzle-orm');
-      const writeDb = this.getWriteDb();
-      const [result] = await writeDb.delete(this.table).where(eq2(idColumn, id2)).returning();
-      return result ?? null;
-    });
-  }
-  /**
-   * Count records (uses Replica)
-   *
-   * @example
-   * const count = await userRepo.count();
-   */
-  async count(where) {
-    return this.executeWithMonitoring("count", async () => {
-      const readDb = this.getReadDb();
-      return countTotal(readDb, this.table, where);
-    });
-  }
-  /**
-   * Find records by filters (uses Replica)
-   *
-   * @example
-   * const users = await userRepo.findWhere({ email: { like: '@gmail.com' }, status: 'active' });
-   */
-  async findWhere(filters) {
-    return this.executeWithMonitoring("findWhere", async () => {
-      const whereCondition = buildFilters(filters, this.table);
-      const readDb = this.getReadDb();
-      return readDb.select().from(this.table).where(whereCondition);
-    });
-  }
-  /**
-   * Find one record by filters (uses Replica)
-   *
-   * @example
-   * const user = await userRepo.findOneWhere({ email: 'john@example.com' });
-   */
-  async findOneWhere(filters) {
-    return this.executeWithMonitoring("findOneWhere", async () => {
-      const whereCondition = buildFilters(filters, this.table);
-      const readDb = this.getReadDb();
-      const [result] = await readDb.select().from(this.table).where(whereCondition);
-      return result ?? null;
-    });
+  if (options?.orderBy) {
+    const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+    query = query.orderBy(...orderByArray);
   }
-  /**
-   * Check if record exists by ID (uses Replica)
-   *
-   * @example
-   * const exists = await userRepo.exists(1);
-   */
-  async exists(id2) {
-    return this.executeWithMonitoring("exists", async () => {
-      const idColumn = this.getIdColumn();
-      const { eq: eq2 } = await import('drizzle-orm');
-      const readDb = this.getReadDb();
-      const [result] = await readDb.select().from(this.table).where(eq2(idColumn, id2)).limit(1);
-      return !!result;
-    });
+  if (options?.limit) {
+    query = query.limit(options.limit);
   }
-  /**
-   * Check if record exists by filters (uses Replica)
-   *
-   * @example
-   * const exists = await userRepo.existsBy({ email: 'john@example.com' });
-   */
-  async existsBy(filters) {
-    return this.executeWithMonitoring("existsBy", async () => {
-      const whereCondition = buildFilters(filters, this.table);
-      const readDb = this.getReadDb();
-      const [result] = await readDb.select().from(this.table).where(whereCondition).limit(1);
-      return !!result;
-    });
+  if (options?.offset) {
+    query = query.offset(options.offset);
   }
-  /**
-   * Count records by filters (uses Replica)
-   *
-   * @example
-   * const count = await userRepo.countBy({ status: 'active' });
-   */
-  async countBy(filters) {
-    return this.executeWithMonitoring("countBy", async () => {
-      const whereCondition = buildFilters(filters, this.table);
-      const readDb = this.getReadDb();
-      return countTotal(readDb, this.table, whereCondition);
-    });
-  }
-  /**
-   * Create multiple records (uses Primary)
-   *
-   * @example
-   * const users = await userRepo.saveMany([
-   *   { email: 'user1@example.com', name: 'User 1' },
-   *   { email: 'user2@example.com', name: 'User 2' }
-   * ]);
-   */
-  async saveMany(data) {
-    return this.executeWithMonitoring("saveMany", async () => {
-      const writeDb = this.getWriteDb();
-      return writeDb.insert(this.table).values(data).returning();
-    });
-  }
-  /**
-   * Update multiple records by filters (uses Primary)
-   *
-   * Automatically injects current timestamp if table has auto-update field configured.
-   *
-   * @example
-   * const count = await userRepo.updateWhere({ status: 'inactive' }, { status: 'archived' });
-   */
-  async updateWhere(filters, data) {
-    return this.executeWithMonitoring("updateWhere", async () => {
-      const updateData = this.injectAutoUpdateTimestamp(data);
-      const whereCondition = buildFilters(filters, this.table);
-      const writeDb = this.getWriteDb();
-      const results = await writeDb.update(this.table).set(updateData).where(whereCondition).returning();
-      return results.length;
-    });
-  }
-  /**
-   * Delete multiple records by filters (uses Primary)
-   *
-   * @example
-   * const count = await userRepo.deleteWhere({ status: 'banned' });
-   */
-  async deleteWhere(filters) {
-    return this.executeWithMonitoring("deleteWhere", async () => {
-      const whereCondition = buildFilters(filters, this.table);
-      const writeDb = this.getWriteDb();
-      const results = await writeDb.delete(this.table).where(whereCondition).returning();
-      return results.length;
-    });
-  }
-  // ============================================================
-  // Query Builder (Fluent Interface)
-  // ============================================================
-  /**
-   * Start a chainable query builder (uses Replica)
-   *
-   * Returns a QueryBuilder instance for building complex queries with method chaining.
-   *
-   * @returns QueryBuilder instance for chaining
-   *
-   * @example
-   * ```typescript
-   * // Simple chaining
-   * const users = await userRepo
-   *     .query()
-   *     .where({ status: 'active' })
-   *     .orderBy('createdAt', 'desc')
-   *     .limit(10)
-   *     .findMany();
-   *
-   * // Multiple conditions
-   * const admins = await userRepo
-   *     .query()
-   *     .where({ role: 'admin' })
-   *     .where({ status: 'active' })  // AND condition
-   *     .findMany();
-   *
-   * // Reusable query
-   * const activeQuery = userRepo.query().where({ status: 'active' });
-   * const users = await activeQuery.findMany();
-   * const count = await activeQuery.count();
-   * ```
-   */
-  query() {
-    const readDb = this.getReadDb();
-    return new QueryBuilder(readDb, this.table);
-  }
-};
-
-// src/db/repository/factory.ts
-var repositoryCache = /* @__PURE__ */ new Map();
-function getCacheKey(table, RepositoryClass) {
-  const tableName = table[Symbol.for("drizzle:Name")] || table.name || table.toString();
-  const className = RepositoryClass?.name || "Repository";
-  return `${tableName}:${className}`;
-}
-function getRepository(table, RepositoryClass) {
-  const cacheKey = getCacheKey(table, RepositoryClass);
-  let repo = repositoryCache.get(cacheKey);
-  if (!repo) {
-    if (RepositoryClass) {
-      repo = new RepositoryClass(table);
-    } else {
-      repo = new Repository(table);
-    }
-    repositoryCache.set(cacheKey, repo);
-  }
-  return repo;
-}
-function clearRepositoryCache() {
-  repositoryCache.clear();
-}
-function getRepositoryCacheSize() {
-  return repositoryCache.size;
+  return query;
 }
-var repositoryStorage = new AsyncLocalStorage();
-function getCacheKey2(table, RepositoryClass) {
-  const tableName = table[Symbol.for("drizzle:Name")] || table.name || table.toString();
-  const className = RepositoryClass?.name || "Repository";
-  return `${tableName}:${className}`;
-}
-function withRepositoryScope(fn) {
-  const cache = /* @__PURE__ */ new Map();
-  return repositoryStorage.run(cache, fn);
-}
-function getScopedRepository(table, RepositoryClass) {
-  const cache = repositoryStorage.getStore();
-  if (!cache) {
-    return RepositoryClass ? new RepositoryClass(table) : new Repository(table);
-  }
-  const key = getCacheKey2(table, RepositoryClass);
-  let repo = cache.get(key);
-  if (!repo) {
-    repo = RepositoryClass ? new RepositoryClass(table) : new Repository(table);
-    cache.set(key, repo);
+async function create(table, data) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-  return repo;
+  const [result] = await db.insert(table).values(data).returning();
+  return result;
 }
-function RepositoryScope() {
-  return async (_c, next) => {
-    return withRepositoryScope(() => next());
-  };
-}
-function getScopedCacheSize() {
-  const cache = repositoryStorage.getStore();
-  return cache?.size ?? 0;
-}
-function isInRepositoryScope() {
-  return repositoryStorage.getStore() !== void 0;
-}
-
-// src/db/repository/relation-registry.ts
-var tableNameCache = /* @__PURE__ */ new WeakMap();
-function getTableName(table) {
-  const cached = tableNameCache.get(table);
-  if (cached) {
-    return cached;
+async function createMany(table, data) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-  const name = table[Symbol.for("drizzle:Name")] || table.constructor.name;
-  tableNameCache.set(table, name);
-  return name;
+  const results = await db.insert(table).values(data).returning();
+  return results;
 }
-
-// src/db/manager/wrapped-db.ts
-var WrappedDb = class {
-  constructor(db2) {
-    this.db = db2;
-  }
-  /**
-   * Repository 패턴으로 테이블 접근
-   *
-   * @example
-   * const db = getDb();
-   * const userRepo = db.for(users);
-   * const result = await userRepo.findPage(pageable);
-   */
-  for(table) {
-    return new Repository(this.db, table);
-  }
-  /**
-   * Drizzle의 모든 메서드를 프록시
-   *
-   * select, insert, update, delete, transaction 등 모든 Drizzle 메서드 사용 가능
-   */
-  get select() {
-    return this.db.select.bind(this.db);
-  }
-  get insert() {
-    return this.db.insert.bind(this.db);
-  }
-  get update() {
-    return this.db.update.bind(this.db);
-  }
-  get delete() {
-    return this.db.delete.bind(this.db);
-  }
-  get execute() {
-    return this.db.execute.bind(this.db);
-  }
-  get transaction() {
-    return this.db.transaction.bind(this.db);
-  }
-  get query() {
-    return this.db.query;
+async function upsert(table, data, options) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
+  }
+  const [result] = await db.insert(table).values(data).onConflictDoUpdate({
+    target: options.target,
+    set: options.set || data
+  }).returning();
+  return result;
+}
+async function updateOne(table, where, data) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-  get $with() {
-    return this.db.$with.bind(this.db);
+  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+  if (!whereClause) {
+    throw new Error("updateOne requires at least one where condition");
   }
-  /**
-   * Raw Drizzle DB 접근 (필요시)
-   */
-  get raw() {
-    return this.db;
+  const [result] = await db.update(table).set(data).where(whereClause).returning();
+  return result ?? null;
+}
+async function updateMany(table, where, data) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-};
-
-// src/db/manager/context.ts
-function getDb(type) {
-  const tx = getTransaction();
-  if (tx) {
-    return new WrappedDb(tx);
-  }
-  const rawDb = getDatabase(type);
-  if (!rawDb) {
-    throw new Error(
-      "Database not initialized. Set DATABASE_URL environment variable or call initDatabase() first."
-    );
+  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+  if (!whereClause) {
+    throw new Error("updateMany requires at least one where condition");
   }
-  return new WrappedDb(rawDb);
+  const results = await db.update(table).set(data).where(whereClause).returning();
+  return results;
 }
-
-// src/db/manager/config-generator.ts
-function detectDialect(url) {
-  if (url.startsWith("postgres://") || url.startsWith("postgresql://")) {
-    return "postgresql";
+async function deleteOne(table, where) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-  if (url.startsWith("mysql://")) {
-    return "mysql";
-  }
-  if (url.startsWith("sqlite://") || url.includes(".db") || url.includes(".sqlite")) {
-    return "sqlite";
+  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+  if (!whereClause) {
+    throw new Error("deleteOne requires at least one where condition");
   }
-  throw new Error(
-    `Unsupported database URL format: ${url}. Supported: postgresql://, mysql://, sqlite://`
-  );
+  const [result] = await db.delete(table).where(whereClause).returning();
+  return result ?? null;
 }
-function getDrizzleConfig(options = {}) {
-  const databaseUrl = options.databaseUrl ?? process.env.DATABASE_URL;
-  if (!databaseUrl) {
-    throw new Error(
-      "DATABASE_URL is required. Set it in .env or pass it to getDrizzleConfig()"
-    );
+async function deleteMany(table, where) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-  const dialect = options.dialect ?? detectDialect(databaseUrl);
-  const schema = options.schema ?? "./src/server/entities/*.ts";
-  const out = options.out ?? "./drizzle/migrations";
-  return {
-    schema,
-    out,
-    dialect,
-    dbCredentials: getDbCredentials(dialect, databaseUrl)
-  };
-}
-function getDbCredentials(dialect, url) {
-  switch (dialect) {
-    case "postgresql":
-    case "mysql":
-      return { url };
-    case "sqlite":
-      const dbPath = url.replace("sqlite://", "").replace("sqlite:", "");
-      return { url: dbPath };
-    default:
-      throw new Error(`Unsupported dialect: ${dialect}`);
+  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 db.delete(table).where(whereClause).returning();
+  return results;
 }
-function generateDrizzleConfigFile(options = {}) {
-  const config2 = getDrizzleConfig(options);
-  return `import { defineConfig } from 'drizzle-kit';
-
-export default defineConfig({
-    schema: '${config2.schema}',
-    out: '${config2.out}',
-    dialect: '${config2.dialect}',
-    dbCredentials: ${JSON.stringify(config2.dbCredentials, null, 4)},
-});
-`;
-}
-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;
+async function count(table, where) {
+  const db = getDatabase("read");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
+  }
+  let query = db.select().from(table);
+  if (where) {
+    const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+    if (whereClause) {
+      query = query.where(whereClause);
+    }
   }
-  return {
-    createdAt: timestamp("created_at", { withTimezone: true, mode: "date" }).defaultNow().notNull(),
-    updatedAt: updatedAtColumn
-  };
-}
-function foreignKey(name, reference, options) {
-  return bigserial(`${name}_id`, { mode: "number" }).notNull().references(reference, { onDelete: options?.onDelete ?? "cascade" });
-}
-function optionalForeignKey(name, reference, options) {
-  return bigserial(`${name}_id`, { mode: "number" }).references(reference, { onDelete: options?.onDelete ?? "set null" });
+  const results = await query;
+  return results.length;
 }
 
-export { QueryBuilder, Repository, RepositoryScope, Transactional, WrappedDb, checkConnection, clearRepositoryCache, closeDatabase, createDatabaseConnection, createDatabaseFromEnv, db, detectDialect, foreignKey, fromPostgresError, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDb, getDrizzleConfig, getRawDb, getRepository, getRepositoryCacheSize, getScopedCacheSize, getScopedRepository, getTableName, getTransaction, id, initDatabase, isInRepositoryScope, optionalForeignKey, runWithTransaction, setDatabase, timestamps, withRepositoryScope };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map