@scx-js/scx-data 0.2.1 → 0.2.3

package/query/SkipIfInfo.js

@@ -0,0 +1,42 @@
+import {SKIP_IF_BLANK_STRING, SKIP_IF_EMPTY_LIST, SKIP_IF_EMPTY_STRING, SKIP_IF_NULL} from "./BuildControl.js";
+
+class SkipIfInfo {
+    skipIfNull;
+    skipIfEmptyList;
+    skipIfEmptyString;
+    skipIfBlankString;
+
+    constructor(skipIfNull, skipIfEmptyList, skipIfEmptyString, skipIfBlankString) {
+        this.skipIfNull = skipIfNull;
+        this.skipIfEmptyList = skipIfEmptyList;
+        this.skipIfEmptyString = skipIfEmptyString;
+        this.skipIfBlankString = skipIfBlankString;
+    }
+
+}
+
+function ofSkipIfInfo(...controls) {
+    let skipIfNull = false;
+    let skipIfEmptyList = false;
+    let skipIfEmptyString = false;
+    let skipIfBlankString = false;
+    for (let control of controls) {
+        if (control === SKIP_IF_NULL) {
+            skipIfNull = true;
+        } else if (control === SKIP_IF_EMPTY_LIST) {
+            skipIfEmptyList = true;
+        } else if (control === SKIP_IF_EMPTY_STRING) {
+            skipIfEmptyString = true;
+        } else if (control === SKIP_IF_BLANK_STRING) {
+            skipIfBlankString = true;
+        }
+    }
+
+    return new SkipIfInfo(skipIfNull, skipIfEmptyList, skipIfEmptyString, skipIfBlankString);
+
+}
+
+export {
+    SkipIfInfo,
+    ofSkipIfInfo,
+};

package/query/WhereClause.js

