@vectorx/functions-framework 0.1.0

package/lib/function-registry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFnId = buildFnId;
+exports.registerFunction = registerFunction;
+exports.getRegisteredFunction = getRegisteredFunction;
+exports.clearRegistry = clearRegistry;
+const functionRegistry = new Map();
+function buildFnId(fnName, functionName) {
+    return `${fnName}:${functionName}`;
+}
+function registerFunction(fnName, fn) {
+    const fnId = buildFnId("@fn", fnName);
+    functionRegistry.set(fnId, fn);
+}
+function getRegisteredFunction(fnId) {
+    return functionRegistry.get(fnId);
+}
+function clearRegistry() {
+    functionRegistry.clear();
+}

package/lib/function-wrapper.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapHandlerFunction = wrapHandlerFunction;
+const config_1 = require("./config");
+const error_1 = require("./error");
+const logger_1 = require("./logger");
+const request_1 = require("./request");
+const sse_1 = require("./sse");
+const unified_responder_1 = require("./unified-responder");
+const helper_1 = require("./utils/helper");
+const wrapEventFunction = (execute, projectConfig) => {
+    return (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        let event;
+        if (ctx.request.files) {
+            event = Object.assign(Object.assign({}, ctx.request.files), ctx.request.body);
+        }
+        else if (ctx.request.body) {
+            event = ctx.request.body;
+        }
+        else {
+            event = ctx.rawBody;
+        }
+        let executeDone = false;
+        let hasSwitchSSEMode = false;
+        const context = {
+            ctxId: ctx.state.eventID,
+            eventID: ctx.state.eventID,
+            eventType: ctx.state.eventType,
+            timestamp: ctx.state.timestamp,
+            httpContext: ctx.httpContext,
+            baseUrl: (0, config_1.getBaseUrl)(),
+            request: new request_1.Request({
+                timeout: 30000,
+                timeoutMsg: "请求超时",
+                restrictedMethods: ["get", "post", "upload", "download"],
+                defaultHeaders: {
+                    "agent-id": projectConfig.agentId,
+                    "open-id": ctx.request.headers["open-id"],
+                },
+            }),
+            logger: logger_1.functionsLogger,
+            sse: () => {
+                var _a;
+                const sseInstance = (_a = ctx.sse) === null || _a === void 0 ? void 0 : _a.call(ctx);
+                if (sseInstance) {
+                    return sseInstance;
+                }
+                if (ctx.res.headersSent || executeDone) {
+                    return null;
+                }
+                hasSwitchSSEMode = true;
+                const sse = new sse_1.ServerSentEvent(ctx);
+                ctx.sse = () => sse;
+                return sse;
+            },
+        };
+        const contextToFreeze = {
+            ctxId: context.ctxId,
+            eventID: context.eventID,
+            eventType: context.eventType,
+            timestamp: context.timestamp,
+            httpContext: context.httpContext,
+            baseUrl: context.baseUrl,
+            request: context.request,
+        };
+        (0, helper_1.deepFreeze)(contextToFreeze);
+        const frozenContext = Object.assign(Object.assign({}, contextToFreeze), { logger: context.logger, sse: context.sse });
+        ctx.state.event = event;
+        ctx.state.contextInjected = frozenContext;
+        let result;
+        const start = Date.now();
+        try {
+            result = yield execute(event, context);
+        }
+        catch (e) {
+            ctx.state.error = e;
+            if (hasSwitchSSEMode) {
+                const sse = (_a = ctx.sse) === null || _a === void 0 ? void 0 : _a.call(ctx);
+                if (sse && !sse.isClosed) {
+                    const errorEvent = {
+                        event: "error",
+                        data: e.message,
+                        comment: "uncaught-exception-from-user-code",
+                    };
+                    sse.emit("error", errorEvent);
+                    sse.end(errorEvent);
+                }
+            }
+        }
+        finally {
+            ctx.state.userCodeTimeCost = Date.now() - start;
+        }
+        executeDone = true;
+        if (hasSwitchSSEMode) {
+            return;
+        }
+        const e = ctx.state.error ? (0, error_1.newSysErr)(ctx.state.error) : null;
+        return (0, unified_responder_1.sendResponse)(ctx, result, e);
+    });
+};
+function wrapHandlerFunction(userFunction, projectConfig) {
+    return wrapEventFunction(userFunction, projectConfig);
+}

package/lib/index.js

