@byted-apaas/server-sdk-node 0.0.2-beta.1

package/kunlun/operator/impl/operator.js

@@ -0,0 +1,221 @@
+"use strict";
+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;
+//# sourceMappingURL=operator.js.map

package/kunlun/operator/impl/operator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator.js","sourceRoot":"","sources":["operator.ts"],"names":[],"mappings":"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"}

package/kunlun/operator/impl/operator.ts

@@ -0,0 +1,255 @@
+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>;
+}