@vectorx/functions-framework 0.0.0-beta-20251112071234

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

@@ -0,0 +1,98 @@
+"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 pageNumParam = ctx.query.pageNum;
+            const pageSizeParam = ctx.query.pageSize;
+            const limitParam = ctx.query.limit;
+            if (pageNumParam !== undefined || pageSizeParam !== undefined) {
+                const pageNum = pageNumParam ? Number.parseInt(pageNumParam) : 1;
+                const pageSize = pageSizeParam ? Number.parseInt(pageSizeParam) : 50;
+                if (Number.isNaN(pageNum) || pageNum <= 0) {
+                    ctx.status = 400;
+                    ctx.body = {
+                        success: false,
+                        error: "Invalid pageNum parameter. Must be a positive number.",
+                    };
+                    return;
+                }
+                if (Number.isNaN(pageSize) || pageSize <= 0 || pageSize > 100) {
+                    ctx.status = 400;
+                    ctx.body = {
+                        success: false,
+                        error: "Invalid pageSize parameter. Must be a positive number <= 100",
+                    };
+                    return;
+                }
+                try {
+                    const result = yield logger_2.functionsLogger.getLogsPaginated({
+                        type,
+                        pageNum,
+                        pageSize,
+                    });
+                    ctx.body = {
+                        success: true,
+                        data: result.logs,
+                        pagination: {
+                            pageNum: result.pageNum,
+                            pageSize: result.pageSize,
+                            total: result.total,
+                            hasMore: result.hasMore,
+                        },
+                    };
+                }
+                catch (error) {
+                    logger_2.functionsLogger.logError(error);
+                    ctx.status = 500;
+                    ctx.body = {
+                        success: false,
+                        error: error.message,
+                    };
+                }
+                return;
+            }
+            else {
+                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();
+    });
+}

package/lib/request.js

