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

package/dist/server/index.js

@@ -96,7 +96,7 @@ var init_pino = __esm({
   "src/logger/adapters/pino.ts"() {
     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";
@@ -129,11 +129,11 @@ var init_pino = __esm({
           });
         }
         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) {
@@ -181,9 +181,9 @@ var init_logger = __esm({
     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
@@ -416,10 +416,10 @@ var init_console = __esm({
       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) {
@@ -450,10 +450,10 @@ var init_file = __esm({
       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 });
         }
@@ -598,10 +598,10 @@ var init_custom = __esm({
     init_config();
     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()
         });
       }
@@ -1096,14 +1096,225 @@ var init_config2 = __esm({
   "src/db/manager/config.ts"() {
   }
 });
+
+// src/env/config.ts
+var ENV_FILE_PRIORITY, TEST_ONLY_FILES;
+var init_config3 = __esm({
+  "src/env/config.ts"() {
+    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)
+    ];
+    TEST_ONLY_FILES = [
+      ".env.test",
+      ".env.test.local"
+    ];
+  }
+});
+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;
+}
+var envLogger, environmentLoaded, cachedLoadResult;
+var init_loader = __esm({
+  "src/env/loader.ts"() {
+    init_logger2();
+    init_config3();
+    envLogger = logger.child("environment");
+    environmentLoaded = false;
+  }
+});
+
+// src/env/validator.ts
+var init_validator = __esm({
+  "src/env/validator.ts"() {
+  }
+});
+
+// src/env/index.ts
+var init_env = __esm({
+  "src/env/index.ts"() {
+    init_loader();
+    init_config3();
+    init_validator();
+  }
+});
 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" });
+    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 {
@@ -1193,6 +1404,7 @@ var init_factory = __esm({
     init_connection();
     init_config2();
     init_logger2();
+    init_env();
     dbLogger2 = logger.child("database");
   }
 });
@@ -1209,28 +1421,28 @@ function setDatabase(write, read) {
   readInstance2 = 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) {
@@ -1316,14 +1528,14 @@ function getDatabaseInfo() {
     isReplica: !!(readInstance2 && readInstance2 !== writeInstance2)
   };
 }
-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 {
@@ -1339,22 +1551,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");
@@ -1370,9 +1582,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");
       }
     }
@@ -1930,21 +2142,21 @@ var init_repository = __esm({
        * @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);
           }
@@ -2480,14 +2692,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)},
 });
 `;
 }
@@ -2907,8 +3119,8 @@ function generateRequestId() {
   const randomPart = randomBytes(6).toString("hex");
   return `req_${timestamp2}_${randomPart}`;
 }
-function RequestLogger(config2) {
-  const cfg = { ...DEFAULT_CONFIG, ...config2 };
+function RequestLogger(config) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
   const apiLogger = logger.child("api");
   return async (c, next) => {
     const path = new URL(c.req.url).pathname;
@@ -2972,7 +3184,7 @@ init_cache();
 init_db();
 init_logger2();
 var serverLogger = logger.child("server");
-async function createServer(config2) {
+async function createServer(config) {
   const cwd = process.cwd();
   const appPath = join(cwd, "src", "server", "app.ts");
   const appJsPath = join(cwd, "src", "server", "app.js");
@@ -2983,23 +3195,23 @@ async function createServer(config2) {
       throw new Error("app.ts must export a default function that returns a Hono app");
     }
     const app2 = await appFactory();
-    const debug2 = config2?.debug ?? process.env.NODE_ENV === "development";
-    await loadRoutes(app2, { routesDir: config2?.routesPath, debug: debug2 });
+    const debug2 = config?.debug ?? process.env.NODE_ENV === "development";
+    await loadRoutes(app2, { routesDir: config?.routesPath, debug: debug2 });
     return app2;
   }
   const app = new Hono();
-  const middlewareConfig = config2?.middleware ?? {};
+  const middlewareConfig = config?.middleware ?? {};
   const enableLogger = middlewareConfig.logger !== false;
   const enableCors = middlewareConfig.cors !== false;
   const enableErrorHandler = middlewareConfig.errorHandler !== false;
   if (enableLogger) {
     app.use("*", RequestLogger());
   }
-  if (enableCors && config2?.cors !== false) {
-    app.use("*", cors(config2?.cors));
+  if (enableCors && config?.cors !== false) {
+    app.use("*", cors(config?.cors));
   }
-  config2?.use?.forEach((mw) => app.use("*", mw));
-  const healthCheckConfig = config2?.healthCheck ?? {};
+  config?.use?.forEach((mw) => app.use("*", mw));
+  const healthCheckConfig = config?.healthCheck ?? {};
   const healthCheckEnabled = healthCheckConfig.enabled !== false;
   const healthCheckPath = healthCheckConfig.path ?? "/health";
   const healthCheckDetailed = healthCheckConfig.detailed ?? process.env.NODE_ENV === "development";
@@ -3041,20 +3253,20 @@ async function createServer(config2) {
     });
     serverLogger.debug(`Health check endpoint enabled at ${healthCheckPath}`);
   }
-  await config2?.beforeRoutes?.(app);
-  const debug = config2?.debug ?? process.env.NODE_ENV === "development";
+  await config?.beforeRoutes?.(app);
+  const debug = config?.debug ?? process.env.NODE_ENV === "development";
   await loadRoutes(app, {
-    routesDir: config2?.routesPath,
+    routesDir: config?.routesPath,
     debug,
-    middlewares: config2?.middlewares
+    middlewares: config?.middlewares
   });
-  await config2?.afterRoutes?.(app);
+  await config?.afterRoutes?.(app);
   if (enableErrorHandler) {
     app.onError(ErrorHandler());
   }
   return app;
 }
-async function startServer(config2) {
+async function startServer(config) {
   const cwd = process.cwd();
   const configPath = join(cwd, "src", "server", "server.config.ts");
   const configJsPath = join(cwd, "src", "server", "server.config.js");
@@ -3065,9 +3277,9 @@ async function startServer(config2) {
   }
   const finalConfig = {
     ...fileConfig,
-    ...config2,
-    port: config2?.port ?? fileConfig?.port ?? (parseInt(process.env.PORT || "", 10) || 4e3),
-    host: config2?.host ?? fileConfig?.host ?? (process.env.HOST || "localhost")
+    ...config,
+    port: config?.port ?? fileConfig?.port ?? (parseInt(process.env.PORT || "", 10) || 4e3),
+    host: config?.host ?? fileConfig?.host ?? (process.env.HOST || "localhost")
   };
   const { host, port, debug } = finalConfig;
   try {