@@ -0,0 +1,23 @@
+"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 __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 });
+__exportStar(require("./framework"), exports);
+__exportStar(require("./router"), exports);
+__exportStar(require("./function-loader"), exports);
+__exportStar(require("./function-registry"), exports);
+__exportStar(require("./sse"), exports);
+__exportStar(require("./server"), exports);
+__exportStar(require("./logger"), exports);

package/lib/logger.js

@@ -0,0 +1,160 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionsLogger = exports.LogLevel = exports.LogType = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const winston_1 = __importDefault(require("winston"));
+const winston_daily_rotate_file_1 = __importDefault(require("winston-daily-rotate-file"));
+const async_context_1 = require("./async-context");
+const user_logger_1 = require("./user-logger");
+const apm_config_1 = require("./utils/apm.config");
+var LogType;
+(function (LogType) {
+    LogType["ACCESS"] = "ACCESS";
+    LogType["USERCODE"] = "USERCODE";
+})(LogType || (exports.LogType = LogType = {}));
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["ERROR"] = "error";
+    LogLevel["WARN"] = "warn";
+    LogLevel["INFO"] = "info";
+    LogLevel["DEBUG"] = "debug";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+const DEFAULT_LOG_DIRNAME = path_1.default.join(process.cwd(), "logs");
+const DEFAULT_MAX_LOG_FILE_SIZE = "10m";
+const DEFAULT_MAX_LOG_FILES = 7;
+class FunctionsLogger {
+    constructor() {
+        this.tLoggers = new Map();
+    }
+    setApmReporter(reporter) {
+        this.apmReporter = reporter;
+    }
+    init(opts) {
+        if (!fs_1.default.existsSync(DEFAULT_LOG_DIRNAME)) {
+            fs_1.default.mkdirSync(DEFAULT_LOG_DIRNAME, { recursive: true });
+        }
+        opts.forEach(({ type, options }) => {
+            this.tLoggers.set(type, this.createWinstonLogger({
+                filename: type,
+                dirname: options.dirname || DEFAULT_LOG_DIRNAME,
+                maxSize: options.maxSize || DEFAULT_MAX_LOG_FILE_SIZE,
+                maxFiles: options.maxFiles || DEFAULT_MAX_LOG_FILES,
+            }));
+        });
+    }
+    formatLogMessage(level, message, metadata) {
+        const eventId = (0, async_context_1.getCurrentEventID)();
+        const logEntry = Object.assign({ "@timestamp": new Date().toISOString(), level,
+            eventId,
+            message }, metadata);
+        return JSON.stringify(logEntry);
+    }
+    logAccesslog(level, message, metadata) {
+        this.log(LogType.ACCESS, level, message, metadata);
+        const asyncContext = (0, async_context_1.getCurrentAsyncContext)();
+        const eventId = (asyncContext === null || asyncContext === void 0 ? void 0 : asyncContext.eventID) || "";
+        if (this.apmReporter && (asyncContext === null || asyncContext === void 0 ? void 0 : asyncContext.apmMeasurementData)) {
+            const measurementData = Object.assign({}, asyncContext.apmMeasurementData);
+            this.apmReporter.report(apm_config_1.APM_MEASUREMENT_NAME, Object.assign(Object.assign({}, measurementData), { kit_runtime_event_type: LogType.ACCESS, kit_runtime_event_id: eventId, kit_runtime_event_data: message, kit_event_extInfo: {} }));
+        }
+    }
+    logUserCodelog() {
+        const logs = (0, user_logger_1.takeUserCodeLogs)();
+        if (logs.length > 0) {
+            const now = new Date().toISOString();
+            const asyncContext = (0, async_context_1.getCurrentAsyncContext)();
+            const eventId = (asyncContext === null || asyncContext === void 0 ? void 0 : asyncContext.eventID) || "";
+            const userCodeLog = {
+                "@timestamp": now,
+                level: "info",
+                module: "@vectorx/functions-framework",
+                name: "",
+                logType: LogType.USERCODE,
+                eventId: eventId,
+                requestId: eventId,
+                scene: (asyncContext === null || asyncContext === void 0 ? void 0 : asyncContext.done) ? "logAfterReturn" : "logBeforeReturn",
+                logs: logs,
+            };
+            const logDetail = JSON.stringify(userCodeLog);
+            this.log(LogType.USERCODE, LogLevel.INFO, logDetail);
+            if (this.apmReporter && (asyncContext === null || asyncContext === void 0 ? void 0 : asyncContext.apmMeasurementData)) {
+                const measurementData = Object.assign({}, asyncContext.apmMeasurementData);
+                this.apmReporter.report(apm_config_1.APM_MEASUREMENT_NAME, Object.assign(Object.assign({}, measurementData), { kit_runtime_event_type: LogType.USERCODE, kit_runtime_event_id: eventId, kit_runtime_event_data: logDetail }));
+            }
+        }
+    }
+    log(type, level, message, metadata) {
+        var _a;
+        const formattedMessage = this.formatLogMessage(level, message, metadata);
+        (_a = this.tLoggers.get(type)) === null || _a === void 0 ? void 0 : _a.log(level, formattedMessage);
+    }
+    getLogs(type_1) {
+        return __awaiter(this, arguments, void 0, function* (type, limit = 100) {
+            const logs = [];
+            const logDir = DEFAULT_LOG_DIRNAME;
+            const files = fs_1.default
+                .readdirSync(logDir)
+                .filter((file) => file.startsWith(type) && file.endsWith(".log"))
+                .sort()
+                .reverse();
+            let index = 0;
+            for (const file of files) {
+                const content = fs_1.default.readFileSync(path_1.default.join(logDir, file), "utf-8");
+                const lines = content.split("\n").filter(Boolean);
+                for (const line of lines) {
+                    try {
+                        const log = JSON.parse(line);
+                        log.id = index++;
+                        logs.push(log);
+                        if (logs.length >= limit) {
+                            return logs;
+                        }
+                    }
+                    catch (e) {
+                        console.error("Failed to parse log line:", line);
+                    }
+                }
+            }
+            return logs;
+        });
+    }
+    createWinstonLogger(options) {
+        const transports = [
+            new winston_daily_rotate_file_1.default({
+                dirname: options.dirname,
+                datePattern: "YYYY-MM-DD-HH-mm",
+                frequency: "720m",
+                filename: options.filename,
+                extension: ".log",
+                auditFile: path_1.default.join(options.dirname, `${options.filename}.audit.json`),
+                maxSize: options.maxSize,
+                maxFiles: options.maxFiles,
+            }),
+        ];
+        return winston_1.default.createLogger({
+            exitOnError: false,
+            level: "info",
+            transports,
+            format: winston_1.default.format.printf(({ message }) => message),
+        });
+    }
+    logError(error, metadata) {
+        const errorMessage = error instanceof Error ? error.message : error;
+        const errorStack = error instanceof Error ? error.stack : undefined;
+        this.log(LogType.ACCESS, LogLevel.ERROR, errorMessage, Object.assign(Object.assign({}, metadata), { stack: errorStack, timestamp: new Date().toISOString() }));
+    }
+}
+exports.functionsLogger = new FunctionsLogger();

