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

package/kunlun/operator/impl/logic.ts

@@ -0,0 +1,595 @@
+import {Expression, ConstantExpressionField, MetadataExpressionField, UserDataType, PathType} from './expression'
+import {operates} from './operator'
+import {utils, exceptions} from '@byted-apaas/server-common-node'
+import * as Request from '../../../request/interface'
+import * as common from "@byted-apaas/server-common-node";
+import fieldType = common.fieldType
+
+const dayjs = require("dayjs");
+
+// 条件操作
+export class Condition {
+    left: string
+    right: Condition | UserDataType
+    op: string
+
+    /**
+     *
+     * @param objectApiName 对象的ApiName
+     * @param fieldApiName  字段的ApiName，指左值，即key
+     * @param index         条件的排序
+     * @returns {Expression}
+     */
+    toExpression(objectApiName: string, fieldApiName: string, index: number): Expression {
+        this.left = fieldApiName;
+        let left: MetadataExpressionField;
+        let right: ConstantExpressionField;
+        let op: string;
+
+        if (this.right instanceof Condition) {
+            left = new MetadataExpressionField(objectApiName, this.right.left);
+            right = new ConstantExpressionField(this.right.right)
+            left.settings.fieldPath.unshift(new MetadataExpressionField(objectApiName, fieldApiName).settings.fieldPath[0]);
+            op = this.right.op;
+        } else {
+            left = new MetadataExpressionField(objectApiName, fieldApiName)
+            right = new ConstantExpressionField(this.right);
+            op = this.op;
+        }
+        return new Expression(left, op, right, index);
+    }
+
+    constructor(left: string, right: Condition | UserDataType, op: string = operates.EQ) {
+        this.left = left;
+        this.right = right;
+        if (op) {
+            this.op = op;
+        }
+    }
+}
+
+// param type should be spercific
+function isKunlunTypeOrSerializedObject(obj: { [index: string]: any }) {
+    // instanceof 改动8
+    // return !!(obj instanceof fieldType.KunlunFieldType || (obj && obj.toJSON && obj.toJSON instanceof Function));
+    return !!(fieldType.isKFieldType(obj) || (obj && obj.toJSON && obj.toJSON instanceof Function));
+}
+
+export type Criterion = {
+    conditions: Expression[]
+    logic: string
+}
+
+/**
+ * 构造 criterion
+ *
+ * @param logic
+ * @param objectApiName
+ * @param maxId 添加 _id>maxId 条件，为 -1 表示不使用该参数
+ */
+export function buildCriterion(logic: Logic, objectApiName: string, maxId: number = -1): Criterion | string {
+    let index = 0;
+    let logics: string[] = [];
+    let expressions: Expression[] = [];
+
+    // check type of logic
+    function f(logic: Logic | { [index: string]: any }, value: string = "and") {
+        // 1.如果是逻辑表达式
+        if (logic instanceof Logic) {
+            logics.push("(");
+            for (let i = 0; i < logic.logics.length; i++) {
+                let p = logic.logics[i];
+                f(p, logic.value);
+                if (i < logic.logics.length - 1) {
+                    logics.push(` ${logic.value} `);
+                }
+            }
+
+            if (logic.expressions) {
+                f(logic.expressions, logic.value);
+            }
+
+            logics.push(")");
+            return;
+        }
+
+        // 2.否则是算法表达式
+        let exps = logic;
+        let logs = [];
+        for (let left of Object.keys(exps)) {
+            let right: { [index: string]: any } = logic[left];
+            let copy: { [index: string]: any } = right;
+            if (utils.isObject(right) && !(right instanceof Condition) && !isKunlunTypeOrSerializedObject(right)) {
+                for (let leftInner of Object.keys(right)) {
+                    index++;
+                    logs.push(index);
+                    copy = {};
+                    copy[leftInner] = right[leftInner];
+                    expressions.push(buildExpression(objectApiName, left, copy, index));
+                }
+            } else {
+                index++;
+                logs.push(index);
+                expressions.push(buildExpression(objectApiName, left, right, index));
+            }
+        }
+
+        logics.push(logs.join(` ${value} `));
+    }
+
+    f(logic);
+
+    // 如果未设置filter，默认添加: _isDeleted = false
+    if (expressions.length < 1) {
+        if(maxId >= 0) {
+            return `{"conditions":[{"index":1,"left":{"type":"metadataVariable","settings":{"fieldPath":[{"objectApiName":"${objectApiName}","fieldApiName":"_isDeleted"}]}},"operator":"equals","right":{"type":"constant","settings":{"data":false}}},{"index":2,"left":{"type":"metadataVariable","settings":{"fieldPath":[{"objectApiName":"${objectApiName}","fieldApiName":"_id"}]}},"operator":"greaterThan","right":{"type":"constant","settings":{"data":${maxId}}}}],"logic":"1 and 2"}`;
+        } else {
+            return `{"conditions":[{"index":1,"left":{"type":"metadataVariable","settings":{"fieldPath":[{"objectApiName":"${objectApiName}","fieldApiName":"_isDeleted"}]}},"operator":"equals","right":{"type":"constant","settings":{"data":false}}}],"logic":"1"}`;
+        }
+    }
+
+    let isContainDeleted = false;
+    for (let i = 0; i < expressions.length; i++) {
+        let expression = expressions[i];
+        try {
+            if (expression.left.type === "metadataVariable" && expression.left.settings.fieldPath[0].fieldApiName === "_isDeleted") {
+                isContainDeleted = true;
+                break;
+            }
+        } catch (e) {
+            console.error(e);
+        }
+    }
+
+    if (!isContainDeleted) {
+        expressions.push(buildExpression(objectApiName, "_isDeleted", false, expressions.length + 1));
+        logics.splice(0, 0, "(");
+        logics.push(" and ", `${expressions.length}`, ")");
+    }
+
+    if (maxId >= 0) {
+        expressions.push(buildExpression(objectApiName, "_id", new Condition("_id", maxId, operates.GT), expressions.length + 1));
+        logics.splice(0, 0, "(");
+        logics.push(" and ", `${expressions.length}`, ")");
+    }
+
+    return {conditions: expressions, logic: logics.join("")};
+}
+
+export function buildExpression(objectApiName: string, left: string, right: Condition | UserDataType, index = 1): Expression {
+    if (!(right instanceof Condition)) {
+        right = new Condition(left, right);
+    }
+
+    if (right instanceof Condition) {
+        if (utils.isObject(right.right) && !(right.right instanceof Condition) && !isKunlunTypeOrSerializedObject(right.right as object)) {
+            let key: string = Object.keys(right.right)[0]
+            let rr: {
+                [index: string]: any
+            } = right.right as object
+            if (key === 'id') {
+                if (rr[key] instanceof Condition) {
+                    right.op = rr[key].op;
+                    right.right = {id: rr[key].right}
+                }
+            } else if (!(rr[key] instanceof Condition)) {
+                right.right = new Condition(key, rr[key], right.op);
+            } else {
+                rr[key].left = key;
+                right.right = rr[key];
+            }
+        }
+        return right.toExpression(objectApiName, left, index);
+    }
+    return null;
+}
+
+// 逻辑操作：and 和 or
+export class Logic {
+    value: string
+    expressions: { [index: string]: any }
+    logics: Logic[]
+
+    constructor(expressions: { [index: string]: any } = null, logicValue: string = "and") {
+        // 通常情况
+        this.value = logicValue;
+        this.expressions = expressions;
+        this.logics = [];
+
+        if (!expressions) {
+            return;
+        }
+
+        // 下钻右值为逻辑表达式 and|or 的情况
+        for (let left of Object.keys(expressions)) {
+            if (expressions[left] instanceof Object && !(expressions[left] instanceof Array)) {
+                let right: {
+                    [index: string]: any,
+                } = expressions[left] as object;
+                for (const key of Object.keys(right)) {
+                    if (right[key] instanceof Logic) {
+                        this.handleRightLogic(right, left);
+                        delete expressions[left];
+                        break;
+                    }
+                }
+            }
+        }
+
+        // 右值为逻辑表达式 and|or 的情况
+        for (let left of Object.keys(expressions)) {
+            let right = expressions[left];
+            if (right instanceof Logic) {
+                this.handleRightLogic(expressions);
+                break;
+            }
+        }
+    }
+
+    /**
+     * 处理：右值包含逻辑表达式and|or的情况
+     *
+     * @param expressions
+     * @param lookupField
+     */
+    handleRightLogic(expressions: { [index: string]: any }, lookupField: string = null) {
+        this.expressions = null;
+        for (let left of Object.keys(expressions)) {
+            let right = expressions[left];
+
+            // 1.如果右值为Logic类型
+            if (right instanceof Logic) {
+                // 1.1 表达式不为空
+                if (right.expressions) {
+                    let exp: { [index: string]: any } = {};
+                    if (lookupField && right.expressions instanceof Condition) {
+                        right.expressions.left = lookupField;
+                        let obj: { [index: string]: any } = {};
+                        obj[left] = right.expressions.right;
+                        right.expressions.right = obj
+                        exp[lookupField] = right.expressions;
+                    } else {
+                        exp[left] = right.expressions;
+                    }
+                    this.logics.push(new Logic(exp, "and"));
+                } else {
+                    // 1.2 表达式为空
+                    let log = new Logic(null, right.value);
+                    for (let logic of right.logics) {
+                        let exp: { [index: string]: any } = {};
+                        if (lookupField && logic.expressions instanceof Condition) {
+                            logic.expressions.left = lookupField;
+                            let obj: { [index: string]: any } = {};
+                            obj[left] = logic.expressions.right;
+                            logic.expressions.right = obj;
+                            exp[lookupField] = logic.expressions;
+                        } else {
+                            if (logic.expressions instanceof Condition) {
+                                logic.expressions.left = left;
+                            }
+                            exp[left] = logic.expressions;
+                        }
+                        log.logics.push(new Logic(exp, logic.value));
+                    }
+                    this.logics.push(log);
+                }
+            } else {
+                let exp: { [index: string]: any } = {};
+                exp[left] = right;
+
+                let log = new Logic(exp, "and");
+                this.logics.push(log);
+            }
+        }
+    }
+
+    addLogic(logic: Logic) {
+        if (logic instanceof Logic) {
+            this.logics.push(logic);
+        }
+    }
+}
+
+export function buildLogic(param: (Logic | object)[], logicValue = "and"): Logic {
+    if (param.length === 1) {
+        return new Logic(param[0], logicValue)
+    }
+
+    let logic = new Logic(null, logicValue);
+    param.forEach(p => {
+        if (!p) {
+            return;
+        }
+
+        // Check：会走到这里吗？
+        if (p instanceof Logic) {
+            logic.logics.push(p);
+        } else if (p instanceof Object && !(p instanceof Array)) {
+            logic.logics.push(new Logic(p, "and"));
+        } else {
+            throw new exceptions.InvalidParamError(`param (${p}) is invalid`);
+        }
+    });
+    return logic;
+}
+
+// where参数的树状结构
+class Filter {
+    filters: Filter[]
+    logic: string
+    expression: Expression
+
+    /**
+     * @param logic: filters之间的逻辑关系
+     */
+    constructor(logic: string) {
+        if (!logic) {
+            this.logic = "and";
+        } else {
+            this.logic = logic;
+        }
+        this.expression = null;
+        this.filters = [];
+    }
+
+    // 现在仅考虑一层结构，不考虑嵌套
+    toCriterion() {
+        let conditions: Expression[] = [];
+        let logics: number[] = [];
+
+        this.filters.forEach((filter, i) => {
+            if (!filter.expression) {
+                return;
+            }
+
+            conditions.push({
+                index: i + 1,
+                left: filter.expression.left,
+                right: filter.expression.right,
+                operator: filter.expression.operator,
+            });
+            logics.push(i + 1);
+        });
+
+        let criterion = {conditions: conditions, logic: logics.join(" and ")};
+        return JSON.stringify(criterion);
+    }
+}
+
+export async function handleCriterion(criterion: string | Criterion): Promise<string | Criterion> {
+    if (typeof criterion === "string") {
+        return criterion
+    }
+
+    if (!criterion || !criterion.conditions || !(criterion.conditions instanceof Array)) {
+        return criterion;
+    }
+
+    let fieldRes: FieldResType = await handleLookupCondition(criterion.conditions);
+
+    for (let condition of criterion.conditions) {
+        if (fieldRes && fieldRes.lookupMap) {
+            let val: LookupField = fieldRes.lookupMap.get(condition.left.settings.fieldPath[0].fieldApiName);
+            if (condition.left.settings.fieldPath[1] && val && val.objectApiName) {
+                condition.left.settings.fieldPath[1].objectApiName = val.objectApiName;
+            }
+        }
+        await handleCondition(condition, fieldRes);
+    }
+
+    return JSON.stringify(criterion);
+}
+
+type FieldResType = {
+    isFirstLayer?: boolean
+    lookupMap?: Map<string, LookupField>,
+    dateSet?: Set<string>
+}
+
+async function handleLookupCondition(conditions: Expression[]): Promise<FieldResType> {
+    if (!(conditions && conditions[0] && conditions[0].left && conditions[0].left.settings && conditions[0].left.settings.fieldPath)) {
+        return null;
+    }
+
+    let queryMap = new Map(), fieldName;
+    let opList = [operates.LT, operates.LTE, operates.GT, operates.GTE, operates.HAS_ANY_OF, operates.HAS_NONE_OF];
+
+    for (const condition of conditions) {
+        if (condition.left.settings.fieldPath.length > 1 || opList.includes(condition.operator)) {
+            fieldName = condition.left.settings.fieldPath[0].fieldApiName;
+            queryMap.set(fieldName, {});
+        }
+    }
+
+    if (queryMap.size === 0) {
+        return {}
+    }
+
+    let lookupMap = new Map<string, LookupField>(), dateSet = new Set<string>()
+
+    let firstObjApiName = conditions[0].left.settings.fieldPath[0].objectApiName;
+
+    let fields = [];
+
+    if (queryMap.size === 1) {
+        fields.push(await Request.GetInstance().getField(firstObjApiName, fieldName));
+    } else {
+        fields = await Request.GetInstance().getFields(firstObjApiName);
+    }
+
+    for (const field of fields) {
+        parseFieldInfo(field, lookupMap, dateSet)
+    }
+
+    return {
+        lookupMap: lookupMap,
+        dateSet: dateSet,
+    }
+}
+
+type Field = {
+    type: {
+        name: string;
+        settings: {
+            referenced_object_api_name: string;
+            is_hierarchy: boolean;
+            target_is_hierarchy: boolean;
+            return_type: string;
+        };
+    }
+    api_name: string;
+}
+
+type LookupField = {
+    objectApiName: string,
+    isHierarchy: boolean,
+    targetIsHierarchy: boolean
+}
+
+function parseFieldInfo(field: Field, lookupMap: Map<string, LookupField>, dateSet: Set<string>) {
+
+    if (!(field && field.type && field.type.name && field.type.settings)) {
+        return;
+    }
+
+    switch (field.type.name) {
+        case 'lookup':
+            lookupMap.set(field.api_name, {
+                objectApiName: field.type.settings.referenced_object_api_name,
+                isHierarchy: field.type.settings.is_hierarchy,
+                targetIsHierarchy: field.type.settings.target_is_hierarchy,
+            });
+            break;
+        case 'date':
+            dateSet.add(field.api_name);
+            break;
+        case 'formula':
+            if (field.type.settings.return_type === "date") {
+                dateSet.add(field.api_name);
+            }
+            break;
+    }
+}
+
+async function handleCondition(condition: Expression, fieldRes: FieldResType) {
+    if (!condition || !condition.left || condition.left.type !== "metadataVariable") {
+        return;
+    }
+
+    if (!condition.left.settings || !condition.left.settings.fieldPath || !(condition.left.settings.fieldPath instanceof Array)) {
+        return;
+    }
+
+    let fieldPathList: PathType[] = condition.left.settings.fieldPath;
+    for (let i = 0; i < fieldPathList.length; i++) {
+        fieldRes.isFirstLayer = (i === 0);
+        if (fieldPathList.length === (i + 1)) { // 最后的查询条件 path 做处理
+            switch (condition.operator) {
+                case operates.LT:
+                    // 日期类型的lte，需要转换成isOnOrBefore
+                    await handleDateAndDatetimeOperator(fieldRes, condition, fieldPathList[i], operates.isOnOrBefore, -1);
+                    break;
+                case operates.LTE:
+                    // 日期类型的lte，需要转换成isOnOrBefore
+                    await handleDateAndDatetimeOperator(fieldRes, condition, fieldPathList[i], operates.isOnOrBefore);
+                    break;
+                case operates.GT:
+                    // 日期类型的gte，需要转换成isOnOrAfter
+                    await handleDateAndDatetimeOperator(fieldRes, condition, fieldPathList[i], operates.isOnOrAfter, 1);
+                    break;
+                case operates.GTE:
+                    // 日期类型的gte，需要转换成isOnOrAfter
+                    await handleDateAndDatetimeOperator(fieldRes, condition, fieldPathList[i], operates.isOnOrAfter);
+                    break;
+                case operates.HAS_ANY_OF:
+                case operates.HAS_NONE_OF:
+                    // hierarchy lookup，需要为extendLogicTags添加all
+                    // lookup 下钻的话，只在最后一层加 all
+                    await handleHierarchyFieldPath(fieldRes, fieldPathList[i]);
+                    break;
+            }
+        }
+
+    }
+}
+
+// 日期类型的lte，需要转换成isOnOrBefore
+// 日期类型的gte，需要转换成isOnOrAfter
+async function handleDateAndDatetimeOperator(fieldRes: FieldResType, condition: Expression, path: PathType, operator: string, addDay: number = 0) {
+    if (!condition || !path || !path.objectApiName || !path.fieldApiName) {
+        return;
+    }
+
+    let isDateType = false;
+
+    if (fieldRes && fieldRes.isFirstLayer) {
+        if (fieldRes.dateSet && fieldRes.dateSet.has(path.fieldApiName)) {
+            isDateType = true;
+        }
+    } else {
+        let field = await Request.GetInstance().getField(path.objectApiName, path.fieldApiName);
+        isDateType = isDate(field)
+    }
+
+    if (isDateType) {
+        condition.operator = operator;
+        if (condition.right && condition.right.settings && condition.right.settings.data) {
+            condition.right.settings.data = dateAdd(condition.right.settings.data as Date, addDay);
+        }
+    }
+}
+
+// hierarchy lookup，需要为extendLogicTags添加all
+async function handleHierarchyFieldPath(fieldRes: FieldResType, path: PathType) {
+    if (!path || !path.objectApiName || !path.fieldApiName) {
+        return;
+    }
+
+    let isHierarchyType = false;
+
+    if (fieldRes && fieldRes.isFirstLayer && fieldRes.lookupMap) {
+        let val = fieldRes.lookupMap.get(path.fieldApiName);
+        if (val && val.targetIsHierarchy) {
+            isHierarchyType = true;
+        }
+    } else {
+        let field = await Request.GetInstance().getField(path.objectApiName, path.fieldApiName);
+        isHierarchyType = targetIsHierarchy(field);
+    }
+
+    if (!isHierarchyType) {
+        return;
+    }
+
+    if (!path.extendLogicTags) {
+        path.extendLogicTags = [];
+    }
+    path.extendLogicTags.push("all");
+}
+
+function isHierarchy(field: Field) {
+    return field && field.type && field.type.name === "lookup" && field.type.settings && field.type.settings.is_hierarchy;
+}
+
+function targetIsHierarchy(field: Field) {
+    return field && field.type && field.type.name === "lookup" && field.type.settings && field.type.settings.target_is_hierarchy;
+}
+
+function isDate(field: Field) {
+    return field && field.type && ((field.type.name === "date") || (field.type.name === "formula" && field.type.settings && field.type.settings.return_type === "date"));
+}
+
+function dateAdd(date: Date | fieldType.Date | string, num: number) {
+    try {
+        if (date instanceof Date) {
+            return dayjs(date).add(num, "day").format("YYYY-MM-DD");
+        // } else if (date instanceof fieldType.Date) { // instanceof 改动9
+        } else if (fieldType.isKFieldTypeDate(date)) {
+            return dayjs((date as any).toJSON()).add(num, "day").format("YYYY-MM-DD");
+        } else if (typeof (date) === "string") {
+            return dayjs(date).add(num, "day").format("YYYY-MM-DD");
+        }
+    } catch (e) {
+        return date;
+    }
+}

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

