@byted-apaas/server-sdk-node 1.1.23-beta.9 → 1.1.23

package/kunlun/operator/impl/logicV2.js

@@ -1,197 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildCriterionV2 = exports.logical = exports.QueryV2 = exports.LogicalExpression = exports.ArithmeticExpression = exports.NewConstantExpressionField = exports.NewMetadataExpressionField = void 0;
-const operator_1 = require("./operator");
-function NewMetadataExpressionField(objectApiName, fieldApiName) {
-    return {
-        type: 'metadataVariable',
-        settings: {
-            fieldPath: [{
-                    objectApiName: objectApiName,
-                    fieldApiName: fieldApiName,
-                    extendLogicTags: []
-                }]
-        }
-    };
-}
-exports.NewMetadataExpressionField = NewMetadataExpressionField;
-function NewConstantExpressionField(data) {
-    return {
-        type: 'constant',
-        settings: {
-            data: data
-        }
-    };
-}
-exports.NewConstantExpressionField = NewConstantExpressionField;
-class ArithmeticExpression {
-    constructor(leftValue, op, rightValue) {
-        let fieldPaths = [];
-        leftValue.split('.').forEach((fieldApiName) => {
-            fieldPaths.push({
-                fieldApiName: fieldApiName,
-                objectApiName: '',
-                extendLogicTags: []
-            });
-        });
-        const left = {
-            type: 'metadataVariable',
-            settings: {
-                fieldPath: fieldPaths,
-                data: null
-            }
-        };
-        let right = {
-            type: 'constant',
-            settings: {
-                fieldPath: [],
-                data: rightValue
-            }
-        };
-        if (op === 'isEmpty' || op === 'isNotEmpty') {
-            right = null;
-        }
-        this.operator = op;
-        this.left = left;
-        this.right = right;
-        this.expr = {
-            leftValue: leftValue,
-            operator: op,
-            rightValue: rightValue
-        };
-    }
-}
-exports.ArithmeticExpression = ArithmeticExpression;
-class LogicalExpression {
-    constructor(logicType, expressions, logics) {
-        this.type = logicType;
-        this.arithmeticExpressions = expressions;
-        this.logicalExpressions = logics;
-    }
-}
-exports.LogicalExpression = LogicalExpression;
-class QueryV2 {
-    buildCriterion(filter) {
-        if (!filter || filter.arithmeticExpressions.length == 0 && filter.logicalExpressions.length == 0) {
-            return null;
-        }
-        var conditions = [];
-        filter.logicalExpressions.forEach((logicalExpression) => {
-            conditions.push({
-                [logicalExpression.type]: this.buildCriterion(logicalExpression),
-            });
-        });
-        filter.arithmeticExpressions.forEach((arithmeticExpression) => {
-            conditions.push(arithmeticExpression.expr);
-        });
-        return conditions;
-    }
-    where(condition) {
-        if (!condition) {
-            return this;
-        }
-        const { logicalExps, arithmeticExps } = logical([condition]);
-        logicalExps.forEach((logicalExpression) => {
-            if (this.filter) {
-                this.filter.logicalExpressions.push(logicalExpression);
-            }
-        });
-        const logicalExpBuiltByArithmeticExps = new LogicalExpression(operator_1.operates.AND, arithmeticExps, []);
-        this.filter.logicalExpressions.push(logicalExpBuiltByArithmeticExps);
-        return this;
-    }
-    offset(offset) {
-        if (offset < 0) {
-            throw new Error('offset must be greater than or equal to 0');
-        }
-        this._offset = offset;
-        return this;
-    }
-    limit(limit) {
-        this._limit = limit;
-        this.isSetLimit = true;
-        return this;
-    }
-    orderBy(fieldApiNames) {
-        fieldApiNames.forEach((fieldApiName) => {
-            this._order.push({
-                field: fieldApiName,
-                direction: 'asc',
-                type: '',
-            });
-        });
-        return this;
-    }
-    orderByDesc(fieldApiNames) {
-        fieldApiNames.forEach((fieldApiName) => {
-            this._order.push({
-                field: fieldApiName,
-                direction: 'desc',
-                type: '',
-            });
-        });
-        return this;
-    }
-    select(fieldApiNames) {
-        fieldApiNames.forEach((fieldApiName) => {
-            this.fields.push(fieldApiName);
-        });
-        return this;
-    }
-    constructor(objectApiName) {
-        this.objectApiName = objectApiName;
-        this._limit = 200;
-        this._offset = 0;
-        this.fields = [];
-        this._order = [];
-        this.filter = {
-            type: 'and',
-            arithmeticExpressions: [],
-            logicalExpressions: [],
-        };
-    }
-}
-exports.QueryV2 = QueryV2;
-function logical(exps) {
-    if (!exps || exps.length == 0) {
-        return null;
-    }
-    var logicalExps = [];
-    var arithmeticExps = [];
-    exps.forEach((exp) => {
-        if (!exp) {
-            return;
-        }
-        if (exp instanceof LogicalExpression) {
-            logicalExps.push(exp);
-        }
-        else {
-            for (var key in exp) {
-                if (exp[key]) {
-                    arithmeticExps.push(new ArithmeticExpression(key, exp[key].operator, exp[key].right));
-                }
-            }
-        }
-    });
-    return {
-        logicalExps: logicalExps,
-        arithmeticExps: arithmeticExps,
-    };
-}
-exports.logical = logical;
-function buildCriterionV2(filter) {
-    if (!filter || filter.logicalExpressions.length == 0 && filter.arithmeticExpressions.length == 0) {
-        return null;
-    }
-    var conditions = [];
-    filter.logicalExpressions.forEach((logicalExp) => {
-        conditions.push({
-            [logicalExp.type]: buildCriterionV2(logicalExp),
-        });
-    });
-    filter.arithmeticExpressions.forEach((arithmeticExp) => {
-        conditions.push(arithmeticExp.expr);
-    });
-    return conditions;
-}
-exports.buildCriterionV2 = buildCriterionV2;

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

@@ -1,179 +0,0 @@
-import { _Cond, _BooleanCond, _LogicalCond } from '../../../types/types';
-import { IOperator } from '../IOperator';
-import { UserDataType } from './expression';
-export declare const operates: {
-    AND: string;
-    OR: string;
-    EMTPY: string;
-    NOT_EMTPY: 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 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>;
-    /**
-     * 逻辑或
-     * @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<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/operator.js

@@ -1,222 +0,0 @@
-"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;