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

package/kunlun/operator/impl/logicV2.js

@@ -0,0 +1,201 @@
+"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;
+//# sourceMappingURL=logicV2.js.map

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

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

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