@zintrust/core 0.1.0

package/src/runtime/adapters/DenoAdapter.js

@@ -0,0 +1,191 @@
+/**
+ * Runtime adapter for Deno
+ */
+import Logger from '../../config/logger';
+import { createMockHttpObjects, ErrorResponse, } from '../RuntimeAdapter';
+/**
+ * Deno runtime adapter for Deno Deploy and edge compute environments
+ * Sealed namespace for immutability
+ */
+export const DenoAdapter = Object.freeze({
+    /**
+     * Create a new Deno adapter instance
+     */
+    create(config) {
+        const logger = config.logger || createDefaultLogger();
+        return {
+            platform: 'deno',
+            async handle(event, context) {
+                return handleDenoRequest(this, config, logger, event, context);
+            },
+            parseRequest(event) {
+                return parseDenoRequest(event);
+            },
+            formatResponse(response) {
+                return formatDenoResponse(response);
+            },
+            getLogger() {
+                return (logger || {
+                    debug: (msg) => Logger.debug(`[Deno] ${msg}`),
+                    info: (msg) => Logger.info(`[Deno] ${msg}`),
+                    warn: (msg) => Logger.warn(`[Deno] ${msg}`),
+                    error: (msg, err) => Logger.error(`[Deno] ${msg}`, err?.message),
+                });
+            },
+            supportsPersistentConnections() {
+                // Deno Deploy isolates are request-scoped
+                return false;
+            },
+            getEnvironment() {
+                return getDenoEnvironment();
+            },
+            async startServer(port = 3000, host = '0.0.0.0') {
+                return DenoAdapter.startServer(this, port, host);
+            },
+        };
+    },
+    /**
+     * Start Deno server for continuous operation
+     */
+    async startServer(adapter, port = 3000, host = '0.0.0.0') {
+        // @ts-ignore - Deno.serve is available in Deno runtime
+        await Deno.serve({ port, hostname: host }, async (req) => {
+            const platformResponse = await adapter.handle(req);
+            return adapter.formatResponse(platformResponse);
+        });
+    },
+    /**
+     * Get Deno KV store for caching/secrets
+     */
+    async getKV() {
+        // @ts-ignore - Deno.openKv is available in Deno runtime
+        return await Deno.openKv?.();
+    },
+    /**
+     * Get environment variable safely
+     */
+    getEnvVar(key, defaultValue) {
+        // @ts-ignore - Deno.env is available in Deno runtime
+        return Deno.env.get?.(key) ?? defaultValue ?? '';
+    },
+    /**
+     * Check if running in Deno Deploy (edge)
+     */
+    isDeployEnvironment() {
+        // @ts-ignore
+        return typeof Deno !== 'undefined' && Deno.mainModule?.includes('denoDeploy');
+    },
+});
+/**
+ * Handle Deno request
+ */
+async function handleDenoRequest(adapter, config, logger, event, _context) {
+    try {
+        const denoRequest = event;
+        const request = adapter.parseRequest(denoRequest);
+        // Read request body
+        const body = denoRequest.method !== 'GET' && denoRequest.method !== 'HEAD'
+            ? await denoRequest.arrayBuffer()
+            : null;
+        // Create mock Node.js request/response for compatibility
+        const { res, responseData } = createMockHttpObjects(request);
+        // Set request timeout
+        const timeout = config.timeout ?? 30000;
+        const timeoutHandle = setTimeout(() => {
+            responseData.statusCode = 504;
+            responseData.body = JSON.stringify({
+                error: 'Gateway Timeout',
+                statusCode: 504,
+            });
+        }, timeout);
+        try {
+            // Process through handler with mock Node.js objects
+            // Note: In a real implementation, we'd use the handler from the adapter config
+            // For compatibility with the existing code structure
+            await config.handler(null, res, body === null ? null : Buffer.from(body));
+        }
+        finally {
+            clearTimeout(timeoutHandle);
+        }
+        logger?.debug('Deno request processed', {
+            statusCode: responseData.statusCode,
+            path: request.path,
+        });
+        return responseData;
+    }
+    catch (error) {
+        Logger.error('Deno handler error', error);
+        const errorResponse = ErrorResponse.create(500, 'Internal Server Error', 
+        // @ts-ignore - Deno is available in Deno runtime
+        typeof Deno !== 'undefined' && Deno.env.get('DENO_ENV') === 'development'
+            ? { message: error.message }
+            : undefined);
+        return errorResponse.toResponse();
+    }
+}
+/**
+ * Parse Deno request
+ */
+function parseDenoRequest(event) {
+    const url = new URL(event.url);
+    const headers = {};
+    // Convert Headers to Record
+    event.headers.forEach((value, key) => {
+        headers[key.toLowerCase()] = value;
+    });
+    return {
+        method: event.method.toUpperCase(),
+        path: url.pathname,
+        headers,
+        query: Object.fromEntries(url.searchParams.entries()),
+        remoteAddr: headers['x-forwarded-for']?.toString().split(',')[0] ?? '0.0.0.0',
+    };
+}
+/**
+ * Format Deno response
+ */
+function formatDenoResponse(response) {
+    // Convert to Deno Response format
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(response.headers)) {
+        if (Array.isArray(value)) {
+            value.forEach((v) => headers.append(key, v));
+        }
+        else {
+            headers.set(key, value);
+        }
+    }
+    let body = '';
+    if (typeof response.body === 'string') {
+        body = response.body;
+    }
+    else if (response.body !== null && response.body !== undefined) {
+        body = response.body.toString('utf-8');
+    }
+    return new Response(body, {
+        status: response.statusCode,
+        headers,
+    });
+}
+/**
+ * Get Deno environment
+ */
+function getDenoEnvironment() {
+    // @ts-ignore - Deno.env is available in Deno runtime
+    const env = (typeof Deno === 'undefined' ? {} : (Deno.env.toObject?.() ?? {}));
+    return {
+        nodeEnv: env['DENO_ENV'] ?? 'production',
+        runtime: 'deno',
+        dbConnection: env['DB_CONNECTION'] ?? 'postgresql',
+        dbHost: env['DB_HOST'],
+        dbPort: env['DB_PORT'] ? Number.parseInt(env['DB_PORT'], 10) : undefined,
+    };
+}
+function createDefaultLogger() {
+    return {
+        debug: (msg, data) => Logger.debug(`[Deno] ${msg}`, data === undefined ? '' : JSON.stringify(data)),
+        info: (msg, data) => Logger.info(`[Deno] ${msg}`, data === undefined ? '' : JSON.stringify(data)),
+        warn: (msg, data) => Logger.warn(`[Deno] ${msg}`, data === undefined ? '' : JSON.stringify(data)),
+        error: (msg, err) => Logger.error(`[Deno] ${msg}`, err?.message),
+    };
+}

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

