@geek-fun/serverlessinsight 0.3.3 → 0.4.0

package/dist/src/stack/localStack/event.js

@@ -3,36 +3,143 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startEvents = void 0;
-const node_http_1 = __importDefault(require("node:http"));
-const common_1 = require("../../common");
+exports.eventsHandler = void 0;
 const types_1 = require("../../types");
 const lodash_1 = require("lodash");
-const startApiGatewayServer = (event) => {
-    const server = node_http_1.default.createServer((req, res) => {
-        const matchedTrigger = event.triggers.find((trigger) => trigger.method === req.method && trigger.path === req.url);
-        if (!matchedTrigger) {
-            res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
-            res.end('Not Found\n');
-            common_1.logger.warn(`API Gateway Event - ${req.method} ${req.url} -> Not Found`);
-            return;
+const common_1 = require("../../common");
+const function_1 = require("./function");
+const aliyunFc_1 = require("./aliyunFc");
+const functionRunner_1 = require("./functionRunner");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const utils_1 = require("./utils");
+const matchTrigger = (req, trigger) => {
+    if (req.method !== 'ANY' && req.method !== trigger.method) {
+        return false;
+    }
+    const normalize = (s) => s.replace(/^\/+|\/+$/g, '');
+    const [pathSegments, triggerSegments] = [
+        normalize(req.path).split('/'),
+        normalize(trigger.path).split('/'),
+    ];
+    const hasWildcard = triggerSegments[triggerSegments.length - 1] === '*';
+    const prefixSegments = hasWildcard ? triggerSegments.slice(0, -1) : triggerSegments;
+    const minRequiredSegments = prefixSegments.length;
+    if (pathSegments.length < minRequiredSegments)
+        return false;
+    return prefixSegments.every((triggerSegment, index) => {
+        const pathSegment = pathSegments[index];
+        if (triggerSegment.startsWith('[') && triggerSegment.endsWith(']')) {
+            return pathSegment !== '';
         }
-        res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
-        res.end(`Invoked backend: ${matchedTrigger.backend}\n`);
-        common_1.logger.info(`API Gateway Event - ${req.method} ${req.url} -> ${matchedTrigger.backend}`);
-    });
-    const port = 3000 + Math.floor(Math.random() * 1000);
-    server.listen(port, () => {
-        common_1.logger.info(`API Gateway "${event.name}" listening on http://localhost:${port}`);
+        return triggerSegment === pathSegment;
     });
 };
-const startEvents = (events) => {
-    const apiGateways = events?.filter((event) => event.type === types_1.EventTypes.API_GATEWAY);
-    if ((0, lodash_1.isEmpty)(apiGateways)) {
-        return;
+const servEvent = async (req, parsed, iac) => {
+    const startTime = new Date();
+    const requestId = (0, aliyunFc_1.generateRequestId)();
+    const sourceIp = req.socket?.remoteAddress || '127.0.0.1';
+    const isAliyun = iac.provider.name === common_1.ProviderEnum.ALIYUN;
+    const event = iac.events?.find((event) => event.type === types_1.EventTypes.API_GATEWAY && event.key === parsed.identifier);
+    if ((0, lodash_1.isEmpty)(event)) {
+        return {
+            statusCode: 404,
+            body: { error: 'API Gateway event not found', event: parsed.identifier },
+        };
     }
-    apiGateways.forEach((gateway) => {
-        startApiGatewayServer(gateway);
-    });
+    common_1.logger.info(`Event trigger ${JSON.stringify(event.triggers)}, req method: ${req.method}, req url${req.url}`);
+    const matchedTrigger = event.triggers.find((trigger) => matchTrigger({ method: parsed.method, path: parsed.url }, trigger));
+    if (!matchedTrigger) {
+        const endTime = new Date();
+        if (isAliyun) {
+            (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, 404, startTime, endTime, sourceIp);
+        }
+        return { statusCode: 404, body: { error: 'No matching trigger found' } };
+    }
+    if (matchedTrigger.backend) {
+        const backendDef = (0, common_1.getIacDefinition)(iac, matchedTrigger.backend);
+        if (!backendDef) {
+            const endTime = new Date();
+            if (isAliyun) {
+                (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, 500, startTime, endTime, sourceIp);
+            }
+            return {
+                statusCode: 500,
+                body: { error: 'Backend definition missing', backend: matchedTrigger.backend },
+            };
+        }
+        // For Aliyun, handle the function execution with proper event transformation
+        if (isAliyun && backendDef.code) {
+            let tempDir = null;
+            try {
+                const { event: aliyunEvent } = await (0, aliyunFc_1.transformToAliyunEvent)(req, parsed.url, parsed.query);
+                const codePath = node_path_1.default.resolve(process.cwd(), backendDef.code.path);
+                let codeDir;
+                if (codePath.endsWith('.zip') && node_fs_1.default.existsSync(codePath)) {
+                    tempDir = await (0, utils_1.extractZipFile)(codePath);
+                    codeDir = tempDir;
+                }
+                else if (node_fs_1.default.existsSync(codePath) && node_fs_1.default.statSync(codePath).isDirectory()) {
+                    codeDir = codePath;
+                }
+                else {
+                    codeDir = node_path_1.default.dirname(codePath);
+                }
+                const funOptions = {
+                    codeDir,
+                    functionKey: backendDef.key,
+                    handler: backendDef.code.handler,
+                    servicePath: '',
+                    timeout: backendDef.timeout * 1000,
+                };
+                const aliyunContext = (0, aliyunFc_1.createAliyunContextSerializable)(iac, backendDef.name, backendDef.code.handler, backendDef.memory, backendDef.timeout, requestId);
+                const env = {
+                    ...backendDef.environment,
+                };
+                common_1.logger.debug(`Invoking FC function with Aliyun event format`);
+                const result = await (0, functionRunner_1.invokeFunction)(funOptions, env, aliyunEvent, aliyunContext);
+                const endTime = new Date();
+                const transformed = (0, aliyunFc_1.transformFCResponse)(result);
+                // Log API Gateway request
+                (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, transformed.statusCode, startTime, endTime, sourceIp);
+                return {
+                    statusCode: transformed.statusCode,
+                    headers: transformed.headers,
+                    body: transformed.body,
+                };
+            }
+            catch (error) {
+                const endTime = new Date();
+                (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, 500, startTime, endTime, sourceIp);
+                common_1.logger.error(`Function execution error: ${error}`);
+                return {
+                    statusCode: 500,
+                    body: {
+                        error: 'Function execution failed',
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                };
+            }
+            finally {
+                if (tempDir && node_fs_1.default.existsSync(tempDir)) {
+                    node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                }
+            }
+        }
+        // For non-Aliyun or when using functionsHandler
+        const result = await (0, function_1.functionsHandler)(req, { ...parsed, identifier: backendDef?.key }, iac);
+        const endTime = new Date();
+        if (isAliyun) {
+            (0, aliyunFc_1.logApiGatewayRequest)(requestId, parsed.url, result.statusCode, startTime, endTime, sourceIp);
+        }
+        return result;
+    }
+    return {
+        statusCode: 202,
+        body: { message: 'Trigger matched but no backend configured' },
+    };
+};
+const eventsHandler = async (req, parsed, iac) => {
+    return await servEvent(req, parsed, iac);
 };
-exports.startEvents = startEvents;
+exports.eventsHandler = eventsHandler;

package/dist/src/stack/localStack/function.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionsHandler = void 0;
+const common_1 = require("../../common");
+const functionRunner_1 = require("./functionRunner");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const aliyunFc_1 = require("./aliyunFc");
+const utils_1 = require("./utils");
+const functionsHandler = async (req, parsed, iac) => {
+    common_1.logger.info(`Function request received by local server -> ${req.method} ${parsed.identifier ?? '/'} `);
+    const fcDef = iac.functions?.find((fn) => fn.key === parsed.identifier);
+    if (!fcDef) {
+        return {
+            statusCode: 404,
+            body: { error: 'Function not found', functionKey: parsed.identifier },
+        };
+    }
+    if (!fcDef.code) {
+        return {
+            statusCode: 400,
+            body: { error: 'Function code configuration not found', functionKey: fcDef.key },
+        };
+    }
+    let tempDir = null;
+    try {
+        const codePath = node_path_1.default.resolve(process.cwd(), fcDef.code.path);
+        let codeDir;
+        if (codePath.endsWith('.zip') && node_fs_1.default.existsSync(codePath)) {
+            tempDir = await (0, utils_1.extractZipFile)(codePath);
+            codeDir = tempDir;
+        }
+        else if (node_fs_1.default.existsSync(codePath) && node_fs_1.default.statSync(codePath).isDirectory()) {
+            codeDir = codePath;
+        }
+        else {
+            codeDir = node_path_1.default.dirname(codePath);
+        }
+        const funOptions = {
+            codeDir,
+            functionKey: fcDef.key,
+            handler: fcDef.code.handler,
+            servicePath: '',
+            timeout: fcDef.timeout * 1000,
+        };
+        // Check if provider is Aliyun to use Aliyun FC format
+        const isAliyun = iac.provider.name === common_1.ProviderEnum.ALIYUN;
+        let event;
+        let fcContext;
+        let env;
+        if (isAliyun) {
+            // Aliyun FC format: event is a Buffer containing JSON
+            const requestId = (0, aliyunFc_1.generateRequestId)();
+            const { event: aliyunEvent } = await (0, aliyunFc_1.transformToAliyunEvent)(req, parsed.url, parsed.query);
+            event = aliyunEvent;
+            // Use serializable context for worker thread (logger will be added inside worker)
+            fcContext = (0, aliyunFc_1.createAliyunContextSerializable)(iac, fcDef.name, fcDef.code.handler, fcDef.memory, fcDef.timeout, requestId);
+            env = {
+                ...fcDef.environment,
+            };
+        }
+        else {
+            // AWS Lambda format (default)
+            const rawBody = await (0, common_1.readRequestBody)(req);
+            event = rawBody ? JSON.parse(rawBody) : {};
+            env = {
+                ...fcDef.environment,
+                AWS_REGION: iac.provider.region || 'us-east-1',
+                FUNCTION_NAME: fcDef.name,
+                FUNCTION_MEMORY_SIZE: String(fcDef.memory),
+                FUNCTION_TIMEOUT: String(fcDef.timeout),
+            };
+            fcContext = {
+                functionName: fcDef.name,
+                functionVersion: '$LATEST',
+                memoryLimitInMB: fcDef.memory,
+                logGroupName: `/aws/lambda/${fcDef.name}`,
+                logStreamName: `${new Date().toISOString().split('T')[0]}/[$LATEST]${Math.random().toString(36).substring(7)}`,
+                invokedFunctionArn: `arn:aws:lambda:${iac.provider.region}:000000000000:function:${fcDef.name}`,
+                awsRequestId: Math.random().toString(36).substring(2, 15),
+            };
+        }
+        common_1.logger.debug(`Invoking worker with event type: ${isAliyun ? 'Buffer' : 'Object'} and context`);
+        common_1.logger.debug(`Worker codeDir: ${codeDir}, handler: ${funOptions.handler}`);
+        const result = await (0, functionRunner_1.invokeFunction)(funOptions, env, event, fcContext);
+        common_1.logger.info(`Function execution result: ${JSON.stringify(result)}`);
+        // For Aliyun, transform FC response to HTTP response if needed
+        if (isAliyun && result) {
+            const transformed = (0, aliyunFc_1.transformFCResponse)(result);
+            return {
+                statusCode: transformed.statusCode,
+                headers: transformed.headers,
+                body: transformed.body,
+            };
+        }
+        return {
+            statusCode: 200,
+            body: result,
+        };
+    }
+    catch (error) {
+        common_1.logger.error(`Function execution error: ${error}`);
+        return {
+            statusCode: 500,
+            body: {
+                error: 'Function execution failed',
+                message: error instanceof Error ? error.message : String(error),
+            },
+        };
+    }
+    finally {
+        if (tempDir && node_fs_1.default.existsSync(tempDir)) {
+            node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+        }
+    }
+};
+exports.functionsHandler = functionsHandler;

package/dist/src/stack/localStack/functionRunner.js

@@ -0,0 +1,270 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeFunction = exports.runFunction = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importStar(require("node:path"));
+const node_url_1 = require("node:url");
+const node_worker_threads_1 = require("node:worker_threads");
+// ============================================================================
+// Worker Thread Code (runs in worker context)
+// ============================================================================
+const parseHandler = (handler) => {
+    const [handlerFile, handlerMethod] = handler.split('.');
+    return [handlerFile, handlerMethod];
+};
+const resolveHandlerPath = (codeDir, servicePath, handlerFile) => servicePath
+    ? node_path_1.default.resolve(servicePath, codeDir, handlerFile)
+    : node_path_1.default.resolve(codeDir, handlerFile);
+const loadHandlerModule = async (handlerPath) => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require(handlerPath);
+    }
+    catch {
+        const fileUrl = (0, node_url_1.pathToFileURL)(handlerPath + '.js').href;
+        return (await Promise.resolve(`${fileUrl}`).then(s => __importStar(require(s))));
+    }
+};
+const getHandlerFunction = (handlerModule, handlerMethod, handlerPath) => {
+    const handlerFn = handlerModule[handlerMethod];
+    if (typeof handlerFn !== 'function') {
+        throw new Error(`Handler "${handlerMethod}" not found or is not a function in ${handlerPath}`);
+    }
+    return handlerFn;
+};
+const invokeHandler = (handlerFn, event, context) => new Promise((resolve, reject) => {
+    // Callback-style handler (3+ parameters)
+    if (handlerFn.length >= 3) {
+        try {
+            handlerFn(event, context, (error, result) => {
+                return error ? reject(error) : resolve(result);
+            });
+        }
+        catch (error) {
+            reject(error);
+        }
+    }
+    else {
+        return Promise.resolve(handlerFn(event, context)).then(resolve).catch(reject);
+    }
+});
+const createTimeoutHandler = (port, timeoutMs) => {
+    const timeoutId = setTimeout(() => {
+        port.postMessage(new Error(`Function execution timed out after ${timeoutMs}ms`));
+        port.close();
+    }, timeoutMs);
+    return {
+        timeoutId,
+        clearTimer: () => clearTimeout(timeoutId),
+    };
+};
+const executeHandler = async ({ event, context, port }) => {
+    let clearTimer;
+    try {
+        const wd = node_worker_threads_1.workerData;
+        const { codeDir, handler, servicePath, timeout } = wd;
+        const timer = createTimeoutHandler(port, timeout);
+        clearTimer = timer.clearTimer;
+        // Convert Uint8Array back to Buffer if needed (worker thread serialization converts Buffers to Uint8Arrays)
+        let actualEvent = event;
+        if (event instanceof Uint8Array && !Buffer.isBuffer(event)) {
+            actualEvent = Buffer.from(event);
+        }
+        // Reconstruct logger and tracing function for Aliyun FC contexts
+        let actualContext = context;
+        if (context &&
+            typeof context === 'object' &&
+            'requestId' in context &&
+            !('logger' in context) &&
+            'function' in context &&
+            'service' in context) {
+            const requestId = context.requestId;
+            const formatLog = (level, message) => {
+                const timestamp = new Date().toISOString();
+                console.log(`${timestamp} ${requestId} [${level}] ${message}`);
+            };
+            const baseContext = context;
+            actualContext = {
+                ...baseContext,
+                tracing: {
+                    ...baseContext.tracing,
+                    parseOpenTracingBaggages: () => ({}),
+                },
+                logger: {
+                    debug: (message) => formatLog('DEBUG', message),
+                    info: (message) => formatLog('INFO', message),
+                    warn: (message) => formatLog('WARNING', message),
+                    error: (message) => formatLog('ERROR', message),
+                    log: (message) => formatLog('INFO', message),
+                },
+            };
+        }
+        const [handlerFile, handlerMethod] = parseHandler(handler);
+        const handlerPath = resolveHandlerPath(codeDir, servicePath, handlerFile);
+        const handlerModule = await loadHandlerModule(handlerPath);
+        const handlerFn = getHandlerFunction(handlerModule, handlerMethod, handlerPath);
+        const result = await invokeHandler(handlerFn, actualEvent, actualContext);
+        clearTimer();
+        port.postMessage(result);
+        port.close();
+    }
+    catch (error) {
+        if (clearTimer)
+            clearTimer();
+        port.postMessage(error instanceof Error ? error : new Error(String(error)));
+        port.close();
+    }
+};
+// Initialize worker thread message handler
+if (!node_worker_threads_1.isMainThread) {
+    node_worker_threads_1.parentPort?.on('message', async (message) => {
+        try {
+            await executeHandler(message);
+        }
+        catch (error) {
+            message.port.postMessage(error instanceof Error ? error : new Error(String(error)));
+            message.port.close();
+        }
+    });
+}
+// ============================================================================
+// Main Thread Code (functional API)
+// ============================================================================
+const resolveWorkerPath = () => {
+    const localPath = (0, node_path_1.join)(__dirname, 'functionRunner.js');
+    if ((0, node_fs_1.existsSync)(localPath)) {
+        return localPath;
+    }
+    // Fallback to dist directory
+    const distPath = __dirname.replace(/src\/stack\/localStack$/, 'dist/src/stack/localStack');
+    return (0, node_path_1.join)(distPath, 'functionRunner.js');
+};
+const createWorker = (funOptions, env) => {
+    const { codeDir, functionKey, handler, servicePath, timeout } = funOptions;
+    const workerPath = resolveWorkerPath();
+    return new node_worker_threads_1.Worker(workerPath, {
+        env,
+        workerData: {
+            codeDir,
+            functionKey,
+            handler,
+            servicePath,
+            timeout,
+        },
+    });
+};
+const createMessageHandler = (port, resolve, reject) => {
+    let resolved = false;
+    const handleMessage = (value) => {
+        if (resolved)
+            return;
+        resolved = true;
+        port.close();
+        return value instanceof Error ? reject(value) : resolve(value);
+    };
+    const handleError = (err) => {
+        if (resolved)
+            return;
+        resolved = true;
+        port.close();
+        reject(err);
+    };
+    const handleClose = () => {
+        if (resolved)
+            return;
+        resolved = true;
+        reject(new Error('Port closed before receiving response'));
+    };
+    port.on('message', handleMessage).on('error', handleError).on('close', handleClose);
+    return () => {
+        port.off('message', handleMessage);
+        port.off('error', handleError);
+        port.off('close', handleClose);
+        port.close();
+    };
+};
+const sendMessage = (worker, event, context, port2) => {
+    worker.postMessage({
+        context,
+        event,
+        port: port2,
+    }, [port2]);
+};
+const runFunction = (funOptions, env) => {
+    const worker = createWorker(funOptions, env);
+    const execute = (event, context) => new Promise((resolve, reject) => {
+        const { port1, port2 } = new node_worker_threads_1.MessageChannel();
+        const cleanup = createMessageHandler(port1, resolve, reject);
+        // Handle worker errors/exit
+        const handleWorkerError = (err) => {
+            cleanup();
+            reject(err);
+        };
+        const handleWorkerExit = (code) => {
+            if (code !== 0) {
+                cleanup();
+                reject(new Error(`Worker stopped with exit code ${code}`));
+            }
+        };
+        worker.once('error', handleWorkerError);
+        worker.once('exit', handleWorkerExit);
+        try {
+            sendMessage(worker, event, context, port2);
+        }
+        catch (error) {
+            worker.off('error', handleWorkerError);
+            worker.off('exit', handleWorkerExit);
+            cleanup();
+            reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+    const terminate = () => worker.terminate();
+    return {
+        execute,
+        terminate,
+    };
+};
+exports.runFunction = runFunction;
+const invokeFunction = async (funOptions, env, event, context) => {
+    const runner = (0, exports.runFunction)(funOptions, env);
+    try {
+        return await runner.execute(event, context);
+    }
+    finally {
+        await runner.terminate();
+    }
+};
+exports.invokeFunction = invokeFunction;

package/dist/src/stack/localStack/index.d.ts

@@ -1,2 +1,5 @@
+import { stopLocal } from './localServer';
+import { ServerlessIac } from '../../types';
 export * from './event';
-export declare const startLocalStack: () => Promise<void>;
+export { stopLocal };
+export declare const startLocalStack: (iac: ServerlessIac) => Promise<void>;

package/dist/src/stack/localStack/index.js

@@ -14,10 +14,20 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startLocalStack = void 0;
+exports.startLocalStack = exports.stopLocal = void 0;
+const localStack_1 = require("../../types/localStack");
+const localServer_1 = require("./localServer");
+Object.defineProperty(exports, "stopLocal", { enumerable: true, get: function () { return localServer_1.stopLocal; } });
+const event_1 = require("./event");
+const function_1 = require("./function");
+const bucket_1 = require("./bucket");
 __exportStar(require("./event"), exports);
-const startLocalStack = async () => {
-    // Placeholder for starting local stack logic
-    console.log('Local stack started');
+const handlers = [
+    { kind: localStack_1.RouteKind.SI_FUNCTIONS, handler: function_1.functionsHandler },
+    { kind: localStack_1.RouteKind.SI_EVENTS, handler: event_1.eventsHandler },
+    { kind: localStack_1.RouteKind.SI_BUCKETS, handler: bucket_1.bucketsHandler },
+];
+const startLocalStack = async (iac) => {
+    await (0, localServer_1.servLocal)(handlers, iac);
 };
 exports.startLocalStack = startLocalStack;