@@ -0,0 +1,58 @@
+import { OrderV2 } from "../../../request/interface";
+import { UserDataType } from "./expression";
+export declare type FieldPath = {
+    objectApiName: string;
+    fieldApiName: string;
+    extendLogicTags: string[];
+};
+export declare type SettingType = {
+    data?: any;
+    fieldPath?: FieldPath[];
+};
+export declare type Expression = {
+    type: string;
+    settings: SettingType;
+};
+export declare function NewMetadataExpressionField(objectApiName: string, fieldApiName: string): Expression;
+export declare function NewConstantExpressionField(data: UserDataType): Expression;
+export declare type ExpressionV2 = {
+    leftValue: string;
+    operator: string;
+    rightValue: any;
+};
+export declare class ArithmeticExpression {
+    left: Expression;
+    operator: string;
+    right: Expression;
+    expr: ExpressionV2;
+    constructor(leftValue: string, op: string, rightValue: any);
+}
+export declare class LogicalExpression {
+    type: string;
+    arithmeticExpressions: ArithmeticExpression[];
+    logicalExpressions: LogicalExpression[];
+    constructor(logicType: string, expressions: ArithmeticExpression[], logics: LogicalExpression[]);
+}
+export declare class QueryV2 {
+    objectApiName: string;
+    _limit: number;
+    _offset: number;
+    fields: string[];
+    _order: OrderV2[];
+    filter: LogicalExpression;
+    buildCriterion(filter: LogicalExpression): any[];
+    where(condition: LogicalExpression | Record<string, ArithmeticExpression>): QueryV2;
+    offset(offset: number): QueryV2;
+    limit(limit: number): QueryV2;
+    orderBy(fieldApiNames: string[]): QueryV2;
+    orderByDesc(fieldApiNames: string[]): QueryV2;
+    select(fieldApiNames: string[]): QueryV2;
+    constructor(objectApiName: string);
+}
+export declare type logicalRet = {
+    logicalExps: LogicalExpression[];
+    arithmeticExps: ArithmeticExpression[];
+};
+export declare function logical(exps: (LogicalExpression | Record<string, ArithmeticExpression>)[]): logicalRet;
+export declare type CriterionV2 = (Record<string, CriterionV2> | ExpressionV2)[];
+export declare function buildCriterionV2(filter: LogicalExpression): CriterionV2;