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

package/kunlun/operator/impl/operatorV2.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorV2 = exports.operates = void 0;
+const server_common_node_1 = require("@byted-apaas/server-common-node");
+const logicV2_1 = require("./logicV2");
+exports.operates = {
+    AND: "and",
+    OR: "or",
+    EMPTY: "isEmpty",
+    NOT_EMPTY: "isNotEmpty",
+    EQ: "equals",
+    NEQ: "notEquals",
+    LT: "lessThan",
+    LTE: "lessThanOrEquals",
+    GT: "greaterThan",
+    GTE: "greaterThanOrEquals",
+    CONTAIN: "contains",
+    NOT_CONTAIN: "notContains",
+    IN: "isAnyOf",
+    NIN: "isNoneOf",
+    HAS_ANY_OF: "hasAnyOf",
+    HAS_NONE_OF: "hasNoneOf",
+    isOnOrBefore: "lt",
+    isOnOrAfter: "gt",
+};
+class OperatorV2 {
+    /**
+     * 逻辑且
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.and({
+     *     age: "22"
+     * },{
+     *     gender: "male"
+     * }))
+     * ```
+     */
+    and(...exps) {
+        const { logicalExps, arithmeticExps } = (0, logicV2_1.logical)(exps);
+        return new logicV2_1.LogicalExpression(exports.operates.AND, arithmeticExps, logicalExps);
+    }
+    ;
+    /**
+     * 逻辑或
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.or({
+     *     age: "22"
+     * },{
+     *     age: "25"
+     * }))
+     * ```
+     */
+    or(...exps) {
+        const { logicalExps, arithmeticExps } = (0, logicV2_1.logical)(exps);
+        return new logicV2_1.LogicalExpression(exports.operates.OR, arithmeticExps, logicalExps);
+    }
+    ;
+    /**
+     * 包含
+     * @param value 判定是否包含的文本值
+     * @example
+     * ```
+     * context.db.object("_user").where({_name: kunlun.operator.contain("a")})
+     * ```
+     */
+    contain(value) {
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.CONTAIN, value);
+    }
+    ;
+    /**
+     * 不包含
+     * @param value 判定是否不包含的文本值
+     * @example
+     * ```
+     * context.db.object("_user").where({_name: kunlun.operator.notContain("a")})
+     * ```
+     */
+    notContain(value) {
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.NOT_CONTAIN, value);
+    }
+    ;
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object("_user").where({employeeType: kunlun.operator.empty()})
+     * ```
+     */
+    empty() {
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.EMPTY, null);
+    }
+    ;
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object("_user").where({employeeType: kunlun.operator.notEmpty()})
+     * ```
+     */
+    notEmpty() {
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.NOT_EMPTY, null);
+    }
+    ;
+    /**
+     * 等于
+     * @param value 判定是否相等的值
+     * @example
+     * ```
+     * context.db.object("_user").where({age: kunlun.operator.eq(20)})
+     * ```
+     */
+    eq(value) {
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.EQ, value);
+    }
+    ;
+    /**
+     * 不等于
+     * @param value 判定是否不相等的值
+     * @example
+     * ```
+     * context.db.object("_user").where({age: kunlun.operator.neq(20)})
+     * ```
+     */
+    neq(value) {
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.NEQ, value);
+    }
+    ;
+    /**
+     * 大于或晚于
+     * @param value 判定是否大于或晚于的值
+     * @example
+     * ```
+     * kunlun.operator.gt(new Date("2020-11-26").getTime())
+     * ```
+     */
+    gt(value) {
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.GT, value);
+    }
+    ;
+    /**
+     * 大于等于或晚于等于
+     * @param value 判定是否大于等于或晚于等于的值
+     * @example
+     * ```
+     * kunlun.operator.gte(new Date("2020-11-26").getTime())
+     * ```
+     */
+    gte(value) {
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.GTE, value);
+    }
+    ;
+    /**
+     * 小于或早于
+     * @param value 判定是否小于或早于的值
+     * @example
+     * ```
+     * kunlun.operator.lt(new Date("2020-11-26").getTime())
+     * ```
+     */
+    lt(value) {
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.LT, value);
+    }
+    ;
+    /**
+     * 小于等于或早于等于
+     * @param value 判定是否小于等于或早于等于的值
+     * @example
+     * ```
+     * kunlun.operator.lte(new Date("2020-11-26").getTime())
+     * ```
+     */
+    lte(value) {
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.LTE, value);
+    }
+    ;
+    in(value, ...restValues) {
+        value = !value ? [] : value;
+        const argList = server_common_node_1.utils.argsToList(value, restValues);
+        if (argList.length === 0) {
+            throw new server_common_node_1.exceptions.InvalidParamError("can not IN empty list");
+        }
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.IN, argList);
+    }
+    ;
+    notIn(value, ...restValues) {
+        value = !value ? [] : value;
+        const argList = server_common_node_1.utils.argsToList(value, restValues);
+        if (argList.length === 0) {
+            throw new server_common_node_1.exceptions.InvalidParamError("can not NOT_IN empty list");
+        }
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.NIN, argList);
+    }
+    ;
+    hasAnyOf(value, ...restValues) {
+        value = !value ? [] : value;
+        const argList = server_common_node_1.utils.argsToList(value, restValues);
+        if (argList.length === 0) {
+            throw new server_common_node_1.exceptions.InvalidParamError("can not HAS_ANY_OF empty list");
+        }
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.HAS_ANY_OF, argList);
+    }
+    ;
+    hasNoneOf(value, ...restValues) {
+        value = !value ? [] : value;
+        const argList = server_common_node_1.utils.argsToList(value, restValues);
+        if (argList.length === 0) {
+            throw new server_common_node_1.exceptions.InvalidParamError("can not HAS_NONE_OF empty list");
+        }
+        return new logicV2_1.ArithmeticExpression(null, exports.operates.HAS_NONE_OF, argList);
+    }
+    ;
+}
+exports.OperatorV2 = OperatorV2;

