@scx-js/scx-data 0.2.3 → 0.3.0

package/x/QueryNodeConverter.js

@@ -0,0 +1,163 @@
+import {WhereClause} from "../query/WhereClause.js";
+import {Not} from "../query/Not.js";
+import {Or} from "../query/Or.js";
+import {And} from "../query/And.js";
+import {Condition} from "../query/Condition.js";
+
+/// QueryNodeConverter
+///
+/// - Query -> Node 采用严格编码.
+
+// ************************* Query *************************
+
+/// query 不允许 null.
+function queryToNode(query) {
+    if (query == null) {
+        throw new Error("query cannot be null");
+    }
+
+    return {
+        "@type": "Query",
+        "where": whereToNode(query.getWhere()),
+        "orderBys": orderBysToNode(query.getOrderBys()),
+        "offset": query.getOffset(),
+        "limit": query.getLimit(),
+    };
+}
+
+// ************************* Where *************************
+
+/// where 可能是 null, 保持为 NullNode
+function whereToNode(where) {
+    if (where == null) {
+        return null;
+    }
+    if (where instanceof Condition) {
+        return conditionToNode(where);
+    }
+    if (where instanceof And) {
+        return andToNode(where);
+    }
+    if (where instanceof Or) {
+        return orToNode(where);
+    }
+    if (where instanceof Not) {
+        return notToNode(where);
+    }
+    if (where instanceof WhereClause) {
+        return whereClauseToNode(where);
+    }
+    throw new Error("Unknown Where type: " + where);
+}
+
+// ************************* OrderBy *************************
+
+/// orderBys 永不可能为 null.
+function orderBysToNode(orderBys) {
+    let node = [];
+    for (let orderBy of orderBys) {
+        node.push(orderByToNode(orderBy));
+    }
+    return node;
+}
+
+/// orderBy 永不可能为 null.
+function orderByToNode(orderBy) {
+    return {
+        "@type": "OrderBy",
+        "selector": orderBy.selector(),
+        "orderByType": orderByTypeToNode(orderBy.orderByType()),
+        "useExpression": orderBy.useExpression(),
+    };
+}
+
+/// orderByType 永不可能为 null.
+function orderByTypeToNode(orderByType) {
+    return orderByType.value();
+}
+
+// ************************* Condition *************************
+
+/// condition 永不可能为 null.
+function conditionToNode(condition) {
+    return {
+        "@type": "Condition",
+        "selector": condition.selector(),
+        "conditionType": conditionTypeToNode(condition.conditionType()),
+        "value1": condition.value1(),
+        "value2": condition.value2(),
+        "useExpression": condition.useExpression(),
+        "useExpressionValue": condition.useExpressionValue(),
+        "skipIfInfo": skipIfInfoToNode(condition.skipIfInfo()),
+    };
+}
+
+/// conditionType 永不可能为 null.
+function conditionTypeToNode(conditionType) {
+    return conditionType.value();
+}
+
+// ************************* And/Or *************************
+
+/// and 永不可能为 null.
+function andToNode(and) {
+    return {
+        "@type": "And",
+        "clauses": clausesToNode(and.clauses()),
+    };
+}
+
+/// or 永不可能为 null.
+function orToNode(or) {
+    return {
+        "@type": "Or",
+        "clauses": clausesToNode(or.clauses()),
+    };
+}
+
+/// clauses 永不可能为 null.
+function clausesToNode(clauses) {
+    let node = [];
+    for (let clause of clauses) {
+        node.push(whereToNode(clause));
+    }
+    return node;
+}
+
+// ************************* Not *************************
+
+/// not 永不可能为 null.
+function notToNode(not) {
+    return {
+        "@type": "Not",
+        "clause": whereToNode(not.clause()),
+    };
+}
+
+// ************************* WhereClause *************************
+
+/// whereClause 永不可能为 null.
+function whereClauseToNode(whereClause) {
+    return {
+        "@type": "WhereClause",
+        "expression": whereClause.expression(),
+        "params": whereClause.params(),
+    };
+}
+
+// ************************* SkipIfInfo *************************
+
+/// skipIfInfo 永不可能为 null.
+function skipIfInfoToNode(skipIfInfo) {
+    return {
+        "@type": "SkipIfInfo",
+        "skipIfNull": skipIfInfo.skipIfNull(),
+        "skipIfEmptyList": skipIfInfo.skipIfEmptyList(),
+        "skipIfEmptyString": skipIfInfo.skipIfEmptyString(),
+        "skipIfBlankString": skipIfInfo.skipIfBlankString(),
+    };
+}
+
+export {
+    queryToNode,
+};

package/serialization/FieldPolicySerializer.js

@@ -1,47 +0,0 @@
-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

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