@zintrust/core 0.1.28 → 0.1.29

package/src/boot/Application.ts

@@ -1,490 +0,0 @@
-/**
- * Application - Framework core entry point
- * Handles application lifecycle, booting, and environment
- */
-
-import { appConfig, cacheConfig, databaseConfig, queueConfig, storageConfig } from '@/config';
-import type { IServiceContainer } from '@/container/ServiceContainer';
-import { ServiceContainer } from '@/container/ServiceContainer';
-import { StartupHealthChecks } from '@/health/StartupHealthChecks';
-import type { IMiddlewareStack } from '@/middleware/MiddlewareStack';
-import { MiddlewareStack } from '@/middleware/MiddlewareStack';
-import broadcastConfig from '@config/broadcast';
-import { FeatureFlags } from '@config/features';
-import { Logger } from '@config/logger';
-import notificationConfig from '@config/notification';
-import { StartupConfigValidator } from '@config/StartupConfigValidator';
-import { type IRouter, Router } from '@core-routes/Router';
-import * as path from '@node-singletons/path';
-import { pathToFileURL } from '@node-singletons/url';
-import { StartupConfigFile, StartupConfigFileRegistry } from '@runtime/StartupConfigFileRegistry';
-
-export interface IApplication {
-  boot(): Promise<void>;
-  shutdown(): Promise<void>;
-  isBooted(): boolean;
-  isDevelopment(): boolean;
-  isProduction(): boolean;
-  isTesting(): boolean;
-  getEnvironment(): string;
-  getRouter(): IRouter;
-  getContainer(): IServiceContainer;
-  getMiddlewareStack(): IMiddlewareStack;
-  getBasePath(): string;
-}
-
-type RoutesModule = { registerRoutes?: (r: IRouter) => void };
-
-type ShutdownHook = () => void | Promise<void>;
-
-interface IShutdownManager {
-  add(hook: ShutdownHook): void;
-  run(): Promise<void>;
-}
-
-const ShutdownManager = Object.freeze({
-  create(): IShutdownManager {
-    const hooks: ShutdownHook[] = [];
-
-    return Object.freeze({
-      add(hook: ShutdownHook): void {
-        hooks.push(hook);
-      },
-      async run(): Promise<void> {
-        for (const hook of hooks) {
-          // eslint-disable-next-line no-await-in-loop
-          await hook();
-        }
-      },
-    });
-  },
-});
-
-const resolveBasePath = (basePath?: string): string => {
-  if (typeof basePath === 'string') return basePath;
-  if (typeof process !== 'undefined' && typeof process.cwd === 'function') return process.cwd();
-  return '';
-};
-
-const makeJoinFromBase =
-  (resolvedBasePath: string) =>
-  (subPath: string): string => {
-    return resolvedBasePath.length > 0 ? `${resolvedBasePath}/${subPath}` : subPath;
-  };
-
-const registerCorePaths = (
-  container: IServiceContainer,
-  resolvedBasePath: string,
-  joinFromBase: (subPath: string) => string
-): void => {
-  container.singleton('paths', {
-    base: resolvedBasePath,
-    app: joinFromBase('app'),
-    config: joinFromBase('config'),
-    database: joinFromBase('database'),
-    routes: joinFromBase('routes'),
-    tests: joinFromBase('tests'),
-  });
-};
-
-const registerCoreInstances = (params: {
-  container: IServiceContainer;
-  environment: string;
-  router: IRouter;
-  middlewareStack: IMiddlewareStack;
-  shutdownManager: IShutdownManager;
-}): void => {
-  params.container.singleton('env', params.environment);
-  params.container.singleton('router', params.router);
-  params.container.singleton('middleware', params.middlewareStack);
-  params.container.singleton('container', params.container);
-  params.container.singleton('shutdownManager', params.shutdownManager);
-};
-
-const registerFrameworkShutdownHooks = (shutdownManager: IShutdownManager): void => {
-  // Register framework-level shutdown hooks for long-lived resources
-  // ConnectionManager may not be initialized; shutdownIfInitialized is safe
-  // Use dynamic import without top-level await to avoid transforming the module into an async module
-  import('@orm/ConnectionManager')
-    .then((mod: { ConnectionManager: { shutdownIfInitialized: () => Promise<void> } }) => {
-      shutdownManager.add(async () => mod.ConnectionManager.shutdownIfInitialized());
-    })
-    .catch(() => {
-      /* ignore import failures in restrictive runtimes */
-    });
-
-  import('@orm/Database')
-    .then((mod: { resetDatabase: () => void }) => {
-      shutdownManager.add(() => mod.resetDatabase());
-    })
-    .catch(() => {
-      /* ignore import failures in restrictive runtimes */
-    });
-
-  import('@cache/Cache')
-    .then((mod: { Cache: { reset: () => void } }) => {
-      shutdownManager.add(() => mod.Cache.reset());
-    })
-    .catch(() => {
-      /* ignore import failures in restrictive runtimes */
-    });
-
-  // Flush file logging streams
-  import('@config/FileLogWriter')
-    .then((mod: { FileLogWriter: { flush: () => void } }) => {
-      shutdownManager.add(() => mod.FileLogWriter.flush());
-    })
-    .catch(() => {
-      /* ignore import failures in restrictive runtimes */
-    });
-
-  import('@broadcast/BroadcastRegistry')
-    .then((mod: { BroadcastRegistry: { reset: () => void } }) => {
-      shutdownManager.add(() => mod.BroadcastRegistry.reset());
-    })
-    .catch(() => {
-      /* ignore import failures in restrictive runtimes */
-    });
-
-  import('@storage/StorageDiskRegistry')
-    .then((mod: { StorageDiskRegistry: { reset: () => void } }) => {
-      shutdownManager.add(() => mod.StorageDiskRegistry.reset());
-    })
-    .catch(() => {
-      /* ignore import failures in restrictive runtimes */
-    });
-
-  import('@notification/NotificationChannelRegistry')
-    .then((mod: { NotificationChannelRegistry: { reset: () => void } }) => {
-      shutdownManager.add(() => mod.NotificationChannelRegistry.reset());
-    })
-    .catch(() => {
-      /* ignore import failures in restrictive runtimes */
-    });
-
-  import('@mail/MailDriverRegistry')
-    .then((mod: { MailDriverRegistry: { reset: () => void } }) => {
-      shutdownManager.add(() => mod.MailDriverRegistry.reset());
-    })
-    .catch(() => {
-      /* ignore import failures in restrictive runtimes */
-    });
-
-  import('@tools/queue/Queue')
-    .then((mod: { Queue: { reset: () => void } }) => {
-      shutdownManager.add(() => mod.Queue.reset());
-    })
-    .catch(() => {
-      /* ignore import failures in restrictive runtimes */
-    });
-
-  import('@zintrust/workers')
-    .then(
-      (mod: {
-        WorkerShutdown: {
-          shutdown: (opts: {
-            signal?: string;
-            timeout?: number;
-            forceExit?: boolean;
-          }) => Promise<void>;
-        };
-      }) => {
-        shutdownManager.add(async () =>
-          mod.WorkerShutdown.shutdown({ signal: 'APP_SHUTDOWN', timeout: 5000, forceExit: false })
-        );
-      }
-    )
-    .catch(() => {
-      /* ignore import failures in restrictive runtimes */
-    });
-};
-
-const tryImportRoutesFromAppBase = async (
-  resolvedBasePath: string
-): Promise<RoutesModule | undefined> => {
-  if (resolvedBasePath === '') return undefined;
-
-  const candidates = [
-    // Dev (tsx)
-    path.join(resolvedBasePath, 'routes', 'api.ts'),
-    // Production build output
-    path.join(resolvedBasePath, 'dist', 'routes', 'api.js'),
-    // Fallback (in case someone transpiles without /dist)
-    path.join(resolvedBasePath, 'routes', 'api.js'),
-  ];
-
-  for (const candidate of candidates) {
-    try {
-      const url = pathToFileURL(candidate).href;
-      // eslint-disable-next-line no-await-in-loop
-      return (await import(url)) as RoutesModule;
-    } catch {
-      // keep trying
-    }
-  }
-
-  return undefined;
-};
-
-const registerRoutes = async (resolvedBasePath: string, router: IRouter): Promise<void> => {
-  try {
-    const mod = await tryImportRoutesFromAppBase(resolvedBasePath);
-    if (typeof mod?.registerRoutes === 'function') {
-      mod.registerRoutes(router);
-    } else {
-      const { registerRoutes: registerFrameworkRoutes } = await import('@routes/api');
-      registerFrameworkRoutes(router);
-    }
-
-    // Always register core framework routes (health, metrics, doc) after app routes
-    // This ensures app can override but core routes always exist
-    const { registerCoreRoutes } = await import('@core-routes/CoreRoutes');
-    registerCoreRoutes(router);
-  } catch (error: unknown) {
-    Logger.error('Failed to register routes:', error as Error);
-  }
-};
-
-const initializeArtifactDirectories = async (resolvedBasePath: string): Promise<void> => {
-  if (resolvedBasePath === '') return;
-  if (typeof process === 'undefined') return;
-
-  let nodeFs:
-    | {
-        existsSync: (path: string) => boolean;
-        mkdirSync: (path: string, options?: { recursive?: boolean }) => void;
-      }
-    | undefined;
-
-  try {
-    nodeFs = await import('@node-singletons/fs');
-  } catch {
-    return;
-  }
-
-  const dirs = ['logs', 'storage', 'tmp'];
-  for (const dir of dirs) {
-    const fullPath = path.join(resolvedBasePath, dir);
-    try {
-      if (!nodeFs.existsSync(fullPath)) {
-        nodeFs.mkdirSync(fullPath, { recursive: true });
-        Logger.info(`✓ Created directory: ${dir}`);
-      }
-    } catch (error: unknown) {
-      Logger.warn(`Failed to create ${dir} directory`, error as Error);
-    }
-  }
-};
-
-const tryImportOptional = async <T>(modulePath: string): Promise<T | undefined> => {
-  try {
-    return (await import(modulePath)) as T;
-  } catch {
-    return undefined;
-  }
-};
-
-const isCompiledJsModule = (): boolean => {
-  // When running from dist, this module is compiled to .js and Node ESM resolution
-  // requires explicit file extensions for relative imports.
-  return import.meta.url.endsWith('.js');
-};
-
-const dbLoader = async (): Promise<void> => {
-  const db = await tryImportOptional<{
-    registerDatabasesFromRuntimeConfig?: (cfg: typeof databaseConfig) => void;
-  }>(
-    isCompiledJsModule()
-      ? '../orm/DatabaseRuntimeRegistration.js'
-      : '../orm/DatabaseRuntimeRegistration'
-  );
-  db?.registerDatabasesFromRuntimeConfig?.(databaseConfig);
-};
-
-const queuesLoader = async (): Promise<void> => {
-  const queues = await tryImportOptional<{
-    registerQueuesFromRuntimeConfig?: (cfg: typeof queueConfig) => void;
-  }>(
-    isCompiledJsModule()
-      ? '../tools/queue/QueueRuntimeRegistration.js'
-      : '../tools/queue/QueueRuntimeRegistration'
-  );
-  queues?.registerQueuesFromRuntimeConfig?.(queueConfig);
-};
-
-const cachesLoader = async (): Promise<void> => {
-  const caches = await tryImportOptional<{
-    registerCachesFromRuntimeConfig?: (cfg: typeof cacheConfig) => void;
-  }>(
-    isCompiledJsModule()
-      ? '../cache/CacheRuntimeRegistration.js'
-      : '../cache/CacheRuntimeRegistration'
-  );
-  caches?.registerCachesFromRuntimeConfig?.(cacheConfig);
-};
-
-const registerFromRuntimeConfig = async (): Promise<void> => {
-  await dbLoader();
-  await queuesLoader();
-  await cachesLoader();
-
-  const broadcasters = await tryImportOptional<{
-    registerBroadcastersFromRuntimeConfig?: (cfg: {
-      default: string;
-      drivers: typeof broadcastConfig.drivers;
-    }) => void;
-  }>(
-    isCompiledJsModule()
-      ? '../tools/broadcast/BroadcastRuntimeRegistration.js'
-      : '../tools/broadcast/BroadcastRuntimeRegistration'
-  );
-  broadcasters?.registerBroadcastersFromRuntimeConfig?.({
-    default: broadcastConfig.default,
-    drivers: broadcastConfig.drivers,
-  });
-
-  const disks = await tryImportOptional<{
-    registerDisksFromRuntimeConfig?: (cfg: typeof storageConfig) => void;
-  }>(
-    isCompiledJsModule()
-      ? '../tools/storage/StorageRuntimeRegistration.js'
-      : '../tools/storage/StorageRuntimeRegistration'
-  );
-  disks?.registerDisksFromRuntimeConfig?.(storageConfig);
-
-  const notifications = await tryImportOptional<{
-    registerNotificationChannelsFromRuntimeConfig?: (cfg: {
-      default: string;
-      drivers: typeof notificationConfig.drivers;
-    }) => void;
-  }>(
-    isCompiledJsModule()
-      ? '../tools/notification/NotificationRuntimeRegistration.js'
-      : '../tools/notification/NotificationRuntimeRegistration'
-  );
-  notifications?.registerNotificationChannelsFromRuntimeConfig?.({
-    default: notificationConfig.default,
-    drivers: notificationConfig.drivers,
-  });
-};
-
-const createLifecycle = (params: {
-  environment: string;
-  resolvedBasePath: string;
-  router: IRouter;
-  shutdownManager: IShutdownManager;
-  getBooted: () => boolean;
-  setBooted: (value: boolean) => void;
-}): { boot: () => Promise<void>; shutdown: () => Promise<void> } => {
-  const boot = async (): Promise<void> => {
-    if (params.getBooted()) return;
-
-    Logger.info(`🚀 Booting ZinTrust Application in ${params.environment} mode...`);
-
-    StartupConfigValidator.assertValid();
-
-    // Preload project-owned config overrides that must be available synchronously.
-    await StartupConfigFileRegistry.preload([
-      StartupConfigFile.Middleware,
-      StartupConfigFile.Cache,
-      StartupConfigFile.Database,
-      StartupConfigFile.Queue,
-      StartupConfigFile.Storage,
-      StartupConfigFile.Mail,
-      StartupConfigFile.Broadcast,
-      StartupConfigFile.Notification,
-    ]);
-
-    FeatureFlags.initialize();
-    await StartupHealthChecks.assertHealthy();
-
-    await registerFromRuntimeConfig();
-
-    await initializeArtifactDirectories(params.resolvedBasePath);
-    await registerRoutes(params.resolvedBasePath, params.router);
-
-    // Register service providers
-    // Bootstrap services
-    Logger.info('✅ Application booted successfully');
-
-    params.setBooted(true);
-  };
-
-  const shutdown = async (): Promise<void> => {
-    Logger.info('🛑 Shutting down application...');
-
-    try {
-      await params.shutdownManager.run();
-    } catch (error: unknown) {
-      Logger.error('Shutdown hook failed:', error as Error);
-    }
-
-    // Ensure FileLogWriter.flush is attempted even if dynamic registration failed.
-    try {
-      const fileLogWriter = await tryImportOptional<{ FileLogWriter: { flush: () => void } }>(
-        '@config/FileLogWriter'
-      );
-      fileLogWriter?.FileLogWriter?.flush?.();
-    } catch {
-      /* best-effort */
-    }
-
-    params.setBooted(false);
-    Logger.info('✅ Application shut down successfully');
-  };
-
-  return { boot, shutdown };
-};
-
-/**
- * Application Factory
- */
-export const Application = Object.freeze({
-  /**
-   * Create a new application instance
-   */
-  create(basePath?: string): IApplication {
-    const resolvedBasePath = resolveBasePath(basePath);
-    const joinFromBase = makeJoinFromBase(resolvedBasePath);
-
-    const environment = appConfig.environment;
-    const container = ServiceContainer.create();
-    const router = Router.createRouter();
-    const middlewareStack = MiddlewareStack.create();
-    const shutdownManager = ShutdownManager.create();
-
-    let booted = false;
-
-    registerCorePaths(container, resolvedBasePath, joinFromBase);
-    registerCoreInstances({ container, environment, router, middlewareStack, shutdownManager });
-
-    registerFrameworkShutdownHooks(shutdownManager);
-
-    const { boot, shutdown } = createLifecycle({
-      environment,
-      resolvedBasePath,
-      router,
-      shutdownManager,
-      getBooted: () => booted,
-      setBooted: (value: boolean) => {
-        booted = value;
-      },
-    });
-
-    return {
-      boot,
-      shutdown,
-      isBooted: (): boolean => booted,
-      isDevelopment: (): boolean => appConfig.isDevelopment(),
-      isProduction: (): boolean => appConfig.isProduction(),
-      isTesting: (): boolean => appConfig.isTesting(),
-      getEnvironment: (): string => environment,
-      getRouter: (): IRouter => router,
-      getContainer: (): IServiceContainer => container,
-      getMiddlewareStack: (): IMiddlewareStack => middlewareStack,
-      getBasePath: (): string => resolvedBasePath,
-    };
-  },
-});
-
-export default Application;

