@zintrust/core 0.1.0

package/src/boot/Server.js

@@ -0,0 +1,236 @@
+/**
+ * Server - HTTP Server implementation
+ * Uses Node.js built-in HTTP server with no external dependencies
+ */
+import { appConfig } from '../config/app';
+import { HTTP_HEADERS, MIME_TYPES } from '../config/constants';
+import { Logger } from '../config/logger';
+import { ErrorFactory } from '../exceptions/ZintrustError';
+import { Request } from '../http/Request';
+import { Response } from '../http/Response';
+import * as fs from '../node-singletons/fs';
+import * as http from '../node-singletons/http';
+import * as path from '../node-singletons/path';
+import { fileURLToPath } from '../node-singletons/url';
+import { Router } from '../routing/Router';
+const MIME_TYPES_MAP = {
+    '.html': MIME_TYPES.HTML,
+    '.js': MIME_TYPES.JS,
+    '.css': MIME_TYPES.CSS,
+    '.json': MIME_TYPES.JSON,
+    '.png': MIME_TYPES.PNG,
+    '.jpg': MIME_TYPES.JPG,
+    '.gif': MIME_TYPES.GIF,
+    '.svg': MIME_TYPES.SVG,
+    '.wav': MIME_TYPES.WAV,
+    '.mp4': MIME_TYPES.MP4,
+    '.woff': MIME_TYPES.WOFF,
+    '.ttf': MIME_TYPES.TTF,
+    '.eot': MIME_TYPES.EOT,
+    '.otf': MIME_TYPES.OTF,
+    '.wasm': MIME_TYPES.WASM,
+};
+const findPackageRoot = (startDir) => {
+    let current = startDir;
+    for (let i = 0; i < 10; i++) {
+        if (fs.existsSync(path.join(current, 'package.json')))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    return startDir;
+};
+const getFrameworkPublicRoots = () => {
+    const thisFile = fileURLToPath(import.meta.url);
+    const thisDir = path.dirname(thisFile);
+    const packageRoot = findPackageRoot(thisDir);
+    return [
+        path.join(packageRoot, 'dist/public'),
+        path.join(packageRoot, 'docs-website/public'),
+        path.join(packageRoot, 'public'), // Fallback for shipped package
+    ];
+};
+const getDocsPublicRoot = () => {
+    const isProduction = process.env.NODE_ENV === 'production';
+    // First try app-local roots (developer app override), then fall back to framework-shipped assets.
+    const appRoots = isProduction
+        ? [path.join(process.cwd(), 'public')]
+        : [path.join(process.cwd(), 'docs-website/public')];
+    const candidates = [...appRoots, ...getFrameworkPublicRoots()];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return appRoots[0];
+};
+const stripLeadingSlashes = (value) => value.replace(/^\/+/, '');
+/**
+ * Map URL path to physical file path
+ */
+const mapStaticPath = (urlPath) => {
+    const publicRoot = getDocsPublicRoot();
+    if (urlPath.startsWith('/doc')) {
+        const rest = stripLeadingSlashes(urlPath.slice('/doc'.length));
+        const docPath = path.join(publicRoot, 'doc');
+        // If a 'doc' folder exists inside publicRoot, use it.
+        // Otherwise, assume publicRoot contains the docs directly.
+        if (fs.existsSync(docPath)) {
+            return rest === '' ? docPath : path.join(docPath, rest);
+        }
+        return rest === '' ? publicRoot : path.join(publicRoot, rest);
+    }
+    return '';
+};
+/**
+ * Send static file to response
+ */
+const sendStaticFile = (filePath, response) => {
+    const ext = path.extname(filePath).toLowerCase();
+    const contentType = MIME_TYPES_MAP[ext] || 'application/octet-stream';
+    const content = fs.readFileSync(filePath);
+    response.setStatus(200);
+    response.setHeader('Content-Type', contentType);
+    response.send(content);
+};
+/**
+ * Serve static files from docs-website
+ */
+// eslint-disable-next-line @typescript-eslint/require-await
+const serveStatic = async (request, response) => {
+    const urlPath = request.getPath();
+    // Canonicalize docs base path (VitePress expects trailing slash for correct relative resolution)
+    if (urlPath === '/doc') {
+        response.setStatus(302);
+        response.setHeader('Location', '/doc/');
+        response.send('');
+        return true;
+    }
+    let filePath = mapStaticPath(urlPath);
+    if (!filePath)
+        return false;
+    try {
+        // If it's a directory, look for index.html
+        if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
+            filePath = path.join(filePath, 'index.html');
+        }
+        // Handle clean URLs (try adding .html)
+        if (!fs.existsSync(filePath) && !path.extname(filePath)) {
+            const htmlPath = `${filePath}.html`;
+            if (fs.existsSync(htmlPath)) {
+                filePath = htmlPath;
+            }
+        }
+        if (fs.existsSync(filePath)) {
+            sendStaticFile(filePath, response);
+            return true;
+        }
+    }
+    catch (error) {
+        ErrorFactory.createTryCatchError(`Error serving static file ${filePath}`, error);
+    }
+    return false;
+};
+/**
+ * Set security headers on response
+ */
+const getContentSecurityPolicyForPath = (requestPath) => {
+    // Default CSP for the API/framework.
+    const baseCsp = "default-src 'self'; " +
+        "script-src 'self' 'unsafe-inline'; " +
+        "style-src 'self' 'unsafe-inline'; " +
+        "img-src 'self' data:; " +
+        "font-src 'self';";
+    // Docs pages intentionally load external assets (Tailwind CDN + Google Fonts).
+    // Keep this relaxation scoped to the docs base path.
+    if (!requestPath.startsWith('/doc'))
+        return baseCsp;
+    return ("default-src 'self'; " +
+        "script-src 'self' 'unsafe-inline' 'unsafe-eval'; " +
+        "script-src-elem '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: https:; " +
+        "font-src 'self' data: https://fonts.gstatic.com;");
+};
+const setSecurityHeaders = (res, requestPath) => {
+    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(requestPath));
+};
+/**
+ * Handle incoming HTTP requests
+ */
+const handleRequest = async (app, req, res) => {
+    try {
+        // Use the raw URL so docs assets (/doc/assets/...) get the correct CSP.
+        const requestPath = typeof req?.url === 'string' ? req.url : '/';
+        setSecurityHeaders(res, requestPath);
+        if (!req) {
+            throw ErrorFactory.createConnectionError('Request object is missing');
+        }
+        const request = Request.create(req);
+        const response = Response.create(res);
+        // Route the request
+        const router = app.getRouter();
+        const route = Router.match(router, request.getMethod(), request.getPath());
+        if (route === null) {
+            // Try serving static files from docs-website
+            if (await serveStatic(request, response)) {
+                return;
+            }
+            // 404 Not Found
+            response.setStatus(404).json({ message: 'Not Found' });
+        }
+        else {
+            // Handler found, execute route handler
+            request.setParams(route.params);
+            await route.handler(request, response);
+        }
+    }
+    catch (error) {
+        ErrorFactory.createTryCatchError('Server error:', error);
+        res.writeHead(500, { [HTTP_HEADERS.CONTENT_TYPE]: MIME_TYPES.JSON });
+        res.end(JSON.stringify({ message: 'Internal Server Error' }));
+    }
+};
+/**
+ * Server - HTTP Server implementation
+ * Refactored to Functional Object pattern
+ */
+export const Server = Object.freeze({
+    /**
+     * Create a new server instance
+     */
+    create(app, port, host) {
+        const serverPort = port ?? appConfig.port;
+        const serverHost = host ?? appConfig.host;
+        const httpServer = http.createServer(async (req, res) => handleRequest(app, req, res));
+        return {
+            async listen() {
+                return new Promise((resolve) => {
+                    httpServer.listen(serverPort, serverHost, () => {
+                        Logger.info(`Zintrust server running at http://${serverHost}:${serverPort}`);
+                        resolve();
+                    });
+                });
+            },
+            async close() {
+                return new Promise((resolve) => {
+                    httpServer.close(() => {
+                        Logger.info('Zintrust server stopped');
+                        resolve();
+                    });
+                });
+            },
+            getHttpServer() {
+                return httpServer;
+            },
+        };
+    },
+});
+export default Server;

