@scx-js/scx-data 0.2.2 → 0.2.4

package/index.js

@@ -1,4 +1,3 @@
-export * from "./field_policy/serializer/FieldPolicySerializer.js";
 export * from "./field_policy/AssignField.js";
 export * from "./field_policy/FieldPolicy.js";
 export * from "./field_policy/FieldPolicyBuilder.js";
@@ -6,7 +5,6 @@ export * from "./field_policy/FieldPolicyImpl.js";
 export * from "./field_policy/FieldPolicyLike.js";
 export * from "./field_policy/FilterMode.js";
 export * from "./field_policy/VirtualField.js";
-export * from "./query/serializer/QuerySerializer.js";
 export * from "./query/Junction.js";
 export * from "./query/And.js";
 export * from "./query/Or.js";
@@ -21,3 +19,5 @@ export * from "./query/BuildControl.js";
 export * from "./query/Condition.js";
 export * from "./query/WhereClause.js";
 export * from "./query/ConditionType.js";
+export * from "./serialization/QuerySerializer.js";
+export * from "./serialization/FieldPolicySerializer.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scx-js/scx-data",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "SCX Data",
   "license": "MIT",
   "author": "scx567888",
@@ -11,6 +11,6 @@
     "url": "https://github.com/scx567888/scx-js.git"
   },
   "dependencies": {
-    "@scx-js/scx-common": "0.2.2"
+    "@scx-js/scx-common": "0.2.4"
   }
 }

package/query/BuildControl.js

@@ -40,6 +40,8 @@ export {
     SKIP_IF_EMPTY_LIST,
     SKIP_IF_BLANK_STRING,
     SKIP_IF_EMPTY_STRING,
+    USE_EXPRESSION,
+    USE_EXPRESSION_VALUE,
     checkUseExpression,
     checkUseExpressionValue,
 };

package/query/Condition.js

@@ -60,7 +60,7 @@ class Condition extends QueryLike {
     }
 
     isEmpty() {
-    
+
     }
 
     toQuery() {

package/query/Junction.js

@@ -16,9 +16,11 @@ import {
     NOT_LIKE_REGEX,
 } from "./ConditionType.js";
 import {Condition} from "./Condition.js";
-// import {QueryImpl} from "./QueryImpl.js";
-// import {Not} from "./Not.js";
-// import {WhereClause} from "./WhereClause.js";
+import {QueryImpl} from "./QueryImpl.js";
+import {Not} from "./Not.js";
+import {WhereClause} from "./WhereClause.js";
+import {checkUseExpression, checkUseExpressionValue} from "./BuildControl.js";
+import {ofSkipIfInfo} from "./SkipIfInfo.js";
 
 class Junction extends QueryLike {
 
@@ -34,16 +36,7 @@ class Junction extends QueryLike {
     }
 
     add(...logicCauses) {
-        for (let logicCause of logicCauses) {
-            if (logicCause == null) {
-                continue;
-            }
-            if (Array.isArray(logicCause)) {
-                this.add(...logicCause);
-                continue;
-            }
-            this.#clauses.push(logicCause);
-        }
+        this.#clauses.push(...logicCauses);
         return this;
     }
 
@@ -53,67 +46,59 @@ class Junction extends QueryLike {
     }
 
     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));
