@byted-apaas/server-sdk-node 0.0.1-beta.3

package/hooks/api.ts

@@ -0,0 +1,341 @@
+import * as common from "@byted-apaas/server-common-node";
+import {IGfCtx} from "@byted-apaas/server-common-node/context/IContext";
+import {InvalidParamError} from "@byted-apaas/server-common-node/utils/exceptions";
+
+import * as api from "../hooks/api";
+import * as metadataApi from '../context/metadata/metadata'
+
+import {Tasks} from "../context/tasks/tasks";
+import {DB} from "../context/db/impl/db";
+import {_Resources} from "../context/resources/impl/resources";
+import {Message} from "../context/msg/msg";
+import * as Request from "../request/interface"
+import * as constants from "../constants/constants";
+import {getRequireFunc} from "@byted-apaas/server-common-node/utils/utils";
+import {IMetaData, MetaData} from "../context/metadata/metadata";
+import {
+    ExecuteOptions,
+    ExecutionInfo,
+    ExecutionResult,
+    FlowTaskInfo,
+    RevokeExecutionOptions
+} from "@byted-apaas/server-common-node/context/workflow/workflow";
+
+const nodeCls = require("node-cls");
+const nodeClsCtx = common.nodeClsCtx;
+const exceptions = common.exceptions;
+const utils = common.utils;
+const checkUtils = common.checkUtils;
+const functionSources = common.constants.functionSources;
+
+type invokeGlobalFuncT = (funcNames: string) => { invoke: (params?: any) => Promise<any>; }
+
+// 同步调用云函数
+export function getFunctionSync(context?: any, logger?: common.Logger): invokeGlobalFuncT {
+    return (funcName: string) => {
+        if (utils.isOnlineDev()) {
+            let oldFuncName = funcName;
+            if (!utils.isMicroservice()) {
+                funcName = utils.handleFuncName(null, funcName);
+                if (!funcName) {
+                    throw new exceptions.InvalidParamError(`The function (${oldFuncName}) does not exist, please confirm ${oldFuncName} exists and has been deployed.`);
+                }
+            } else {
+                funcName = undefined;
+            }
+
+            let idOrName: any = {};
+            // 2.0 通过 apiAlias 触发
+            if (funcName === oldFuncName) {
+                idOrName = {
+                    APIName: funcName,
+                    isInvokeByAPIName: true,
+                }
+            } else if (utils.isMicroservice()) {
+                // 微服务
+                idOrName = {
+                    APIName: oldFuncName,
+                    isInvokeByAPIName: true,
+                }
+            } else { // 1.0 通过 apiID 触发
+                idOrName = {
+                    APIId: funcName,
+                    isInvokeByAPIName: false,
+                }
+            }
+
+            return {
+                invoke: async (params?: any) => {
+                    // 微服务的场景
+                    if (utils.isMicroservice()) {
+                        return await Request.GetInstance().invokeFuncSync(idOrName, params)
+                    } else {
+                        let func = utils.getGlobalFunc(null, funcName);
+                        if (!func) {
+                            // 改为远程调用
+                            return await Request.GetInstance().invokeFuncSync(idOrName, params)
+                        }
+
+                        let loopMasks = [funcName];
+                        let reqCtx = nodeCls.get("loopCtx");
+                        if (reqCtx && reqCtx.loopMasks && Array.isArray(reqCtx.loopMasks)) {
+                            if (reqCtx.loopMasks.includes(funcName)) {
+                                throw new exceptions.InvalidParamError(`Task execution forms a loop.`);
+                            }
+                            loopMasks.push(...reqCtx.loopMasks);
+                        }
+                        // 修改 source 全局函数
+                        let ctx = nodeCls.create("loopCtx");
+                        ctx.loopMasks = loopMasks;
+                        return await ctx.run(async () => {
+                            const dynCtx = nodeClsCtx.getDynCtx();
+                            dynCtx.source = functionSources.globalFunction;
+                            return await dynCtx.run(async () => {
+                                return await common.hooks.invoke(func, params, context as any, logger);
+                            });
+                        });
+                    }
+                }
+            };
+        }
+
+        return {
+            invoke: async (params?: any) => {
+                let func = getRequireFunc()(funcName);
+                if (!func) {
+                    throw new exceptions.InvalidParamError(`The function (${funcName}) does not exist.`);
+                }
+
+                let loopMasks = [funcName];
+                let reqCtx = nodeCls.get("loopCtx");
+                if (reqCtx && reqCtx.loopMasks && Array.isArray(reqCtx.loopMasks)) {
+                    if (reqCtx.loopMasks.includes(funcName)) {
+                        throw new exceptions.InvalidParamError(`Task execution forms a loop.`);
+                    }
+                    loopMasks.push(...reqCtx.loopMasks);
+                }
+                // 修改 source 全局函数
+                let ctx = nodeCls.create("loopCtx");
+                ctx.loopMasks = loopMasks;
+                return await ctx.run(async () => {
+                    const dynCtx = nodeClsCtx.getDynCtx();
+                    dynCtx.source = functionSources.globalFunction;
+                    return await dynCtx.run(async () => {
+                        return await common.hooks.invoke(func, params, context as any, logger);
+                    });
+                });
+            }
+        };
+    };
+}
+
+// 设置请求头
+export function setRespHeader() {
+    return function () {
+        switch (arguments.length) {
+            case 1:
+                if (checkUtils.isObject(arguments[0])) {
+                    try {
+                        for (let k of Object.keys(arguments[0])) {
+                            utils.setHttpHeaders(k, toString(arguments[0][k]));
+                        }
+                    } catch (err) {
+                        throw new exceptions.InternalError(err.message);
+                    }
+                } else {
+                    throw new exceptions.InvalidParamError("setResponseHeaders param is not a object");
+                }
+                break;
+            case 2:
+                try {
+                    utils.setHttpHeaders(arguments[0], toString(arguments[1]));
+                } catch (err) {
+                    throw new exceptions.InternalError(err.message);
+                }
+                break;
+            default:
+                throw new exceptions.InvalidParamError("the number of setResponseHeaders param is 1 or 2");
+        }
+    }
+}
+
+export function toString(value: any) {
+    if (value instanceof Array) {
+        let arr = [];
+        for (let v of value) {
+            if (typeof v === "string") {
+                arr.push(v);
+            } else {
+                arr.push(utils.stringify(v));
+            }
+        }
+        return arr.join(", ");
+    } else if (typeof value === "string") {
+        return value;
+    }
+    return utils.stringify(value);
+}
+
+export function setRedirectLocation(context: any) {
+    return function (location: string) {
+        context.setResponseHeader(constants.httpHeaderKeys.location, location);
+        context.setResponseHeader(constants.httpHeaderKeys.statusCode, String(constants.httpStatusCodes.redirect));
+    }
+}
+
+// 请求方法
+export function method() {
+    return utils.getHttpMethod();
+}
+
+export function mountMetadata(context: any) {
+    // 1.挂载metadata
+    context.metadata = metadataApi.metadata(context);
+
+    // 2.挂载metaType
+    if (!global.kunlun) {
+        (global as any).kunlun = {};
+    }
+    (global as any).kunlun.metaType = metadataApi.metaType();
+}
+
+export function mountWorkflowFeature(context: any) {
+    if (context && context.workflow) {
+        context.workflow.updateVariable = common.updateVariable(context, Request.GetInstance().updateWorkflowVariables);
+    } else {
+        context.workflow = {};
+    }
+    // 此处挂载保证了 terminate 存在
+    context.workflow.terminate = terminateWorkflow();
+}
+
+export function terminateWorkflow() {
+    return async (workflowInstanceId: number, options: any) => {
+        let operator: number = utils.getUser()._id, reason: string = null;
+        if (options && options.reason) {
+            // instanceof 改动5
+            // if (options.reason instanceof common.fieldType.Multilingual) {
+            if (common.fieldType.isKFieldTypeMultilingual(options.reason)) {
+                reason = options.reason.toString();
+            } else {
+                reason = new common.fieldType.Multilingual(options.reason).toString();
+            }
+        }
+
+        await Request.GetInstance().terminateWorkflowInstance(workflowInstanceId, operator, reason);
+    };
+}
+
+export function mockFlowFeature(context: any) {
+    if (!context.flow) {
+        context.flow = {};
+    }
+
+    context.flow.updateVariable = common.updateVariable(context, Request.GetInstance().updateWorkflowVariables);
+
+    context.flow.getExecutionUserTaskInfo = mockGetExecutionUserTaskInfo();
+
+    context.flow.execute = mockExecuteFlow();
+    context.flow.revokeExecution = mockRevokeExecution();
+    context.flow.getExecutionInfo = mockGetExecutionInfo();
+    return context.flow;
+}
+
+function mockGetExecutionUserTaskInfo() {
+    return async (executionId: bigint): Promise<FlowTaskInfo[]> => {
+        if (!executionId || typeof executionId !== "number") {
+            throw new InvalidParamError(`param's type (${executionId}) need number, but is ${typeof executionId}`);
+        }
+        return await Request.GetInstance().getExecutionUserTaskInfo(executionId);
+    };
+}
+
+function mockExecuteFlow() {
+    return async (APIName: string, options?: ExecuteOptions): Promise<ExecutionResult> => {
+        if (!APIName || typeof APIName !== "string") {
+            throw new InvalidParamError(`param's type (${APIName}) need string, but is ${typeof APIName}`);
+        }
+        if (options && options.params && checkUtils.isNotObject(options.params)) {
+            throw new InvalidParamError(`options.params's type (${options}) need object, but is ${Array.isArray(options) ? "array" : typeof options.params}`);
+        }
+        if (!options) {
+            options = {} as any;
+        }
+        return await Request.GetInstance().executeFlow(APIName, options);
+    };
+}
+
+function mockRevokeExecution() {
+    return async (executionId: number, options: RevokeExecutionOptions): Promise<void> => {
+        if (!executionId || typeof executionId !== "number") {
+            throw new InvalidParamError(`param's type (${executionId}) is need number, but is ${typeof executionId}`);
+        }
+        return await Request.GetInstance().revokeExecution(executionId, options);
+    };
+}
+
+function mockGetExecutionInfo() {
+    return async (executionId: number): Promise<ExecutionInfo> => {
+        if (!executionId || typeof executionId !== "number") {
+            throw new InvalidParamError(`param's type (${executionId}) is not matched to number, but is ${typeof executionId}`);
+        }
+        return await Request.GetInstance().getExecutionInfo(executionId);
+    };
+}
+
+export function invokeMicroservice() {
+    /**
+     * 微服务
+     * @param apiName 微服务的名称
+     */
+    return function (apiName: string) {
+        if (!apiName || typeof (apiName) !== "string") {
+            throw new InvalidParamError(`The apiName (${apiName}) is invalid and should be a non-empty field string.`);
+        }
+
+        return {
+            /**
+             * 同步调用微服务
+             * @param path 请求路径，如：/ping
+             * @param method 请求方法，默认为 GET
+             * @param params 请求参数，默认为 undefined
+             */
+            invoke: async function (path: string, method: string = "GET", params: any = undefined) {
+                if (!path || typeof (path) !== "string") {
+                    throw new InvalidParamError(`The path (${path}) is invalid and should be a non-empty field string.`);
+                }
+                if (!method || typeof (method) !== "string") {
+                    throw new InvalidParamError(`The method (${method}) is invalid and should be a non-empty field string.`);
+                }
+                return await Request.GetFaaSInfraInstance().invokeMicroserviceSync(apiName, path, method, params);
+            },
+            /**
+             * 异步调用微服务
+             * @param path 请求路径，如：/ping
+             * @param method 请求方法，默认为 GET
+             * @param params 请求参数，默认为 undefined
+             */
+            invokeAsync: async function (path: string, method: string = "GET", params: any = undefined) {
+                if (!path || typeof (path) !== "string") {
+                    throw new InvalidParamError(`The path (${path}) is invalid and should be a non-empty field string.`);
+                }
+                if (!method || typeof (method) !== "string") {
+                    throw new InvalidParamError(`The method (${method}) is invalid and should be a non-empty field string.`);
+                }
+                return await Request.GetFaaSInfraInstance().invokeMicroserviceAsync(apiName, path, method, params);
+            },
+        };
+    };
+}
+
+export const db = new DB<IGfCtx>();
+export const resources = new _Resources();
+export const msg = new Message();
+export const tasks = new Tasks();
+export const cloudfunction = api.getFunctionSync();
+export const microservice = api.invokeMicroservice();
+export const workflow = {
+    terminate: terminateWorkflow(),
+};
+export const metaData: IMetaData<{}> = new MetaData<{}>(null)
+export {Application} from "../application/impl/impl";

