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

package/kunlun/operator/impl/logicV2.js

@@ -0,0 +1,200 @@
+"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 {
+    constructor(objectApiName) {
+        this.objectApiName = objectApiName;
+        this._limit = 200;
+        this._offset = 0;
+        this.fields = [];
+        this._order = [];
+        this.filter = {
+            type: "and",
+            arithmeticExpressions: null,
+            logicalExpressions: null,
+        };
+    }
+    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) {
+        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) {
+        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;
+    }
+}
+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/logicV2.ts

@@ -0,0 +1,254 @@
+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.d.ts

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