@byted-apaas/server-sdk-node 1.1.23 → 1.1.24

package/hooks/api.d.ts

@@ -0,0 +1,65 @@
+import * as common from '@byted-apaas/server-common-node';
+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 { IMetaData } from '../context/metadata/metadata';
+import { ExecuteOptions, ExecutionInfo, ExecutionResult, FlowTaskInfo, RevokeExecutionOptions } from '@byted-apaas/server-common-node/context/workflow/workflow';
+type invokeGlobalFuncT = (funcNames: string) => {
+    invoke: (params?: any) => Promise<any>;
+};
+export declare function getFunctionSync(context?: any, logger?: common.Logger): invokeGlobalFuncT;
+export declare function setRespHeader(): () => void;
+export declare function toString(value: any): string;
+export declare function setRedirectLocation(context: any): (location: string) => void;
+export declare function method(): string;
+export declare function mountMetadata(context: any): void;
+export declare function mountWorkflowFeature(context: any): void;
+export declare function terminateWorkflow(): (workflowInstanceId: number, options: any) => Promise<void>;
+export declare function mockFlowFeature(context: any): any;
+export declare function mockGetExecutionUserTaskInfo(): (executionId: bigint) => Promise<FlowTaskInfo[]>;
+export declare function mockExecuteFlow(): (apiName: string, options?: ExecuteOptions) => Promise<ExecutionResult>;
+export declare function mockRevokeExecution(): (executionId: number, options: RevokeExecutionOptions) => Promise<void>;
+export declare function mockGetExecutionInfo(): (executionId: number) => Promise<ExecutionInfo>;
+export declare function invokeMicroservice(): (apiName: string) => {
+    /**
+     * 同步调用微服务
+     * @param path 请求路径，如：/ping
+     * @param method 请求方法，默认为 GET
+     * @param params 请求参数，默认为 undefined
+     */
+    invoke: (path: string, method?: string, params?: any) => Promise<any>;
+    /**
+     * 异步调用微服务
+     * @param path 请求路径，如：/ping
+     * @param method 请求方法，默认为 GET
+     * @param params 请求参数，默认为 undefined
+     */
+    invokeAsync: (path: string, method?: string, params?: any) => Promise<any>;
+};
+export declare const db: DB<import("@byted-apaas/server-common-node/context/IContext").IContext, import("../data").metadataMap>;
+export declare const resources: _Resources;
+export declare const msg: Message;
+export declare const tasks: Tasks<unknown>;
+export declare const cloudfunction: invokeGlobalFuncT;
+export declare const microservice: (apiName: string) => {
+    /**
+     * 同步调用微服务
+     * @param path 请求路径，如：/ping
+     * @param method 请求方法，默认为 GET
+     * @param params 请求参数，默认为 undefined
+     */
+    invoke: (path: string, method?: string, params?: any) => Promise<any>;
+    /**
+     * 异步调用微服务
+     * @param path 请求路径，如：/ping
+     * @param method 请求方法，默认为 GET
+     * @param params 请求参数，默认为 undefined
+     */
+    invokeAsync: (path: string, method?: string, params?: any) => Promise<any>;
+};
+export declare const workflow: {
+    terminate: (workflowInstanceId: number, options: any) => Promise<void>;
+};
+export declare const metaData: IMetaData<{}>;
+export { Application } from '../application/impl/impl';