package/lib/middlewares/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apmMiddleware = exports.openGwRequestMiddleware = exports.logsQueryMiddleware = exports.loggerMiddleware = exports.functionRouteMiddleware = exports.eventIdMiddleware = exports.contextInjectionMiddleware = exports.asyncContextMiddleware = void 0;
+var middle_async_context_1 = require("./middle-async-context");
+Object.defineProperty(exports, "asyncContextMiddleware", { enumerable: true, get: function () { return middle_async_context_1.asyncContextMiddleware; } });
+var middle_context_injection_1 = require("./middle-context-injection");
+Object.defineProperty(exports, "contextInjectionMiddleware", { enumerable: true, get: function () { return middle_context_injection_1.contextInjectionMiddleware; } });
+var middle_event_id_1 = require("./middle-event-id");
+Object.defineProperty(exports, "eventIdMiddleware", { enumerable: true, get: function () { return middle_event_id_1.eventIdMiddleware; } });
+var middle_function_route_1 = require("./middle-function-route");
+Object.defineProperty(exports, "functionRouteMiddleware", { enumerable: true, get: function () { return middle_function_route_1.functionRouteMiddleware; } });
+var middle_common_logger_1 = require("./middle-common-logger");
+Object.defineProperty(exports, "loggerMiddleware", { enumerable: true, get: function () { return middle_common_logger_1.loggerMiddleware; } });
+var middle_logs_request_1 = require("./middle-logs-request");
+Object.defineProperty(exports, "logsQueryMiddleware", { enumerable: true, get: function () { return middle_logs_request_1.logsQueryMiddleware; } });
+var middle_open_gw_request_1 = require("./middle-open-gw-request");
+Object.defineProperty(exports, "openGwRequestMiddleware", { enumerable: true, get: function () { return middle_open_gw_request_1.openGwRequestMiddleware; } });
+var middle_apm_injection_1 = require("./middle-apm-injection");
+Object.defineProperty(exports, "apmMiddleware", { enumerable: true, get: function () { return middle_apm_injection_1.apmMiddleware; } });

