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

package/kunlun/operator/impl/operator.js

@@ -0,0 +1,222 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operator = exports.operates = void 0;
+const server_common_node_1 = require("@byted-apaas/server-common-node");
+const logic_1 = require("./logic");
+exports.operates = {
+    AND: "and",
+    OR: "or",
+    EMTPY: "isEmpty",
+    NOT_EMTPY: "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: "isOnOrBefore",
+    isOnOrAfter: "isOnOrAfter",
+};
+class Operator {
+    /**
+     * 逻辑且
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.and({
+     *     age: "22"
+     * },{
+     *     gender: "male"
+     * }))
+     * ```
+     */
+    and(...conditions) {
+        if (conditions.length < 1) {
+            return null;
+        }
+        return (0, logic_1.buildLogic)(conditions, exports.operates.AND);
+    }
+    ;
+    /**
+     * 逻辑或
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.or({
+     *     age: "22"
+     * },{
+     *     age: "25"
+     * }))
+     * ```
+     */
+    or(...conditions) {
+        if (conditions.length < 1) {
+            return null;
+        }
+        return (0, logic_1.buildLogic)(conditions, exports.operates.OR);
+    }
+    ;
+    /**
+     * 包含
+     * @param value 判定是否包含的文本值
+     * @example
+     * ```
+     * context.db.object("_user").where({_name: kunlun.operator.contain("a")})
+     * ```
+     */
+    contain(value) {
+        return new logic_1.Condition(null, value, exports.operates.CONTAIN);
+    }
+    ;
+    /**
+     * 不包含
+     * @param value 判定是否不包含的文本值
+     * @example
+     * ```
+     * context.db.object("_user").where({_name: kunlun.operator.notContain("a")})
+     * ```
+     */
+    notContain(value) {
+        return new logic_1.Condition(null, value, exports.operates.NOT_CONTAIN);
+    }
+    ;
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object("_user").where({employeeType: kunlun.operator.empty()})
+     * ```
+     */
+    empty() {
+        return new logic_1.Condition(null, null, exports.operates.EMTPY);
+    }
+    ;
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object("_user").where({employeeType: kunlun.operator.notEmpty()})
+     * ```
+     */
+    notEmpty() {
+        return new logic_1.Condition(null, null, exports.operates.NOT_EMTPY);
+    }
+    ;
+    /**
+     * 等于
+     * @param value 判定是否相等的值
+     * @example
+     * ```
+     * context.db.object("_user").where({age: kunlun.operator.eq(20)})
+     * ```
+     */
+    eq(value) {
+        return new logic_1.Condition(null, value, exports.operates.EQ);
+    }
+    ;
+    /**
+     * 不等于
+     * @param value 判定是否不相等的值
+     * @example
+     * ```
+     * context.db.object("_user").where({age: kunlun.operator.neq(20)})
+     * ```
+     */
+    neq(value) {
+        return new logic_1.Condition(null, value, exports.operates.NEQ);
+    }
+    ;
+    /**
+     * 大于或晚于
+     * @param value 判定是否大于或晚于的值
+     * @example
+     * ```
+     * kunlun.operator.gt(new Date("2020-11-26").getTime())
+     * ```
+     */
+    gt(value) {
+        return new logic_1.Condition(null, value, exports.operates.GT);
+    }
+    ;
+    /**
+     * 大于等于或晚于等于
+     * @param value 判定是否大于等于或晚于等于的值
+     * @example
+     * ```
+     * kunlun.operator.gte(new Date("2020-11-26").getTime())
+     * ```
+     */
+    gte(value) {
+        return new logic_1.Condition(null, value, exports.operates.GTE);
+    }
+    ;
+    /**
+     * 小于或早于
+     * @param value 判定是否小于或早于的值
+     * @example
+     * ```
+     * kunlun.operator.lt(new Date("2020-11-26").getTime())
+     * ```
+     */
+    lt(value) {
+        return new logic_1.Condition(null, value, exports.operates.LT);
+    }
+    ;
+    /**
+     * 小于等于或早于等于
+     * @param value 判定是否小于等于或早于等于的值
+     * @example
+     * ```
+     * kunlun.operator.lte(new Date("2020-11-26").getTime())
+     * ```
+     */
+    lte(value) {
+        return new logic_1.Condition(null, value, exports.operates.LTE);
+    }
+    ;
+    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 logic_1.Condition(null, argList, exports.operates.IN);
+    }
+    ;
+    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 logic_1.Condition(null, argList, exports.operates.NIN);
+    }
+    ;
+    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 logic_1.Condition(null, argList, exports.operates.HAS_ANY_OF);
+    }
+    ;
+    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 logic_1.Condition(null, argList, exports.operates.HAS_NONE_OF);
+    }
+    ;
+}
+exports.Operator = Operator;

package/kunlun/operator/impl/operator.ts

