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

package/kunlun/kunlun.ts

@@ -0,0 +1,72 @@
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+
+import { IOperator } from './operator/IOperator';
+import { globalVariables } from '../data/index'
+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 { Tool } from "@byted-apaas/server-common-node/kunlun/tool/impl/tool";
+import { errCodes } from "@byted-apaas/server-common-node/utils/exceptions";
+import { Operator } from "./operator/impl/operator";
+import * as common from "@byted-apaas/server-common-node";
+import * as Request from "../request/interface";
+
+declare global {
+    export namespace kunlun {
+        /**
+         * 指令操作符
+         */
+        export let operator: IOperator;
+    }
+}
+
+export namespace kunlun {
+    /**
+     * 引用时区信息
+     */
+    export const GMTOffset: typeof GMT = GMT;
+
+    /**
+     * 引用国际区号
+     */
+    export const countryCode: typeof area2code = area2code;
+
+    /**
+     * 工具方法
+     */
+    export let tool: ITool & IToolsExtra = new Tool();
+
+    /**
+     * 生成复杂数据结构
+     */
+    export 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
+    }
+
+    /**
+     * 错误码
+     */
+    export const errorCode = {
+        /**
+         * 限流错误码
+         */
+        RATE_LIMIT_ERROR: errCodes.RATE_LIMIT_ERROR,
+    }
+
+    /**
+     * 根据 key 获取对应的全局变量
+     * @param key 全局变量的 key
+     */
+    export async function getVar(key: string): Promise<string> {
+        return await Request.GetInstance().getGlobalConfigByKey(key);
+    }
+
+    /**
+     * 指令操作符
+     */
+    export const operator: IOperator = new Operator();
+}

package/kunlun/operator/IOperator.d.ts