@@ -3,31 +3,21 @@ import {QueryImpl} from "./QueryImpl.js";
 
 class WhereClause extends QueryLike {
 
-    #whereClause;
+    #expression;
     #params;
 
-    constructor(whereClause, params) {
+    constructor(expression, params) {
         super();
-        this.#whereClause = whereClause;
+        this.#expression = expression;
         this.#params = params;
     }
 
-    /**
-     * 拼接
-     *
-     * @param other a
-     * @return WhereClause
-     */
-    concat(other) {
-        return new WhereClause(this.#whereClause.concat(other.#whereClause), this.#params.concat(other.params));
-    }
-
     isEmpty() {
-        return (this.#whereClause == null || this.#whereClause.isEmpty()) && (this.#params == null || this.#params.length === 0);
+        return (this.#expression == null || this.#expression.isEmpty()) && (this.#params == null || this.#params.length === 0);
     }
 
-    whereClause() {
-        return this.#whereClause;
+    expression() {
+        return this.#expression;
     }
 
     params() {

package/serialization/FieldPolicySerializer.js

@@ -0,0 +1,47 @@
+import {FieldPolicy} from "../field_policy/FieldPolicy.js";
+
+function serializeFieldPolicyToJson(fieldPolicy) {
+    return JSON.stringify(serializeFieldPolicy(fieldPolicy));
+}
+
+function serializeFieldPolicy(fieldPolicy) {
+    return {
+        "@type": "FieldPolicy",
+        "filterMode": fieldPolicy.getFilterMode(),
+        "fieldNames": fieldPolicy.getFieldNames(),
+        "virtualFields": serializeVirtualFields(fieldPolicy.getVirtualFields()),
+        "ignoreNull": fieldPolicy.getIgnoreNull(),
+        "ignoreNulls": fieldPolicy.getIgnoreNulls(),
+        "assignFields": serializeAssignFields(fieldPolicy.getAssignFields()),
+    };
+}
+
+function serializeVirtualField(virtualField) {
+    return {
+        "@type": "VirtualField",
+        "expression": virtualField.expression(),
+        "virtualFieldName": virtualField.virtualFieldName(),
+    };
+}
+
+
+function serializeAssignField(assignField) {
+    return {
+        "@type": "AssignField",
+        "fieldName": assignField.fieldName(),
+        "expression": assignField.expression(),
+    };
+}
+
+function serializeVirtualFields(virtualFields) {
+    return virtualFields.map(s => serializeVirtualField(s));
+}
+
+function serializeAssignFields(assignFields) {
+    return assignFields.map(s => serializeAssignField(s));
+}
+
+export {
+    serializeFieldPolicyToJson,
+    serializeFieldPolicy,
+};

package/serialization/QuerySerializer.js

@@ -0,0 +1,120 @@
+import {WhereClause} from "../query/WhereClause.js";
+import {And} from "../query/And.js";
+import {Or} from "../query/Or.js";
+import {Not} from "../query/Not.js";
+import {Condition} from "../query/Condition.js";
+
+function serializeQueryToJson(query) {
+    return JSON.stringify(serializeQuery(query));
+}
+
+function serializeQuery(query) {
+    return {
+        "@type": "Query",
+        where: serializeWhere(query.getWhere()),
+        orderBys: serializeOrderBys(query.getOrderBys()),
+        offset: query.getOffset(),
+        limit: query.getLimit(),
+    };
+}
+
+function serializeWhere(obj) {
+    if (!obj) {
+        return null;
+    }
+
+    if (obj instanceof WhereClause) {
+        return serializeWhereClause(obj);
+    }
+    if (obj instanceof And) {
+        return serializeAnd(obj);
+    }
+    if (obj instanceof Or) {
+        return serializeOr(obj);
+    }
+
+    if (obj instanceof Not) {
+        return serializeNot(obj);
+    }
+
+    if (obj instanceof Condition) {
+        return serializeCondition(obj);
+    }
+
+    throw new Error(`Unknown Where type: ${obj}`);
+
+}
+
+function serializeWhereClause(w) {
+    return {
+        "@type": "WhereClause",
+        expression: w.expression(),
+        params: w.params(),
+    };
+}
+
+function serializeAnd(a) {
+    return {
+        "@type": "And",
+        clauses: serializeWhereAll(a.clauses()),
+    };
+}
+
+function serializeOr(o) {
+    return {
+        "@type": "Or",
+        clauses: serializeWhereAll(o.clauses()),
+    };
+}
+
+function serializeNot(n) {
+    return {
+        "@type": "Not",
+        clause: serializeWhere(n.clause()),
+    };
+}
+
+function serializeCondition(w) {
+    return {
+        "@type": "Condition",
+        selector: w.selector(),
+        conditionType: w.conditionType(),
+        value1: w.value1(),
+        value2: w.value2(),
+        useExpression: w.useExpression(),
+        useExpressionValue: w.useExpressionValue(),
+        skipIfInfo: serializeSkipIfInfo(w.skipIfInfo()),
+    };
+}
+
+function serializeWhereAll(objs) {
+    return objs.map(obj => serializeWhere(obj));
+}
+
+function serializeOrderBys(objs) {
+    return objs.map(obj => serializeOrderBy(obj));
+}
+
+function serializeOrderBy(orderBy) {
+    return {
+        "@type": "OrderBy",
+        selector: orderBy.selector(),
+        orderByType: orderBy.orderByType(),
+        useExpression: orderBy.useExpression(),
+    };
+}
+
+function serializeSkipIfInfo(info) {
+    return {
+        "@type": "SkipIfInfo",
+        skipIfNull: info.skipIfNull,
+        skipIfEmptyList: info.skipIfEmptyList,
+        skipIfEmptyString: info.skipIfEmptyString,
+        skipIfBlankString: info.skipIfBlankString,
+    };
+}
+
+export {
+    serializeQueryToJson,
+    serializeQuery,
+};

package/field_policy/serializer/FieldPolicySerializer.js

@@ -1,30 +0,0 @@
-import {FieldPolicy} from "../FieldPolicy.js";
-
-class FieldPolicySerializer {
-
-    serialize(obj) {
-        if (obj instanceof FieldPolicy) {
-            return this.serializeFieldPolicy(obj);
-        }
-        return obj;
-    }
-
-    serializeFieldPolicy(fieldPolicy) {
-        return {
-            "@type": "FieldPolicy",
-            "filterMode": fieldPolicy.filterMode(),
-            "fieldNames": fieldPolicy.fieldNames(),
-            "ignoreNull": fieldPolicy.ignoreNull_(),
-            "ignoreNulls": fieldPolicy.ignoreNulls(),
-            "expressions": fieldPolicy.expressions(),
-        };
-    }
-
-}
-
-const FIELD_POLICY_SERIALIZER = new FieldPolicySerializer();
-
-export {
-    FIELD_POLICY_SERIALIZER,
-    FieldPolicySerializer,
-};

package/query/GroupBy.js

@@ -1,36 +0,0 @@
-import {isBlank} from "@scx-js/scx-common";
-import {QueryImpl} from "./QueryImpl.js";
-import {QueryLike} from "./QueryLike.js";
-import {ofInfo} from "./QueryOption.js";
-
-class GroupBy extends QueryLike {
-
-    #name;
-    #info;
-
-    constructor(name, ...options) {
-        super();
-        if (isBlank(name)) {
-            throw new Error("GroupBy 参数错误 : 名称 不能为空 !!!");
-        }
-        this.#name = name;
-        this.#info = ofInfo(...options);
-    }
-
-    name() {
-        return this.#name;
-    }
-
-    info() {
-        return this.#info;
-    }
-
-    toQuery() {
-        return new QueryImpl().groupBy(this);
-    }
-
-}
-
-export {
-    GroupBy,
-};

package/query/QueryOption.js

@@ -1,74 +0,0 @@
-class QueryOption {
-
-    #value;
-
-    constructor(value) {
-        this.#value = value;
-    }
-
-
-}
-
-const REPLACE = new QueryOption("REPLACE");
-const SKIP_IF_NULL = new QueryOption("SKIP_IF_NULL");
-const SKIP_IF_EMPTY_LIST = new QueryOption("SKIP_IF_EMPTY_LIST");
-const USE_ORIGINAL_NAME = new QueryOption("USE_ORIGINAL_NAME");
-const USE_JSON_EXTRACT = new QueryOption("USE_JSON_EXTRACT");
-const USE_ORIGINAL_VALUE = new QueryOption("USE_ORIGINAL_VALUE");
-
-function ofInfo(...queryOptions) {
-    let replace = false;
-    let skipIfNull = false;
-    let skipIfEmptyList = false;
-    let useOriginalName = false;
-    let useJsonExtract = false;
-    let useOriginalValue = false;
-    for (let option of queryOptions) {
-        if (option === REPLACE) {
-            replace = true;
-        } else if (option === SKIP_IF_NULL) {
-            skipIfNull = true;
-        } else if (option === SKIP_IF_EMPTY_LIST) {
-            skipIfEmptyList = true;
-        } else if (option === USE_ORIGINAL_NAME) {
-            useOriginalName = true;
-        } else if (option === USE_JSON_EXTRACT) {
-            useJsonExtract = true;
-        } else if (option === USE_ORIGINAL_VALUE) {
-            useOriginalValue = true;
-        }
-    }
-    return new Info(replace, skipIfNull, skipIfEmptyList, useOriginalName, useJsonExtract, useOriginalValue);
-}
-
-class Info {
-    replace;
-    skipIfNull;
-    skipIfEmptyList;
-    useOriginalName;
-    useJsonExtract;
-    useOriginalValue;
-
-
-    constructor(replace, skipIfNull, skipIfEmptyList, useOriginalName, useJsonExtract, useOriginalValue) {
-        this.replace = replace;
-        this.skipIfNull = skipIfNull;
-        this.skipIfEmptyList = skipIfEmptyList;
-        this.useOriginalName = useOriginalName;
-        this.useJsonExtract = useJsonExtract;
-        this.useOriginalValue = useOriginalValue;
-    }
-
-}
-
-export {
-    QueryOption,
-    REPLACE,
-    SKIP_IF_NULL,
-    SKIP_IF_EMPTY_LIST,
-    USE_ORIGINAL_NAME,
-    USE_JSON_EXTRACT,
-    USE_ORIGINAL_VALUE,
-    Info,
-    ofInfo,
-};

package/query/Where.js

@@ -1,59 +0,0 @@
-import {QueryLike} from "./QueryLike.js";
-import {isBlank} from "@scx-js/scx-common";
-import {QueryImpl} from "./QueryImpl.js";
-import {ofInfo} from "./QueryOption.js";
-
-class Where extends QueryLike {
-
-    #name;
-    #whereType;
-    #value1;
-    #value2;
-    #info;
-
-    constructor(name, whereType, value1, value2, ...options) {
-        super();
-        //名称不能为空
-        if (isBlank(name)) {
-            throw new Error("Where 参数错误 : 名称 不能为空 !!!");
-        }
-        //类型也不能为空
-        if (whereType == null) {
-            throw new Error("Where 参数错误 : whereType 不能为空 !!!");
-        }
-        this.#name = name;
-        this.#whereType = whereType;
-        this.#value1 = value1;
-        this.#value2 = value2;
-        this.#info = ofInfo(...options);
-    }
-
-    name() {
-        return this.#name;
-    }
-
-    whereType() {
-        return this.#whereType;
-    }
-
-    value1() {
-        return this.#value1;
-    }
-
-    value2() {
-        return this.#value2;
-    }
-
-    info() {
-        return this.#info;
-    }
-
-    toQuery() {
-        return new QueryImpl().where(this);
-    }
-
-}
-
-export {
-    Where,
-};

package/query/serializer/GroupBySerializer.js

@@ -1,50 +0,0 @@
-import {Query} from "../Query.js";
-import {isArray} from "@scx-js/scx-common";
-import {GroupBy} from "../GroupBy.js";
-
-class GroupBySerializer {
-
-    serialize(obj) {
-        if (obj instanceof String) {
-            return this.serializeString(obj);
-        }
-        if (obj instanceof GroupBy) {
-            return this.serializeGroupBy(obj);
-        }
-        if (obj instanceof Query) {
-            return this.serializeQuery(obj.getWhere());
-        }
-        if (isArray(obj)) {
-            return this.serializeAll(obj);
-        }
-        return obj;
-    }
-
-    serializeString(str) {
-        return str;
-    }
-
-    serializeGroupBy(w) {
-        return {
-            "@type": "GroupBy",
-            "name": w.name(),
-            "info": w.info(),
-        };
-    }
-
-    serializeQuery(w) {
-        return this.serializeAll(w.getGroupBy());
-    }
-
-
-    serializeAll(objs) {
-        const arr = [];
-        for (let i = 0; i < objs.length; i = i + 1) {
-            arr[i] = this.serialize(objs[i]);
-        }
-        return arr;
-    }
-
-}
-
-export {GroupBySerializer};

package/query/serializer/OrderBySerializer.js

@@ -1,54 +0,0 @@
-import {Query} from "../Query.js";
-import {isArray} from "@scx-js/scx-common";
-import {OrderBy} from "../OrderBy.js";
-
-class OrderBySerializer {
-
-    serialize(obj) {
-        if (obj instanceof String) {
-            return this.serializeString(obj);
-        }
-        if (obj instanceof OrderBy) {
-            return this.serializeOrderBy(obj);
-        }
-        if (obj instanceof Query) {
-            return this.serializeQuery(obj.getWhere());
-        }
-        if (isArray(obj)) {
-            return this.serializeAll(obj);
-        }
-        return obj;
-    }
-
-    serializeString(str) {
-        return str;
-    }
-
-    serializeOrderBy(w) {
-        return {
-            "@type": "OrderBy",
-            "name": w.name(),
-            "orderByType": w.orderByType(),
-            "info": w.info(),
-        };
-    }
-
-    serializeQuery(w) {
-        return this.serializeAll(w.getOrderBy());
-    }
-
-
-    serializeAll(objs) {
-        const arr = [];
-        for (let i = 0; i < objs.length; i = i + 1) {
-            arr[i] = this.serialize(objs[i]);
-        }
-        return arr;
-    }
-
-
-}
-
-export {
-    OrderBySerializer,
-};

package/query/serializer/QuerySerializer.js

@@ -1,35 +0,0 @@
-import {WhereSerializer} from "./WhereSerializer.js";
-import {GroupBySerializer} from "./GroupBySerializer.js";
-import {OrderBySerializer} from "./OrderBySerializer.js";
-
-class QuerySerializer {
-
-    #whereSerializer;
-    #groupBySerializer;
-    #orderBySerializer;
-
-    constructor() {
-        this.#whereSerializer = new WhereSerializer();
-        this.#groupBySerializer = new GroupBySerializer();
-        this.#orderBySerializer = new OrderBySerializer();
-    }
-
-    serializeQuery(query) {
-        return {
-            "@type": "Query",
-            "where": this.#whereSerializer.serialize(query.getWhere()),
-            "groupBy": this.#groupBySerializer.serialize(query.getGroupBy()),
-            "orderBy": this.#orderBySerializer.serialize(query.getOrderBy()),
-            "offset": query.getOffset(),
-            "limit": query.getLimit(),
-        };
-    }
-
-}
-
-const QUERY_SERIALIZER = new QuerySerializer();
-
-export {
-    QuerySerializer,
-    QUERY_SERIALIZER,
-};

package/query/serializer/WhereSerializer.js

@@ -1,100 +0,0 @@
-import {Where} from "../Where.js";
-import {isArray} from "@scx-js/scx-common";
-import {Query} from "../Query.js";
-import {WhereClause} from "../WhereClause.js";
-import {And} from "../And.js";
-import {Or} from "../Or.js";
-import {Not} from "../Not.js";
-
-class WhereSerializer {
-
-    serialize(obj) {
-        if (obj instanceof String) {
-            return this.serializeString(obj);
-        }
-        if (obj instanceof WhereClause) {
-            return this.serializeWhereClause(obj);
-        }
-        if (obj instanceof And) {
-            return this.serializeAnd(obj);
-        }
-        if (obj instanceof Or) {
-            return this.serializeOr(obj);
-        }
-        if (obj instanceof Not) {
-            return this.serializeNot(obj);
-        }
-        if (obj instanceof Where) {
-            return this.serializeWhere(obj);
-        }
-        if (obj instanceof Query) {
-            return this.serializeQuery(obj.getWhere());
-        }
-        if (isArray(obj)) {
-            return this.serializeAll(obj);
-        }
-        return obj;
-    }
-
-    serializeString(str) {
-        return str;
-    }
-
-    serializeWhereClause(w) {
-        return {
-            "@type": "WhereClause",
-            "whereClause": w.whereClause(),
-            "params": w.params(),
-        };
-    }
-
-    serializeAnd(l) {
-        return {
-            "@type": "And",
-            "clauses": this.serializeAll(l.clauses()),
-        };
-    }
-
-    serializeOr(l) {
-        return {
-            "@type": "Or",
-            "clauses": this.serializeAll(l.clauses()),
-        };
-    }
-
-    serializeNot(l) {
-        return {
-            "@type": "Not",
-            "clause": this.serialize(l.clause()),
-        };
-    }
-
-    serializeWhere(w) {
-        return {
-            "@type": "Where",
-            "name": w.name(),
-            "whereType": w.whereType(),
-            "value1": w.value1(),
-            "value2": w.value2(),
-            "info": w.info(),
-        };
-    }
-
-    serializeQuery(w) {
-        return this.serializeAll(w.getWhere());
-    }
-
-
-    serializeAll(objs) {
-        const arr = [];
-        for (let i = 0; i < objs.length; i = i + 1) {
-            arr[i] = this.serialize(objs[i]);
-        }
-        return arr;
-    }
-
-}
-
-export {
-    WhereSerializer,
-};