@@ -0,0 +1,162 @@
+"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.Request = void 0;
+const stream_1 = require("stream");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const helper_1 = require("./utils/helper");
+function headersInit2Indexable(h) {
+    if (isHeaders(h)) {
+        const ret = {};
+        h.forEach((val, key) => {
+            ret[key] = val;
+        });
+        return ret;
+    }
+    return h;
+    function isHeaders(h) {
+        return h instanceof Headers;
+    }
+}
+class Request {
+    constructor(config = {}) {
+        const { timeout, timeoutMsg, restrictedMethods, defaultHeaders = {} } = config;
+        this.defaultHeaders = defaultHeaders;
+        this.timeout = timeout || 0;
+        this.timeoutMsg = timeoutMsg || "请求超时";
+        this.restrictedMethods = restrictedMethods || ["get", "post", "upload", "download"];
+    }
+    get(options) {
+        return this.request(Object.assign(Object.assign({}, options), { method: "get" }), this.restrictedMethods.includes("get"));
+    }
+    post(options) {
+        return this.request(Object.assign(Object.assign({}, options), { method: "post" }), this.restrictedMethods.includes("post"));
+    }
+    put(options) {
+        return this.request(Object.assign(Object.assign({}, options), { method: "put" }));
+    }
+    upload(options) {
+        var _a;
+        const { data: _data, file, name, method, headers = {} } = options;
+        if (file === undefined || name === undefined) {
+            throw new Error("file and name is required");
+        }
+        const data = (0, helper_1.obj2StrRecord)(_data !== null && _data !== void 0 ? _data : {});
+        const loweredMethod = method === null || method === void 0 ? void 0 : method.toLowerCase();
+        const reqMethod = (_a = ["post", "put"].find((m) => m === loweredMethod)) !== null && _a !== void 0 ? _a : "put";
+        if (reqMethod === "post") {
+            const formData = new FormData();
+            Object.keys(data).forEach((key) => {
+                formData.append(key, data[key]);
+            });
+            formData.append("key", name);
+            formData.append("file", file);
+            return this.request(Object.assign(Object.assign({}, options), { data: formData, method: reqMethod }), this.restrictedMethods.includes("upload"));
+        }
+        return this.request(Object.assign(Object.assign({}, options), { method: "put", headers, body: file }), this.restrictedMethods.includes("upload"));
+    }
+    download(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.get(Object.assign(Object.assign({}, options), { headers: {}, responseType: "blob" }));
+            return {
+                statusCode: 200,
+                tempFilePath: options.url,
+                data,
+            };
+        });
+    }
+    request(options_1) {
+        return __awaiter(this, arguments, void 0, function* (options, enableAbort = false) {
+            const { url, headers: _headers = {}, data, responseType, withCredentials, body, method: _method } = options, headers = Object.assign(Object.assign({}, this.defaultHeaders), (0, helper_1.obj2StrRecord)(_headers)), method = String(_method).toLowerCase() || "get";
+            let queryParams = {};
+            if (method === "get" || method === "head") {
+                queryParams = Object.assign(Object.assign({}, (data || {})), (body && typeof body === "object" ? body : {}));
+            }
+            else {
+                queryParams = method === "get" ? data : {};
+            }
+            const realUrl = (0, helper_1.formatUrl)("https", url !== null && url !== void 0 ? url : "", queryParams), controller = new AbortController(), { signal } = controller;
+            let timer;
+            if (enableAbort && this.timeout) {
+                timer = setTimeout(() => {
+                    console.warn(this.timeoutMsg);
+                    controller.abort(new Error(this.timeoutMsg));
+                }, this.timeout);
+            }
+            let payload;
+            if (method !== "get" && method !== "head") {
+                if ((0, helper_1.isFormData)(data)) {
+                    payload = data;
+                }
+                else if (headers["content-type"] === "application/x-www-form-urlencoded") {
+                    payload = (0, helper_1.toQueryString)(data !== null && data !== void 0 ? data : {});
+                }
+                else if (body) {
+                    payload = body;
+                }
+                else {
+                    payload = data ? JSON.stringify(data) : undefined;
+                }
+            }
+            const requestOptions = Object.assign(Object.assign({ method,
+                headers }, (payload !== undefined && { body: payload })), { credentials: withCredentials ? "include" : "same-origin", signal });
+            try {
+                const response = yield (0, node_fetch_1.default)(realUrl, requestOptions), result = {
+                    header: {},
+                    statusCode: response.status,
+                };
+                try {
+                    result.data = responseType === "blob" ? yield response.blob() : yield response.json();
+                }
+                catch (_) {
+                    result.data = responseType === "blob" ? yield response.blob() : yield response.text();
+                }
+                const { headers } = response;
+                headers.forEach((val, key) => (result.header[key.toLowerCase()] = val));
+                return result;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        });
+    }
+    fetch(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { url, enableAbort = false, stream = false } = options, abortController = new AbortController();
+            let timer = undefined;
+            if (enableAbort && this.timeout) {
+                timer = setTimeout(() => {
+                    console.warn(this.timeoutMsg);
+                    abortController.abort(new Error(this.timeoutMsg));
+                }, this.timeout);
+            }
+            const res = yield (yield node_fetch_1.default)(url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, this.defaultHeaders), (options.headers ? headersInit2Indexable(options.headers) : {})), body: options.body, signal: abortController.signal }))
+                .then((x) => {
+                clearTimeout(timer);
+                return x;
+            })
+                .catch((x) => {
+                clearTimeout(timer);
+                return Promise.reject(x);
+            });
+            const ret = {
+                data: stream ? (res.body ? stream_1.Readable.toWeb(res.body) : res.body) : yield res.json(),
+                statusCode: res.status,
+                header: res.headers,
+            };
+            return ret;
+        });
+    }
+}
+exports.Request = Request;

package/lib/router.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+exports.routeFunction = routeFunction;
+const radix3_1 = require("radix3");
+const function_registry_1 = require("./function-registry");
+class Router {
+    constructor(config) {
+        this.routes = new Map();
+        this.router = (0, radix3_1.createRouter)({
+            strictTrailingSlash: false,
+        });
+        for (const route of config.routes) {
+            if (route.path) {
+                const p = route.path.endsWith("/") ? route.path : route.path + "/";
+                if (this.routes.has(p)) {
+                    continue;
+                }
+                this.routes.set(p, route);
+                this.routes.set(p + "**", route);
+            }
+        }
+        for (const [path, route] of this.routes.entries()) {
+            this.addRoute(path, route);
+        }
+    }
+    addRoute(path, route) {
+        this.router.insert(path, route);
+    }
+    findRoute(path) {
+        const found = this.router.lookup(path);
+        if (!found) {
+            return null;
+        }
+        if (found.params) {
+            delete found.params;
+        }
+        return found;
+    }
+}
+exports.Router = Router;
+function routeFunction(router, path) {
+    const matchedRoute = router.findRoute(path);
+    if (matchedRoute) {
+        return {
+            routeDefinition: matchedRoute,
+            handleFunction: (0, function_registry_1.getRegisteredFunction)((0, function_registry_1.buildFnId)("@fn", matchedRoute.functionName)),
+        };
+    }
+    return {};
+}