package/lib/middlewares/middle-apm-injection.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apmMiddleware = apmMiddleware;
+const async_context_1 = require("../async-context");
+const common_1 = require("../utils/common");
+function apmMiddleware() {
+    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (common_1.AGENT_HEALTH_REG.test(ctx.path)) {
+            return yield next();
+        }
+        const agentInfo = ctx.state.agentInfo || {};
+        const kitInfo = ((_a = ctx.state.frameworkOptions) === null || _a === void 0 ? void 0 : _a.kitInfo) || {};
+        const env = process.env.OPEN_PLATFORM_STAGE === "production" ? 0 : 1;
+        const baseMeasurementData = {
+            kit_agent_desc: agentInfo.desc,
+            kit_agent_id: agentInfo.agentId,
+            kit_agent_version: agentInfo.version,
+            context_artifactVersion: kitInfo.agentRuntimeVersion,
+            kit_agent_runtime_version: kitInfo.agentRuntimeVersion,
+            kit_function_framework_version: kitInfo.functionsFrameworkVersion,
+            kit_cloud_env: env,
+            kit_runtime_event_id: (0, async_context_1.getCurrentEventID)(),
+        };
+        ctx.state.apmMeasurementData = baseMeasurementData;
+        yield next();
+    });
+}

package/lib/middlewares/middle-async-context.js

@@ -0,0 +1,27 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncContextMiddleware = void 0;
+const async_context_1 = require("../async-context");
+const asyncContextMiddleware = () => {
+    return (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        const executionContext = (0, async_context_1.newExecutionContext)(ctx.state.eventID, ctx.state.apmMeasurementData);
+        yield (0, async_context_1.wrapWithAsyncContext)(executionContext, () => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                yield next();
+            }
+            finally {
+                (0, async_context_1.done)();
+            }
+        }));
+    });
+};
+exports.asyncContextMiddleware = asyncContextMiddleware;

package/lib/middlewares/middle-common-logger.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerMiddleware = loggerMiddleware;
+const chalk_1 = __importDefault(require("chalk"));
+const async_context_1 = require("../async-context");
+const logger_1 = require("../logger");
+const common_1 = require("../utils/common");
+function loggerMiddleware() {
+    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+        const startTime = Date.now();
+        const eventId = (0, async_context_1.getCurrentEventID)();
+        if (ctx.path.match(common_1.AGENT_HEALTH_REG)) {
+            yield next();
+            return;
+        }
+        process.stdout.write(chalk_1.default.greenBright(`▶️ ${chalk_1.default.gray(`[${new Date().toLocaleString()} - ${ctx.method}:${eventId}]`)} ${ctx.url}`));
+        try {
+            const accessLog = {
+                type: "HTTP_ACCESS",
+                scene: "SERVER_REQUEST_START",
+                method: ctx.method,
+                url: ctx.url,
+                headers: ctx.headers,
+                data: ctx.request.body,
+                eventId,
+                ip: ctx.ip,
+                userAgent: ctx.headers["user-agent"],
+            };
+            logger_1.functionsLogger.logAccesslog(logger_1.LogLevel.INFO, JSON.stringify(accessLog));
+            yield next();
+        }
+        finally {
+            const endTime = Date.now();
+            const duration = endTime - startTime;
+            const accessLog = {
+                type: "HTTP_ACCESS",
+                method: ctx.method,
+                scene: "SERVER_REQUEST_END",
+                url: ctx.url,
+                status: ctx.status,
+                duration: `${duration}ms`,
+                headers: ctx.headers,
+                data: ctx.request.body,
+                response: ctx.response,
+                eventId,
+                ip: ctx.ip,
+                userAgent: ctx.headers["user-agent"],
+            };
+            logger_1.functionsLogger.logAccesslog(logger_1.LogLevel.INFO, JSON.stringify(accessLog));
+            logger_1.functionsLogger.logUserCodelog();
+            process.stdout.write(chalk_1.default.greenBright(`▶️ ${chalk_1.default.gray(`[${new Date().toLocaleString()} - ${eventId.slice(0, -10)}]`)} - ${duration}ms\n`));
+            process.stdout.write(chalk_1.default.greenBright(`\n`));
+        }
+    });
+}