package/kunlun/operator/impl/operatorV2.ts

@@ -0,0 +1,249 @@
+import { _Cond, _BooleanCond, _LogicalCond } from '../../../types/types'
+import { IOperator } from "../IOperator";
+import { exceptions, utils } from '@byted-apaas/server-common-node'
+import { LogicalExpression, logical, ArithmeticExpression } from './logicV2';
+import { UserDataType } from './expression';
+
+export const operates = {
+    AND: "and", // 逻辑与
+    OR: "or", // 逻辑或
+
+    EMPTY: "isEmpty", // 为空
+    NOT_EMPTY: "isNotEmpty", // 不为空
+
+    EQ: "equals", // 等于
+    NEQ: "notEquals", // 不等于
+    LT: "lessThan", // 小于
+    LTE: "lessThanOrEquals", // 小于或等于
+    GT: "greaterThan", // 大于
+    GTE: "greaterThanOrEquals", // 大于或等于
+
+    CONTAIN: "contains", // 包含
+    NOT_CONTAIN: "notContains", // 不包含
+
+    IN: "isAnyOf", // 在......列表内
+    NIN: "isNoneOf", // 不在......列表内
+
+    HAS_ANY_OF: "hasAnyOf", // 右值和左值有交集
+    HAS_NONE_OF: "hasNoneOf", // 右值和左值无交集
+
+    isOnOrBefore: "lt",
+    isOnOrAfter: "gt",
+}
+
+export class OperatorV2<T> implements IOperator {
+    /**
+     * 逻辑且
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.and({
+     *     age: "22"
+     * },{
+     *     gender: "male"
+     * }))
+     * ```
+     */
+    and<T>(...exps: (_Cond<T> | _BooleanCond<T> | LogicalExpression)[]): LogicalExpression {
+        const { logicalExps, arithmeticExps } = logical(exps as any);
+        return new LogicalExpression(operates.AND, arithmeticExps, logicalExps);
+    };
+    /**
+     * 逻辑或
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.or({
+     *     age: "22"
+     * },{
+     *     age: "25"
+     * }))
+     * ```
+     */
+    or<T>(...exps: (_Cond<T> | _BooleanCond<T> | LogicalExpression)[]): LogicalExpression {
+        const { logicalExps, arithmeticExps } = logical(exps as any);
+        return new LogicalExpression(operates.OR, arithmeticExps, logicalExps);
+    };
+    /**
+     * 包含
+     * @param value 判定是否包含的文本值
+     * @example
+     * ```
+     * context.db.object("_user").where({_name: kunlun.operator.contain("a")})
+     * ```
+     */
+    contain<T>(value: UserDataType): _BooleanCond<T> {
+        return new ArithmeticExpression(null, operates.CONTAIN, value);
+    };
+    /**
+     * 不包含
+     * @param value 判定是否不包含的文本值
+     * @example
+     * ```
+     * context.db.object("_user").where({_name: kunlun.operator.notContain("a")})
+     * ```
+     */
+    notContain<T>(value: UserDataType): _BooleanCond<T> {
+        return new ArithmeticExpression(null, operates.NOT_CONTAIN, value);
+    };
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object("_user").where({employeeType: kunlun.operator.empty()})
+     * ```
+     */
+    empty(): _BooleanCond<undefined> {
+        return new ArithmeticExpression(null, operates.EMPTY, null);
+    };
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object("_user").where({employeeType: kunlun.operator.notEmpty()})
+     * ```
+     */
+    notEmpty(): _BooleanCond<undefined> {
+        return new ArithmeticExpression(null, operates.NOT_EMPTY, null);
+    };
+    /**
+     * 等于
+     * @param value 判定是否相等的值
+     * @example
+     * ```
+     * context.db.object("_user").where({age: kunlun.operator.eq(20)})
+     * ```
+     */
+    eq<T>(value: UserDataType): _BooleanCond<T> {
+        return new ArithmeticExpression(null, operates.EQ, value);
+    };
+    /**
+     * 不等于
+     * @param value 判定是否不相等的值
+     * @example
+     * ```
+     * context.db.object("_user").where({age: kunlun.operator.neq(20)})
+     * ```
+     */
+    neq<T>(value: UserDataType): _BooleanCond<T> {
+        return new ArithmeticExpression(null, operates.NEQ, value);
+    };
+    /**
+     * 大于或晚于
+     * @param value 判定是否大于或晚于的值
+     * @example
+     * ```
+     * kunlun.operator.gt(new Date("2020-11-26").getTime())
+     * ```
+     */
+    gt<T>(value: number | Date): _BooleanCond<T> {
+        return new ArithmeticExpression(null, operates.GT, value);
+    };
+    /**
+     * 大于等于或晚于等于
+     * @param value 判定是否大于等于或晚于等于的值
+     * @example
+     * ```
+     * kunlun.operator.gte(new Date("2020-11-26").getTime())
+     * ```
+     */
+    gte<T>(value: number | Date): _BooleanCond<T> {
+        return new ArithmeticExpression(null, operates.GTE, value);
+    };
+    /**
+     * 小于或早于
+     * @param value 判定是否小于或早于的值
+     * @example
+     * ```
+     * kunlun.operator.lt(new Date("2020-11-26").getTime())
+     * ```
+     */
+    lt<T>(value: number | Date): _BooleanCond<T> {
+        return new ArithmeticExpression(null, operates.LT, value);
+    };
+    /**
+     * 小于等于或早于等于
+     * @param value 判定是否小于等于或早于等于的值
+     * @example
+     * ```
+     * kunlun.operator.lte(new Date("2020-11-26").getTime())
+     * ```
+     */
+    lte<T>(value: number | Date): _BooleanCond<T> {
+        return new ArithmeticExpression(null, operates.LTE, value);
+    };
+    /**
+     * 存在于给定的数组内
+     * @param values 判定是否存在于的一组值，用数组传递
+     */
+    in<T>(values: T[]): _BooleanCond<T>;
+    /**
+     * 存在于给定的数组内
+     * @param values 判定是否存在于的一组值，用逗号分隔
+     */
+    in<T>(...values: T[]): _BooleanCond<T>;
+    in<T>(value: T | T[], ...restValues: T[]): _BooleanCond<T> {
+        value = !value ? [] : value;
+        const argList = utils.argsToList(value, restValues);
+        if (argList.length === 0) {
+            throw new exceptions.InvalidParamError("can not IN empty list");
+        }
+        return new ArithmeticExpression(null, operates.IN, argList);
+    };
+    /**
+     * 不存在于给定的数组内
+     * @param values 判定是否不存在于的一组值，用数组传递
+     */
+    notIn<T>(values: T[]): _BooleanCond<T>;
+    /**
+     * 不存在于给定的数组内
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    notIn<T>(...values: T[]): _BooleanCond<T>;
+    notIn<T>(value: T | T[], ...restValues: T[]): _BooleanCond<T> {
+        value = !value ? [] : value;
+        const argList = utils.argsToList(value, restValues);
+        if (argList.length === 0) {
+            throw new exceptions.InvalidParamError("can not NOT_IN empty list");
+        }
+        return new ArithmeticExpression(null, operates.NIN, argList);
+    };
+
+    /**
+     * 存在给定的多个值中的任何一个值
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    hasAnyOf<T>(values: number[] | string[]): _BooleanCond<T>;
+    /**
+     * 存在给定的多个值中的任何一个值
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    hasAnyOf<T>(...values: (number | string)[]): _BooleanCond<T>;
+    hasAnyOf<T>(value: (number | string) | (number | string)[], ...restValues: (number | string)[]): _BooleanCond<T> {
+        value = !value ? [] : value;
+        const argList = utils.argsToList(value, restValues);
+        if (argList.length === 0) {
+            throw new exceptions.InvalidParamError("can not HAS_ANY_OF empty list");
+        }
+        return new ArithmeticExpression(null, operates.HAS_ANY_OF, argList);
+    };
+    /**
+     * 不存在给定的多个值中的任何值
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    hasNoneOf<T>(values: number[] | string[]): _BooleanCond<T>;
+
+    /**
+     * 不存在给定的多个值中的任何值
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    hasNoneOf<T>(...values: (number | string)[]): _BooleanCond<T>;
+    hasNoneOf<T>(value: (number | string) | (number | string)[], ...restValues: (number | string)[]): _BooleanCond<T> {
+        value = !value ? [] : value;
+        const argList = utils.argsToList(value, restValues);
+        if (argList.length === 0) {
+            throw new exceptions.InvalidParamError("can not HAS_NONE_OF empty list");
+        }
+        return new ArithmeticExpression(null, operates.HAS_NONE_OF, argList);
+    };
+}

package/lib/core.d.ts

@@ -0,0 +1,4 @@
+export * as hooks from "../hooks/hooks";
+export declare const isNewSystemProxyFunc: boolean;
+export { kunlun } from "../kunlun/kunlun";
+export { db, resources, msg, tasks, cloudfunction, microservice, workflow, metaData, Application } from "../hooks/api";

package/lib/core.js

@@ -0,0 +1,19 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+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.kunlun = exports.isNewSystemProxyFunc = exports.hooks = void 0;
+exports.hooks = require("../hooks/hooks");
+exports.isNewSystemProxyFunc = true;
+var kunlun_1 = require("../kunlun/kunlun");
+Object.defineProperty(exports, "kunlun", { enumerable: true, get: function () { return kunlun_1.kunlun; } });
+var api_1 = require("../hooks/api");
+Object.defineProperty(exports, "db", { enumerable: true, get: function () { return api_1.db; } });
+Object.defineProperty(exports, "resources", { enumerable: true, get: function () { return api_1.resources; } });
+Object.defineProperty(exports, "msg", { enumerable: true, get: function () { return api_1.msg; } });
+Object.defineProperty(exports, "tasks", { enumerable: true, get: function () { return api_1.tasks; } });
+Object.defineProperty(exports, "cloudfunction", { enumerable: true, get: function () { return api_1.cloudfunction; } });
+Object.defineProperty(exports, "microservice", { enumerable: true, get: function () { return api_1.microservice; } });
+Object.defineProperty(exports, "workflow", { enumerable: true, get: function () { return api_1.workflow; } });
+Object.defineProperty(exports, "metaData", { enumerable: true, get: function () { return api_1.metaData; } });
+Object.defineProperty(exports, "Application", { enumerable: true, get: function () { return api_1.Application; } });

package/lib/core.ts

@@ -0,0 +1,7 @@
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+
+export * as hooks from "../hooks/hooks"
+export const isNewSystemProxyFunc: boolean = true;
+export {kunlun} from "../kunlun/kunlun";
+export {db, resources, msg, tasks, cloudfunction, microservice, workflow, metaData, Application} from "../hooks/api";

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@byted-apaas/server-sdk-node",
+  "version": "0.0.1-beta.3",
+  "description": "aPaaS Server SDK",
+  "author": "zhouwexin <zhouwexin@bytedance.com>",
+  "homepage": "",
+  "license": "MIT",
+  "main": "lib/core.js",
+  "files": [
+    "constants",
+    "context",
+    "data",
+    "hooks",
+    "request",
+    "kunlun",
+    "lib",
+    "types",
+    "application"
+  ],
+  "scripts": {
+    "compile": "tsc -d",
+    "compile.local": "tsc -d --sourceMap",
+    "pre-build": "rm -rf build && tsc"
+  },
+  "dependencies": {
+    "@byted-apaas/server-common-node": "0.0.2-beta.1",
+    "@jorgeferrero/stream-to-buffer": "^2.0.6",
+    "dayjs": "^1.9.6",
+    "form-data": "^3.0.0",
+    "uuid": "^8.3.2"
+  },
+  "devDependencies": {
+    "@types/mocha": "^9.0.0",
+    "axios": "^0.21.0",
+    "madge": "^3.12.0",
+    "mocha": "^9.1.3",
+    "node-cls": "^1.0.7"
+  },
+  "mocha": {
+    "color": true,
+    "recursive": [
+      "test/**/*.test.ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "timeout": 20000
+  },
+  "gitHead": "e2274551684797a45a4fa5e2168f1c54a7559c7e"
+}