package/hooks/hooks.d.ts

@@ -0,0 +1 @@
+export {};

package/hooks/hooks.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resources_1 = require("../context/resources/impl/resources");
+const tasks_1 = require("../context/tasks/tasks");
+const msg_1 = require("../context/msg/msg");
+const server_common_node_1 = require("@byted-apaas/server-common-node");
+const api = require("./api");
+const operator_1 = require("../kunlun/operator/impl/operator");
+const constants_1 = require("@byted-apaas/server-common-node/constants/constants");
+const db_1 = require("../context/db/impl/db");
+const common_1 = require("../request/common");
+/**
+ * 根据 key 获取对应的全局变量
+ * @param key 全局变量的 key
+ */
+function getVar(key) {
+    return server_common_node_1.utils.getGlobalVariableByKey(key);
+}
+function pre(params, context, logger, requireFunc) {
+    // 初始化 kunlun
+    if (!global.kunlun) {
+        // 缺省的情况，先对 kunlun 进行初始化
+        global.kunlun = {};
+    }
+    global.kunlun.operator = new operator_1.Operator();
+    global.kunlun.getVar = getVar;
+    global.kunlun.tool.getTenantInfo = common_1.getTenantInfo;
+    // 对 context 下的能力进行初始化
+    mountContext(context, logger, requireFunc);
+}
+/**
+ * mountContext 函数用于初始化 context 在 core 包中实现的部分，包括：
+ *   - db
+ *   - (global function 场景下): setRespHeader, setRedirectLocation
+ *   - task, function, msg, resources
+ * @param context 系统代理函数中经由 common 创建的用户 context，根据 source 分为不同类型
+ * @param logger Logger
+ * @param requireFunc
+ */
+function mountContext(context, logger, requireFunc) {
+    const source = server_common_node_1.utils.getSource();
+    // 1. 根据不同调用场景差异化初始化内容
+    //    - db 是否包含 currentObject，transaction 是否包含 currentObject
+    //    - global function 场景需要初始化 setRespHeader 和 RedirectLocation 方法，以及 method 属性
+    switch (source) {
+        case constants_1.functionSources.workflow:
+            context.db = new db_1.DBWithCurrentObject(context.objectApiName);
+            break;
+        case constants_1.functionSources.globalFunction:
+            context.db = new db_1.DBWithCurrentObject(null);
+            // set response headers
+            context.setResponseHeader = api.setRespHeader();
+            context.setRedirectLocation = api.setRedirectLocation(context);
+            // 暴露context.method属性
+            context.method = server_common_node_1.utils.getHttpMethod();
+            break;
+        case constants_1.functionSources.recordAutomation:
+            context.db = new db_1.DBWithCurrentObject(context.objectApiName);
+            break;
+        case constants_1.functionSources.scheduleAutomation:
+            context.db = new db_1.DBWithCurrentObject(null);
+            break;
+        default:
+            throw new server_common_node_1.exceptions.InvalidParamError(`This npm package does not contain this source ${source}`);
+    }
+    // 2. 初始化 core 包中需要初始化的内容，因此强转为 IContext 类型
+    //    - function
+    //    - tasks
+    //    - msg
+    //    - resources
+    //    - microservice
+    //    - getVar
+    context.function = api.getFunctionSync(context, logger);
+    context.tasks = new tasks_1.Tasks(context.function);
+    context.msg = new msg_1.Message();
+    context.resources = new resources_1._Resources();
+    context.getVar = getVar;
+    context.microservice = api.invokeMicroservice();
+    api.mountWorkflowFeature(context);
+    // 挂载 metadata
+    api.mountMetadata(context);
+    api.mockFlowFeature(context);
+    // 防止 context.function 被串改
+    Object.freeze(context.function);
+}
+module.exports = {
+    pre,
+};

