@zintrust/core 0.4.15 → 0.4.17

package/src/boot/Application.js

@@ -1,95 +0,0 @@
-/**
- * Application - Framework core entry point
- * Handles application lifecycle, booting, and environment
- */
-import { appConfig } from '../config/index.js';
-import { ServiceContainer } from '../container/ServiceContainer.js';
-import { MiddlewareStack } from '../middleware/MiddlewareStack.js';
-import { Router } from '../routes/Router.js';
-import { createLifecycle, registerFrameworkShutdownHooks } from './registry/runtime.js';
-const ShutdownManager = Object.freeze({
-    create() {
-        const hooks = [];
-        return Object.freeze({
-            add(hook) {
-                hooks.push(hook);
-            },
-            async run() {
-                // Run hooks in parallel for better performance
-                await Promise.all(hooks.map(async (hook) => hook()));
-            },
-        });
-    },
-});
-const resolveBasePath = (basePath) => {
-    if (typeof basePath === 'string')
-        return basePath;
-    if (typeof process !== 'undefined' && typeof process.cwd === 'function')
-        return process.cwd();
-    return '';
-};
-const makeJoinFromBase = (resolvedBasePath) => (subPath) => {
-    return resolvedBasePath.length > 0 ? `${resolvedBasePath}/${subPath}` : subPath;
-};
-const registerCorePaths = (container, resolvedBasePath, joinFromBase) => {
-    container.singleton('paths', {
-        base: resolvedBasePath,
-        app: joinFromBase('app'),
-        config: joinFromBase('config'),
-        database: joinFromBase('database'),
-        routes: joinFromBase('routes'),
-        tests: joinFromBase('tests'),
-    });
-};
-const registerCoreInstances = (params) => {
-    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);
-};
-/**
- * Application Factory
- */
-export const Application = Object.freeze({
-    /**
-     * Create a new application instance
-     */
-    create(basePath) {
-        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) => {
-                booted = value;
-            },
-        });
-        return {
-            boot,
-            shutdown,
-            isBooted: () => booted,
-            isDevelopment: () => appConfig.isDevelopment(),
-            isProduction: () => appConfig.isProduction(),
-            isTesting: () => appConfig.isTesting(),
-            getEnvironment: () => environment,
-            getRouter: () => router,
-            getContainer: () => container,
-            getMiddlewareStack: () => middlewareStack,
-            getBasePath: () => resolvedBasePath,
-        };
-    },
-});
-export default Application;

package/src/boot/Server.d.ts

@@ -1,24 +0,0 @@
-/**
- * Server - HTTP Server implementation
- * Uses Node.js built-in HTTP server with no external dependencies
- */
-import type { IKernel } from '../http/Kernel';
-import * as http from '../node-singletons/http';
-import type { IApplication } from './registry/type';
-export interface IServer {
-    listen(): Promise<void>;
-    close(): Promise<void>;
-    getHttpServer(): http.Server;
-}
-/**
- * Server - HTTP Server implementation
- * Refactored to Functional Object pattern
- */
-export declare const Server: Readonly<{
-    /**
-     * Create a new server instance
-     */
-    create(app: IApplication, port?: number, host?: string, kernel?: IKernel | null): IServer;
-}>;
-export default Server;
-//# sourceMappingURL=Server.d.ts.map

package/src/boot/Server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Server.d.ts","sourceRoot":"","sources":["../../../src/boot/Server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAM5C,OAAO,KAAK,IAAI,MAAM,uBAAuB,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,WAAW,OAAO;IACtB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,aAAa,IAAI,IAAI,CAAC,MAAM,CAAC;CAC9B;AAkED;;;GAGG;AACH,eAAO,MAAM,MAAM;IACjB;;OAEG;gBACS,YAAY,SAAS,MAAM,SAAS,MAAM,WAAU,OAAO,GAAG,IAAI,GAAU,OAAO;EA4D/F,CAAC;AAEH,eAAe,MAAM,CAAC"}