-    }
-
-    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));
+        return this.add(condition2(fieldName, NOT_BETWEEN, value1, value2, ...options));
     }
 
     and(...clauses) {
@@ -138,6 +123,21 @@ class Junction extends QueryLike {
 
 }
 
+
+function condition(fieldName, conditionType, value, ...controls) {
+    let useExpression = checkUseExpression(...controls);
+    let useExpressionValue = checkUseExpressionValue(...controls);
+    let skipIfInfo = ofSkipIfInfo(...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);
+    return new Condition(fieldName, conditionType, value1, value2, useExpression, useExpressionValue, skipIfInfo);
+}
+
 export {
     Junction,
 };

package/query/QueryBuilder.js

@@ -72,12 +72,12 @@ function condition2(fieldName, conditionType, value1, value2, ...controls) {
 }
 
 function orderBy(selector, orderByType, ...controls) {
-    let useExpression = checkUseExpression(controls);
+    let useExpression = checkUseExpression(...controls);
     return new OrderBy(selector, orderByType, useExpression);
 }
 
 function whereClause(expression, ...params) {
-    return new WhereClause(expression, params);
+    return new WhereClause(expression, ...params);
 }
 
 function asc(name, ...options) {

package/query/QueryImpl.js

@@ -28,7 +28,7 @@ class QueryImpl extends Query {
 
 
     orderBys(...orderBys) {
-        this.#orderBys = orderBys;
+        this.#orderBys = [...orderBys];
         return this;
     }
 
@@ -86,22 +86,22 @@ class QueryImpl extends Query {
     }
 
     orderBy(...orderBys) {
-        this.#orderBys.push(orderBys);
+        this.#orderBys.push(...orderBys);
         return this;
     }
 
 
     asc(selector, ...controls) {
-        let useExpression = checkUseExpression(controls);
-        let o= new OrderBy(selector, ASC, useExpression);
+        let useExpression = checkUseExpression(...controls);
+        let o = new OrderBy(selector, ASC, useExpression);
         this.orderBy(o);
         return this;
     }
 
 
     desc(selector, ...controls) {
-        let useExpression = checkUseExpression(controls);
-        let o= new OrderBy(selector, DESC, useExpression);
+        let useExpression = checkUseExpression(...controls);
+        let o = new OrderBy(selector, DESC, useExpression);
         this.orderBy(o);
         return this;
     }

package/query/QueryLike.js

@@ -16,8 +16,8 @@ class QueryLike extends Query {
         return this;
     }
 
-    orderBys(...orderByClauses) {
-        this.query().orderBy(...orderByClauses);
+    orderBys(...orderBys) {
+        this.query().orderBy(...orderBys);
         return this;
     }
 
@@ -35,12 +35,8 @@ class QueryLike extends Query {
         return this.query().getWhere();
     }
 
-    getGroupBy() {
-        return this.query().getGroupBy();
-    }
-
-    getOrderBy() {
-        return this.query().getOrderBy();
+    getOrderBys() {
+        return this.query().getOrderBys();
     }
 
     getOffset() {
@@ -56,16 +52,6 @@ class QueryLike extends Query {
         return this;
     }
 
-    clearGroupBy() {
-        this.query().clearGroupBy();
-        return this;
-    }
-
-    clearOrderBy() {
-        this.query().clearOrderBy();
-        return this;
-    }
-
     clearOffset() {
         this.query().clearOffset();
         return this;
@@ -77,17 +63,17 @@ class QueryLike extends Query {
     }
 
     orderBy(...orderByClauses) {
-        this.query().orderBy(orderByClauses);
+        this.query().orderBy(...orderByClauses);
         return this;
     }
 
     asc(selector, ...controls) {
-        this.query().asc(selector,...controls);
+        this.query().asc(selector, ...controls);
         return this;
     }
 
     desc(selector, ...controls) {
-        this.query().desc(selector,...controls);
+        this.query().desc(selector, ...controls);
         return this;
     }
 

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,55 +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.getFilterMode(),
-            "fieldNames": fieldPolicy.getFieldNames(),
-            "virtualFields": this.serializeVirtualFields(fieldPolicy.getVirtualFields()),
-            "ignoreNull": fieldPolicy.getIgnoreNull(),
-            "ignoreNulls": fieldPolicy.getIgnoreNulls(),
-            "assignFields": this.serializeAssignFields(fieldPolicy.getAssignFields()),
-        };
-    }
-
-    serializeVirtualFields(v) {
-        return v.map(s => this.serializeVirtualField(s));
-    }
-
-    serializeVirtualField(v) {
-        return {
-            "@type": "VirtualField",
-            "expression": v.expression(),
-            "virtualFieldName": v.virtualFieldName(),
-        };
-    }
-
-    serializeAssignFields(v) {
-        return v.map(s => this.serializeAssignField(s));
-    }
-
-    serializeAssignField(v) {
-        return {
-            "@type": "AssignField",
-            "fieldName": v.fieldName(),
-            "expression": v.expression(),
-        };
-    }
-
-}
-
-const FIELD_POLICY_SERIALIZER = new FieldPolicySerializer();
-
-export {
-    FIELD_POLICY_SERIALIZER,
-    FieldPolicySerializer,
-};

package/query/serializer/QuerySerializer.js

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