@vectorx/functions-framework 0.1.0

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) : 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,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.createServer = createServer;
+const http_1 = __importDefault(require("http"));
+const koa_1 = __importDefault(require("koa"));
+const koa_body_1 = require("koa-body");
+const raw_body_1 = __importDefault(require("raw-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((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,
+        onError: (err, ctx) => {
+            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* () {
+        if (!(ctx.request.files || ctx.request.body || ctx.state.isTimeout)) {
+            try {
+                ctx.rawBody = yield (0, raw_body_1.default)(ctx.req);
+            }
+            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;
+}

package/lib/sse.js

@@ -0,0 +1,176 @@
+"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.ServerSentEvent = void 0;
+const events_1 = require("events");
+const stream_1 = require("stream");
+const util = __importStar(require("util"));
+const helper_1 = require("./utils/helper");
+const kDefaultEncoder = new util.TextEncoder();
+class ServerSentEvent extends events_1.EventEmitter {
+    constructor(ctx) {
+        super();
+        this.closed = false;
+        this.encoder = kDefaultEncoder;
+        this.ctx = ctx;
+        this.stream = new stream_1.PassThrough({
+            objectMode: false,
+        });
+        this.stream.pipe(ctx.res);
+        ctx.respond = false;
+        ctx.req.once("close", () => {
+            this.emit("close");
+            this.closed = true;
+        });
+        if (ctx.req.socket) {
+            ctx.req.socket.setTimeout(0);
+            ctx.req.socket.setNoDelay(true);
+            ctx.req.socket.setKeepAlive(true, 0);
+        }
+        const headers = {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        };
+        if (ctx.state && ctx.state.eventID) {
+            headers["X-Request-Id"] = ctx.state.eventID;
+        }
+        ctx.set(headers);
+        ctx.status = 200;
+        ctx.flushHeaders();
+        for (const key of ["ctx", "stream", "encoder"]) {
+            Object.defineProperty(this, key, {
+                configurable: false,
+                enumerable: false,
+                writable: false,
+            });
+        }
+    }
+    setEncoder(encoder) {
+        this.encoder = encoder;
+    }
+    emitMessage(event, data) {
+        if (this.closed)
+            return false;
+        const message = {
+            event,
+            data,
+        };
+        return this.send(message);
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    send(event) {
+        const encoder = this.encoder;
+        const stream = this.stream;
+        if (this.closed) {
+            return false;
+        }
+        const events = Array.isArray(event) ? event : [event];
+        const bufs = [];
+        for (const event of events) {
+            if (Buffer.isBuffer(event)) {
+                bufs.push(event);
+            }
+            else if (typeof event === "string") {
+                bufs.push(Buffer.from(encoder.encode(event)));
+            }
+            else if ((0, helper_1.isPlainObject)(event)) {
+                const msgs = eventToMsgs(event);
+                for (const msg of msgs) {
+                    if (Buffer.isBuffer(msg)) {
+                        bufs.push(msg);
+                    }
+                    else {
+                        bufs.push(Buffer.from(encoder.encode(msg)));
+                    }
+                }
+            }
+        }
+        const buf = Buffer.concat(bufs);
+        if (Buffer.byteLength(buf) > 0) {
+            return stream.write(Buffer.concat(bufs));
+        }
+        return false;
+    }
+    end(msg) {
+        if (msg) {
+            this.send(msg);
+        }
+        this.stream.end();
+        this.ctx.res.end();
+        this.closed = true;
+    }
+    get isClosed() {
+        return this.closed;
+    }
+}
+exports.ServerSentEvent = ServerSentEvent;
+function eventToMsgs(event) {
+    const msgs = [];
+    if ("comment" in event) {
+        msgs.push(`: ${event.comment}\n`);
+    }
+    if ("event" in event) {
+        msgs.push(`event: ${event.event}\n`);
+    }
+    if ("id" in event) {
+        msgs.push(`id: ${event.id}\n`);
+    }
+    if ("retry" in event) {
+        msgs.push(`retry: ${event.retry}\n`);
+    }
+    if ("data" in event) {
+        msgs.push(toDataEventString(event.data));
+    }
+    if (msgs.length > 0) {
+        msgs.push("\n");
+    }
+    return msgs;
+}
+function toDataEventString(data) {
+    if (Buffer.isBuffer(data)) {
+        return Buffer.concat([Buffer.from("data: "), data, Buffer.from("\n")]);
+    }
+    if ((0, helper_1.isPlainObject)(data)) {
+        return toDataEventString(JSON.stringify(data));
+    }
+    const dataStr = typeof data !== "string" ? `${data}` : data;
+    return dataStr
+        .split(/[\r\n]+/)
+        .map((line) => `data: ${line}\n`)
+        .join("");
+}

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/unified-responder.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendResponse = sendResponse;
+const error_1 = require("./error");
+const logger_1 = require("./logger");
+function sendResponse(ctx, data, error, errStatusCode = 500, withStack = true) {
+    if (error) {
+        if (!ctx.response) {
+            return;
+        }
+        const errorStack = (0, error_1.decorateErrorStack)(error.cause);
+        logger_1.functionsLogger.log(logger_1.LogType.ACCESS, logger_1.LogLevel.ERROR, error.message, {
+            code: error.code,
+            stack: errorStack,
+            statusCode: errStatusCode,
+        });
+        console.error(`[ERROR] ${error.message}\n${errorStack}`);
+        ctx.status = errStatusCode;
+        if (withStack) {
+            data = {
+                code: error.code,
+                message: error.message,
+                stack: errorStack,
+                requestId: ctx.state.eventID,
+            };
+        }
+        else {
+            data = {
+                code: error.code,
+                message: error.message,
+                requestId: ctx.state.eventID,
+            };
+        }
+    }
+    if (isIntegrationResponse(data)) {
+        return sendIntegrationResponse(ctx, data);
+    }
+    if (typeof data === "undefined" || data === null) {
+        ctx.status = 204;
+    }
+    else {
+        ctx.body = data;
+    }
+    const eResult = data;
+    if (eResult && eResult.code) {
+        ctx.state.errorResult = {
+            code: eResult.code,
+            message: eResult.message,
+        };
+    }
+    return;
+}
+function isIntegrationResponse(result) {
+    if (typeof result !== "object" || !result) {
+        return false;
+    }
+    const { statusCode, headers } = result;
+    return typeof statusCode === "number" && typeof headers === "object";
+}
+function sendIntegrationResponse(ctx, result) {
+    ctx.set(result.headers);
+    ctx.body = result.body;
+    ctx.status = result.statusCode;
+}

package/lib/user-logger.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeUserCodeLogs = takeUserCodeLogs;
+exports.pushUserCodeLogs = pushUserCodeLogs;
+exports.addUserCodeLog = addUserCodeLog;
+exports.getUserCodeLogs = getUserCodeLogs;
+const async_context_1 = require("./async-context");
+const logger_1 = require("./logger");
+const USER_CODE_LOGS_MAX_COUNT = 100;
+const USER_CODE_LOGS_FLUSH_TIMER_TIMEOUT = 1000;
+function lazyInitUserCodeLogs() {
+    const currentContext = (0, async_context_1.getCurrentAsyncContext)();
+    if (currentContext && currentContext.userCodeLogs === undefined) {
+        currentContext.userCodeLogs = [];
+    }
+}
+function takeUserCodeLogs() {
+    lazyInitUserCodeLogs();
+    const context = (0, async_context_1.getCurrentAsyncContext)();
+    if (context !== undefined) {
+        const logs = context.userCodeLogs || [];
+        context.userCodeLogs = [];
+        return logs;
+    }
+    return [];
+}
+function pushUserCodeLogs(log) {
+    lazyInitUserCodeLogs();
+    const context = (0, async_context_1.getCurrentAsyncContext)();
+    if (context === null || context === void 0 ? void 0 : context.userCodeLogs) {
+        context.userCodeLogs.push(log);
+    }
+}
+function addUserCodeLog(log) {
+    var _a;
+    lazyInitUserCodeLogs();
+    const userCodeLogs = ((_a = (0, async_context_1.getCurrentAsyncContext)()) === null || _a === void 0 ? void 0 : _a.userCodeLogs) || [];
+    if (userCodeLogs.length >= USER_CODE_LOGS_MAX_COUNT) {
+        logger_1.functionsLogger.logUserCodelog();
+    }
+    const currentContext = (0, async_context_1.getCurrentAsyncContext)();
+    if (currentContext && currentContext.done && !currentContext.userCodeLogsFlushTimer) {
+        currentContext.userCodeLogsFlushTimer = setTimeout(() => {
+            logger_1.functionsLogger.logUserCodelog();
+            currentContext.userCodeLogsFlushTimer = undefined;
+        }, USER_CODE_LOGS_FLUSH_TIMER_TIMEOUT);
+    }
+    pushUserCodeLogs(log);
+}
+function getUserCodeLogs() {
+    lazyInitUserCodeLogs();
+    const context = (0, async_context_1.getCurrentAsyncContext)();
+    return (context === null || context === void 0 ? void 0 : context.userCodeLogs) || [];
+}

package/lib/utils/apm.config.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultConfig = exports.APM_MEASUREMENT_NAME = void 0;
+exports.APM_MEASUREMENT_NAME = "vectorx_kit_agent_runtime";
+exports.defaultConfig = {
+    endpoint: "https://apm-fe.xiaohongshu.com/api/data",
+};