package/src/boot/Server.js

@@ -1,123 +0,0 @@
-/**
- * Server - HTTP Server implementation
- * Uses Node.js built-in HTTP server with no external dependencies
- */
-import { appConfig } from '../config/app.js';
-import { HTTP_HEADERS } from '../config/constants.js';
-import { Logger } from '../config/logger.js';
-import { ServiceContainer } from '../container/ServiceContainer.js';
-import { ErrorRouting } from '../routes/error.js';
-import { ErrorFactory } from '../exceptions/ZintrustError.js';
-import { Kernel } from '../http/Kernel.js';
-import { Request } from '../http/Request.js';
-import { Response } from '../http/Response.js';
-import * as http from '../node-singletons/http.js';
-/**
- * Set security headers on response
- */
-const getContentSecurityPolicyForPath = () => {
-    // Default CSP for the API/framework
-    return ("default-src 'self'; " +
-        "script-src 'self' 'unsafe-inline'; " +
-        "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; " +
-        "style-src-elem 'self' 'unsafe-inline' https://fonts.googleapis.com; " +
-        "img-src 'self' data:; " +
-        "font-src 'self' https://fonts.gstatic.com;");
-};
-const setSecurityHeaders = (res, contentType) => {
-    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');
-    // Only apply CSP to HTML responses, not API endpoints
-    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
-    if (contentType !== undefined && contentType !== null && contentType.includes('text/html')) {
-        res.setHeader(HTTP_HEADERS.CONTENT_SECURITY_POLICY, getContentSecurityPolicyForPath());
-    }
-};
-const handleRequest = async (params, req, res) => {
-    let request;
-    let response;
-    try {
-        const contentType = req?.headers['content-type'];
-        setSecurityHeaders(res, contentType);
-        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, port, host, kernel = null) {
-        const serverPort = port ?? appConfig.port;
-        const serverHost = host ?? appConfig.host;
-        let kernelInstance = kernel;
-        const getKernel = () => {
-            if (kernelInstance !== null)
-                return kernelInstance;
-            const anyApp = app;
-            const container = typeof anyApp.getContainer === 'function'
-                ? anyApp.getContainer()
-                : ServiceContainer.create();
-            kernelInstance = Kernel.create(app.getRouter(), container);
-            return kernelInstance;
-        };
-        const httpServer = http.createServer(async (req, res) => handleRequest({ getKernel }, req, res));
-        const sockets = new Set();
-        httpServer.on('connection', (socket) => {
-            sockets.add(socket);
-            socket.on('close', () => sockets.delete(socket));
-        });
-        return {
-            async listen() {
-                return new Promise((resolve) => {
-                    httpServer.listen(serverPort, serverHost, () => {
-                        resolve();
-                    });
-                });
-            },
-            async close() {
-                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() {
-                return httpServer;
-            },
-        };
-    },
-});
-export default Server;

package/src/boot/bootstrap.d.ts

@@ -1,7 +0,0 @@
-/**
- * Application Bootstrap
- * Entry point for running the ZinTrust server
- * Sealed namespace for immutability
- */
-export {};
-//# sourceMappingURL=bootstrap.d.ts.map

package/src/boot/bootstrap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/boot/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/src/boot/bootstrap.js

