@scx-js/scx-data 0.2.4 → 0.3.0

package/query/Not.js

@@ -17,6 +17,7 @@ class Not extends QueryLike {
     toQuery() {
         return new QueryImpl().where(this);
     }
+
 }
 
 export {Not};

package/query/Or.js

@@ -5,11 +5,11 @@ class Or extends Junction {
 
     // 因为 js 不允许 循环依赖 所以 这两个方法迁移到子类
     and(...clauses) {
-        return this.add(new And().add(clauses));
+        return this.add(new And().add(...clauses));
     }
 
     or(...clauses) {
-        return this.add(new Or().add(clauses));
+        return this.add(new Or().add(...clauses));
     }
 
 }

package/query/OrderBy.js

@@ -1,4 +1,3 @@
-import {isBlank} from "@scx-js/scx-common";
 import {QueryImpl} from "./QueryImpl.js";
 import {QueryLike} from "./QueryLike.js";
 
@@ -8,20 +7,19 @@ class OrderBy extends QueryLike {
     #orderByType;
     #useExpression;
 
-    constructor(name, orderByType, useExpression) {
+    constructor(selector, orderByType, useExpression) {
         super();
-        if (isBlank(name)) {
-            throw new Error("OrderBy 参数错误 : 名称 不能为空 !!!");
+        if (selector == null) {
+            throw new Error("selector cannot be null");
         }
         if (orderByType == null) {
-            throw new Error("OrderBy 参数错误 : orderByType 不能为空 !!!");
+            throw new Error("orderByType cannot be null");
         }
-        this.#selector = name;
+        this.#selector = selector;
         this.#orderByType = orderByType;
         this.#useExpression = useExpression;
     }
 
-
     selector() {
         return this.#selector;
     }

package/query/OrderByType.js

@@ -1,8 +1,22 @@
-const ASC = "ASC";
+class OrderByType {
 
-const DESC = "DESC";
+    #value;
+
+    constructor(value) {
+        this.#value = value;
+    }
+
+    value() {
+        return this.#value;
+    }
+
+}
+
+const ASC = new OrderByType("ASC");
+const DESC = new OrderByType("DESC");
 
 export {
+    OrderByType,
     ASC,
     DESC,
 };

package/query/QueryBuilder.js

@@ -22,15 +22,30 @@ import {ASC, DESC} from "./OrderByType.js";
 import {Not} from "./Not.js";
 import {And} from "./And.js";
 import {Or} from "./Or.js";
-import {checkUseExpression, checkUseExpressionValue} from "./BuildControl.js";
-import {ofSkipIfInfo} from "./SkipIfInfo.js";
+import {toSkipIfInfo, toUseExpression, toUseExpressionValue} from "./BuildControl.js";
 
-function query(oldQuery) {
-    return new QueryImpl(oldQuery);
+function query() {
+    return new QueryImpl();
 }
 
-function where(whereClauses) {
-    return new QueryImpl().where(whereClauses);
+function query_(oldQuery) {
+    if (oldQuery == null) {
+        throw new Error("oldQuery cannot be null");
+    }
+    let query = new QueryImpl();
+    query.where(oldQuery.getWhere());
+    query.orderBys(...oldQuery.getOrderBys());
+    if (oldQuery.getOffset() != null) {
+        query.offset(oldQuery.getOffset());
+    }
+    if (oldQuery.getLimit() != null) {
+        query.limit(oldQuery.getLimit());
+    }
+    return query;
+}
+
+function where(where) {
+    return new QueryImpl().where(where);
 }
 
 function orderBys(...orderBys) {
@@ -57,29 +72,29 @@ function not(clause) {
     return new Not(clause);
 }
 
+function whereClause(expression, ...params) {
+    return new WhereClause(expression, ...params);
+}
+
 function condition(fieldName, conditionType, value, ...controls) {
-    let useExpression = checkUseExpression(...controls);
-    let useExpressionValue = checkUseExpressionValue(...controls);
-    let skipIfInfo = ofSkipIfInfo(...controls);
+    let useExpression = toUseExpression(...controls);
+    let useExpressionValue = toUseExpressionValue(...controls);
+    let skipIfInfo = toSkipIfInfo(...controls);
     return new Condition(fieldName, conditionType, value, null, useExpression, useExpressionValue, skipIfInfo);
 }
 
 function condition2(fieldName, conditionType, value1, value2, ...controls) {
-    let useExpression = checkUseExpression(...controls);
-    let useExpressionValue = checkUseExpressionValue(...controls);
-    let skipIfInfo = ofSkipIfInfo(...controls);
+    let useExpression = toUseExpression(...controls);
+    let useExpressionValue = toUseExpressionValue(...controls);
+    let skipIfInfo = toSkipIfInfo(...controls);
     return new Condition(fieldName, conditionType, value1, value2, useExpression, useExpressionValue, skipIfInfo);
 }
 
 function orderBy(selector, orderByType, ...controls) {
-    let useExpression = checkUseExpression(...controls);
+    let useExpression = toUseExpression(...controls);
     return new OrderBy(selector, orderByType, useExpression);
 }
 
-function whereClause(expression, ...params) {
-    return new WhereClause(expression, ...params);
-}
-
 function asc(name, ...options) {
     return orderBy(name, ASC, ...options);
 }
@@ -144,11 +159,12 @@ function notBetween(fieldName, value1, value2, ...options) {
     return condition2(fieldName, NOT_BETWEEN, value1, value2, ...options);
 }
 
-
 export {
     query,
+    query_,
     where,
     orderBy,
+    orderBys,
     offset,
     limit,
     and,
@@ -171,4 +187,6 @@ export {
     between,
     notBetween,
     whereClause,
+    condition,
+    condition2,
 };

package/query/QueryImpl.js

@@ -1,5 +1,5 @@
 import {Query} from "./Query.js";
-import {checkUseExpression} from "./BuildControl.js";
+import {toUseExpression} from "./BuildControl.js";
 import {OrderBy} from "./OrderBy.js";
 import {ASC, DESC} from "./OrderByType.js";
 
@@ -10,10 +10,7 @@ class QueryImpl extends Query {
     #offset;
     #limit;
 
-    /**
-     * 创建 Query 对象
-     */
-    constructor(old) {
+    constructor() {
         super();
         this.#where = null;
         this.#orderBys = [];
@@ -26,16 +23,23 @@ class QueryImpl extends Query {
         return this;
     }
 
-
     orderBys(...orderBys) {
-        this.#orderBys = [...orderBys];
+        if (orderBys == null) {
+            throw new Error("orderBys cannot be null");
+        }
+        let newOrderBys = [];
+        for (let orderBy of orderBys) {
+            if (orderBy != null) {
+                newOrderBys.push(orderBy);
+            }
+        }
+        this.#orderBys = newOrderBys;
         return this;
     }
 
-
     offset(offset) {
         if (offset < 0) {
-            throw new Error("Limit 参数错误 : offset (偏移量) 不能小于 0 !!!");
+            throw new Error("offset must be >= 0");
         }
         this.#offset = offset;
         return this;
@@ -43,7 +47,7 @@ class QueryImpl extends Query {
 
     limit(limit) {
         if (limit < 0) {
-            throw new Error("Limit 参数错误 : limit (行长度) 不能小于 0 !!!");
+            throw new Error("limit must be >= 0");
         }
         this.#limit = limit;
         return this;
@@ -86,26 +90,42 @@ class QueryImpl extends Query {
     }
 
     orderBy(...orderBys) {
-        this.#orderBys.push(...orderBys);
+        if (orderBys == null) {
+            throw new Error("orderBys cannot be null");
+        }
+        for (let orderBy of orderBys) {
+            if (orderBy != null) {
+                this.#orderBys.push(orderBy);
+            }
+        }
         return this;
     }
 
-
     asc(selector, ...controls) {
-        let useExpression = checkUseExpression(...controls);
-        let o = new OrderBy(selector, ASC, useExpression);
-        this.orderBy(o);
+        this.orderBy(asc(selector, ...controls));
         return this;
     }
 
-
     desc(selector, ...controls) {
-        let useExpression = checkUseExpression(...controls);
-        let o = new OrderBy(selector, DESC, useExpression);
-        this.orderBy(o);
+        this.orderBy(desc(selector, ...controls));
         return this;
     }
 
 }
 
+// 防止循环依赖 QueryBuilder 这里拷贝一份
+
+function orderBy(selector, orderByType, ...controls) {
+    let useExpression = toUseExpression(...controls);
+    return new OrderBy(selector, orderByType, useExpression);
+}
+
+function asc(name, ...options) {
+    return orderBy(name, ASC, ...options);
+}
+
+function desc(name, ...options) {
+    return orderBy(name, DESC, ...options);
+}
+
 export {QueryImpl};

package/query/QueryLike.js

@@ -17,7 +17,7 @@ class QueryLike extends Query {
     }
 
     orderBys(...orderBys) {
-        this.query().orderBy(...orderBys);
+        this.query().orderBys(...orderBys);
         return this;
     }
 
@@ -52,6 +52,11 @@ class QueryLike extends Query {
         return this;
     }
 
+    clearOrderBys() {
+        this.query().clearOrderBys();
+        return this;
+    }
+
     clearOffset() {
         this.query().clearOffset();
         return this;
@@ -78,6 +83,7 @@ class QueryLike extends Query {
     }
 
     toQuery() {
+
     }
 
 }

package/query/SkipIfInfo.js

@@ -1,42 +1,35 @@
-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;
+
+    #skipIfNull;
+    #skipIfEmptyList;
+    #skipIfEmptyString;
+    #skipIfBlankString;
 
     constructor(skipIfNull, skipIfEmptyList, skipIfEmptyString, skipIfBlankString) {
-        this.skipIfNull = skipIfNull;
-        this.skipIfEmptyList = skipIfEmptyList;
-        this.skipIfEmptyString = skipIfEmptyString;
-        this.skipIfBlankString = skipIfBlankString;
+        this.#skipIfNull = skipIfNull;
+        this.#skipIfEmptyList = skipIfEmptyList;
+        this.#skipIfEmptyString = skipIfEmptyString;
+        this.#skipIfBlankString = skipIfBlankString;
     }
 
-}
+    skipIfNull() {
+        return this.#skipIfNull;
+    }
 
-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;
-        }
+    skipIfEmptyList() {
+        return this.#skipIfEmptyList;
     }
 
-    return new SkipIfInfo(skipIfNull, skipIfEmptyList, skipIfEmptyString, skipIfBlankString);
+    skipIfEmptyString() {
+        return this.#skipIfEmptyString;
+    }
+
+    skipIfBlankString() {
+        return this.#skipIfBlankString;
+    }
 
 }
 
 export {
     SkipIfInfo,
-    ofSkipIfInfo,
 };

package/query/WhereClause.js

@@ -6,16 +6,12 @@ class WhereClause extends QueryLike {
     #expression;
     #params;
 
-    constructor(expression, params) {
+    constructor(expression, ...params) {
         super();
         this.#expression = expression;
         this.#params = params;
     }
 
-    isEmpty() {
-        return (this.#expression == null || this.#expression.isEmpty()) && (this.#params == null || this.#params.length === 0);
-    }
-
     expression() {
         return this.#expression;
     }

package/x/FieldPolicyNodeConverter.js

@@ -0,0 +1,73 @@
+/// FieldPolicyNodeConverter
+///
+/// - FieldPolicy -> Node 采用严格编码.
+
+// ************************* FieldPolicy *************************
+
+/// fieldPolicy 不允许 null.
+function fieldPolicyToNode(fieldPolicy) {
+    if (fieldPolicy == null) {
+        throw new Error("fieldPolicy cannot be null");
+    }
+
+    return {
+        "@type": "FieldPolicy",
+        "filterMode": filterModeToNode(fieldPolicy.getFilterMode()),
+        "fieldNames": fieldPolicy.getFieldNames(),
+        "virtualFields": virtualFieldsToNode(fieldPolicy.getVirtualFields()),
+        "assignFields": assignFieldsToNode(fieldPolicy.getAssignFields()),
+        "ignoreNull": fieldPolicy.getIgnoreNull(),
+        "ignoreNulls": fieldPolicy.getIgnoreNulls(),
+    };
+}
+
+// ************************* FilterMode *************************
+
+/// filterMode 永不可能为 null.
+function filterModeToNode(filterMode) {
+    return filterMode.value();
+}
+
+// ************************* VirtualField *************************
+
+/// virtualFields 永不可能为 null.
+function virtualFieldsToNode(virtualFields) {
+    let node = [];
+    for (let virtualField of virtualFields) {
+        node.push(virtualFieldToNode(virtualField));
+    }
+    return node;
+}
+
+/// virtualField 永不可能为 null.
+function virtualFieldToNode(virtualField) {
+    return {
+        "@type": "VirtualField",
+        "virtualFieldName": virtualField.virtualFieldName(),
+        "expression": virtualField.expression(),
+    };
+}
+
+// ************************* AssignField *************************
+
+/// assignFields 永不可能为 null.
+function assignFieldsToNode(assignFields) {
+    let node = [];
+    for (let assignField of assignFields) {
+        node.push(assignFieldToNode(assignField));
+    }
+    return node;
+}
+
+/// assignField 永不可能为 null.
+function assignFieldToNode(assignField) {
+    return {
+        "@type": "AssignField",
+        "fieldName": assignField.fieldName(),
+        "expression": assignField.expression(),
+    };
+}
+
+export {
+    fieldPolicyToNode,
+};

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