@scx-js/scx-data 0.2.3 → 0.3.0

package/query/Junction.js

@@ -15,10 +15,11 @@ import {
     NOT_LIKE,
     NOT_LIKE_REGEX,
 } from "./ConditionType.js";
+import {QueryImpl} from "./QueryImpl.js";
+import {Not} from "./Not.js";
+import {WhereClause} from "./WhereClause.js";
+import {toSkipIfInfo, toUseExpression, toUseExpressionValue} from "./BuildControl.js";
 import {Condition} from "./Condition.js";
-// import {QueryImpl} from "./QueryImpl.js";
-// import {Not} from "./Not.js";
-// import {WhereClause} from "./WhereClause.js";
 
 class Junction extends QueryLike {
 
@@ -33,16 +34,15 @@ class Junction extends QueryLike {
         return this.#clauses;
     }
 
-    add(...logicCauses) {
-        for (let logicCause of logicCauses) {
-            if (logicCause == null) {
-                continue;
-            }
-            if (Array.isArray(logicCause)) {
-                this.add(...logicCause);
-                continue;
+    /// null 项会被忽略.
+    add(...clauses) {
+        if (clauses == null) {
+            throw new Error("clauses cannot be null");
+        }
+        for (let clause of clauses) {
+            if (clause != null) {
+                this.#clauses.push(clause);
             }
-            this.#clauses.push(logicCause);
         }
         return this;
     }
@@ -52,90 +52,98 @@ class Junction extends QueryLike {
         return this;
     }
 
+    and(...clauses) {
+        // 因为 js 不允许 循环依赖 所以 这个方法迁移到子类实现
+    }
+
+    or(...clauses) {
+        // 因为 js 不允许 循环依赖 所以 这个方法迁移到子类实现
+    }
+
+    not(clause) {
+        return this.add(new Not(clause));
+    }
+
+    whereClause(expression, ...params) {
+        return this.add(new WhereClause(expression, ...params));
+    }
+
     eq(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, EQ, value, null, ...options));
+        return this.add(condition(fieldName, EQ, value, ...options));
     }
 
     ne(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, NE, value, null, ...options));
+        return this.add(condition(fieldName, NE, value, ...options));
     }
 
     lt(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, LT, value, null, ...options));
+        return this.add(condition(fieldName, LT, value, ...options));
     }
 
     lte(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, LTE, value, null, ...options));
+        return this.add(condition(fieldName, LTE, value, ...options));
     }
 
     gt(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, GT, value, null, ...options));
+        return this.add(condition(fieldName, GT, value, ...options));
     }
 
     gte(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, GTE, value, null, ...options));
+        return this.add(condition(fieldName, GTE, value, ...options));
     }
 
     like(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, LIKE, value, null, ...options));
+        return this.add(condition(fieldName, LIKE, value, ...options));
     }
 
     notLike(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, NOT_LIKE, value, null, ...options));
+        return this.add(condition(fieldName, NOT_LIKE, value, ...options));
     }
 
     likeRegex(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, LIKE_REGEX, value, null, ...options));
+        return this.add(condition(fieldName, LIKE_REGEX, value, ...options));
     }
 
     notLikeRegex(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, NOT_LIKE_REGEX, value, null, ...options));
+        return this.add(condition(fieldName, NOT_LIKE_REGEX, value, ...options));
     }
 
     in(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, IN, value, null, ...options));
+        return this.add(condition(fieldName, IN, value, ...options));
     }
 
     notIn(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, NOT_IN, value, null, ...options));
+        return this.add(condition(fieldName, NOT_IN, value, ...options));
     }
 
     between(fieldName, value1, value2, ...options) {
-        return this.add(new Condition(fieldName, BETWEEN, value1, value2, ...options));
+        return this.add(condition2(fieldName, BETWEEN, value1, value2, ...options));
     }
 
     notBetween(fieldName, value1, value2, ...options) {
-        return this.add(new Condition(fieldName, NOT_BETWEEN, value1, value2, ...options));
+        return this.add(condition2(fieldName, NOT_BETWEEN, value1, value2, ...options));
     }
 
-    jsonContains(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, JSON_CONTAINS, value, null, ...options));
-    }
-
-    jsonOverlaps(fieldName, value, ...options) {
-        return this.add(new Condition(fieldName, JSON_OVERLAPS, value, null, ...options));
-    }
-
-    and(...clauses) {
-        // 因为 js 不允许 循环依赖 所以 这个方法迁移到子类实现
-    }
-
-    or(...clauses) {
-        // 因为 js 不允许 循环依赖 所以 这个方法迁移到子类实现
+    toQuery() {
+        return new QueryImpl().where(this);
     }
 
-    not(clause) {
-        return this.add(new Not(clause));
-    }
+}
 
-    whereClause(expression, ...params) {
-        return this.add(new WhereClause(expression, params));
-    }
+// 防止循环依赖 QueryBuilder 这里拷贝一份
 
-    toQuery() {
-        return new QueryImpl().where(this);
-    }
+function condition(fieldName, conditionType, value, ...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 = toUseExpression(...controls);
+    let useExpressionValue = toUseExpressionValue(...controls);
+    let skipIfInfo = toSkipIfInfo(...controls);
+    return new Condition(fieldName, conditionType, value1, value2, useExpression, useExpressionValue, skipIfInfo);
 }
 
 export {

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