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

package/dist/server/index.d.ts

@@ -229,13 +229,119 @@ interface ServerConfig {
         detailed?: boolean;
     };
     /**
-     * Hook: Run before routes are loaded
+     * Infrastructure initialization control
+     * Controls automatic initialization of database and Redis
+     * @default Both enabled if credentials exist
      */
-    beforeRoutes?: (app: Hono) => void | Promise<void>;
+    infrastructure?: {
+        /**
+         * Enable/disable automatic database initialization
+         * @default true if DATABASE_URL exists
+         */
+        database?: boolean;
+        /**
+         * Enable/disable automatic Redis initialization
+         * @default true if REDIS_URL exists
+         */
+        redis?: boolean;
+    };
     /**
-     * Hook: Run after routes are loaded
+     * Server lifecycle hooks for custom infrastructure setup and management
+     * Allows initialization of custom services and resources at different stages
      */
-    afterRoutes?: (app: Hono) => void | Promise<void>;
+    lifecycle?: {
+        /**
+         * Hook: Run before infrastructure initialization
+         * Execute before database and Redis are initialized
+         * Use this for pre-initialization setup (logging, monitoring, etc.)
+         *
+         * @param config - The final server configuration
+         * @example
+         * ```typescript
+         * beforeInfrastructure: async (config) => {
+         *   await initMonitoring();
+         *   await setupCustomLogger();
+         * }
+         * ```
+         */
+        beforeInfrastructure?: (config: ServerConfig) => Promise<void>;
+        /**
+         * Hook: Run after infrastructure (DB/Redis) is initialized
+         * Database and Redis instances are available via getDatabase() and getRedis()
+         * Use this for:
+         * - Running migrations
+         * - Seeding initial data
+         * - Initializing services that depend on DB/Redis
+         *
+         * @example
+         * ```typescript
+         * import { getDatabase } from '@spfn/core/db';
+         * import { migrate } from 'drizzle-orm/postgres-js/migrator';
+         *
+         * afterInfrastructure: async () => {
+         *   const db = getDatabase();
+         *   await migrate(db, { migrationsFolder: './drizzle' });
+         *   await seedInitialData(db);
+         * }
+         * ```
+         */
+        afterInfrastructure?: () => Promise<void>;
+        /**
+         * Hook: Run before routes are loaded
+         * Use this to add global middleware or prepare the app before routes
+         *
+         * @param app - The Hono app instance
+         * @example
+         * ```typescript
+         * beforeRoutes: async (app) => {
+         *   app.use('/*', globalMiddleware());
+         * }
+         * ```
+         */
+        beforeRoutes?: (app: Hono) => void | Promise<void>;
+        /**
+         * Hook: Run after routes are loaded
+         * Use this to add fallback handlers or final middleware
+         *
+         * @param app - The Hono app instance
+         * @example
+         * ```typescript
+         * afterRoutes: async (app) => {
+         *   app.notFound((c) => c.json({ error: 'Not Found' }, 404));
+         * }
+         * ```
+         */
+        afterRoutes?: (app: Hono) => void | Promise<void>;
+        /**
+         * Hook: Run after server starts successfully
+         * Server is listening and ready to accept requests
+         * Receives the server instance for runtime access
+         *
+         * @param instance - The server instance with server, app, config, and close()
+         * @example
+         * ```typescript
+         * afterStart: async (instance) => {
+         *   console.log(`Server ready at http://${instance.config.host}:${instance.config.port}`);
+         *   await notifyHealthCheckService();
+         * }
+         * ```
+         */
+        afterStart?: (instance: ServerInstance) => Promise<void>;
+        /**
+         * Hook: Run before graceful shutdown
+         * Infrastructure (DB/Redis) is still available
+         * Use this to cleanup custom resources and services
+         *
+         * @example
+         * ```typescript
+         * beforeShutdown: async () => {
+         *   await closeMessageQueue();
+         *   await closeSearchService();
+         * }
+         * ```
+         */
+        beforeShutdown?: () => Promise<void>;
+    };
 }
 /**
  * App Factory Function

package/dist/server/index.js

@@ -1,4 +1,3 @@
-import pino from 'pino';
 import { readFileSync, existsSync, readdirSync, statSync, mkdirSync, accessSync, constants, writeFileSync, unlinkSync, createWriteStream, renameSync } from 'fs';
 import { join, dirname, relative, basename } from 'path';
 import { config } from 'dotenv';
@@ -24,76 +23,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var PinoAdapter;
-var init_pino = __esm({
-  "src/logger/adapters/pino.ts"() {
-    PinoAdapter = class _PinoAdapter {
-      logger;
-      constructor(config) {
-        const isDevelopment = process.env.NODE_ENV === "development";
-        const transport = isDevelopment ? {
-          target: "pino-pretty",
-          options: {
-            colorize: true,
-            translateTime: "HH:MM:ss.l",
-            ignore: "pid,hostname",
-            singleLine: false,
-            messageFormat: "{module} {msg}",
-            errorLikeObjectKeys: ["err", "error"]
-          }
-        } : void 0;
-        try {
-          this.logger = pino({
-            level: config.level,
-            // 기본 필드
-            base: config.module ? { module: config.module } : void 0,
-            // Transport (pretty print in development if available)
-            transport
-          });
-        } catch (error) {
-          this.logger = pino({
-            level: config.level,
-            base: config.module ? { module: config.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/types.ts
 var LOG_LEVEL_PRIORITY;
@@ -769,7 +698,7 @@ var init_config = __esm({
   }
 });
 
-// src/logger/adapters/custom.ts
+// src/logger/factory.ts
 function initializeTransports() {
   const transports = [];
   const consoleConfig = getConsoleConfig();
@@ -780,89 +709,19 @@ function initializeTransports() {
   }
   return transports;
 }
-var CustomAdapter;
-var init_custom = __esm({
-  "src/logger/adapters/custom.ts"() {
-    init_logger();
-    init_console();
-    init_file();
-    init_config();
-    CustomAdapter = class _CustomAdapter {
-      logger;
-      constructor(config) {
-        this.logger = new Logger({
-          level: config.level,
-          module: config.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";
-}
 function initializeLogger() {
   validateConfig();
-  return createAdapter(getAdapterType());
+  return new Logger({
+    level: getDefaultLogLevel(),
+    transports: initializeTransports()
+  });
 }
 var logger;
-var init_adapter_factory = __esm({
-  "src/logger/adapter-factory.ts"() {
-    init_pino();
-    init_custom();
+var init_factory = __esm({
+  "src/logger/factory.ts"() {
+    init_logger();
+    init_console();
+    init_file();
     init_config();
     logger = initializeLogger();
   }
@@ -871,7 +730,8 @@ var init_adapter_factory = __esm({
 // src/logger/index.ts
 var init_logger2 = __esm({
   "src/logger/index.ts"() {
-    init_adapter_factory();
+    init_factory();
+    init_logger();
   }
 });
 
@@ -1592,7 +1452,7 @@ async function createDatabaseFromEnv(options) {
   }
 }
 var dbLogger2;
-var init_factory = __esm({
+var init_factory2 = __esm({
   "src/db/manager/factory.ts"() {
     init_logger2();
     init_env();
@@ -1708,17 +1568,51 @@ var dbLogger3;
 var init_health_check = __esm({
   "src/db/manager/health-check.ts"() {
     init_logger2();
-    init_factory();
+    init_factory2();
     init_global_state();
     dbLogger3 = logger.child("database");
   }
 });
 
 // src/db/manager/manager.ts
+function getCallerInfo() {
+  try {
+    const stack = new Error().stack;
+    if (!stack) return void 0;
+    const lines = stack.split("\n");
+    for (let i = 3; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.includes("node_modules") && !line.includes("/db/manager/")) {
+        const match = line.match(/\((.+):(\d+):(\d+)\)/) || line.match(/at (.+):(\d+):(\d+)/);
+        if (match) {
+          const fullPath = match[1];
+          const parts = fullPath.split("/");
+          const srcIndex = parts.lastIndexOf("src");
+          if (srcIndex !== -1) {
+            const relativePath = parts.slice(srcIndex).join("/");
+            return `${relativePath}:${match[2]}`;
+          }
+          return `${fullPath}:${match[2]}`;
+        }
+        break;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
 function getDatabase(type) {
   const writeInst = getWriteInstance();
   const readInst = getReadInstance();
-  dbLogger4.debug(`getDatabase() called with type=${type}, writeInstance=${!!writeInst}, readInstance=${!!readInst}`);
+  if (process.env.DB_DEBUG_TRACE === "true") {
+    const caller = getCallerInfo();
+    dbLogger4.debug("getDatabase() called", {
+      type: type || "write",
+      hasWrite: !!writeInst,
+      hasRead: !!readInst,
+      caller
+    });
+  }
   if (type === "read") {
     return readInst ?? writeInst;
   }
@@ -1823,7 +1717,7 @@ var dbLogger4;
 var init_manager = __esm({
   "src/db/manager/manager.ts"() {
     init_logger2();
-    init_factory();
+    init_factory2();
     init_config3();
     init_global_state();
     init_health_check();
@@ -1834,7 +1728,7 @@ var init_manager = __esm({
 // src/db/manager/index.ts
 var init_manager2 = __esm({
   "src/db/manager/index.ts"() {
-    init_factory();
+    init_factory2();
     init_manager();
     init_connection();
   }
@@ -3017,6 +2911,22 @@ function generateRequestId() {
   const randomPart = randomBytes(6).toString("hex");
   return `req_${timestamp2}_${randomPart}`;
 }
+function maskSensitiveData2(obj, sensitiveFields, seen = /* @__PURE__ */ new WeakSet()) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (seen.has(obj)) return "[Circular]";
+  seen.add(obj);
+  const lowerFields = sensitiveFields.map((f) => f.toLowerCase());
+  const masked = Array.isArray(obj) ? [...obj] : { ...obj };
+  for (const key in masked) {
+    const lowerKey = key.toLowerCase();
+    if (lowerFields.some((field) => lowerKey.includes(field))) {
+      masked[key] = "***MASKED***";
+    } else if (typeof masked[key] === "object" && masked[key] !== null) {
+      masked[key] = maskSensitiveData2(masked[key], sensitiveFields, seen);
+    }
+  }
+  return masked;
+}
 function RequestLogger(config) {
   const cfg = { ...DEFAULT_CONFIG, ...config };
   const apiLogger = logger.child("api");
@@ -3042,8 +2952,6 @@ function RequestLogger(config) {
       await next();
       const duration = Date.now() - startTime;
       const status = c.res.status;
-      const logLevel = status >= 400 ? "warn" : "info";
-      const isSlowRequest = duration >= cfg.slowRequestThreshold;
       const logData = {
         requestId,
         method,
@@ -3051,9 +2959,25 @@ function RequestLogger(config) {
         status,
         duration
       };
+      const isSlowRequest = duration >= cfg.slowRequestThreshold;
       if (isSlowRequest) {
         logData.slow = true;
       }
+      if (status >= 400) {
+        try {
+          const responseBody = await c.res.clone().json();
+          logData.response = responseBody;
+        } catch {
+        }
+        if (["POST", "PUT", "PATCH"].includes(method)) {
+          try {
+            const requestBody = await c.req.json();
+            logData.request = maskSensitiveData2(requestBody, cfg.sensitiveFields);
+          } catch {
+          }
+        }
+      }
+      const logLevel = status >= 500 ? "error" : status >= 400 ? "warn" : "info";
       apiLogger[logLevel]("Request completed", logData);
     } catch (error) {
       const duration = Date.now() - startTime;
@@ -3251,11 +3175,11 @@ function registerHealthCheckEndpoint(app, config) {
   }
 }
 async function executeBeforeRoutesHook(app, config) {
-  if (!config?.beforeRoutes) {
+  if (!config?.lifecycle?.beforeRoutes) {
     return;
   }
   try {
-    await config.beforeRoutes(app);
+    await config.lifecycle.beforeRoutes(app);
   } catch (error) {
     serverLogger.error("beforeRoutes hook failed", error);
     throw new Error("Server initialization failed in beforeRoutes hook");
@@ -3270,11 +3194,11 @@ async function loadAppRoutes(app, config) {
   });
 }
 async function executeAfterRoutesHook(app, config) {
-  if (!config?.afterRoutes) {
+  if (!config?.lifecycle?.afterRoutes) {
     return;
   }
   try {
-    await config.afterRoutes(app);
+    await config.lifecycle.afterRoutes(app);
   } catch (error) {
     serverLogger.error("afterRoutes hook failed", error);
     throw new Error("Server initialization failed in afterRoutes hook");
@@ -3384,10 +3308,10 @@ async function startServer(config) {
       port
     });
     logServerStarted(debug, host, port, finalConfig, timeouts);
-    const shutdownServer = createShutdownHandler(server);
+    const shutdownServer = createShutdownHandler(server, finalConfig);
     const shutdown = createGracefulShutdown(shutdownServer, finalConfig);
     registerShutdownHandlers(shutdown);
-    return {
+    const serverInstance = {
       server,
       app,
       config: finalConfig,
@@ -3396,10 +3320,19 @@ async function startServer(config) {
         await shutdownServer();
       }
     };
+    if (finalConfig.lifecycle?.afterStart) {
+      serverLogger2.debug("Executing afterStart hook...");
+      try {
+        await finalConfig.lifecycle.afterStart(serverInstance);
+      } catch (error) {
+        serverLogger2.error("afterStart hook failed", error);
+      }
+    }
+    return serverInstance;
   } catch (error) {
     const err = error;
     serverLogger2.error("Server initialization failed", err);
-    await cleanupOnFailure();
+    await cleanupOnFailure(finalConfig);
     throw error;
   }
 }
@@ -3437,18 +3370,47 @@ function logMiddlewareOrder(config) {
   });
 }
 async function initializeInfrastructure(config) {
-  serverLogger2.debug("Initializing database...");
-  await initDatabase(config.database);
-  serverLogger2.debug("Initializing Redis...");
-  await initRedis();
+  if (config.lifecycle?.beforeInfrastructure) {
+    serverLogger2.debug("Executing beforeInfrastructure hook...");
+    try {
+      await config.lifecycle.beforeInfrastructure(config);
+    } catch (error) {
+      serverLogger2.error("beforeInfrastructure hook failed", error);
+      throw new Error("Server initialization failed in beforeInfrastructure hook");
+    }
+  }
+  const shouldInitDatabase = config.infrastructure?.database !== false;
+  if (shouldInitDatabase) {
+    serverLogger2.debug("Initializing database...");
+    await initDatabase(config.database);
+  } else {
+    serverLogger2.debug("Database initialization disabled");
+  }
+  const shouldInitRedis = config.infrastructure?.redis !== false;
+  if (shouldInitRedis) {
+    serverLogger2.debug("Initializing Redis...");
+    await initRedis();
+  } else {
+    serverLogger2.debug("Redis initialization disabled");
+  }
+  if (config.lifecycle?.afterInfrastructure) {
+    serverLogger2.debug("Executing afterInfrastructure hook...");
+    try {
+      await config.lifecycle.afterInfrastructure();
+    } catch (error) {
+      serverLogger2.error("afterInfrastructure hook failed", error);
+      throw new Error("Server initialization failed in afterInfrastructure hook");
+    }
+  }
 }
 function startHttpServer(app, host, port) {
   serverLogger2.debug(`Starting server on ${host}:${port}...`);
-  return serve({
+  const server = serve({
     fetch: app.fetch,
     port,
     hostname: host
   });
+  return server;
 }
 function logServerTimeouts(timeouts) {
   serverLogger2.info("Server timeouts configured", {
@@ -3466,7 +3428,7 @@ function logServerStarted(debug, host, port, config, timeouts) {
     config: startupConfig
   });
 }
-function createShutdownHandler(server) {
+function createShutdownHandler(server, config) {
   return async () => {
     serverLogger2.debug("Closing HTTP server...");
     await new Promise((resolve) => {
@@ -3475,10 +3437,24 @@ function createShutdownHandler(server) {
         resolve();
       });
     });
-    serverLogger2.debug("Closing database connections...");
-    await closeDatabase();
-    serverLogger2.debug("Closing Redis connections...");
-    await closeRedis();
+    if (config.lifecycle?.beforeShutdown) {
+      serverLogger2.debug("Executing beforeShutdown hook...");
+      try {
+        await config.lifecycle.beforeShutdown();
+      } catch (error) {
+        serverLogger2.error("beforeShutdown hook failed", error);
+      }
+    }
+    const shouldCloseDatabase = config.infrastructure?.database !== false;
+    const shouldCloseRedis = config.infrastructure?.redis !== false;
+    if (shouldCloseDatabase) {
+      serverLogger2.debug("Closing database connections...");
+      await closeDatabase();
+    }
+    if (shouldCloseRedis) {
+      serverLogger2.debug("Closing Redis connections...");
+      await closeRedis();
+    }
     serverLogger2.info("Server shutdown completed");
   };
 }
@@ -3510,10 +3486,22 @@ function createGracefulShutdown(shutdownServer, config) {
   };
 }
 function registerShutdownHandlers(shutdown) {
+  process.setMaxListeners(15);
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("uncaughtException", (error) => {
-    serverLogger2.error("Uncaught exception", error);
+    if (error.message?.includes("EADDRINUSE")) {
+      serverLogger2.error("Port conflict detected - detailed trace:", {
+        error: error.message,
+        stack: error.stack,
+        code: error.code,
+        port: error.port,
+        address: error.address,
+        syscall: error.syscall
+      });
+    } else {
+      serverLogger2.error("Uncaught exception", error);
+    }
     shutdown("UNCAUGHT_EXCEPTION");
   });
   process.on("unhandledRejection", (reason, promise) => {
@@ -3524,11 +3512,17 @@ function registerShutdownHandlers(shutdown) {
     shutdown("UNHANDLED_REJECTION");
   });
 }
-async function cleanupOnFailure() {
+async function cleanupOnFailure(config) {
   try {
     serverLogger2.debug("Cleaning up after initialization failure...");
-    await closeDatabase();
-    await closeRedis();
+    const shouldCleanupDatabase = config.infrastructure?.database !== false;
+    const shouldCleanupRedis = config.infrastructure?.redis !== false;
+    if (shouldCleanupDatabase) {
+      await closeDatabase();
+    }
+    if (shouldCleanupRedis) {
+      await closeRedis();
+    }
     serverLogger2.debug("Cleanup completed");
   } catch (cleanupError) {
     serverLogger2.error("Cleanup failed", cleanupError);