@@ -0,0 +1,40 @@
+import { type IncomingMessage, type Server, type ServerResponse } from '../../node-singletons/http';
+import type { AdapterConfig, RuntimeAdapter } from '../RuntimeAdapter';
+export interface FargateEnvironment {
+    [key: string]: unknown;
+    nodeEnv: string;
+    runtime: string;
+    dbConnection: string;
+    dbHost: string | undefined;
+    dbPort: number | undefined;
+}
+export interface FargateAdapterState {
+    server?: Server;
+}
+export type NodeServerFactory = (requestListener: (req: IncomingMessage, res: ServerResponse) => void) => Server;
+export declare function createFargateAdapter(config: AdapterConfig): RuntimeAdapter & {
+    startServer(port?: number, host?: string): Promise<void>;
+    stop(): Promise<void>;
+};
+/**
+ * Fargate/Container adapter for running Zintrust in AWS Fargate, Cloud Run, or Docker
+ * Wraps existing Node.js HTTP server for container orchestration
+ * Sealed namespace for immutability
+ */
+export declare const FargateAdapter: Readonly<{
+    create: typeof createFargateAdapter;
+}>;
+export declare function startFargateServer(state: FargateAdapterState, config: AdapterConfig, logger: AdapterConfig['logger'], port: number, host: string, serverFactory?: NodeServerFactory): Promise<void>;
+export declare function stopFargateServer(state: FargateAdapterState, logger: AdapterConfig['logger']): Promise<void>;
+/**
+ * Read the full request body (Buffer) for IncomingMessage.
+ * Exported for unit testing.
+ */
+export declare function readIncomingMessageBody(req: IncomingMessage): Promise<Buffer | null>;
+export declare function handleFargateRequest(config: AdapterConfig, logger: AdapterConfig['logger'], req: IncomingMessage, res: ServerResponse): Promise<void>;
+/**
+ * Exported helper for tests (and safer than casting unknown to Error).
+ */
+export declare function normalizeError(error: unknown): Error;
+export declare function createDefaultFargateLogger(): AdapterConfig['logger'];
+//# sourceMappingURL=FargateAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FargateAdapter.d.ts","sourceRoot":"","sources":["../../../../src/runtime/adapters/FargateAdapter.ts"],"names":[],"mappings":"AAUA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,MAAM,EACX,KAAK,cAAc,EACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EACV,aAAa,EAGb,cAAc,EACf,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,kBAAkB;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,iBAAiB,GAAG,CAC9B,eAAe,EAAE,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,KAAK,IAAI,KACjE,MAAM,CAAC;AAEZ,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc,GAAG;IAC5E,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB,CAyDA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc;;EAEzB,CAAC;AAEH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,mBAAmB,EAC1B,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,EAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,aAAa,GAAE,iBAAgC,GAC9C,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,mBAAmB,EAC1B,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,GAC9B,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAgB1F;AAED,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,EAC/B,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,IAAI,CAAC,CAuBf;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAIpD;AAED,wBAAgB,0BAA0B,IAAI,aAAa,CAAC,QAAQ,CAAC,CAUpE"}