package/hooks/hooks.ts

@@ -0,0 +1,100 @@
+import * as common from "@byted-apaas/server-common-node";
+import { IContext } from "../context/context";
+import { _Resources } from "../context/resources/impl/resources";
+import { Tasks } from "../context/tasks/tasks";
+import { Message } from "../context/msg/msg";
+import { exceptions, utils } from '@byted-apaas/server-common-node'
+import * as api from './api'
+import { Operator } from "../kunlun/operator/impl/operator";
+import { functionSources } from "@byted-apaas/server-common-node/constants/constants";
+import { IWfCtx, IGfCtx, IRaCtx, ISaCtx } from '@byted-apaas/server-common-node/context/IContext'
+import { DBWithCurrentObject } from "../context/db/impl/db";
+import { getTenantInfo } from "../request/common";
+
+type AllICtx = IGfCtx | IWfCtx | IRaCtx | ISaCtx;
+
+/**
+ * 根据 key 获取对应的全局变量
+ * @param key 全局变量的 key
+ */
+function getVar(key: string): string | number | number[] {
+    return utils.getGlobalVariableByKey(key);
+}
+
+function pre(params: any, context: AllICtx, logger: common.Logger, requireFunc: Function) {
+    // 初始化 kunlun
+    if (!global.kunlun) {
+        // 缺省的情况，先对 kunlun 进行初始化
+        (global as any).kunlun = {}
+    }
+    global.kunlun.operator = new Operator();
+    ((global.kunlun as any).getVar as any) = getVar;
+    ((global.kunlun as any).tool as any).getTenantInfo = getTenantInfo as any;
+    // 对 context 下的能力进行初始化
+    mountContext(context, logger, requireFunc);
+}
+
+/**
+ * mountContext 函数用于初始化 context 在 core 包中实现的部分，包括：
+ *   - db
+ *   - (global function 场景下): setRespHeader, setRedirectLocation
+ *   - task, function, msg, resources
+ * @param context 系统代理函数中经由 common 创建的用户 context，根据 source 分为不同类型
+ * @param logger Logger
+ * @param requireFunc
+ */
+function mountContext(context: AllICtx, logger: common.Logger, requireFunc: Function) {
+    const source: string = utils.getSource();
+
+    // 1. 根据不同调用场景差异化初始化内容
+    //    - db 是否包含 currentObject，transaction 是否包含 currentObject
+    //    - global function 场景需要初始化 setRespHeader 和 RedirectLocation 方法，以及 method 属性
+    switch (source) {
+        case functionSources.workflow:
+            (context as IContext<IWfCtx> & IWfCtx).db = new DBWithCurrentObject<IWfCtx>((context as IWfCtx).objectApiName)
+            break;
+        case functionSources.globalFunction:
+            (context as IContext<IGfCtx> & IGfCtx).db = new DBWithCurrentObject<IGfCtx>(null);
+
+            // set response headers
+            (context as IGfCtx).setResponseHeader = api.setRespHeader();
+            (context as IGfCtx).setRedirectLocation = api.setRedirectLocation(context as IGfCtx);
+
+            // 暴露context.method属性
+            (context as IGfCtx).method = utils.getHttpMethod();
+            break;
+        case functionSources.recordAutomation:
+            (context as IContext<IRaCtx> & IRaCtx).db = new DBWithCurrentObject<IRaCtx>((context as IRaCtx).objectApiName)
+            break;
+        case functionSources.scheduleAutomation:
+            (context as IContext<ISaCtx> & ISaCtx).db = new DBWithCurrentObject<ISaCtx>(null)
+            break;
+        default:
+            throw new exceptions.InvalidParamError(`This npm package does not contain this source ${source}`)
+    }
+
+    // 2. 初始化 core 包中需要初始化的内容，因此强转为 IContext 类型
+    //    - function
+    //    - tasks
+    //    - msg
+    //    - resources
+    //    - microservice
+    //    - getVar
+    (context as unknown as IContext<null>).function = api.getFunctionSync(context, logger);
+    (context as unknown as IContext<null>).tasks = new Tasks((context as unknown as IContext<null>).function);
+    (context as unknown as IContext<null>).msg = new Message();
+    (context as unknown as IContext<null>).resources = new _Resources();
+    ((context as unknown as IContext<null>).getVar as any) = getVar;
+    (context as any).microservice = api.invokeMicroservice();
+    api.mountWorkflowFeature(context);
+    // 挂载 metadata
+    api.mountMetadata(context);
+    api.mockFlowFeature(context as any);
+
+    // 防止 context.function 被串改
+    Object.freeze((context as unknown as IContext<null>).function);
+}
+
+module.exports = {
+    pre,
+}

