@spfn/core 0.1.0-alpha.1

package/dist/db/index.js

@@ -0,0 +1,2099 @@
+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 { AsyncLocalStorage } from 'async_hooks';
+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';
+
+// src/db/manager/factory.ts
+var PinoAdapter = class _PinoAdapter {
+  logger;
+  constructor(config2) {
+    const isProduction = process.env.NODE_ENV === "production";
+    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"
+        }
+      });
+    }
+    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
+        }
+      });
+    }
+    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 });
+    childLogger.logger = this.logger.child({ module });
+    return childLogger;
+  }
+  debug(message, context) {
+    this.logger.debug(context || {}, message);
+  }
+  info(message, context) {
+    this.logger.info(context || {}, message);
+  }
+  warn(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.warn({ err: errorOrContext, ...context }, message);
+    } else {
+      this.logger.warn(errorOrContext || {}, message);
+    }
+  }
+  error(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.error({ err: errorOrContext, ...context }, message);
+    } else {
+      this.logger.error(errorOrContext || {}, message);
+    }
+  }
+  fatal(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.fatal({ err: errorOrContext, ...context }, message);
+    } else {
+      this.logger.fatal(errorOrContext || {}, message);
+    }
+  }
+  async close() {
+  }
+};
+
+// src/logger/logger.ts
+var Logger = class _Logger {
+  config;
+  module;
+  constructor(config2) {
+    this.config = config2;
+    this.module = config2.module;
+  }
+  /**
+   * Get current log level
+   */
+  get level() {
+    return this.config.level;
+  }
+  /**
+   * Create child logger (per module)
+   */
+  child(module) {
+    return new _Logger({
+      ...this.config,
+      module
+    });
+  }
+  /**
+   * Debug log
+   */
+  debug(message, context) {
+    this.log("debug", message, void 0, context);
+  }
+  /**
+   * Info log
+   */
+  info(message, context) {
+    this.log("info", message, void 0, context);
+  }
+  warn(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.log("warn", message, errorOrContext, context);
+    } else {
+      this.log("warn", message, void 0, errorOrContext);
+    }
+  }
+  error(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.log("error", message, errorOrContext, context);
+    } else {
+      this.log("error", message, void 0, errorOrContext);
+    }
+  }
+  fatal(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.log("fatal", message, errorOrContext, context);
+    } else {
+      this.log("fatal", message, void 0, errorOrContext);
+    }
+  }
+  /**
+   * Log processing (internal)
+   */
+  log(level, message, error, context) {
+    const metadata = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      message,
+      module: this.module,
+      error,
+      context
+    };
+    this.processTransports(metadata);
+  }
+  /**
+   * Process Transports
+   */
+  processTransports(metadata) {
+    const promises = this.config.transports.filter((transport) => transport.enabled).map((transport) => this.safeTransportLog(transport, metadata));
+    Promise.all(promises).catch((error) => {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[Logger] Transport error: ${errorMessage}
+`);
+    });
+  }
+  /**
+   * Transport log (error-safe)
+   */
+  async safeTransportLog(transport, metadata) {
+    try {
+      await transport.log(metadata);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[Logger] Transport "${transport.name}" failed: ${errorMessage}
+`);
+    }
+  }
+  /**
+   * Close all Transports
+   */
+  async close() {
+    const closePromises = this.config.transports.filter((transport) => transport.close).map((transport) => transport.close());
+    await Promise.all(closePromises);
+  }
+};
+
+// src/logger/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;
+  }
+  async log(metadata) {
+    if (!this.enabled) {
+      return;
+    }
+    if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
+      return;
+    }
+    const message = formatConsole(metadata, this.colorize);
+    if (metadata.level === "warn" || metadata.level === "error" || metadata.level === "fatal") {
+      console.error(message);
+    } else {
+      console.log(message);
+    }
+  }
+};
+var FileTransport = class {
+  name = "file";
+  level;
+  enabled;
+  logDir;
+  currentStream = null;
+  currentFilename = null;
+  constructor(config2) {
+    this.level = config2.level;
+    this.enabled = config2.enabled;
+    this.logDir = config2.logDir;
+    if (!existsSync(this.logDir)) {
+      mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+  async log(metadata) {
+    if (!this.enabled) {
+      return;
+    }
+    if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
+      return;
+    }
+    const message = formatJSON(metadata);
+    const filename = this.getLogFilename(metadata.timestamp);
+    if (this.currentFilename !== filename) {
+      await this.rotateStream(filename);
+    }
+    if (this.currentStream) {
+      return new Promise((resolve, reject) => {
+        this.currentStream.write(message + "\n", "utf-8", (error) => {
+          if (error) {
+            process.stderr.write(`[FileTransport] Failed to write log: ${error.message}
+`);
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+      });
+    }
+  }
+  /**
+   * 스트림 교체 (날짜 변경 시)
+   */
+  async rotateStream(filename) {
+    if (this.currentStream) {
+      await this.closeStream();
+    }
+    const filepath = join(this.logDir, filename);
+    this.currentStream = createWriteStream(filepath, {
+      flags: "a",
+      // append mode
+      encoding: "utf-8"
+    });
+    this.currentFilename = filename;
+    this.currentStream.on("error", (error) => {
+      process.stderr.write(`[FileTransport] Stream error: ${error.message}
+`);
+      this.currentStream = null;
+      this.currentFilename = null;
+    });
+  }
+  /**
+   * 현재 스트림 닫기
+   */
+  async closeStream() {
+    if (!this.currentStream) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      this.currentStream.end((error) => {
+        if (error) {
+          reject(error);
+        } else {
+          this.currentStream = null;
+          this.currentFilename = null;
+          resolve();
+        }
+      });
+    });
+  }
+  /**
+   * 날짜별 로그 파일명 생성
+   */
+  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();
+  }
+};
+
+// src/logger/config.ts
+function getDefaultLogLevel() {
+  const isProduction = process.env.NODE_ENV === "production";
+  const isDevelopment = process.env.NODE_ENV === "development";
+  if (isDevelopment) {
+    return "debug";
+  }
+  if (isProduction) {
+    return "info";
+  }
+  return "warn";
+}
+function getConsoleConfig() {
+  const isProduction = process.env.NODE_ENV === "production";
+  return {
+    level: "debug",
+    enabled: true,
+    colorize: !isProduction
+    // Dev: colored output, Production: plain text
+  };
+}
+function getFileConfig() {
+  const isProduction = process.env.NODE_ENV === "production";
+  return {
+    level: "info",
+    enabled: isProduction,
+    // File logging in production only
+    logDir: process.env.LOG_DIR || "./logs",
+    maxFileSize: 10 * 1024 * 1024,
+    // 10MB
+    maxFiles: 10
+  };
+}
+
+// src/logger/adapters/custom.ts
+function initializeTransports() {
+  const transports = [];
+  const consoleConfig = getConsoleConfig();
+  transports.push(new ConsoleTransport(consoleConfig));
+  const fileConfig = getFileConfig();
+  if (fileConfig.enabled) {
+    transports.push(new FileTransport(fileConfig));
+  }
+  return transports;
+}
+var CustomAdapter = class _CustomAdapter {
+  logger;
+  constructor(config2) {
+    this.logger = new Logger({
+      level: config2.level,
+      module: config2.module,
+      transports: initializeTransports()
+    });
+  }
+  child(module) {
+    const adapter = new _CustomAdapter({ level: this.logger.level, module });
+    adapter.logger = this.logger.child(module);
+    return adapter;
+  }
+  debug(message, context) {
+    this.logger.debug(message, context);
+  }
+  info(message, context) {
+    this.logger.info(message, context);
+  }
+  warn(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.warn(message, errorOrContext, context);
+    } else {
+      this.logger.warn(message, errorOrContext);
+    }
+  }
+  error(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.error(message, errorOrContext, context);
+    } else {
+      this.logger.error(message, errorOrContext);
+    }
+  }
+  fatal(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.fatal(message, errorOrContext, context);
+    } else {
+      this.logger.fatal(message, errorOrContext);
+    }
+  }
+  async close() {
+    await this.logger.close();
+  }
+};
+
+// src/logger/adapter-factory.ts
+function createAdapter(type) {
+  const level = getDefaultLogLevel();
+  switch (type) {
+    case "pino":
+      return new PinoAdapter({ level });
+    case "custom":
+      return new CustomAdapter({ level });
+    default:
+      return new PinoAdapter({ level });
+  }
+}
+function getAdapterType() {
+  const adapterEnv = process.env.LOGGER_ADAPTER;
+  if (adapterEnv === "custom" || adapterEnv === "pino") {
+    return adapterEnv;
+  }
+  return "pino";
+}
+var logger = createAdapter(getAdapterType());
+
+// src/errors/database-errors.ts
+var DatabaseError = class extends Error {
+  statusCode;
+  details;
+  timestamp;
+  constructor(message, statusCode = 500, details) {
+    super(message);
+    this.name = "DatabaseError";
+    this.statusCode = statusCode;
+    this.details = details;
+    this.timestamp = /* @__PURE__ */ new Date();
+    Error.captureStackTrace(this, this.constructor);
+  }
+  /**
+   * Serialize error for API response
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      details: this.details,
+      timestamp: this.timestamp.toISOString()
+    };
+  }
+};
+var ConnectionError = class extends DatabaseError {
+  constructor(message, details) {
+    super(message, 503, details);
+    this.name = "ConnectionError";
+  }
+};
+var QueryError = class extends DatabaseError {
+  constructor(message, statusCode = 500, details) {
+    super(message, statusCode, details);
+    this.name = "QueryError";
+  }
+};
+var ValidationError = class extends QueryError {
+  constructor(message, details) {
+    super(message, 400, details);
+    this.name = "ValidationError";
+  }
+};
+var TransactionError = class extends DatabaseError {
+  constructor(message, statusCode = 500, details) {
+    super(message, statusCode, details);
+    this.name = "TransactionError";
+  }
+};
+var DeadlockError = class extends TransactionError {
+  constructor(message, details) {
+    super(message, 409, details);
+    this.name = "DeadlockError";
+  }
+};
+var DuplicateEntryError = class extends QueryError {
+  constructor(field, value) {
+    super(`${field} '${value}' already exists`, 409, { field, value });
+    this.name = "DuplicateEntryError";
+  }
+};
+
+// src/db/postgres-errors.ts
+function parseUniqueViolation(message) {
+  const patterns = [
+    // Standard format: Key (field)=(value)
+    /Key \(([^)]+)\)=\(([^)]+)\)/i,
+    // With quotes: Key ("field")=('value')
+    /Key \(["']?([^)"']+)["']?\)=\(["']?([^)"']+)["']?\)/i,
+    // Alternative format
+    /Key `([^`]+)`=`([^`]+)`/i
+  ];
+  for (const pattern of patterns) {
+    const match = message.match(pattern);
+    if (match) {
+      const field = match[1].trim().replace(/["'`]/g, "");
+      const value = match[2].trim().replace(/["'`]/g, "");
+      return { field, value };
+    }
+  }
+  return null;
+}
+function fromPostgresError(error) {
+  const code = error?.code;
+  const message = error?.message || "Database error occurred";
+  switch (code) {
+    // Class 08 — Connection Exception
+    case "08000":
+    // connection_exception
+    case "08001":
+    // sqlclient_unable_to_establish_sqlconnection
+    case "08003":
+    // connection_does_not_exist
+    case "08004":
+    // sqlserver_rejected_establishment_of_sqlconnection
+    case "08006":
+    // connection_failure
+    case "08007":
+    // transaction_resolution_unknown
+    case "08P01":
+      return new ConnectionError(message, { code });
+    // Class 23 — Integrity Constraint Violation
+    case "23000":
+    // integrity_constraint_violation
+    case "23001":
+      return new ValidationError(message, { code, constraint: "integrity" });
+    case "23502":
+      return new ValidationError(message, { code, constraint: "not_null" });
+    case "23503":
+      return new ValidationError(message, { code, constraint: "foreign_key" });
+    case "23505":
+      const parsed = parseUniqueViolation(message);
+      if (parsed) {
+        return new DuplicateEntryError(parsed.field, parsed.value);
+      }
+      return new DuplicateEntryError("field", "value");
+    case "23514":
+      return new ValidationError(message, { code, constraint: "check" });
+    // Class 40 — Transaction Rollback
+    case "40000":
+    // transaction_rollback
+    case "40001":
+    // serialization_failure
+    case "40002":
+    // transaction_integrity_constraint_violation
+    case "40003":
+      return new TransactionError(message, 500, { code });
+    case "40P01":
+      return new DeadlockError(message, { code });
+    // Class 42 — Syntax Error or Access Rule Violation
+    case "42000":
+    // syntax_error_or_access_rule_violation
+    case "42601":
+    // syntax_error
+    case "42501":
+    // insufficient_privilege
+    case "42602":
+    // invalid_name
+    case "42622":
+    // name_too_long
+    case "42701":
+    // duplicate_column
+    case "42702":
+    // ambiguous_column
+    case "42703":
+    // undefined_column
+    case "42704":
+    // undefined_object
+    case "42P01":
+    // undefined_table
+    case "42P02":
+      return new QueryError(message, 400, { code });
+    // Class 53 — Insufficient Resources
+    case "53000":
+    // insufficient_resources
+    case "53100":
+    // disk_full
+    case "53200":
+    // out_of_memory
+    case "53300":
+      return new ConnectionError(message, { code });
+    // Class 57 — Operator Intervention
+    case "57000":
+    // operator_intervention
+    case "57014":
+    // query_canceled
+    case "57P01":
+    // admin_shutdown
+    case "57P02":
+    // crash_shutdown
+    case "57P03":
+      return new ConnectionError(message, { code });
+    // Default: Unknown error
+    default:
+      return new QueryError(message, 500, { code });
+  }
+}
+
+// src/db/manager/connection.ts
+var dbLogger = logger.child("database");
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function createDatabaseConnection(connectionString, poolConfig, retryConfig) {
+  let lastError;
+  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+    try {
+      const client = postgres(connectionString, {
+        max: poolConfig.max,
+        idle_timeout: poolConfig.idleTimeout
+      });
+      await client`SELECT 1 as test`;
+      if (attempt > 0) {
+        dbLogger.info(`Database connected successfully after ${attempt} retries`);
+      } else {
+        dbLogger.info("Database connected successfully");
+      }
+      return client;
+    } catch (error) {
+      lastError = fromPostgresError(error);
+      if (attempt < retryConfig.maxRetries) {
+        const delayMs = Math.min(
+          retryConfig.initialDelay * Math.pow(retryConfig.factor, attempt),
+          retryConfig.maxDelay
+        );
+        dbLogger.warn(
+          `Connection failed (attempt ${attempt + 1}/${retryConfig.maxRetries + 1}), retrying in ${delayMs}ms...`,
+          lastError,
+          {
+            attempt: attempt + 1,
+            maxRetries: retryConfig.maxRetries + 1,
+            delayMs
+          }
+        );
+        await delay(delayMs);
+      }
+    }
+  }
+  const errorMessage = `Failed to connect to database after ${retryConfig.maxRetries + 1} attempts: ${lastError?.message || "Unknown error"}`;
+  throw new ConnectionError(errorMessage);
+}
+async function checkConnection(client) {
+  try {
+    await client`SELECT 1 as health_check`;
+    return true;
+  } catch (error) {
+    dbLogger.error("Database health check failed", error);
+    return false;
+  }
+}
+
+// src/db/manager/config.ts
+function getPoolConfig(options) {
+  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 };
+}
+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)
+  };
+}
+
+// src/db/manager/factory.ts
+var dbLogger2 = logger.child("database");
+function hasDatabaseConfig() {
+  return !!(process.env.DATABASE_URL || process.env.DATABASE_WRITE_URL || process.env.DATABASE_READ_URL);
+}
+async function createDatabaseFromEnv(options) {
+  if (!hasDatabaseConfig()) {
+    config({ path: ".env.local" });
+  }
+  if (!hasDatabaseConfig()) {
+    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
+      };
+    }
+    return { write: void 0, read: void 0 };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    dbLogger2.error("Failed to create database connection", {
+      error: message,
+      stage: "initialization",
+      hasWriteUrl: !!process.env.DATABASE_WRITE_URL,
+      hasReadUrl: !!process.env.DATABASE_READ_URL,
+      hasUrl: !!process.env.DATABASE_URL,
+      hasReplicaUrl: !!process.env.DATABASE_REPLICA_URL
+    });
+    return { write: void 0, read: void 0 };
+  }
+}
+
+// src/db/manager/manager.ts
+var dbLogger3 = logger.child("database");
+var writeInstance;
+var readInstance;
+var writeClient;
+var readClient;
+var healthCheckInterval;
+var monitoringConfig;
+function getDatabase(type) {
+  if (type === "read") {
+    return readInstance ?? writeInstance;
+  }
+  return writeInstance;
+}
+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)
+  };
+}
+async function initDatabase(options) {
+  if (writeInstance) {
+    dbLogger3.debug("Database already initialized");
+    return { write: writeInstance, read: readInstance };
+  }
+  const result = await createDatabaseFromEnv(options);
+  if (result.write) {
+    try {
+      await result.write.execute("SELECT 1");
+      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;
+      const hasReplica = result.read && result.read !== result.write;
+      dbLogger3.info(
+        hasReplica ? "Database connected (Primary + Replica)" : "Database connected"
+      );
+      const healthCheckConfig = getHealthCheckConfig(options?.healthCheck);
+      if (healthCheckConfig.enabled) {
+        startHealthCheck(healthCheckConfig);
+      }
+      monitoringConfig = getMonitoringConfig(options?.monitoring);
+      if (monitoringConfig.enabled) {
+        dbLogger3.info("Database query monitoring enabled", {
+          slowThreshold: `${monitoringConfig.slowThreshold}ms`,
+          logQueries: monitoringConfig.logQueries
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      dbLogger3.error("Database connection failed", { error: message });
+      await closeDatabase();
+      return { write: void 0, read: void 0 };
+    }
+  } else {
+    dbLogger3.warn("No database configuration found");
+    dbLogger3.warn("Set DATABASE_URL environment variable to enable database");
+  }
+  return { write: writeInstance, read: readInstance };
+}
+async function closeDatabase() {
+  if (!writeInstance && !readInstance) {
+    dbLogger3.debug("No database connections to close");
+    return;
+  }
+  stopHealthCheck();
+  try {
+    const closePromises = [];
+    if (writeClient) {
+      dbLogger3.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))
+      );
+    }
+    if (readClient && readClient !== writeClient) {
+      dbLogger3.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))
+      );
+    }
+    await Promise.all(closePromises);
+    dbLogger3.info("All database connections closed");
+  } catch (error) {
+    dbLogger3.error("Error during database cleanup", error);
+    throw error;
+  } finally {
+    writeInstance = void 0;
+    readInstance = void 0;
+    writeClient = void 0;
+    readClient = void 0;
+    monitoringConfig = void 0;
+  }
+}
+function getDatabaseInfo() {
+  return {
+    hasWrite: !!writeInstance,
+    hasRead: !!readInstance,
+    isReplica: !!(readInstance && readInstance !== writeInstance)
+  };
+}
+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");
+      }
+      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);
+      }
+    }
+  }, config2.interval);
+}
+async function attemptReconnection(config2) {
+  dbLogger3.warn("Attempting database reconnection", {
+    maxRetries: config2.maxRetries,
+    retryInterval: `${config2.retryInterval}ms`
+  });
+  for (let attempt = 1; attempt <= config2.maxRetries; attempt++) {
+    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;
+      }
+    } 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");
+      }
+    }
+  }
+}
+function stopHealthCheck() {
+  if (healthCheckInterval) {
+    clearInterval(healthCheckInterval);
+    healthCheckInterval = void 0;
+    dbLogger3.info("Database health check stopped");
+  }
+}
+function getDatabaseMonitoringConfig() {
+  return monitoringConfig;
+}
+
+// src/db/manager/instance.ts
+var db = new Proxy({}, {
+  get(_target, prop) {
+    const instance = getDatabase("write");
+    if (!instance) {
+      throw new Error(
+        "Database not initialized. Set DATABASE_URL environment variable or call initDatabase() first."
+      );
+    }
+    return instance[prop];
+  }
+});
+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."
+    );
+  }
+  return instance;
+}
+var asyncContext = new AsyncLocalStorage();
+function getTransaction() {
+  const context = asyncContext.getStore();
+  return context?.tx ?? null;
+}
+function runWithTransaction(tx, callback) {
+  return asyncContext.run({ tx }, callback);
+}
+function Transactional(options = {}) {
+  const defaultTimeout = parseInt(process.env.TRANSACTION_TIMEOUT || "30000", 10);
+  const {
+    slowThreshold = 1e3,
+    enableLogging = true,
+    timeout = defaultTimeout
+  } = options;
+  const txLogger = logger.child("transaction");
+  return createMiddleware(async (c, next) => {
+    const txId = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const startTime = Date.now();
+    const route = `${c.req.method} ${c.req.path}`;
+    if (enableLogging) {
+      txLogger.debug("Transaction started", { txId, route });
+    }
+    try {
+      const transactionPromise = db.transaction(async (tx) => {
+        await runWithTransaction(tx, async () => {
+          await next();
+          const contextWithError = c;
+          if (contextWithError.error) {
+            throw contextWithError.error;
+          }
+        });
+      });
+      if (timeout > 0) {
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(
+              new TransactionError(
+                `Transaction timeout after ${timeout}ms`,
+                500,
+                {
+                  txId,
+                  route,
+                  timeout: `${timeout}ms`
+                }
+              )
+            );
+          }, timeout);
+        });
+        await Promise.race([transactionPromise, timeoutPromise]);
+      } else {
+        await transactionPromise;
+      }
+      const duration = Date.now() - startTime;
+      if (enableLogging) {
+        if (duration >= slowThreshold) {
+          txLogger.warn("Slow transaction committed", {
+            txId,
+            route,
+            duration: `${duration}ms`,
+            threshold: `${slowThreshold}ms`
+          });
+        } else {
+          txLogger.debug("Transaction committed", {
+            txId,
+            route,
+            duration: `${duration}ms`
+          });
+        }
+      }
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const customError = error instanceof TransactionError ? error : fromPostgresError(error);
+      if (enableLogging) {
+        txLogger.error("Transaction rolled back", {
+          txId,
+          route,
+          duration: `${duration}ms`,
+          error: customError.message,
+          errorType: customError.name
+        });
+      }
+      throw customError;
+    }
+  });
+}
+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
+  };
+}
+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;
+}
+
+// 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+    }
+  }
+  /**
+   * 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;
+    });
+  }
+  /**
+   * 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;
+    });
+  }
+  /**
+   * 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;
+    });
+  }
+  /**
+   * 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;
+}
+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);
+  }
+  return repo;
+}
+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;
+  }
+  const name = table[Symbol.for("drizzle:Name")] || table.constructor.name;
+  tableNameCache.set(table, name);
+  return name;
+}
+
+// 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;
+  }
+  get $with() {
+    return this.db.$with.bind(this.db);
+  }
+  /**
+   * Raw Drizzle DB 접근 (필요시)
+   */
+  get raw() {
+    return this.db;
+  }
+};
+
+// 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."
+    );
+  }
+  return new WrappedDb(rawDb);
+}
+
+// src/db/manager/config-generator.ts
+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://`
+  );
+}
+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 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}`);
+  }
+}
+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;
+  }
+  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" });
+}
+
+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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map