package/src/runtime/adapters/FargateAdapter.js

@@ -0,0 +1,156 @@
+/**
+ * Runtime adapter for AWS Fargate
+ *
+ * Refactor note:
+ * - Extracted all internal logic into exported, named functions so they can be unit tested directly.
+ * - Removed nested event-handler nesting where possible by introducing readIncomingMessageBody().
+ */
+import { Env } from '../../config/env';
+import { Logger } from '../../config/logger';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { createServer, } from '../../node-singletons/http';
+export function createFargateAdapter(config) {
+    const logger = config.logger ?? createDefaultFargateLogger();
+    const state = {};
+    return {
+        platform: 'fargate',
+        async handle() {
+            // Fargate adapter doesn't handle individual requests
+            // Instead, use startServer() to run continuous HTTP server
+            throw ErrorFactory.createConfigError('Fargate adapter requires startServer() method. Use RuntimeDetector for automatic initialization.');
+        },
+        parseRequest() {
+            throw ErrorFactory.createConfigError('Fargate adapter uses native Node.js HTTP server');
+        },
+        formatResponse() {
+            throw ErrorFactory.createConfigError('Fargate adapter uses native Node.js HTTP server');
+        },
+        async startServer(port = 3000, host = '0.0.0.0') {
+            return startFargateServer(state, config, logger, port, host);
+        },
+        async stop() {
+            return stopFargateServer(state, logger);
+        },
+        getLogger() {
+            return (logger ?? {
+                debug: (msg) => Logger.debug(`[Fargate] ${msg}`),
+                info: (msg) => Logger.info(`[Fargate] ${msg}`),
+                warn: (msg) => Logger.warn(`[Fargate] ${msg}`),
+                error: (msg, err) => Logger.error(`[Fargate] ${msg}`, err?.message),
+            });
+        },
+        supportsPersistentConnections() {
+            // Container environments support persistent connections
+            return true;
+        },
+        getEnvironment() {
+            return {
+                nodeEnv: Env.NODE_ENV,
+                runtime: 'fargate',
+                dbConnection: Env.DB_CONNECTION,
+                dbHost: Env.DB_HOST,
+                dbPort: Env.DB_PORT,
+            };
+        },
+    };
+}
+/**
+ * Fargate/Container adapter for running Zintrust in AWS Fargate, Cloud Run, or Docker
+ * Wraps existing Node.js HTTP server for container orchestration
+ * Sealed namespace for immutability
+ */
+export const FargateAdapter = Object.freeze({
+    create: createFargateAdapter,
+});
+export async function startFargateServer(state, config, logger, port, host, serverFactory = createServer) {
+    return new Promise((resolve, reject) => {
+        state.server = serverFactory((req, res) => {
+            void handleFargateRequest(config, logger, req, res);
+        });
+        state.server.listen(port, host, () => {
+            logger?.info(`Fargate server listening on http://${host}:${port}`);
+            resolve();
+        });
+        state.server.on('error', (error) => {
+            logger?.error('Server error', error);
+            reject(error);
+        });
+    });
+}
+export async function stopFargateServer(state, logger) {
+    const server = state.server;
+    if (server === undefined)
+        return;
+    await new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                logger?.error('Error closing server', error);
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+    state.server = undefined;
+}
+/**
+ * Read the full request body (Buffer) for IncomingMessage.
+ * Exported for unit testing.
+ */
+export async function readIncomingMessageBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            resolve(chunks.length === 0 ? null : Buffer.concat(chunks));
+        });
+        req.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+export async function handleFargateRequest(config, logger, req, res) {
+    try {
+        const body = await readIncomingMessageBody(req);
+        try {
+            await config.handler(req, res, body);
+        }
+        catch (error) {
+            const err = normalizeError(error);
+            Logger.error('Request handler error', err);
+            if (res.headersSent === false) {
+                res.statusCode = 500;
+                res.end('Internal Server Error');
+            }
+        }
+    }
+    catch (error) {
+        Logger.error('Error reading request body', error);
+        const err = normalizeError(error);
+        logger?.error('Request error', err);
+        if (res.headersSent === false) {
+            res.statusCode = 500;
+            res.end('Internal Server Error');
+        }
+    }
+}
+/**
+ * Exported helper for tests (and safer than casting unknown to Error).
+ */
+export function normalizeError(error) {
+    if (error instanceof Error)
+        return error;
+    if (typeof error === 'string')
+        return ErrorFactory.createGeneralError(error);
+    return ErrorFactory.createGeneralError('Unknown error', error);
+}
+export function createDefaultFargateLogger() {
+    return {
+        debug: (msg, data) => Logger.debug(`[Fargate] ${msg}`, data === undefined ? '' : JSON.stringify(data)),
+        info: (msg, data) => Logger.info(`[Fargate] ${msg}`, data === undefined ? '' : JSON.stringify(data)),
+        warn: (msg, data) => Logger.warn(`[Fargate] ${msg}`, data === undefined ? '' : JSON.stringify(data)),
+        error: (msg, err) => Logger.error(`[Fargate] ${msg}`, err?.message),
+    };
+}

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

@@ -0,0 +1,13 @@
+import { AdapterConfig, RuntimeAdapter } from '../RuntimeAdapter';
+/**
+ * AWS Lambda adapter for API Gateway and ALB events
+ * Converts Lambda events to standard HTTP format for Zintrust framework
+ * Sealed namespace for immutability
+ */
+export declare const LambdaAdapter: Readonly<{
+    /**
+     * Create a new Lambda adapter instance
+     */
+    create(config: AdapterConfig): RuntimeAdapter;
+}>;
+//# sourceMappingURL=LambdaAdapter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LambdaAdapter.d.ts","sourceRoot":"","sources":["../../../../src/runtime/adapters/LambdaAdapter.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,aAAa,EAKb,cAAc,EACf,MAAM,yBAAyB,CAAC;AASjC;;;;GAIG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;mBACY,aAAa,GAAG,cAAc;EA8D7C,CAAC"}