package/src/boot/Server.ts

@@ -1,155 +0,0 @@
-/**
- * Server - HTTP Server implementation
- * Uses Node.js built-in HTTP server with no external dependencies
- */
-
-import type { IApplication } from '@boot/Application';
-import { appConfig } from '@config/app';
-import { HTTP_HEADERS } from '@config/constants';
-import { Logger } from '@config/logger';
-import { ServiceContainer, type IServiceContainer } from '@container/ServiceContainer';
-import { ErrorRouting } from '@core-routes/error';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import type { IKernel } from '@http/Kernel';
-import { Kernel } from '@http/Kernel';
-import type { IRequest } from '@http/Request';
-import { Request } from '@http/Request';
-import type { IResponse } from '@http/Response';
-import { Response } from '@http/Response';
-import * as http from '@node-singletons/http';
-import type { Socket } from '@node-singletons/net';
-
-export interface IServer {
-  listen(): Promise<void>;
-  close(): Promise<void>;
-  getHttpServer(): http.Server;
-}
-
-/**
- * Set security headers on response
- */
-const getContentSecurityPolicyForPath = (): string => {
-  // Default CSP for the API/framework
-  return (
-    "default-src 'self'; " +
-    "script-src 'self' 'unsafe-inline'; " +
-    "style-src 'self' 'unsafe-inline'; " +
-    "img-src 'self' data:; " +
-    "font-src 'self';"
-  );
-};
-
-const setSecurityHeaders = (res: http.ServerResponse): void => {
-  res.setHeader(HTTP_HEADERS.X_POWERED_BY, 'ZinTrust');
-  res.setHeader(HTTP_HEADERS.X_CONTENT_TYPE_OPTIONS, 'nosniff');
-  res.setHeader(HTTP_HEADERS.X_FRAME_OPTIONS, 'DENY');
-  res.setHeader(HTTP_HEADERS.X_XSS_PROTECTION, '1; mode=block');
-  res.setHeader(HTTP_HEADERS.REFERRER_POLICY, 'strict-origin-when-cross-origin');
-  res.setHeader(HTTP_HEADERS.CONTENT_SECURITY_POLICY, getContentSecurityPolicyForPath());
-};
-
-const handleRequest = async (
-  params: { getKernel: () => IKernel },
-  req: http.IncomingMessage | null,
-  res: http.ServerResponse
-): Promise<void> => {
-  let request: IRequest | undefined;
-  let response: IResponse | undefined;
-
-  try {
-    setSecurityHeaders(res);
-
-    if (!req) {
-      throw ErrorFactory.createConnectionError('Request object is missing');
-    }
-
-    const kernel = params.getKernel();
-    request = Request.create(req);
-    response = Response.create(res);
-
-    // Delegate request lifecycle to Kernel (routing + middleware + handler execution).
-    await kernel.handleRequest(request, response);
-  } catch (error) {
-    ErrorFactory.createTryCatchError('Server error:', error);
-
-    // Prefer wrapper-based error handling when available.
-    if (request !== undefined && response !== undefined) {
-      ErrorRouting.handleInternalServerErrorWithWrappers(request, response, error);
-      return;
-    }
-
-    ErrorRouting.handleInternalServerErrorRaw(res);
-  }
-};
-
-/**
- * Server - HTTP Server implementation
- * Refactored to Functional Object pattern
- */
-export const Server = Object.freeze({
-  /**
-   * Create a new server instance
-   */
-  create(app: IApplication, port?: number, host?: string, kernel: IKernel | null = null): IServer {
-    const serverPort = port ?? appConfig.port;
-    const serverHost = host ?? appConfig.host;
-
-    let kernelInstance: IKernel | null = kernel;
-
-    const getKernel = (): IKernel => {
-      if (kernelInstance !== null) return kernelInstance;
-
-      const anyApp = app as unknown as { getContainer?: () => unknown };
-      const container: IServiceContainer =
-        typeof anyApp.getContainer === 'function'
-          ? (anyApp.getContainer() as IServiceContainer)
-          : ServiceContainer.create();
-
-      kernelInstance = Kernel.create(app.getRouter(), container);
-      return kernelInstance;
-    };
-
-    const httpServer = http.createServer(
-      async (req: http.IncomingMessage, res: http.ServerResponse) =>
-        handleRequest({ getKernel }, req, res)
-    );
-
-    const sockets = new Set<Socket>();
-    httpServer.on('connection', (socket: Socket) => {
-      sockets.add(socket);
-      socket.on('close', () => sockets.delete(socket));
-    });
-
-    return {
-      async listen(): Promise<void> {
-        return new Promise((resolve) => {
-          httpServer.listen(serverPort, serverHost, () => {
-            resolve();
-          });
-        });
-      },
-      async close(): Promise<void> {
-        return new Promise((resolve) => {
-          httpServer.close(() => {
-            Logger.info('ZinTrust server stopped');
-            resolve();
-          });
-
-          // Ensure keep-alive / hanging connections don't block shutdown
-          for (const socket of sockets) {
-            try {
-              socket.destroy();
-            } catch {
-              // best-effort
-            }
-          }
-        });
-      },
-      getHttpServer(): http.Server {
-        return httpServer;
-      },
-    };
-  },
-});
-
-export default Server;