@scx-js/scx-data 0.2.2 → 0.2.3

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.3",
   "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.3"
   }
 }

package/query/Condition.js

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

package/query/QueryImpl.js

@@ -28,7 +28,7 @@ class QueryImpl extends Query {
 
 
     orderBys(...orderBys) {
-        this.#orderBys = orderBys;
+        this.#orderBys = [...orderBys];
         return this;
     }
 
@@ -86,14 +86,14 @@ 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 o = new OrderBy(selector, ASC, useExpression);
         this.orderBy(o);
         return this;
     }
@@ -101,7 +101,7 @@ class QueryImpl extends Query {
 
     desc(selector, ...controls) {
         let useExpression = checkUseExpression(controls);
-        let o= new OrderBy(selector, DESC, useExpression);
+        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,
-};