@zintrust/core 0.1.0

package/src/runtime/adapters/LambdaAdapter.js

@@ -0,0 +1,302 @@
+/**
+ * Runtime adapter for AWS Lambda
+ */
+import { Env } from '../../config/env';
+import { Logger } from '../../config/logger';
+import { ErrorResponse, HttpResponse, } from '../RuntimeAdapter';
+import { IncomingMessage, ServerResponse, } from 'node:http';
+/**
+ * AWS Lambda adapter for API Gateway and ALB events
+ * Converts Lambda events to standard HTTP format for Zintrust framework
+ * Sealed namespace for immutability
+ */
+export const LambdaAdapter = Object.freeze({
+    /**
+     * Create a new Lambda adapter instance
+     */
+    create(config) {
+        const configuredLoggerProvided = config.logger !== undefined;
+        const defaultLogger = configuredLoggerProvided ? undefined : createDefaultLogger();
+        const adapter = {
+            platform: 'lambda',
+            logger: config.logger,
+            createMockHttpObjects,
+            async handle(event, context) {
+                return handleLambdaRequest(adapter, config, event, context);
+            },
+            parseRequest(event) {
+                return parseLambdaRequest(event);
+            },
+            formatResponse(response) {
+                return formatLambdaResponse(response);
+            },
+            getLogger() {
+                if (adapter.logger !== undefined)
+                    return adapter.logger;
+                if (configuredLoggerProvided === true)
+                    return createFallbackLogger();
+                return defaultLogger ?? createDefaultLogger();
+            },
+            supportsPersistentConnections() {
+                // Lambda containers persist for warm invocations
+                return true;
+            },
+            getEnvironment() {
+                return {
+                    nodeEnv: Env.NODE_ENV,
+                    runtime: 'lambda',
+                    dbConnection: Env.DB_CONNECTION,
+                    dbHost: Env.DB_HOST,
+                    dbPort: Env.DB_PORT,
+                };
+            },
+        };
+        return adapter;
+    },
+});
+/**
+ * Handle Lambda request
+ */
+async function handleLambdaRequest(adapter, config, event, _context) {
+    try {
+        const lambdaEvent = event;
+        const request = adapter.parseRequest(event);
+        // Create mock Node.js request/response objects
+        const { req, res, responseData } = (adapter.createMockHttpObjects ?? createMockHttpObjects)(request);
+        // Parse body
+        const body = parseBody(lambdaEvent);
+        // Set request timeout
+        const timeout = config.timeout ?? 30000;
+        const timeoutHandle = setTimeout(() => {
+            res.writeHead(504, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                error: 'Gateway Timeout',
+                statusCode: 504,
+            }));
+        }, timeout);
+        try {
+            // Process request through Zintrust handler
+            await config.handler(req, res, body);
+        }
+        finally {
+            clearTimeout(timeoutHandle);
+        }
+        // Extract response
+        const response = HttpResponse.create();
+        response.setStatus(responseData.statusCode);
+        response.setHeaders(responseData.headers);
+        response.setBody(responseData.body);
+        adapter.getLogger().debug('Lambda request processed', {
+            statusCode: response.statusCode,
+            path: request.path,
+            method: request.method,
+        });
+        return response.toResponse();
+    }
+    catch (error) {
+        Logger.error('Lambda handler error', error);
+        const errorResponse = ErrorResponse.create(500, 'Internal Server Error', Env.NODE_ENV === 'development' ? { message: error.message } : undefined);
+        return errorResponse.toResponse();
+    }
+}
+/**
+ * Parse Lambda request
+ */
+function parseLambdaRequest(event) {
+    const lambdaEvent = event;
+    // Support both API Gateway v1 and v2 formats, plus ALB
+    const isV2 = 'requestContext' in lambdaEvent && 'http' in lambdaEvent.requestContext;
+    const isAlb = 'requestContext' in lambdaEvent && 'elb' in lambdaEvent.requestContext;
+    let requestData;
+    if (isV2 === true) {
+        requestData = parseV2Request(lambdaEvent);
+    }
+    else if (isAlb === true) {
+        requestData = parseAlbRequest(lambdaEvent);
+    }
+    else {
+        requestData = parseV1Request(lambdaEvent);
+    }
+    return {
+        method: requestData.method.toUpperCase(),
+        path: requestData.path,
+        headers: normalizeHeaders(requestData.headers),
+        body: requestData.body === null ? null : Buffer.from(requestData.body),
+        query: requestData.query,
+        remoteAddr: requestData.remoteAddr,
+    };
+}
+/**
+ * Format Lambda response
+ */
+function formatLambdaResponse(response) {
+    // Lambda expects specific format
+    return {
+        statusCode: response.statusCode,
+        headers: response.headers,
+        body: typeof response.body === 'string' ? response.body : (response.body?.toString('utf-8') ?? ''),
+        isBase64Encoded: response.isBase64Encoded ?? false,
+    };
+}
+/**
+ * Parse body from Lambda event
+ */
+function parseBody(event) {
+    const body = event.body;
+    if (body === null || body === undefined || body === '')
+        return null;
+    if (event.isBase64Encoded === true && typeof body === 'string') {
+        return Buffer.from(body, 'base64');
+    }
+    return typeof body === 'string' ? Buffer.from(body, 'utf-8') : Buffer.from(body);
+}
+/**
+ * Create mock Node.js request/response objects
+ */
+function createMockHttpObjects(request) {
+    const responseData = {
+        statusCode: 200,
+        headers: { 'Content-Type': 'application/json' },
+        body: null,
+    };
+    // Create mock request object
+    const req = new IncomingMessage(null);
+    req.method = request.method;
+    req.url = request.path;
+    req.headers = request.headers;
+    req.remoteAddress =
+        request.remoteAddr !== undefined && request.remoteAddr !== '' ? request.remoteAddr : '0.0.0.0';
+    // Create mock response object
+    const res = new ServerResponse(req);
+    res.writeHead = function (statusCode, statusMessageOrHeaders, headers) {
+        responseData.statusCode = statusCode;
+        const headersObj = typeof statusMessageOrHeaders === 'object' ? statusMessageOrHeaders : headers;
+        if (headersObj) {
+            Object.assign(responseData.headers, headersObj);
+        }
+        return res;
+    };
+    res.end = function (chunk, _encodingOrCb, _cb) {
+        if (typeof chunk === 'function') {
+            chunk();
+        }
+        else if (chunk !== null && chunk !== undefined) {
+            responseData.body = chunk;
+        }
+        return res;
+    };
+    res.write = function (chunk) {
+        responseData.body = chunk;
+        return true;
+    };
+    return { req, res, responseData };
+}
+/**
+ * Get remote address for API Gateway v2
+ */
+function getRemoteAddrV2(event, headers) {
+    if (event.requestContext.http.sourceIp !== '') {
+        return event.requestContext.http.sourceIp;
+    }
+    const forwarded = headers['x-forwarded-for']?.toString().split(',')[0];
+    if (forwarded !== undefined && forwarded !== '') {
+        return forwarded;
+    }
+    return '0.0.0.0';
+}
+/**
+ * Get remote address for ALB
+ */
+function getRemoteAddrAlb(headers) {
+    const forwarded = headers['x-forwarded-for']?.toString().split(',')[0];
+    if (forwarded !== undefined && forwarded !== '') {
+        return forwarded;
+    }
+    const realIp = headers['x-real-ip']?.toString();
+    if (realIp !== undefined && realIp !== '') {
+        return realIp;
+    }
+    return '0.0.0.0';
+}
+/**
+ * Get remote address for API Gateway v1
+ */
+function getRemoteAddrV1(headers) {
+    const forwardedCap = headers['X-Forwarded-For']?.toString().split(',')[0];
+    if (forwardedCap !== undefined && forwardedCap !== '') {
+        return forwardedCap;
+    }
+    const forwarded = headers['x-forwarded-for']?.toString().split(',')[0];
+    if (forwarded !== undefined && forwarded !== '') {
+        return forwarded;
+    }
+    return '0.0.0.0';
+}
+/**
+ * Parse API Gateway v2 request
+ */
+function parseV2Request(event) {
+    const headers = event.headers ?? {};
+    return {
+        method: event.requestContext.http.method,
+        path: event.rawPath,
+        headers,
+        query: event.queryStringParameters ?? {},
+        body: event.body ?? null,
+        remoteAddr: getRemoteAddrV2(event, headers),
+    };
+}
+/**
+ * Parse ALB request
+ */
+function parseAlbRequest(event) {
+    const headers = event.headers ?? {};
+    return {
+        method: event.httpMethod,
+        path: event.path,
+        headers,
+        query: event.queryStringParameters ?? {},
+        body: event.body ?? null,
+        remoteAddr: getRemoteAddrAlb(headers),
+    };
+}
+/**
+ * Parse API Gateway v1 request
+ */
+function parseV1Request(event) {
+    const headers = event.headers ?? {};
+    return {
+        method: event.httpMethod,
+        path: event.path,
+        headers,
+        query: event.queryStringParameters ?? {},
+        body: event.body ?? null,
+        remoteAddr: getRemoteAddrV1(headers),
+    };
+}
+/**
+ * Normalize headers to lowercase
+ */
+function normalizeHeaders(headers) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(headers)) {
+        normalized[key.toLowerCase()] = value;
+    }
+    return normalized;
+}
+function createDefaultLogger() {
+    return {
+        debug: (msg, data) => Logger.debug(`[Lambda] ${msg}`, data === undefined ? '' : JSON.stringify(data)),
+        info: (msg, data) => Logger.info(`[Lambda] ${msg}`, data === undefined ? '' : JSON.stringify(data)),
+        warn: (msg, data) => Logger.warn(`[Lambda] ${msg}`, data === undefined ? '' : JSON.stringify(data)),
+        error: (msg, err) => Logger.error(`[Lambda] ${msg}`, err?.message),
+    };
+}
+function createFallbackLogger() {
+    return {
+        debug: (msg) => Logger.debug(`[Lambda] ${msg}`),
+        info: (msg) => Logger.info(`[Lambda] ${msg}`),
+        warn: (msg) => Logger.warn(`[Lambda] ${msg}`),
+        error: (msg, err) => Logger.error(`[Lambda] ${msg}`, err?.message),
+    };
+}