package/kunlun/kunlun.d.ts

@@ -0,0 +1,55 @@
+import { IOperator } from './operator/IOperator';
+import { GMTOffset as GMT } from "@byted-apaas/server-common-node/constants/timeZone";
+import { area2code } from "@byted-apaas/server-common-node/constants/countryCode";
+import { ITool, IToolsExtra } from "@byted-apaas/server-common-node/kunlun/tool/Itool";
+import { errCodes } from "@byted-apaas/server-common-node/utils/exceptions";
+import * as common from "@byted-apaas/server-common-node";
+declare global {
+    export namespace kunlun {
+        /**
+         * 指令操作符
+         */
+        let operator: IOperator;
+    }
+}
+export declare namespace kunlun {
+    /**
+     * 引用时区信息
+     */
+    const GMTOffset: typeof GMT;
+    /**
+     * 引用国际区号
+     */
+    const countryCode: typeof area2code;
+    /**
+     * 工具方法
+     */
+    let tool: ITool & IToolsExtra;
+    /**
+     * 生成复杂数据结构
+     */
+    namespace type {
+        export import Multilingual = common.fieldType.Multilingual;
+        export import Phone = common.fieldType.Phone;
+        export import Date = common.fieldType.Date;
+        export import DateTime = common.fieldType.DateTime;
+    }
+    /**
+     * 错误码
+     */
+    const errorCode: {
+        /**
+         * 限流错误码
+         */
+        RATE_LIMIT_ERROR: errCodes;
+    };
+    /**
+     * 根据 key 获取对应的全局变量
+     * @param key 全局变量的 key
+     */
+    function getVar(key: string): Promise<string>;
+    /**
+     * 指令操作符
+     */
+    const operator: IOperator;
+}