package/hooks/api.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Application = exports.metaData = exports.workflow = exports.microservice = exports.cloudfunction = exports.tasks = exports.msg = exports.resources = exports.db = exports.invokeMicroservice = exports.mockGetExecutionInfo = exports.mockRevokeExecution = exports.mockExecuteFlow = exports.mockGetExecutionUserTaskInfo = exports.mockFlowFeature = exports.terminateWorkflow = exports.mountWorkflowFeature = exports.mountMetadata = exports.method = exports.setRedirectLocation = exports.toString = exports.setRespHeader = exports.getFunctionSync = void 0;
+const common = require("@byted-apaas/server-common-node");
+const exceptions_1 = require("@byted-apaas/server-common-node/utils/exceptions");
+const api = require("../hooks/api");
+const metadataApi = require("../context/metadata/metadata");
+const tasks_1 = require("../context/tasks/tasks");
+const db_1 = require("../context/db/impl/db");
+const resources_1 = require("../context/resources/impl/resources");
+const msg_1 = require("../context/msg/msg");
+const Request = require("../request/interface");
+const constants = require("../constants/constants");
+const metadata_1 = require("../context/metadata/metadata");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const nodeCls = require('node-cls'); //nolint:byted_s_ts_no_require_imports
+const nodeClsCtx = common.nodeClsCtx;
+const exceptions = common.exceptions;
+const utils = common.utils;
+const checkUtils = common.checkUtils;
+const functionSources = common.constants.functionSources;
+// 同步调用云函数
+function getFunctionSync(context, logger) {
+    return (funcName) => {
+        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 = {};
+            // 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) => {
+                    // 微服务的场景
+                    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];
+                        const 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 全局函数
+                        const 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, logger);
+                            });
+                        });
+                    }
+                }
+            };
+        }
+        return {
+            invoke: async (params) => {
+                // 非微服务场景
+                if (!utils.isMicroservice()) {
+                    let func = undefined;
+                    let requireFunc = utils.getRequireFunc();
+                    if (requireFunc) {
+                        try {
+                            func = requireFunc(funcName);
+                        }
+                        catch (e) {
+                        }
+                    }
+                    if (func) {
+                        // 本地调用
+                        let loopMasks = [funcName];
+                        const 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 全局函数
+                        const 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, logger);
+                            });
+                        });
+                    }
+                }
+                // 远程调用 微服务 | 函数找不到
+                return await Request.GetInstance().invokeFuncSync({
+                    APIName: funcName,
+                    isInvokeByAPIName: true
+                }, params);
+            }
+        };
+    };
+}
+exports.getFunctionSync = getFunctionSync;
+// 设置请求头
+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');
+        }
+    };
+}
+exports.setRespHeader = setRespHeader;
+function toString(value) {
+    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);
+}
+exports.toString = toString;
+function setRedirectLocation(context) {
+    return function (location) {
+        context.setResponseHeader(constants.httpHeaderKeys.location, location);
+        context.setResponseHeader(constants.httpHeaderKeys.statusCode, String(constants.httpStatusCodes.redirect));
+    };
+}
+exports.setRedirectLocation = setRedirectLocation;
+// 请求方法
+function method() {
+    return utils.getHttpMethod();
+}
+exports.method = method;
+function mountMetadata(context) {
+    // 1.挂载metadata
+    context.metadata = metadataApi.metadata(context);
+    // 2.挂载metaType
+    if (!global.kunlun) {
+        global.kunlun = {};
+    }
+    global.kunlun.metaType = metadataApi.metaType();
+}
+exports.mountMetadata = mountMetadata;
+function mountWorkflowFeature(context) {
+    if (context && context.workflow) {
+        context.workflow.updateVariable = common.updateVariable(context, Request.GetInstance().updateWorkflowVariables);
+    }
+    else {
+        context.workflow = {};
+    }
+    // 此处挂载保证了 terminate 存在
+    context.workflow.terminate = terminateWorkflow();
+}
+exports.mountWorkflowFeature = mountWorkflowFeature;
+function terminateWorkflow() {
+    return async (workflowInstanceId, options) => {
+        let operator = utils.getUser()._id, reason = 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);
+    };
+}
+exports.terminateWorkflow = terminateWorkflow;
+function mockFlowFeature(context) {
+    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;
+}
+exports.mockFlowFeature = mockFlowFeature;
+function mockGetExecutionUserTaskInfo() {
+    return async (executionId) => {
+        if (!executionId || typeof executionId !== 'number') {
+            throw new exceptions_1.InvalidParamError(`param's type (${executionId}) need number, but is ${typeof executionId}`);
+        }
+        return await Request.GetInstance().getExecutionUserTaskInfo(executionId);
+    };
+}
+exports.mockGetExecutionUserTaskInfo = mockGetExecutionUserTaskInfo;
+function mockExecuteFlow() {
+    return async (apiName, options) => {
+        if (!apiName || typeof apiName !== 'string') {
+            throw new exceptions_1.InvalidParamError(`param's type (${apiName}) need string, but is ${typeof apiName}`);
+        }
+        if (options && options.params && checkUtils.isNotObject(options.params)) {
+            throw new exceptions_1.InvalidParamError(`options.params's type (${options}) need object, but is ${Array.isArray(options) ? 'array' : typeof options.params}`);
+        }
+        if (!options) {
+            options = {};
+        }
+        return await Request.GetInstance().executeFlow(apiName, options, false);
+    };
+}
+exports.mockExecuteFlow = mockExecuteFlow;
+function mockRevokeExecution() {
+    return async (executionId, options) => {
+        if (!executionId || typeof executionId !== 'number') {
+            throw new exceptions_1.InvalidParamError(`param's type (${executionId}) is need number, but is ${typeof executionId}`);
+        }
+        return await Request.GetInstance().revokeExecution(executionId, options);
+    };
+}
+exports.mockRevokeExecution = mockRevokeExecution;
+function mockGetExecutionInfo() {
+    return async (executionId) => {
+        if (!executionId || typeof executionId !== 'number') {
+            throw new exceptions_1.InvalidParamError(`param's type (${executionId}) is not matched to number, but is ${typeof executionId}`);
+        }
+        return await Request.GetInstance().getExecutionInfo(executionId);
+    };
+}
+exports.mockGetExecutionInfo = mockGetExecutionInfo;
+function invokeMicroservice() {
+    /**
+     * 微服务
+     * @param apiName 微服务的名称
+     */
+    return function (apiName) {
+        if (!apiName || typeof (apiName) !== 'string') {
+            throw new exceptions_1.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 (path, method = 'GET', params = undefined) => {
+                if (!path || typeof (path) !== 'string') {
+                    throw new exceptions_1.InvalidParamError(`The path (${path}) is invalid and should be a non-empty field string.`);
+                }
+                if (!method || typeof (method) !== 'string') {
+                    throw new exceptions_1.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 (path, method = 'GET', params = undefined) => {
+                if (!path || typeof (path) !== 'string') {
+                    throw new exceptions_1.InvalidParamError(`The path (${path}) is invalid and should be a non-empty field string.`);
+                }
+                if (!method || typeof (method) !== 'string') {
+                    throw new exceptions_1.InvalidParamError(`The method (${method}) is invalid and should be a non-empty field string.`);
+                }
+                return await Request.GetFaaSInfraInstance().invokeMicroserviceAsync(apiName, path, method, params);
+            },
+        };
+    };
+}
+exports.invokeMicroservice = invokeMicroservice;
+exports.db = new db_1.DB();
+exports.resources = new resources_1._Resources();
+exports.msg = new msg_1.Message();
+exports.tasks = new tasks_1.Tasks();
+exports.cloudfunction = api.getFunctionSync();
+exports.microservice = api.invokeMicroservice();
+exports.workflow = {
+    terminate: terminateWorkflow(),
+};
+exports.metaData = new metadata_1.MetaData(null);
+var impl_1 = require("../application/impl/impl");
+Object.defineProperty(exports, "Application", { enumerable: true, get: function () { return impl_1.Application; } });

package/hooks/hooks.d.ts

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

package/hooks/hooks.js

@@ -0,0 +1,107 @@
+"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 db_1 = require("../context/db/impl/db");
+const common_1 = require("../request/common");
+const integration_1 = require("../context/integration/impl/integration");
+const metadataApi = require("../context/metadata/metadata");
+const flow_1 = require("../global/application/flow/flow");
+/**
+ * 根据 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);
+    mountApplication(context);
+}
+/**
+ * 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) {
+    // 1. 全量挂载
+    context.db = new db_1.DBWithCurrentObject(context.objectApiName);
+    // set response headers
+    context.setResponseHeader = api.setRespHeader();
+    context.setRedirectLocation = api.setRedirectLocation(context);
+    context.method = server_common_node_1.utils.getHttpMethod();
+    // 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.integration = new integration_1._Integration();
+    context.getVar = getVar;
+    context.microservice = api.invokeMicroservice();
+    api.mountWorkflowFeature(context);
+    // 挂载 metadata
+    api.mountMetadata(context);
+    api.mockFlowFeature(context);
+    // 防止 context.function 被串改
+    Object.freeze(context.function);
+}
+function mountApplication(context) {
+    if (!global.application) {
+        global.application = {};
+    }
+    global.application.data = new db_1.DB();
+    // (global as any).application.dataV3 = new DBV3<IGfCtx>();
+    // publicAPI
+    if (!global.application.publicAPI) {
+        global.application.publicAPI = {};
+    }
+    global.application.publicAPI.setResponseHeader = api.setRespHeader();
+    global.application.publicAPI.setRedirectLocation = api.setRedirectLocation(context);
+    global.application.publicAPI.method = server_common_node_1.utils.getHttpMethod();
+    global.application.publicAPI.headers = server_common_node_1.utils.getHttpHeaders();
+    global.application.msg = new msg_1.Message();
+    global.application.resources = new resources_1._Resources();
+    global.application.metadata = metadataApi.metadata(context);
+    // (global as any).application.metadataV3 = metadataApi.metadataV3(context);
+    // globalVar
+    if (!global.application.globalVar) {
+        global.application.globalVar = {};
+    }
+    global.application.globalVar.getVar = getVar;
+    // constants
+    if (!global.application.constants) {
+        global.application.constants = {};
+    }
+    global.application.constants.metaType = metadataApi.metaType();
+    // flow
+    global.application.flow = (0, flow_1.newFlow)(context);
+    // operator
+    global.application.operator = new operator_1.Operator();
+    global.application.integration = new integration_1._Integration();
+}
+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 = {}));