package/src/runtime/adapters/NodeServerAdapter.d.ts

@@ -0,0 +1,16 @@
+import { AdapterConfig, RuntimeAdapter } from '../RuntimeAdapter';
+/**
+ * Node.js HTTP Server adapter for standard containers and traditional servers
+ * Uses Node.js built-in HTTP server for maximum compatibility
+ * Sealed namespace for immutability
+ */
+export declare const NodeServerAdapter: Readonly<{
+    /**
+     * Create a new Node.js server adapter instance
+     */
+    create(config: AdapterConfig): RuntimeAdapter & {
+        startServer(port?: number, host?: string): Promise<void>;
+        stop(): Promise<void>;
+    };
+}>;
+//# sourceMappingURL=NodeServerAdapter.d.ts.map

package/src/runtime/adapters/NodeServerAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeServerAdapter.d.ts","sourceRoot":"","sources":["../../../../src/runtime/adapters/NodeServerAdapter.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,aAAa,EAGb,cAAc,EACf,MAAM,yBAAyB,CAAC;AAEjC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;IAC5B;;OAEG;mBACY,aAAa,GAAG,cAAc,GAAG;QAC9C,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QACzD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;KACvB;EAmED,CAAC"}

package/src/runtime/adapters/NodeServerAdapter.js