@@ -0,0 +1,258 @@
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+
+import { _Cond, _BooleanCond, _LogicalCond } from '../../../types/types'
+import { IOperator } from "../IOperator";
+import { exceptions, utils } from '@byted-apaas/server-common-node'
+import { buildLogic, Condition } from './logic'
+import { UserDataType } from './expression';
+
+export const operates = {
+    AND: "and", // 逻辑与
+    OR: "or", // 逻辑或
+
+    EMTPY: "isEmpty", // 为空
+    NOT_EMTPY: "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: "isOnOrBefore",
+    isOnOrAfter: "isOnOrAfter",
+}
+
+export class Operator<T> implements 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> {
+        if (conditions.length < 1) {
+            return null;
+        }
+
+        return buildLogic(conditions, operates.AND);
+    };
+    /**
+     * 逻辑或
+     * @param conditions 多个条件，用逗号分隔
+     * @example
+     * ```
+     * context.db.object("_user").where(kunlun.operator.or({
+     *     age: "22"
+     * },{
+     *     age: "25"
+     * }))
+     * ```
+     */
+    or<T>(...conditions: (_Cond<T> | _BooleanCond<T>)[]): _LogicalCond<T> {
+        if (conditions.length < 1) {
+            return null;
+        }
+
+        return buildLogic(conditions, operates.OR);
+    };
+    /**
+     * 包含
+     * @param value 判定是否包含的文本值
+     * @example
+     * ```
+     * context.db.object("_user").where({_name: kunlun.operator.contain("a")})
+     * ```
+     */
+    contain<T>(value: UserDataType): _BooleanCond<T> {
+        return new Condition(null, value, operates.CONTAIN)
+    };
+    /**
+     * 不包含
+     * @param value 判定是否不包含的文本值
+     * @example
+     * ```
+     * context.db.object("_user").where({_name: kunlun.operator.notContain("a")})
+     * ```
+     */
+    notContain<T>(value: UserDataType): _BooleanCond<T> {
+        return new Condition(null, value, operates.NOT_CONTAIN)
+    };
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object("_user").where({employeeType: kunlun.operator.empty()})
+     * ```
+     */
+    empty(): _BooleanCond<undefined> {
+        return new Condition(null, null, operates.EMTPY);
+    };
+    /**
+     * 无需入参，判断是否为空
+     * @example
+     * ```
+     * context.db.object("_user").where({employeeType: kunlun.operator.notEmpty()})
+     * ```
+     */
+    notEmpty(): _BooleanCond<undefined> {
+        return new Condition(null, null, operates.NOT_EMTPY);
+    };
+    /**
+     * 等于
+     * @param value 判定是否相等的值
+     * @example
+     * ```
+     * context.db.object("_user").where({age: kunlun.operator.eq(20)})
+     * ```
+     */
+    eq<T>(value: UserDataType): _BooleanCond<T> {
+        return new Condition(null, value, operates.EQ);
+    };
+    /**
+     * 不等于
+     * @param value 判定是否不相等的值
+     * @example
+     * ```
+     * context.db.object("_user").where({age: kunlun.operator.neq(20)})
+     * ```
+     */
+    neq<T>(value: UserDataType): _BooleanCond<T> {
+        return new Condition(null, value, operates.NEQ)
+    };
+    /**
+     * 大于或晚于
+     * @param value 判定是否大于或晚于的值
+     * @example
+     * ```
+     * kunlun.operator.gt(new Date("2020-11-26").getTime())
+     * ```
+     */
+    gt<T>(value: number | Date): _BooleanCond<T> {
+        return new Condition(null, value, operates.GT)
+    };
+    /**
+     * 大于等于或晚于等于
+     * @param value 判定是否大于等于或晚于等于的值
+     * @example
+     * ```
+     * kunlun.operator.gte(new Date("2020-11-26").getTime())
+     * ```
+     */
+    gte<T>(value: number | Date): _BooleanCond<T> {
+        return new Condition(null, value, operates.GTE)
+    };
+    /**
+     * 小于或早于
+     * @param value 判定是否小于或早于的值
+     * @example
+     * ```
+     * kunlun.operator.lt(new Date("2020-11-26").getTime())
+     * ```
+     */
+    lt<T>(value: number | Date): _BooleanCond<T> {
+        return new Condition(null, value, operates.LT)
+    };
+    /**
+     * 小于等于或早于等于
+     * @param value 判定是否小于等于或早于等于的值
+     * @example
+     * ```
+     * kunlun.operator.lte(new Date("2020-11-26").getTime())
+     * ```
+     */
+    lte<T>(value: number | Date): _BooleanCond<T> {
+        return new Condition(null, value, operates.LTE)
+    };
+    /**
+     * 存在于给定的数组内
+     * @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 Condition(null, argList, operates.IN)
+    };
+    /**
+     * 不存在于给定的数组内
+     * @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 Condition(null, argList, operates.NIN)
+    };
+
+    /**
+     * 存在给定的多个值中的任何一个值
+     * @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 Condition(null, argList, operates.HAS_ANY_OF)
+    };
+    /**
+     * 不存在给定的多个值中的任何值
+     * @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 Condition(null, argList, operates.HAS_NONE_OF)
+    };
+}

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>;
+}