@byted-apaas/server-sdk-node 0.0.2-beta.2 → 0.0.2-beta.5

package/kunlun/operator/impl/logicV2.ts

@@ -1,254 +0,0 @@
-import { OrderV2 } from "../../../request/interface";
-import { UserDataType } from "./expression";
-import { operates } from "./operator";
-
-export type FieldPath = {
-    objectApiName: string;
-    fieldApiName: string;
-    extendLogicTags: string[];
-}
-
-export type SettingType = {
-    data?: any;
-    fieldPath?: FieldPath[];
-}
-
-export type Expression = {
-    type: string;
-    settings: SettingType;
-}
-
-export function NewMetadataExpressionField(objectApiName: string, fieldApiName: string): Expression {
-    return {
-        type: "metadataVariable",
-        settings: {
-            fieldPath: [{
-                objectApiName: objectApiName,
-                fieldApiName: fieldApiName,
-                extendLogicTags: []
-            }]
-        }
-    }
-}
-
-export function NewConstantExpressionField(data: UserDataType): Expression {
-    return {
-        type: "constant",
-        settings: {
-            data: data
-        }
-    }
-}
-
-export type ExpressionV2 = {
-    leftValue: string;
-    operator: string;
-    rightValue: any;
-}
-
-export class ArithmeticExpression {
-    left: Expression;
-    operator: string;
-    right: Expression;
-    expr: ExpressionV2;
-
-    constructor(leftValue: string, op: string, rightValue: any) {
-        let fieldPaths: FieldPath[] = [];
-        leftValue.split('.').forEach((fieldApiName) => {
-            fieldPaths.push({
-                fieldApiName: fieldApiName,
-                objectApiName: "",
-                extendLogicTags: []
-            });
-        })
-        const left: Expression = {
-            type: "metadataVariable",
-            settings: {
-                fieldPath: fieldPaths,
-                data: null
-            }
-        };
-        let right: Expression = {
-            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
-        }
-    }
-};
-
-
-export class LogicalExpression {
-    type: string;
-    arithmeticExpressions: ArithmeticExpression[];
-    logicalExpressions: LogicalExpression[];
-
-    constructor(logicType: string, expressions: ArithmeticExpression[], logics: LogicalExpression[]) {
-        this.type = logicType;
-        this.arithmeticExpressions = expressions;
-        this.logicalExpressions = logics;
-    }
-}
-
-export class QueryV2 {
-    objectApiName: string;
-    _limit: number;
-    _offset: number;
-    fields: string[];
-    _order: OrderV2[];
-    filter: LogicalExpression;
-
-    buildCriterion(filter: LogicalExpression): any[] {
-        if (!filter || filter.arithmeticExpressions.length == 0 && filter.logicalExpressions.length == 0) {
-            return null;
-        }
-        var conditions: any[] = [];
-
-        filter.logicalExpressions.forEach((logicalExpression) => {
-            conditions.push({
-                [logicalExpression.type]: this.buildCriterion(logicalExpression),
-            });
-        })
-
-        filter.arithmeticExpressions.forEach((arithmeticExpression) => {
-            conditions.push(arithmeticExpression.expr);
-        });
-        return conditions;
-    }
-
-    where(condition: LogicalExpression | Record<string, ArithmeticExpression>): QueryV2 {
-        if (!condition) {
-            return this;
-        }
-
-        const { logicalExps, arithmeticExps } = logical([condition]);
-        logicalExps.forEach((logicalExpression) => {
-            if (this.filter) {
-                this.filter.logicalExpressions.push(logicalExpression);
-            }
-        });
-        const logicalExpBuiltByArithmeticExps = new LogicalExpression(operates.AND, arithmeticExps, []);
-        this.filter.logicalExpressions.push(logicalExpBuiltByArithmeticExps);
-
-        return this;
-    }
-
-    offset(offset: number): QueryV2 {
-        if (offset < 0) {
-            throw new Error("offset must be greater than or equal to 0");
-        }
-        this._offset = offset;
-        return this;
-    }
-
-    limit(limit: number): QueryV2 {
-        if (limit <= 0 || limit > 200) {
-            throw new Error("limit must be greater than 0 and less than or equal to 200");
-        }
-        this._limit = limit;
-        return this;
-    }
-
-    orderBy(fieldApiNames: string[]): QueryV2 {
-        fieldApiNames.forEach((fieldApiName) => {
-            this._order.push({
-                field: fieldApiName,
-                direction: "asc",
-                type: "",
-            });
-        });
-        return this;
-    }
-
-    orderByDesc(fieldApiNames: string[]): QueryV2 {
-        fieldApiNames.forEach((fieldApiName) => {
-            this._order.push({
-                field: fieldApiName,
-                direction: "desc",
-                type: "",
-            });
-        });
-        return this;
-    }
-
-    select(fieldApiNames: string[]): QueryV2 {
-        fieldApiNames.forEach((fieldApiName) => {
-            this.fields.push(fieldApiName);
-        });
-        return this;
-    }
-
-    constructor(objectApiName: string) {
-        this.objectApiName = objectApiName;
-        this._limit = 200;
-        this._offset = 0;
-        this.fields = [];
-        this._order = [];
-        this.filter = {
-            type: "and",
-            arithmeticExpressions: null,
-            logicalExpressions: null,
-        };
-    }
-}
-
-export type logicalRet = {
-    logicalExps: LogicalExpression[];
-    arithmeticExps: ArithmeticExpression[];
-}
-
-export function logical(exps: (LogicalExpression | Record<string, ArithmeticExpression>)[]): logicalRet {
-    if (!exps || exps.length == 0) {
-        return null;
-    }
-    var logicalExps: LogicalExpression[] = [];
-    var arithmeticExps: ArithmeticExpression[] = [];
-    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,
-    }
-}
-
-export type CriterionV2 = (Record<string, CriterionV2> | ExpressionV2)[];
-
-export function buildCriterionV2(filter: LogicalExpression): CriterionV2 {
-    if (!filter || filter.logicalExpressions.length == 0 && filter.arithmeticExpressions.length == 0) {
-        return null;
-    }
-    var conditions: any[] = [];
-    filter.logicalExpressions.forEach((logicalExp) => {
-        conditions.push({
-            [logicalExp.type]: buildCriterionV2(logicalExp),
-        })
-    });
-    filter.arithmeticExpressions.forEach((arithmeticExp) => {
-        conditions.push(arithmeticExp.expr);
-    });
-    return conditions;
-}

package/kunlun/operator/impl/operator.ts

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