@@ -0,0 +1,199 @@
+import { Env } from '../../config/env';
+import Logger from '../../config/logger';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { createServer } from '../../node-singletons/http';
+/**
+ * Node.js HTTP Server adapter for standard containers and traditional servers
+ * Uses Node.js built-in HTTP server for maximum compatibility
+ * Sealed namespace for immutability
+ */
+export const NodeServerAdapter = Object.freeze({
+    /**
+     * Create a new Node.js server adapter instance
+     */
+    create(config) {
+        const logger = config.logger || createDefaultLogger();
+        const state = {};
+        return {
+            platform: 'nodejs',
+            async handle() {
+                throw ErrorFactory.createConfigError('Node.js adapter requires startServer() method. Use RuntimeDetector for automatic initialization.');
+            },
+            /**
+             * Start HTTP server for Node.js environments
+             */
+            async startServer(port = 3000, host = 'localhost') {
+                return startNodeServer(state, config, logger, port, host);
+            },
+            /**
+             * Stop the HTTP server gracefully
+             */
+            async stop() {
+                return stopNodeServer(state, logger);
+            },
+            parseRequest() {
+                throw ErrorFactory.createConfigError('Node.js adapter uses native Node.js HTTP');
+            },
+            formatResponse() {
+                throw ErrorFactory.createConfigError('Node.js adapter uses native Node.js HTTP');
+            },
+            getLogger() {
+                return (logger ?? {
+                    debug: (msg) => Logger.debug(`[Node.js] ${msg}`),
+                    info: (msg) => Logger.info(`[Node.js] ${msg}`),
+                    warn: (msg) => Logger.warn(`[Node.js] ${msg}`),
+                    error: (msg, err) => Logger.error(`[Node.js] ${msg}`, err?.message),
+                });
+            },
+            supportsPersistentConnections() {
+                return true;
+            },
+            getEnvironment() {
+                return getNodeEnvironment();
+            },
+        };
+    },
+});
+/**
+ * Start Node.js HTTP server
+ */
+async function startNodeServer(state, config, logger, port, host) {
+    return new Promise((resolve, reject) => {
+        state.server = createServer((req, res) => {
+            void handleRequest(req, res, config, logger);
+        });
+        state.server.listen(port, host, () => {
+            logger?.info(`Node.js server listening on http://${host}:${port}`);
+            resolve();
+        });
+        state.server.on('error', (error) => {
+            logger?.error('Server error', error);
+            reject(error);
+        });
+        state.server.on('clientError', (error, socket) => {
+            if (error.code === 'ECONNRESET' || !socket.writable) {
+                return;
+            }
+            logger?.warn(`Client error: ${error.message}`);
+        });
+    });
+}
+/**
+ * Stop Node.js HTTP server
+ */
+async function stopNodeServer(state, logger) {
+    return new Promise((resolve) => {
+        if (state.server) {
+            state.server.close(() => {
+                logger?.info('Node.js server stopped');
+                resolve();
+            });
+        }
+        else {
+            resolve();
+        }
+    });
+}
+/**
+ * Get Node.js environment
+ */
+function getNodeEnvironment() {
+    return {
+        nodeEnv: Env.NODE_ENV,
+        runtime: 'nodejs',
+        dbConnection: Env.DB_CONNECTION,
+        dbHost: Env.DB_HOST,
+        dbPort: Env.DB_PORT,
+    };
+}
+/**
+ * Handle request processing
+ */
+async function handleRequest(req, res, config, logger) {
+    const chunks = [];
+    let body = null;
+    // Collect request body
+    req.on('data', (chunk) => {
+        const maxSize = config.maxBodySize ?? 10 * 1024 * 1024;
+        if (chunks.length * chunk.length > maxSize) {
+            res.writeHead(413, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Payload Too Large' }));
+            req.socket.destroy();
+            return;
+        }
+        chunks.push(chunk);
+    });
+    req.on('end', async () => {
+        try {
+            body = chunks.length > 0 ? Buffer.concat(chunks) : null;
+            // Set request timeout
+            const timeout = config.timeout ?? 30000;
+            const timeoutHandle = setTimeout(() => {
+                if (!res.headersSent) {
+                    res.writeHead(504, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Gateway Timeout' }));
+                }
+            }, timeout);
+            try {
+                // Call Zintrust handler
+                await config.handler(req, res, body);
+            }
+            finally {
+                clearTimeout(timeoutHandle);
+            }
+            logger?.debug('Request processed', {
+                method: req.method,
+                url: req.url,
+                statusCode: res.statusCode,
+                remoteAddr: req.socket.remoteAddress,
+            });
+        }
+        catch (error) {
+            const err = error;
+            logger?.error('Request processing error', err);
+            Logger.error('Request processing error', err.message);
+            handleError(res, err, logger);
+        }
+    });
+    req.on('error', (error) => {
+        Logger.error('Request stream error', error.message);
+        handleRequestError(res, error, logger);
+    });
+}
+/**
+ * Handle request handler errors
+ */
+function handleError(res, error, logger) {
+    logger?.error('Request handler error', error);
+    Logger.error('Request handler error', error.message);
+    if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            error: 'Internal Server Error',
+            statusCode: 500,
+            timestamp: new Date().toISOString(),
+            ...(Env.get('NODE_ENV') === 'development' && {
+                message: error.message,
+            }),
+        }));
+    }
+}
+/**
+ * Handle request stream errors
+ */
+function handleRequestError(res, error, logger) {
+    logger?.error('Request error', error);
+    Logger.error('Request error', error.message);
+    if (!res.headersSent) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Bad Request' }));
+    }
+}
+function createDefaultLogger() {
+    return {
+        debug: (msg, data) => Logger.debug(`[Node.js] ${msg}`, data !== undefined && data !== null ? JSON.stringify(data) : ''),
+        info: (msg, data) => Logger.info(`[Node.js] ${msg}`, data !== undefined && data !== null ? JSON.stringify(data) : ''),
+        warn: (msg, data) => Logger.warn(`[Node.js] ${msg}`, data !== undefined && data !== null ? JSON.stringify(data) : ''),
+        error: (msg, err) => Logger.error(`[Node.js] ${msg}`, err?.message),
+    };
+}

package/src/scripts/TemplateSync.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Template Sync Script
+ * Synchronizes base framework files to .tpl templates when checksums change
+ * Runs during npm run build
+ */
+export {};
+//# sourceMappingURL=TemplateSync.d.ts.map

package/src/scripts/TemplateSync.d.ts.map

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