package/src/boot/bootstrap.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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

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

package/src/boot/bootstrap.js

@@ -0,0 +1,64 @@
+/**
+ * Application Bootstrap
+ * Entry point for running the Zintrust server
+ * Sealed namespace for immutability
+ */
+import { Application } from './Application';
+import { Server } from './Server';
+import { Env } from '../config/env';
+import { Logger } from '../config/logger';
+import { ErrorFactory } from '../exceptions/ZintrustError';
+/**
+ * Bootstrap implementation
+ */
+const BootstrapFunctions = Object.freeze({
+    /**
+     * Bootstrap and start the server
+     */
+    async start() {
+        try {
+            // Create application instance
+            const app = Application.create();
+            // Boot application
+            await app.boot();
+            // Get port and host from environment
+            const port = Env.getInt('PORT', 3000);
+            const host = Env.get('HOST', 'localhost');
+            // Create and start server
+            const server = Server.create(app, port, host);
+            // Start listening
+            await server.listen();
+            Logger.info(`Server running at http://${host}:${port}`);
+        }
+        catch (error) {
+            Logger.error('Failed to bootstrap application:', error);
+            ErrorFactory.createTryCatchError('Failed to bootstrap application:', error);
+            process.exit(1);
+        }
+    },
+    /**
+     * Handle graceful shutdown
+     */
+    setupShutdownHandler() {
+        process.on('SIGTERM', () => {
+            Logger.info('SIGTERM received, shutting down gracefully...');
+            process.exit(0);
+        });
+        process.on('SIGINT', () => {
+            Logger.info('SIGINT received, shutting down gracefully...');
+            process.exit(0);
+        });
+    },
+});
+// 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/builder/BundleOptimizer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Bundle Optimizer for Zintrust Framework
+ * Reduces deployment package size by:
+ * - Tree-shaking unused ORM adapters
+ * - Minifying compiled JavaScript
+ * - Removing dev dependencies
+ * - Inlining configuration
+ */
+export interface OptimizationOptions {
+    platform: 'lambda' | 'cloudflare' | 'deno' | 'fargate';
+    targetSize?: number;
+    analyzeOnly?: boolean;
+    verbose?: boolean;
+}
+export interface BundleAnalysis {
+    platform: string;
+    totalSize: number;
+    files: Array<{
+        path: string;
+        size: number;
+        percentage: number;
+    }>;
+    recommendations: string[];
+}
+export interface IBundleOptimizer {
+    optimize(): Promise<BundleAnalysis>;
+}
+/**
+ * Bundle optimizer - reduces deployed package size
+ * Sealed namespace for immutability
+ */
+export declare const BundleOptimizer: Readonly<{
+    /**
+     * Create a new bundle optimizer instance
+     */
+    create(options: OptimizationOptions): IBundleOptimizer;
+}>;
+/**
+ * CLI command for bundle optimization
+ */
+export declare function runOptimizer(): Promise<void>;
+//# sourceMappingURL=BundleOptimizer.d.ts.map

package/src/builder/BundleOptimizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BundleOptimizer.d.ts","sourceRoot":"","sources":["../../../src/builder/BundleOptimizer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,QAAQ,GAAG,YAAY,GAAG,MAAM,GAAG,SAAS,CAAC;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;IACH,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC;CACrC;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B;;OAEG;oBACa,mBAAmB,GAAG,gBAAgB;EA0CtD,CAAC;AAkXH;;GAEG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAclD"}