package/lib/middlewares/middle-context-injection.js

@@ -0,0 +1,33 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextInjectionMiddleware = contextInjectionMiddleware;
+function contextInjectionMiddleware(frameworkOptions, projectConfig) {
+    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+        if (!ctx.state) {
+            ctx.state = {};
+        }
+        ctx.state.eventType = "http";
+        ctx.state.timestamp = new Date().toISOString();
+        ctx.state.frameworkOptions = frameworkOptions;
+        ctx.httpContext = {
+            url: ctx.URL.toString(),
+            httpMethod: ctx.method,
+            headers: Object.assign({}, ctx.headers),
+        };
+        ctx.state.agentInfo = {
+            agentId: projectConfig.agentId,
+            version: projectConfig.version || "",
+            desc: projectConfig.desc || "",
+        };
+        yield next();
+    });
+}

package/lib/middlewares/middle-event-id.js

@@ -0,0 +1,20 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventIdMiddleware = void 0;
+const uuid_1 = require("uuid");
+const eventIdMiddleware = () => {
+    return (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        ctx.state.eventID = ctx.headers["x-open-agent-trace-id"] || `event-${(0, uuid_1.v4)()}`;
+        yield next();
+    });
+};
+exports.eventIdMiddleware = eventIdMiddleware;

package/lib/middlewares/middle-function-route.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionRouteMiddleware = functionRouteMiddleware;
+const function_wrapper_1 = require("../function-wrapper");
+const router_1 = require("../router");
+function functionRouteMiddleware(router, projectConfig) {
+    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+        const { routeDefinition, handleFunction } = (0, router_1.routeFunction)(router, ctx.path);
+        if (routeDefinition) {
+            ctx.state.matchedRoute = routeDefinition;
+        }
+        if (handleFunction) {
+            return yield (0, function_wrapper_1.wrapHandlerFunction)(handleFunction, projectConfig)(ctx, next);
+        }
+        return next();
+    });
+}

package/lib/middlewares/middle-logs-request.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logsQueryMiddleware = logsQueryMiddleware;
+const logger_1 = require("../logger");
+const logger_2 = require("../logger");
+function logsQueryMiddleware() {
+    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+        if (ctx.path.startsWith("/@logs")) {
+            const type = ctx.query.type || logger_1.LogType.ACCESS;
+            const limitParam = ctx.query.limit;
+            const limit = limitParam ? Number.parseInt(limitParam) : 100;
+            if (Number.isNaN(limit) || limit <= 0 || limit > 1000) {
+                ctx.status = 400;
+                ctx.body = {
+                    success: false,
+                    error: "Invalid limit parameter. Must be a positive number <= 1000",
+                };
+                return;
+            }
+            try {
+                const logs = yield logger_2.functionsLogger.getLogs(type, limit);
+                ctx.body = {
+                    success: true,
+                    data: logs,
+                };
+            }
+            catch (error) {
+                logger_2.functionsLogger.logError(error);
+                ctx.status = 500;
+                ctx.body = {
+                    success: false,
+                    error: error.message,
+                };
+            }
+            return;
+        }
+        return yield next();
+    });
+}

package/lib/middlewares/middle-open-gw-request.js

@@ -0,0 +1,29 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openGwRequestMiddleware = openGwRequestMiddleware;
+const error_1 = require("../error");
+const unified_responder_1 = require("../unified-responder");
+function openGwRequestMiddleware(agentId) {
+    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+        if (process.env.OPEN_PLATFORM_STAGE === "production") {
+            const openId = ctx.headers["open-id"];
+            if (!openId) {
+                return (0, unified_responder_1.sendResponse)(ctx, undefined, (0, error_1.newBadRequestErr)("open-id is required"), 401);
+            }
+            const requestAgentId = ctx.headers["agent-id"];
+            if (requestAgentId !== agentId) {
+                return (0, unified_responder_1.sendResponse)(ctx, undefined, (0, error_1.newBadRequestErr)("unauthorized, agent-id mismatch!"), 401);
+            }
+        }
+        yield next();
+    });
+}