@spfn/core 0.1.0-alpha.21 → 0.1.0-alpha.23

package/dist/db/index.js

@@ -1,9 +1,9 @@
-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 { config } from 'dotenv';
 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';
@@ -12,7 +12,7 @@ import { bigserial, timestamp } from 'drizzle-orm/pg-core';
 // src/db/manager/factory.ts
 var PinoAdapter = class _PinoAdapter {
   logger;
-  constructor(config2) {
+  constructor(config) {
     const isProduction = process.env.NODE_ENV === "production";
     const isDevelopment = process.env.NODE_ENV === "development";
     const fileLoggingEnabled = process.env.LOGGER_FILE_ENABLED === "true";
@@ -45,11 +45,11 @@ var PinoAdapter = class _PinoAdapter {
       });
     }
     this.logger = pino({
-      level: config2.level,
+      level: config.level,
       // Transport 설정 (targets가 있으면 사용, 없으면 기본 stdout)
       transport: targets.length > 0 ? { targets } : void 0,
       // 기본 필드
-      base: config2.module ? { module: config2.module } : void 0
+      base: config.module ? { module: config.module } : void 0
     });
   }
   child(module) {
@@ -92,9 +92,9 @@ var PinoAdapter = class _PinoAdapter {
 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
@@ -310,10 +310,10 @@ var ConsoleTransport = class {
   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) {
@@ -337,10 +337,10 @@ var FileTransport = class {
   logDir;
   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;
     if (!existsSync(this.logDir)) {
       mkdirSync(this.logDir, { recursive: true });
     }
@@ -472,10 +472,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()
     });
   }
@@ -790,6 +790,178 @@ function getRetryConfig() {
   };
 }
 
+// src/env/config.ts
+var ENV_FILE_PRIORITY = [
+  ".env",
+  // Base configuration (lowest priority)
+  ".env.{NODE_ENV}",
+  // Environment-specific
+  ".env.local",
+  // Local overrides
+  ".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 = [];
+  for (const pattern of ENV_FILE_PRIORITY) {
+    const fileName = pattern.replace("{NODE_ENV}", nodeEnv);
+    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 || "development",
+    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);
+    } 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;
+    }
+  }
+  environmentLoaded = true;
+  cachedLoadResult = result;
+  return result;
+}
+
 // src/db/manager/factory.ts
 var dbLogger2 = logger.child("database");
 function hasDatabaseConfig() {
@@ -797,9 +969,24 @@ function hasDatabaseConfig() {
 }
 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 {
@@ -880,7 +1067,7 @@ 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 });
   }
 }
 
@@ -903,28 +1090,28 @@ function setDatabase(write, read) {
   readInstance = read ?? write;
 }
 function getHealthCheckConfig(options) {
-  const parseBoolean = (value, defaultValue) => {
+  const parseBoolean2 = (value, defaultValue) => {
     if (value === void 0) return defaultValue;
     return value.toLowerCase() === "true";
   };
   return {
-    enabled: options?.enabled ?? parseBoolean(process.env.DB_HEALTH_CHECK_ENABLED, true),
+    enabled: options?.enabled ?? parseBoolean2(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),
+    reconnect: options?.reconnect ?? parseBoolean2(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) => {
+  const parseBoolean2 = (value, defaultValue) => {
     if (value === void 0) return defaultValue;
     return value.toLowerCase() === "true";
   };
   return {
-    enabled: options?.enabled ?? parseBoolean(process.env.DB_MONITORING_ENABLED, isDevelopment),
+    enabled: options?.enabled ?? parseBoolean2(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)
+    logQueries: options?.logQueries ?? parseBoolean2(process.env.DB_MONITORING_LOG_QUERIES, false)
   };
 }
 async function initDatabase(options) {
@@ -962,7 +1149,7 @@ async function initDatabase(options) {
       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 };
+      throw new Error(`Database connection test failed: ${message}`, { cause: error });
     }
   } else {
     dbLogger3.warn("No database configuration found");
@@ -1010,14 +1197,14 @@ function getDatabaseInfo() {
     isReplica: !!(readInstance && readInstance !== writeInstance)
   };
 }
-function startHealthCheck(config2) {
+function startHealthCheck(config) {
   if (healthCheckInterval) {
     dbLogger3.debug("Health check already running");
     return;
   }
   dbLogger3.info("Starting database health check", {
-    interval: `${config2.interval}ms`,
-    reconnect: config2.reconnect
+    interval: `${config.interval}ms`,
+    reconnect: config.reconnect
   });
   healthCheckInterval = setInterval(async () => {
     try {
@@ -1033,22 +1220,22 @@ function startHealthCheck(config2) {
     } 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);
+      if (config.reconnect) {
+        await attemptReconnection(config);
       }
     }
-  }, config2.interval);
+  }, config.interval);
 }
-async function attemptReconnection(config2) {
+async function attemptReconnection(config) {
   dbLogger3.warn("Attempting database reconnection", {
-    maxRetries: config2.maxRetries,
-    retryInterval: `${config2.retryInterval}ms`
+    maxRetries: config.maxRetries,
+    retryInterval: `${config.retryInterval}ms`
   });
-  for (let attempt = 1; attempt <= config2.maxRetries; attempt++) {
+  for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
     try {
-      dbLogger3.debug(`Reconnection attempt ${attempt}/${config2.maxRetries}`);
+      dbLogger3.debug(`Reconnection attempt ${attempt}/${config.maxRetries}`);
       await closeDatabase();
-      await new Promise((resolve) => setTimeout(resolve, config2.retryInterval));
+      await new Promise((resolve) => setTimeout(resolve, config.retryInterval));
       const result = await createDatabaseFromEnv();
       if (result.write) {
         await result.write.execute("SELECT 1");
@@ -1064,9 +1251,9 @@ async function attemptReconnection(config2) {
       dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
         error: message,
         attempt,
-        maxRetries: config2.maxRetries
+        maxRetries: config.maxRetries
       });
-      if (attempt === config2.maxRetries) {
+      if (attempt === config.maxRetries) {
         dbLogger3.error("Max reconnection attempts reached, giving up");
       }
     }
@@ -1569,21 +1756,21 @@ var Repository = class {
    * @returns Result of the operation
    */
   async executeWithMonitoring(operation, fn) {
-    const config2 = getDatabaseMonitoringConfig();
-    if (!config2?.enabled) {
+    const config = getDatabaseMonitoringConfig();
+    if (!config?.enabled) {
       return fn();
     }
     const startTime = performance.now();
     try {
       const result = await fn();
       const duration = performance.now() - startTime;
-      if (duration >= config2.slowThreshold) {
+      if (duration >= config.slowThreshold) {
         const dbLogger4 = logger.child("database");
         const logData = {
           operation,
           table: this.table._.name,
           duration: `${duration.toFixed(2)}ms`,
-          threshold: `${config2.slowThreshold}ms`
+          threshold: `${config.slowThreshold}ms`
         };
         dbLogger4.warn("Slow query detected", logData);
       }
@@ -2063,14 +2250,14 @@ function getDbCredentials(dialect, url) {
   }
 }
 function generateDrizzleConfigFile(options = {}) {
-  const config2 = getDrizzleConfig(options);
+  const config = 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)},
+    schema: '${config.schema}',
+    out: '${config.out}',
+    dialect: '${config.dialect}',
+    dbCredentials: ${JSON.stringify(config.dbCredentials, null, 4)},
 });
 `;
 }