package/request/common.d.ts

@@ -0,0 +1,13 @@
+import { AppCtx } from "../application/application";
+export declare function getDebugExtraInfo(): Record<string, string>;
+export declare function getTriggerCtx(): any;
+export declare function transMapToFlowVariable(params: Record<string, any>): {
+    api_name: string;
+    value: any;
+}[];
+export declare function transFlowVariableToMap(variables: {
+    api_name: string;
+    value: any;
+}[]): Record<string, any>;
+export declare function getTenantInfo(appCtx: AppCtx): Promise<any>;
+export declare function getNamespaceForOpenAndFaaSSDK(): Promise<string>;

package/request/common.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNamespaceForOpenAndFaaSSDK = exports.getTenantInfo = exports.transFlowVariableToMap = exports.transMapToFlowVariable = exports.getTriggerCtx = exports.getDebugExtraInfo = void 0;
+const constants_1 = require("@byted-apaas/server-common-node/constants/constants");
+const common = require("@byted-apaas/server-common-node");
+const interface_1 = require("./interface");
+const credential_1 = require("@byted-apaas/server-common-node/credential/credential");
+const exceptions_1 = require("@byted-apaas/server-common-node/utils/exceptions");
+const common_1 = require("../application/impl/common");
+const utils = common.utils;
+const checkUtils = common.checkUtils;
+const exceptions = common.exceptions;
+const nodeCls = require("node-cls");
+function checkLoopCtx(reqCtx) {
+    return reqCtx && reqCtx.loopMasks && Array.isArray(reqCtx.loopMasks);
+}
+function getDebugExtraInfo() {
+    let extra = {
+        "FunctionFrameVersion": "FunctionFrameV2",
+    };
+    if (utils.isDebug()) {
+        extra.DebugInfo = utils.getDebugCode();
+    }
+    return extra;
+}
+exports.getDebugExtraInfo = getDebugExtraInfo;
+function getTriggerCtx() {
+    let triggerCtx = {}, taskID = utils.getTriggerTaskID();
+    if (taskID) {
+        triggerCtx[constants_1.headers.triggerTaskId] = taskID;
+    }
+    let temp = utils.getDistributedHandleMask();
+    if (temp) {
+        triggerCtx[constants_1.headers.distributedHandleMask] = temp;
+    }
+    let reqCtx = nodeCls.get(constants_1.headers.loopCtxKey);
+    if (checkLoopCtx(reqCtx)) {
+        triggerCtx[constants_1.headers.loopMasks] = reqCtx.loopMasks;
+    }
+    return triggerCtx;
+}
+exports.getTriggerCtx = getTriggerCtx;
+function transMapToFlowVariable(params) {
+    let variables = [];
+    if (params) {
+        if (checkUtils.isNotObject(params)) {
+            throw new exceptions.InvalidParamError(`params should be object, and not array`);
+        }
+        for (const [k, v] of Object.entries(params)) {
+            variables.push({ api_name: k, value: v });
+        }
+    }
+    return variables;
+}
+exports.transMapToFlowVariable = transMapToFlowVariable;
+function transFlowVariableToMap(variables) {
+    let data = {};
+    if (variables && Array.isArray(variables)) {
+        for (const o of variables) {
+            data[o.api_name] = o.value;
+        }
+    }
+    return data;
+}
+exports.transFlowVariableToMap = transFlowVariableToMap;
+async function getTenantInfo(appCtx) {
+    if (!appCtx) {
+        appCtx = {
+            mode: "faasSDK",
+            credential: new credential_1.AppCredential(utils.getClientId(), utils.getClientSecret(), true)
+        };
+    }
+    if (!appCtx.credential) {
+        throw new exceptions_1.InvalidParamError(`credential is empty`);
+    }
+    return await (0, common_1.runCtxForOpenSDK)(appCtx, async () => {
+        return await (0, interface_1.GetInstance)().getTenantInfo(appCtx);
+    });
+}
+exports.getTenantInfo = getTenantInfo;
+async function getNamespaceForOpenAndFaaSSDK() {
+    if (utils.isOpenSDKMode()) { // TODO check need assign?
+        return (await utils.getCredential().getTenantInfo()).namespace;
+    }
+    return utils.getNamespaceFromCtx();
+}
+exports.getNamespaceForOpenAndFaaSSDK = getNamespaceForOpenAndFaaSSDK;