@@ -1,285 +0,0 @@
-/**
- * Application Bootstrap
- * Entry point for running the ZinTrust server
- * Sealed namespace for immutability
- */
-import { Application } from './Application.js';
-import { Server } from './Server.js';
-import { appConfig } from '../config/app.js';
-import { Env } from '../config/env.js';
-import { Logger } from '../config/logger.js';
-import { ErrorFactory } from '../exceptions/ZintrustError.js';
-import { ProjectRuntime } from '../runtime/ProjectRuntime.js';
-import { loadWorkersModule } from '../runtime/WorkersModule.js';
-let appInstance;
-let serverInstance;
-let isShuttingDown = false;
-let shutdownHandlersRegistered = false;
-const logBootstrapErrorDetails = (error) => {
-    // Best-effort: surface startup config validation details (already redacted)
-    // so container runs show which env vars are missing/misconfigured.
-    try {
-        const details = error?.details;
-        if (details?.errors !== undefined) {
-            Logger.error('Startup configuration errors:', details.errors);
-        }
-    }
-    catch {
-        // best-effort logging
-    }
-    // Best-effort: surface startup health-check report details.
-    try {
-        const details = error?.details;
-        if (details?.report !== undefined) {
-            Logger.error('Startup health report:', details.report);
-        }
-    }
-    catch {
-        // best-effort logging
-    }
-};
-const startSchedulesIfNeeded = async (application) => {
-    try {
-        if (Env.getBool('SCHEDULES_ENABLED', false) === false)
-            return;
-        const runtime = appConfig.detectRuntime();
-        if (runtime !== 'nodejs' && runtime !== 'fargate')
-            return;
-        const { SchedulerRuntime } = await import('../scheduler/SchedulerRuntime.js');
-        const coreSchedules = await import('../schedules/index.js');
-        let appSchedules = {};
-        try {
-            const appSchedulesModuleId = '@app/' + 'Schedules';
-            appSchedules = (await import(appSchedulesModuleId));
-        }
-        catch {
-            /* v8 ignore next */
-            appSchedules = {};
-        }
-        const isSchedule = (value) => {
-            if (value === null || value === undefined || typeof value !== 'object')
-                return false;
-            return ('name' in value &&
-                typeof value.name === 'string' &&
-                value.name.trim().length > 0);
-        };
-        const coreScheduleEntries = Object.values(coreSchedules).filter(isSchedule);
-        const appScheduleEntries = Object.values(appSchedules).filter(isSchedule);
-        SchedulerRuntime.registerMany(coreScheduleEntries, 'core');
-        SchedulerRuntime.registerMany(appScheduleEntries, 'app');
-        SchedulerRuntime.start();
-        // Add shutdown hook to stop schedules gracefully
-        const shutdownManager = application.getContainer().get('shutdownManager');
-        if ((typeof shutdownManager === 'object' || typeof shutdownManager === 'function') &&
-            shutdownManager !== null &&
-            'add' in shutdownManager &&
-            typeof shutdownManager.add === 'function') {
-            shutdownManager.add(async () => {
-                const scheduleTimeoutMs = Env.getInt('SCHEDULE_SHUTDOWN_TIMEOUT_MS', 30000);
-                await SchedulerRuntime.stop(scheduleTimeoutMs);
-            });
-        }
-    }
-    catch (err) {
-        Logger.warn('Failed to start schedules:', err);
-    }
-};
-const withTimeout = async (promise, timeoutMs, label) => {
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
-        return promise;
-    let timeoutId;
-    try {
-        const timeoutPromise = new Promise((_, reject) => {
-            timeoutId = globalThis.setTimeout(() => {
-                reject(ErrorFactory.createGeneralError(label, { timeoutMs }));
-            }, timeoutMs);
-        });
-        return await Promise.race([promise, timeoutPromise]);
-    }
-    finally {
-        if (timeoutId !== undefined)
-            globalThis.clearTimeout(timeoutId);
-    }
-};
-const gracefulShutdown = async (signal) => {
-    if (isShuttingDown)
-        return;
-    isShuttingDown = true;
-    const shutdownBudgetMs = Env.getInt('SHUTDOWN_TIMEOUT', 1500);
-    const minForceExitMs = shutdownBudgetMs + 250;
-    const forceExitMs = Math.max(Env.getInt('SHUTDOWN_FORCE_EXIT_MS', 10000), minForceExitMs);
-    const deadlineMs = Date.now() + shutdownBudgetMs;
-    const remainingMs = () => Math.max(0, deadlineMs - Date.now());
-    Logger.info(`${signal} received, shutting down gracefully...`);
-    try {
-        const forceExitTimer = globalThis.setTimeout(() => {
-            process.exit(0);
-        }, forceExitMs);
-        // Best-effort: don't keep the process alive just for this timer
-        forceExitTimer.unref?.();
-        await withTimeout((async () => {
-            // Shutdown worker management system FIRST (before database closes)
-            if (appConfig.worker === true &&
-                (appConfig.detectRuntime() === 'nodejs' || appConfig.detectRuntime() === 'lambda') &&
-                appConfig.dockerWorker === false) {
-                try {
-                    const workers = await loadWorkersModule();
-                    const workerBudgetMs = Math.min(15000, remainingMs());
-                    await withTimeout(workers.WorkerShutdown.shutdown({
-                        signal,
-                        timeout: workerBudgetMs,
-                        forceExit: false,
-                    }), workerBudgetMs, 'Worker shutdown timed out');
-                }
-                catch (error) {
-                    Logger.warn('Worker shutdown failed (continuing with app shutdown)', error);
-                }
-            }
-            if (serverInstance !== undefined) {
-                await serverInstance.close();
-            }
-            if (appInstance !== undefined) {
-                try {
-                    const appBudgetMs = Math.min(5000, remainingMs());
-                    await withTimeout(appInstance.shutdown(), appBudgetMs, 'App shutdown timed out');
-                }
-                catch (error) {
-                    Logger.warn('App shutdown failed or timed out, forcing exit', error);
-                }
-            }
-        })(), shutdownBudgetMs, 'Graceful shutdown timed out');
-        globalThis.clearTimeout(forceExitTimer);
-        process.exit(0);
-    }
-    catch (error) {
-        Logger.error('Graceful shutdown failed:', error);
-        process.exit(1);
-    }
-};
-async function useWorkerStarter() {
-    // Check if workers are enabled in this environment
-    if (!appConfig.worker || appConfig.dockerWorker === true) {
-        Logger.info('Workers disabled in this runtime (WORKER_ENABLED=false && DOCKER_WORKER=true), skipping worker management initialization');
-        return;
-    }
-    // Initialize worker management system
-    let workerInit = null;
-    try {
-        const workers = await loadWorkersModule();
-        if (workers?.WorkerInit !== undefined) {
-            workerInit = workers.WorkerInit;
-            await workers.WorkerInit.initialize({
-                enableResourceMonitoring: true,
-                enableHealthMonitoring: true,
-                enableAutoScaling: false, // Disabled by default, enable via config
-                registerShutdownHandlers: true,
-                resourceMonitoringInterval: 60000,
-            });
-            Logger.info('Worker management system initialized');
-        }
-    }
-    catch {
-        // Logger.warn('Worker management system initialization failed (non-fatal)', error as Error);
-        // Non-fatal - application can still run without worker management
-    }
-    if (workerInit?.autoStartPersistedWorkers) {
-        await workerInit.autoStartPersistedWorkers();
-    }
-}
-/**
- * Bootstrap implementation
- */
-const BootstrapFunctions = Object.freeze({
-    /**
-     * Bootstrap and start the server
-     */
-    async start() {
-        try {
-            // Ensure project-installed adapters/drivers are registered for web server.
-            // (This is driven by src/zintrust.plugins.ts generated by `zin plugin install`.)
-            try {
-                const { PluginAutoImports } = await import('../runtime/PluginAutoImports.js');
-                if (appConfig.dockerWorker === true) {
-                    const officialImports = await PluginAutoImports.tryImportRuntimeAutoImports('base');
-                    if (!officialImports.ok) {
-                        Logger.warn('Official plugin auto-imports failed:', ErrorFactory.createGeneralError('officialImports', officialImports.errorMessage));
-                    }
-                }
-                const projectImports = await PluginAutoImports.tryImportProjectAutoImports();
-                if (!projectImports.ok && projectImports.reason !== 'not-found') {
-                    Logger.warn('Project plugin auto-imports failed:', ErrorFactory.createGeneralError('projectImports', projectImports.errorMessage));
-                }
-            }
-            catch (error) {
-                // best-effort; run without plugins if loader fails (e.g. non-Node runtime)
-                Logger.warn('Plugin auto-imports loader skipped:', error);
-            }
-            try {
-                await ProjectRuntime.tryLoadNodeRuntime();
-            }
-            catch (error) {
-                Logger.warn('Project runtime hook loader skipped:', error);
-            }
-            // Create application instance
-            // if (Env.ZINTRUST_PROJECT_ROOT) {
-            // }
-            const app = Application.create(Env.ZINTRUST_PROJECT_ROOT || undefined);
-            appInstance = app;
-            // Boot application
-            await app.boot();
-            // Get port and host from environment
-            const port = Env.getInt('PORT', 7777);
-            const host = Env.get('HOST', 'localhost');
-            // Create and start server
-            const server = Server.create(app, port, host);
-            serverInstance = server;
-            // Start listening
-            await server.listen();
-            Logger.info(`Server running at http://${host}:${port}`);
-            Logger.info(`ZinTrust documentation at http://${host}:${port}/zintrust-doc`);
-            // Start schedules for long-running runtimes (Node.js / Fargate)
-            await startSchedulesIfNeeded(app);
-            if (appConfig.worker === true &&
-                appConfig.dockerWorker === false &&
-                (appConfig.detectRuntime() === 'nodejs' || appConfig.detectRuntime() === 'lambda')) {
-                await useWorkerStarter();
-            }
-        }
-        catch (error) {
-            try {
-                Logger.error('Failed to bootstrap application:', error);
-            }
-            catch {
-                // best-effort logging
-            }
-            logBootstrapErrorDetails(error);
-            process.exit(1);
-        }
-    },
-    /**
-     * Handle graceful shutdown
-     */
-    setupShutdownHandler() {
-        if (shutdownHandlersRegistered)
-            return;
-        shutdownHandlersRegistered = true;
-        process.on('SIGTERM', async () => {
-            await gracefulShutdown('SIGTERM');
-        });
-        process.on('SIGINT', async () => {
-            await gracefulShutdown('SIGINT');
-        });
-    },
-});
-// Run bootstrap
-await BootstrapFunctions.start().catch((error) => {
-    try {
-        Logger.error('Failed to bootstrap application:', error);
-    }
-    catch {
-        // best-effort logging
-    }
-    process.exit(1);
-});
-// Handle graceful shutdown
-BootstrapFunctions.setupShutdownHandler();

package/src/boot/registry/registerRoute.d.ts

@@ -1,6 +0,0 @@
-import { type IRouter } from '../../routes/Router';
-export declare const isCompiledJsModule: () => boolean;
-export declare const tryImportOptional: <T>(modulePath: string) => Promise<T | undefined>;
-export declare const tryImportOptionalR: <T>(modulePath: string) => Promise<T | undefined>;
-export declare const registerMasterRoutes: (resolvedBasePath: string, router: IRouter) => Promise<void>;
-//# sourceMappingURL=registerRoute.d.ts.map

package/src/boot/registry/registerRoute.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerRoute.d.ts","sourceRoot":"","sources":["../../../../src/boot/registry/registerRoute.ts"],"names":[],"mappings":"AAEA,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAc3D,eAAO,MAAM,kBAAkB,QAAO,OAKrC,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,CAAC,EAAE,YAAY,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAMpF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,CAAC,EAAE,YAAY,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAOrF,CAAC;AA2LF,eAAO,MAAM,oBAAoB,GAC/B,kBAAkB,MAAM,EACxB,QAAQ,OAAO,KACd,OAAO,CAAC,IAAI,CAqBd,CAAC"}