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

package/kunlun/operator/impl/operatorV2.d.ts

@@ -0,0 +1,180 @@
+import { _Cond, _BooleanCond } from '../../../types/types';
+import { IOperator } from '../IOperator';
+import { LogicalExpression } from './logicV2';
+import { UserDataType } from './expression';
+export declare const operates: {
+    AND: string;
+    OR: string;
+    EMPTY: string;
+    NOT_EMPTY: string;
+    EQ: string;
+    NEQ: string;
+    LT: string;
+    LTE: string;
+    GT: string;
+    GTE: string;
+    CONTAIN: string;
+    NOT_CONTAIN: string;
+    IN: string;
+    NIN: string;
+    HAS_ANY_OF: string;
+    HAS_NONE_OF: string;
+    isOnOrBefore: string;
+    isOnOrAfter: string;
+};
+export declare 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;
+    /**
+     * 逻辑或
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object('_user').where(kunlun.operator.or({
+     *     age: '22'
+     * },{
+     *     age: '25'
+     * }))
+     * ```
+     */
+    or<T>(...exps: (_Cond<T> | _BooleanCond<T> | LogicalExpression)[]): LogicalExpression;
+    /**
+     * 包含
+     * @param value 判定是否包含的文本值
+     * @example
+     * ```
+     * context.db.object('_user').where({_name: kunlun.operator.contain('a')})
+     * ```
+     */
+    contain<T>(value: UserDataType): _BooleanCond<T>;
+    /**
+     * 不包含
+     * @param value 判定是否不包含的文本值
+     * @example
+     * ```
+     * context.db.object('_user').where({_name: kunlun.operator.notContain('a')})
+     * ```
+     */
+    notContain<T>(value: UserDataType): _BooleanCond<T>;
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object('_user').where({employeeType: kunlun.operator.empty()})
+     * ```
+     */
+    empty(): _BooleanCond<undefined>;
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object('_user').where({employeeType: kunlun.operator.notEmpty()})
+     * ```
+     */
+    notEmpty(): _BooleanCond<undefined>;
+    /**
+     * 等于
+     * @param value 判定是否相等的值
+     * @example
+     * ```
+     * context.db.object('_user').where({age: kunlun.operator.eq(20)})
+     * ```
+     */
+    eq<T>(value: UserDataType): _BooleanCond<T>;
+    /**
+     * 不等于
+     * @param value 判定是否不相等的值
+     * @example
+     * ```
+     * context.db.object('_user').where({age: kunlun.operator.neq(20)})
+     * ```
+     */
+    neq<T>(value: UserDataType): _BooleanCond<T>;
+    /**
+     * 大于或晚于
+     * @param value 判定是否大于或晚于的值
+     * @example
+     * ```
+     * kunlun.operator.gt(new Date('2020-11-26').getTime())
+     * ```
+     */
+    gt<T>(value: number | Date): _BooleanCond<T>;
+    /**
+     * 大于等于或晚于等于
+     * @param value 判定是否大于等于或晚于等于的值
+     * @example
+     * ```
+     * kunlun.operator.gte(new Date('2020-11-26').getTime())
+     * ```
+     */
+    gte<T>(value: number | Date): _BooleanCond<T>;
+    /**
+     * 小于或早于
+     * @param value 判定是否小于或早于的值
+     * @example
+     * ```
+     * kunlun.operator.lt(new Date('2020-11-26').getTime())
+     * ```
+     */
+    lt<T>(value: number | Date): _BooleanCond<T>;
+    /**
+     * 小于等于或早于等于
+     * @param value 判定是否小于等于或早于等于的值
+     * @example
+     * ```
+     * kunlun.operator.lte(new Date('2020-11-26').getTime())
+     * ```
+     */
+    lte<T>(value: number | Date): _BooleanCond<T>;
+    /**
+     * 存在于给定的数组内
+     * @param values 判定是否存在于的一组值，用数组传递
+     */
+    in<T>(values: T[]): _BooleanCond<T>;
+    /**
+     * 存在于给定的数组内
+     * @param values 判定是否存在于的一组值，用逗号分隔
+     */
+    in<T>(...values: T[]): _BooleanCond<T>;
+    /**
+     * 不存在于给定的数组内
+     * @param values 判定是否不存在于的一组值，用数组传递
+     */
+    notIn<T>(values: T[]): _BooleanCond<T>;
+    /**
+     * 不存在于给定的数组内
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    notIn<T>(...values: T[]): _BooleanCond<T>;
+    /**
+     * 存在给定的多个值中的任何一个值
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    hasAnyOf<T>(values: number[] | string[]): _BooleanCond<T>;
+    /**
+     * 存在给定的多个值中的任何一个值
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    hasAnyOf<T>(...values: (number | string)[]): _BooleanCond<T>;
+    /**
+     * 不存在给定的多个值中的任何值
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    hasNoneOf<T>(values: number[] | string[]): _BooleanCond<T>;
+    /**
+     * 不存在给定的多个值中的任何值
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    hasNoneOf<T>(...values: (number | string)[]): _BooleanCond<T>;
+}

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byted-apaas/server-sdk-node",
-  "version": "1.1.23",
+  "version": "1.1.24",
   "description": "aPaaS Server SDK",
   "author": "zhouwexin <zhouwexin@bytedance.com>",
   "homepage": "",

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,88 @@
+"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;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+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;

package/request/constants.d.ts

@@ -0,0 +1,12 @@
+import { GetHttpConfig, PostHttpConfig } from '@byted-apaas/server-common-node/http/config';
+export declare const metricsMethodKeys: Record<string, string>;
+export declare const openapiHttpPath: {
+    getBatchAttachmentToken: PostHttpConfig;
+    oql: PostHttpConfig;
+    getExecutionUserTaskInfo: GetHttpConfig;
+    executeFlow: PostHttpConfig;
+    revokeExecution: PostHttpConfig;
+    getExecutionInfo: GetHttpConfig;
+    getApprovalInstanceList: GetHttpConfig;
+    getApprovalInstance: GetHttpConfig;
+};

package/request/constants.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openapiHttpPath = exports.metricsMethodKeys = void 0;
+const config_1 = require("@byted-apaas/server-common-node/http/config");
+const constants_1 = require("@byted-apaas/server-common-node/http/constants");
+exports.metricsMethodKeys = {
+    // openapi
+    // file upload & download
+    getBatchAttachmentToken: 'openapi_getBatchAttachmentToken',
+    oql: 'openapi_oql',
+    // flow
+    getExecutionUserTaskInfo: 'openapi_getExecutionUserTaskInfo',
+    getExecutionInfo: 'openapi_getExecutionInfo',
+    revokeExecution: 'openapi_revokeExecution',
+    executeFlow: 'openapi_executeFlow',
+    getApprovalInstanceList: 'openapi_getApprovalInstanceList',
+    getApprovalInstance: 'openapi_getApprovalInstance',
+};
+exports.openapiHttpPath = {
+    getBatchAttachmentToken: new config_1.PostHttpConfig(`/attachment/v1/getBatchAttachmentToken`, exports.metricsMethodKeys.getBatchAttachmentToken),
+    oql: new config_1.PostHttpConfig(`/data/v5/namespaces/${constants_1.replaceKeys.namespace}/records/query`, exports.metricsMethodKeys.oql),
+    // flow
+    getExecutionUserTaskInfo: new config_1.GetHttpConfig(`/api/flow/v1/namespaces/${constants_1.replaceKeys.namespace}/executions/${constants_1.replaceKeys.id}/userTaskInfo`, exports.metricsMethodKeys.getExecutionUserTaskInfo),
+    executeFlow: new config_1.PostHttpConfig(`/api/flow/v1/namespaces/${constants_1.replaceKeys.namespace}/flows/${constants_1.replaceKeys.apiName}/execute`, exports.metricsMethodKeys.executeFlow),
+    revokeExecution: new config_1.PostHttpConfig(`/api/flow/v1/namespaces/${constants_1.replaceKeys.namespace}/executions/${constants_1.replaceKeys.id}/revoke`, exports.metricsMethodKeys.revokeExecution),
+    getExecutionInfo: new config_1.GetHttpConfig(`/api/flow/v1/namespaces/${constants_1.replaceKeys.namespace}/executions/${constants_1.replaceKeys.id}/detail`, exports.metricsMethodKeys.getExecutionInfo),
+    getApprovalInstanceList: new config_1.GetHttpConfig(`/api/approval/v1/approval_instances/listids`, exports.metricsMethodKeys.getApprovalInstanceList),
+    getApprovalInstance: new config_1.GetHttpConfig(`/api/approval/v1/approval_instances/${constants_1.replaceKeys.id}`, exports.metricsMethodKeys.getApprovalInstance),
+};

package/request/faasinfra.d.ts

@@ -0,0 +1,8 @@
+import { IFaaSInfraRequest } from './interface';
+export declare class FaaSInfraRequest implements IFaaSInfraRequest {
+    constructor();
+    createDistributeTaskV1(dataset: any, handlerFunc: string, progressCallbackFunc: string, completedCallbackFunc: string, options: any): Promise<any>;
+    createDistributeTaskV2(dataset: any, handlerFunc: string, progressCallbackFunc: string, completedCallbackFunc: string, options: any): Promise<any>;
+    invokeMicroserviceSync(apiName: string, path: string, method: string, body: any): Promise<any>;
+    invokeMicroserviceAsync(apiName: string, path: string, method: string, body: any): Promise<any>;
+}