@@ -0,0 +1,158 @@
+import { _Cond, _BooleanCond, _LogicalCond } from '../../types/types';
+import { UserDataType } from './impl/expression';
+export interface IOperator {
+    /**
+     * 逻辑与
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.and({
+     *     age: "22"
+     * },{
+     *     gender: "male"
+     * }))
+     * ```
+     */
+    and<T>(...conditions: (_Cond<T> | _BooleanCond<T>)[]): _LogicalCond<T>;
+    /**
+     * 逻辑或
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.or({
+     *     age: "22"
+     * },{
+     *     age: "25"
+     * }))
+     * ```
+     */
+    or<T>(...conditions: (_Cond<T> | _BooleanCond<T>)[]): _LogicalCond<T>;
+    /**
+     * 包含
+     * @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<any>;
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object("_user").where({employeeType: kunlun.operator.notEmpty()})
+     * ```
+     */
+    notEmpty(): _BooleanCond<any>;
+    /**
+     * 等于
+     * @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: UserDataType[]): _BooleanCond<T>;
+    /**
+     * 存在于给定的数组内
+     * @param values 判定是否存在于的一组值，用逗号分隔
+     */
+    in<T>(...values: UserDataType[]): _BooleanCond<T>;
+    /**
+     * 不存在于给定的数组内
+     * @param values 判定是否不存在于的一组值，用数组传递
+     */
+    notIn<T>(values: UserDataType[]): _BooleanCond<T>;
+    /**
+     * 不存在于给定的数组内
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    notIn<T>(...values: UserDataType[]): _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/IOperator.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });

package/kunlun/operator/IOperator.ts

@@ -0,0 +1,166 @@
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+
+import { _Cond, _BooleanCond, _LogicalCond } from '../../types/types'
+import { UserDataType } from './impl/expression';
+
+export interface IOperator {
+    /**
+     * 逻辑与
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.and({
+     *     age: "22"
+     * },{
+     *     gender: "male"
+     * }))
+     * ```
+     */
+    and<T>(...conditions: (_Cond<T> | _BooleanCond<T>)[]): _LogicalCond<T>;
+    /**
+     * 逻辑或
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.or({
+     *     age: "22"
+     * },{
+     *     age: "25"
+     * }))
+     * ```
+     */
+    or<T>(...conditions: (_Cond<T> | _BooleanCond<T>)[]): _LogicalCond<T>;
+    /**
+     * 包含
+     * @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<any>;
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object("_user").where({employeeType: kunlun.operator.notEmpty()})
+     * ```
+     */
+    notEmpty(): _BooleanCond<any>;
+    /**
+     * 等于
+     * @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: UserDataType[]): _BooleanCond<T>;
+    /**
+     * 存在于给定的数组内
+     * @param values 判定是否存在于的一组值，用逗号分隔
+     */
+    in<T>(...values: UserDataType[]): _BooleanCond<T>;
+    /**
+     * 不存在于给定的数组内
+     * @param values 判定是否不存在于的一组值，用数组传递
+     */
+    notIn<T>(values: UserDataType[]): _BooleanCond<T>;
+    /**
+     * 不存在于给定的数组内
+     * @param values 判定是否不存在于的一组值，用逗号分隔
+     */
+    notIn<T>(...values: UserDataType[]): _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/expression.d.ts

@@ -0,0 +1,47 @@
+export declare type UserDataType = null | string | boolean | number | Date | object;
+export declare class Expression {
+    index: number;
+    left: ExpressionField;
+    operator: string;
+    right: ExpressionField;
+    constructor(left: ExpressionField, operator: string, right: ExpressionField, index: number);
+}
+declare type SettingType = {
+    data?: UserDataType;
+    fieldPath?: PathType[];
+};
+export declare type PathType = {
+    objectApiName: string;
+    fieldApiName: string;
+    extendLogicTags: string[];
+};
+/**
+ * 总共有4种类型，当前仅支持constant，metadataVariable
+ *
+ * constant：不可为左值
+ * metadataVariable
+ * function
+ * customizedVariable
+ */
+declare class ExpressionField {
+    type: string;
+    settings: SettingType;
+    constructor(type: string, settings: SettingType);
+}
+/**
+ * 常量表达式字段
+ *
+ * 比如在 condition: user.name equal "bob" 中，"bob" 将被构建为 ConstantExpressionField
+ */
+export declare class ConstantExpressionField extends ExpressionField {
+    constructor(data: UserDataType);
+}
+/**
+ * 元数据表达式字段
+ *
+ * 比如在 condition: user.name equal "bob" 中，"user.name" 将被构建为 MetadataExpressionField
+ */
+export declare class MetadataExpressionField extends ExpressionField {
+    constructor(objectApiName: string, fieldApiName: string);
+}
+export {};

package/kunlun/operator/impl/expression.js

@@ -0,0 +1,56 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataExpressionField = exports.ConstantExpressionField = exports.Expression = void 0;
+class Expression {
+    constructor(left, operator, right, index) {
+        this.index = index;
+        this.left = left;
+        this.operator = operator;
+        this.right = right;
+    }
+}
+exports.Expression = Expression;
+/**
+ * 总共有4种类型，当前仅支持constant，metadataVariable
+ *
+ * constant：不可为左值
+ * metadataVariable
+ * function
+ * customizedVariable
+ */
+class ExpressionField {
+    constructor(type, settings) {
+        this.type = type;
+        this.settings = settings;
+    }
+}
+/**
+ * 常量表达式字段
+ *
+ * 比如在 condition: user.name equal "bob" 中，"bob" 将被构建为 ConstantExpressionField
+ */
+class ConstantExpressionField extends ExpressionField {
+    constructor(data) {
+        super("constant", { "data": data });
+    }
+}
+exports.ConstantExpressionField = ConstantExpressionField;
+/**
+ * 元数据表达式字段
+ *
+ * 比如在 condition: user.name equal "bob" 中，"user.name" 将被构建为 MetadataExpressionField
+ */
+class MetadataExpressionField extends ExpressionField {
+    constructor(objectApiName, fieldApiName) {
+        super("metadataVariable", {
+            "fieldPath": [{
+                    objectApiName: objectApiName,
+                    fieldApiName: fieldApiName,
+                    extendLogicTags: [],
+                }]
+        });
+    }
+}
+exports.MetadataExpressionField = MetadataExpressionField;

package/kunlun/operator/impl/expression.ts

@@ -0,0 +1,74 @@
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+
+export type UserDataType = null | string | boolean | number | Date | object
+
+export class Expression {
+    index: number
+    left:  ExpressionField
+    operator: string
+    right: ExpressionField
+    
+    constructor(left: ExpressionField, operator: string, right: ExpressionField, index: number) {
+        this.index = index;
+        this.left = left;
+        this.operator = operator;
+        this.right = right;
+    }
+}
+
+type SettingType = {
+    data?: UserDataType
+    fieldPath?: PathType[]
+}
+
+export type PathType = {
+    objectApiName: string
+    fieldApiName: string
+    extendLogicTags: string[]
+}
+
+/**
+ * 总共有4种类型，当前仅支持constant，metadataVariable
+ *
+ * constant：不可为左值
+ * metadataVariable
+ * function
+ * customizedVariable
+ */
+class ExpressionField {
+    type: string
+    settings: SettingType
+    constructor(type: string, settings: SettingType) {
+        this.type = type;
+        this.settings = settings;
+    }
+}
+
+/**
+ * 常量表达式字段
+ * 
+ * 比如在 condition: user.name equal "bob" 中，"bob" 将被构建为 ConstantExpressionField
+ */
+export class ConstantExpressionField extends ExpressionField {
+    constructor(data: UserDataType) {
+        super("constant", {"data": data});
+    }
+}
+
+/**
+ * 元数据表达式字段
+ * 
+ * 比如在 condition: user.name equal "bob" 中，"user.name" 将被构建为 MetadataExpressionField
+ */
+export class MetadataExpressionField extends ExpressionField {
+    constructor(objectApiName: string, fieldApiName: string) {
+        super("metadataVariable", {
+            "fieldPath": [{
+                objectApiName: objectApiName,
+                fieldApiName: fieldApiName,
+                extendLogicTags: [],
+            }]
+        });
+    }
+}

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

@@ -0,0 +1,50 @@
+import { Expression, UserDataType } from './expression';
+export declare class Condition {
+    left: string;
+    right: Condition | UserDataType;
+    op: string;
+    /**
+     *
+     * @param objectApiName 对象的ApiName
+     * @param fieldApiName  字段的ApiName，指左值，即key
+     * @param index         条件的排序
+     * @returns {Expression}
+     */
+    toExpression(objectApiName: string, fieldApiName: string, index: number): Expression;
+    constructor(left: string, right: Condition | UserDataType, op?: string);
+}
+export declare type Criterion = {
+    conditions: Expression[];
+    logic: string;
+};
+/**
+ * 构造 criterion
+ *
+ * @param logic
+ * @param objectApiName
+ * @param maxId 添加 _id>maxId 条件，为 -1 表示不使用该参数
+ */
+export declare function buildCriterion(logic: Logic, objectApiName: string, maxId?: number): Criterion | string;
+export declare function buildExpression(objectApiName: string, left: string, right: Condition | UserDataType, index?: number): Expression;
+export declare class Logic {
+    value: string;
+    expressions: {
+        [index: string]: any;
+    };
+    logics: Logic[];
+    constructor(expressions?: {
+        [index: string]: any;
+    }, logicValue?: string);
+    /**
+     * 处理：右值包含逻辑表达式and|or的情况
+     *
+     * @param expressions
+     * @param lookupField
+     */
+    handleRightLogic(expressions: {
+        [index: string]: any;
+    }, lookupField?: string): void;
+    addLogic(logic: Logic): void;
+}
+export declare function buildLogic(param: (Logic | object)[], logicValue?: string): Logic;
+export declare function handleCriterion(criterion: string | Criterion): Promise<string | Criterion>;