package/lib/server.js

@@ -0,0 +1,115 @@
+"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.createServer = createServer;
+const http_1 = __importDefault(require("http"));
+const koa_1 = __importDefault(require("koa"));
+const koa_body_1 = require("koa-body");
+const error_1 = require("./error");
+const middlewares_1 = require("./middlewares");
+const unified_responder_1 = require("./unified-responder");
+function corsMiddleware() {
+    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+        ctx.set("Access-Control-Allow-Origin", "*");
+        ctx.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+        ctx.set("Access-Control-Allow-Headers", "Content-Type, Authorization, Accept, X-Requested-With, Referer, referrer");
+        ctx.set("Access-Control-Max-Age", "86400");
+        if (ctx.method === "OPTIONS") {
+            ctx.status = 204;
+            return;
+        }
+        yield next();
+    });
+}
+function createServer(options, router, projectConfig) {
+    const app = new koa_1.default();
+    app.use(corsMiddleware());
+    app.use((0, middlewares_1.logsQueryMiddleware)());
+    app.use((ctx, next) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const h = ctx.request.headers || {};
+            console.log("[REQ-IN]", ctx.method, ctx.url, {
+                "content-type": h["content-type"],
+                "content-length": h["content-length"],
+                "transfer-encoding": h["transfer-encoding"],
+            });
+        }
+        catch (e) {
+        }
+        yield next();
+    }));
+    app.use((0, middlewares_1.contextInjectionMiddleware)(options, projectConfig));
+    app.use((0, middlewares_1.eventIdMiddleware)());
+    app.use((0, middlewares_1.apmMiddleware)());
+    app.use((0, middlewares_1.asyncContextMiddleware)());
+    app.use((0, middlewares_1.loggerMiddleware)());
+    app.use((0, koa_body_1.koaBody)({
+        multipart: true,
+        patchKoa: true,
+        formidable: {
+            maxFileSize: 50 * 1024 * 1024,
+            enabledPlugins: ["octetstream", "json", "multipart"],
+            keepExtensions: true,
+            filter: ({ originalFilename }) => {
+                return !!originalFilename;
+            },
+        },
+        onError: (err, ctx) => {
+            var _a;
+            try {
+                const h = ((_a = ctx.request) === null || _a === void 0 ? void 0 : _a.headers) || {};
+                console.error("[koa-body][error]", {
+                    message: err === null || err === void 0 ? void 0 : err.message,
+                    name: err === null || err === void 0 ? void 0 : err.name,
+                    code: err === null || err === void 0 ? void 0 : err.code,
+                    status: err === null || err === void 0 ? void 0 : err.status,
+                    headers: {
+                        "content-type": h["content-type"],
+                        "content-length": h["content-length"],
+                        "transfer-encoding": h["transfer-encoding"],
+                    },
+                });
+            }
+            catch (_) { }
+            return (0, unified_responder_1.sendResponse)(ctx, undefined, (0, error_1.newBadRequestErr)(err), 400);
+        },
+    }));
+    app.use((ctx, next) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            const fields = ((_a = ctx.request) === null || _a === void 0 ? void 0 : _a.body) ? Object.keys(ctx.request.body) : [];
+            const files = (_b = ctx.request) === null || _b === void 0 ? void 0 : _b.files;
+            console.log("[REQ-PARSED] Body", JSON.stringify(ctx.request.body, null, 2));
+            console.log("[REQ-PARSED] files", JSON.stringify(ctx.request.files, null, 2));
+        }
+        catch (_) { }
+        yield next();
+    }));
+    app.use((ctx, next) => __awaiter(this, void 0, void 0, function* () {
+        if (!(ctx.request.files || ctx.request.body || ctx.state.isTimeout)) {
+            try {
+                console.log("==== ctx.request.files ====", ctx.request.files);
+                console.log("==== ctx.request.body ====", ctx.request.body);
+            }
+            catch (err) {
+                return (0, unified_responder_1.sendResponse)(ctx, undefined, (0, error_1.newBadRequestErr)(err), 400);
+            }
+        }
+        yield next();
+    }));
+    app.use((0, middlewares_1.openGwRequestMiddleware)(projectConfig.agentId));
+    app.use((0, middlewares_1.functionRouteMiddleware)(router, projectConfig));
+    const httpServer = http_1.default.createServer(app.callback());
+    return httpServer;
+}