package/kunlun/kunlun.js

@@ -0,0 +1,58 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kunlun = void 0;
+const timeZone_1 = require("@byted-apaas/server-common-node/constants/timeZone");
+const countryCode_1 = require("@byted-apaas/server-common-node/constants/countryCode");
+const tool_1 = require("@byted-apaas/server-common-node/kunlun/tool/impl/tool");
+const exceptions_1 = require("@byted-apaas/server-common-node/utils/exceptions");
+const operator_1 = require("./operator/impl/operator");
+const common = require("@byted-apaas/server-common-node");
+const Request = require("../request/interface");
+var kunlun;
+(function (kunlun) {
+    /**
+     * 引用时区信息
+     */
+    kunlun.GMTOffset = timeZone_1.GMTOffset;
+    /**
+     * 引用国际区号
+     */
+    kunlun.countryCode = countryCode_1.area2code;
+    /**
+     * 工具方法
+     */
+    kunlun.tool = new tool_1.Tool();
+    /**
+     * 生成复杂数据结构
+     */
+    let type;
+    (function (type) {
+        type.Multilingual = common.fieldType.Multilingual;
+        type.Phone = common.fieldType.Phone;
+        type.Date = common.fieldType.Date;
+        type.DateTime = common.fieldType.DateTime;
+    })(type = kunlun.type || (kunlun.type = {}));
+    /**
+     * 错误码
+     */
+    kunlun.errorCode = {
+        /**
+         * 限流错误码
+         */
+        RATE_LIMIT_ERROR: exceptions_1.errCodes.RATE_LIMIT_ERROR,
+    };
+    /**
+     * 根据 key 获取对应的全局变量
+     * @param key 全局变量的 key
+     */
+    async function getVar(key) {
+        return await Request.GetInstance().getGlobalConfigByKey(key);
+    }
+    kunlun.getVar = getVar;
+    /**
+     * 指令操作符
+     */
+    kunlun.operator = new operator_1.Operator();
+})(kunlun = exports.kunlun || (exports.kunlun = {}));