@scx-js/scx-data 0.2.0 → 0.2.2

package/field_policy/AssignField.js

@@ -0,0 +1,39 @@
+import {FieldPolicyLike} from "./FieldPolicyLike.js";
+import {FieldPolicyImpl} from "./FieldPolicyImpl.js";
+import {EXCLUDED} from "./FilterMode.js";
+
+class AssignField extends FieldPolicyLike {
+
+    #fieldName;
+    #expression;
+
+    constructor(fieldName, expression) {
+        super();
+        if (fieldName == null) {
+            throw new Error("fieldName is null");
+        }
+        if (expression == null) {
+            throw new Error("expression is null");
+        }
+        this.#fieldName = fieldName;
+        this.#expression = expression;
+    }
+
+    fieldName() {
+        return this.#fieldName;
+    }
+
+    expression() {
+        return this.#expression;
+    }
+
+    toFieldPolicy() {
+        //排除 0个 就是包含所有
+        return new FieldPolicyImpl(EXCLUDED).assignFields(this);
+    }
+
+}
+
+export {
+    AssignField,
+};

package/field_policy/FieldPolicy.js

@@ -8,44 +8,66 @@ class FieldPolicy {
         return this;
     }
 
-    filterMode() {
+    getFilterMode() {
     }
 
-    fieldNames() {
+    getFieldNames() {
     }
 
     clearFieldNames() {
+        return this;
     }
 
-    ignoreNull(ignoreNullValue) {
+    virtualFields(...virtualFields) {
         return this;
     }
 
-    ignoreNull_() {
+    getVirtualFields() {
     }
 
-    ignoreNull__(fieldName, ignoreNullValue) {
+    clearVirtualFields() {
+        return this;
     }
 
-    removeIgnoreNull(fieldName) {
+    virtualField(virtualFieldName, expression) {
+        return this;
     }
 
-    ignoreNulls() {
+    ignoreNull(ignoreNull) {
+        return this;
     }
 
-    clearIgnoreNulls() {
+    ignoreNull_(fieldName, ignoreNull) {
+        return this;
+    }
+
+    assignFields(...assignFields) {
+        return this;
+    }
+
+    getIgnoreNull() {
+    }
+
+    getIgnoreNulls() {
     }
 
-    expression(fieldName, expression) {
+    getAssignFields() {
     }
 
-    expressions() {
+    clearIgnoreNulls() {
+        return this;
     }
 
-    removeExpression(fieldName) {
+    clearAssignFields() {
+        return this;
     }
 
-    clearExpressions() {
+    removeIgnoreNull(fieldName) {
+        return this;
+    }
+
+    assignField(fieldName, expression) {
+        return this;
     }
 
 }

package/field_policy/FieldPolicyBuilder.js

@@ -1,5 +1,7 @@
 import {FieldPolicyImpl} from "./FieldPolicyImpl.js";
 import {EXCLUDED, INCLUDED} from "./FilterMode.js";
+import {AssignField} from "./AssignField.js";
+import {VirtualField} from "./VirtualField.js";
 
 function includeAll() {
     return new FieldPolicyImpl(EXCLUDED);
@@ -9,34 +11,31 @@ function excludeAll() {
     return new FieldPolicyImpl(INCLUDED);
 }
 
-/**
- *
- * @param fieldNames
- * @return {FieldPolicy}
- */
 function include(...fieldNames) {
     return excludeAll().include(...fieldNames);
 }
 
-/**
- *
- * @param fieldNames
- * @return {FieldPolicy}
- */
 function exclude(...fieldNames) {
     return includeAll().exclude(...fieldNames);
 }
 
+/// 默认包含所有
 function ignoreNull(ignoreNull) {
     return includeAll().ignoreNull(ignoreNull);
 }
 
-function ignoreNull__(fieldName, ignoreNull) {
-    return includeAll().ignoreNull__(fieldName, ignoreNull);
+/// 默认包含所有
+function ignoreNull_(fieldName, ignoreNull) {
+    return includeAll().ignoreNull_(fieldName, ignoreNull);
 }
 
-function expression(fieldName, expression) {
-    return includeAll().expression(fieldName, expression);
+/// 默认包含所有
+function assignField(fieldName, expression) {
+    return new AssignField(fieldName, expression);
+}
+
+function virtualField(virtualFieldName, expression) {
+    return new VirtualField(virtualFieldName, expression);
 }
 
 export {
@@ -45,6 +44,7 @@ export {
     include,
     exclude,
     ignoreNull,
-    ignoreNull__,
-    expression,
+    ignoreNull_,
+    assignField,
+    virtualField,
 };

package/field_policy/FieldPolicyImpl.js

@@ -1,46 +1,48 @@
 import {EXCLUDED, INCLUDED} from "./FilterMode.js";
 import {FieldPolicy} from "./FieldPolicy.js";
+import {AssignField} from "./AssignField.js";
+import {VirtualField} from "./VirtualField.js";
 
 class FieldPolicyImpl extends FieldPolicy {
 
     #filterMode;
     #fieldNames;
-    #expressions;
     #ignoreNulls;
+    #virtualFields;
+    #assignFields;
     #ignoreNull;
 
     constructor(filterMode) {
         super();
         this.#filterMode = filterMode;
         this.#fieldNames = new Set();
-        this.#expressions = new Map();
+        this.#virtualFields = [];
+        this.#assignFields = [];
         this.#ignoreNulls = new Map();
         this.#ignoreNull = true;
     }
 
     include(...fieldNames) {
         if (this.#filterMode === INCLUDED) {
-            this.addFieldNames(...fieldNames);
+            return this.addFieldNames(...fieldNames);
         } else if (this.#filterMode === EXCLUDED) {
-            this.removeFieldNames(...fieldNames);
+            return this.removeFieldNames(...fieldNames);
         }
-        return this;
     }
 
     exclude(...fieldNames) {
-        if (this.#filterMode === EXCLUDED) {
-            this.addFieldNames(...fieldNames);
-        } else if (this.#filterMode === INCLUDED) {
-            this.removeFieldNames(...fieldNames);
+        if (this.#filterMode === INCLUDED) {
+            return this.removeFieldNames(...fieldNames);
+        } else if (this.#filterMode === EXCLUDED) {
+            return this.addFieldNames(...fieldNames);
         }
-        return this;
     }
 
-    filterMode() {
+    getFilterMode() {
         return this.#filterMode;
     }
 
-    fieldNames() {
+    getFieldNames() {
         return Array.from(this.#fieldNames);
     }
 
@@ -49,64 +51,83 @@ class FieldPolicyImpl extends FieldPolicy {
         return this;
     }
 
-    ignoreNull(ignoreNullValue) {
-        this.#ignoreNull = ignoreNullValue;
+    addFieldNames(...fieldNames) {
+        for (const name of fieldNames) {
+            this.#fieldNames.add(name);
+        }
         return this;
     }
 
-    ignoreNull_() {
-        return this.#ignoreNull;
+    removeFieldNames(...fieldNames) {
+        for (const name of fieldNames) {
+            this.#fieldNames.delete(name);
+        }
+        return this;
     }
 
-    ignoreNull__(fieldName, ignoreNull) {
-        this.#ignoreNulls.set(fieldName, ignoreNull);
+    virtualFields(...virtualFields) {
+        this.#virtualFields = [...virtualFields];
         return this;
     }
 
-    removeIgnoreNull(fieldName) {
-        this.#ignoreNulls.delete(fieldName);
+    getVirtualFields() {
+        return this.#virtualFields;
+    }
+
+    clearVirtualFields() {
+        this.#virtualFields = [];
         return this;
     }
 
-    ignoreNulls() {
-        return this.#ignoreNulls;
+    virtualField(name, expression) {
+        this.#virtualFields.push(new VirtualField(name, expression));
+        return this;
     }
 
-    clearIgnoreNulls() {
-        this.#ignoreNulls.clear();
+    ignoreNull(ignoreNull) {
+        this.#ignoreNull = ignoreNull;
         return this;
     }
 
-    expression(fieldName, expression) {
-        this.#expressions.set(fieldName, expression);
+    ignoreNull_(fieldName, ignoreNull) {
+        this.#ignoreNulls.set(fieldName, ignoreNull);
         return this;
     }
 
-    expressions() {
-        return this.#expressions;
+    assignFields(...assignFields) {
+        this.#assignFields = [...assignFields];
+        return this;
+    }
+
+    getIgnoreNull() {
+        return this.#ignoreNull;
+    }
+
+    getIgnoreNulls() {
+        return Object.fromEntries(this.#ignoreNulls);
+    }
+
+    getAssignFields() {
+        return this.#assignFields;
     }
 
-    removeExpression(fieldName) {
-        this.#expressions.delete(fieldName);
+    clearIgnoreNulls() {
+        this.#ignoreNulls.clear();
         return this;
     }
 
-    clearExpressions() {
-        this.#expressions.clear();
+    clearAssignFields() {
+        this.#assignFields = [];
         return this;
     }
 
-    addFieldNames(...fieldNames) {
-        for (let fieldName of fieldNames) {
-            this.#fieldNames.add(fieldName);
-        }
+    removeIgnoreNull(fieldName) {
+        this.#ignoreNulls.delete(fieldName);
         return this;
     }
 
-    removeFieldNames(...fieldNames) {
-        for (let fieldName of fieldNames) {
-            this.#fieldNames.delete(fieldName);
-        }
+    assignField(fieldName, expression) {
+        this.#assignFields.push(new AssignField(fieldName, expression));
         return this;
     }
 

package/field_policy/FieldPolicyLike.js

@@ -0,0 +1,111 @@
+import {FieldPolicy} from "./FieldPolicy.js";
+
+class FieldPolicyLike extends FieldPolicy {
+
+    #fieldPolicy;
+
+    fieldPolicy() {
+        if (this.#fieldPolicy == null) {
+            this.#fieldPolicy = this.toFieldPolicy();
+        }
+        return this.#fieldPolicy;
+    }
+
+    include(...fieldNames) {
+        this.fieldPolicy().include(...fieldNames);
+        return this;
+    }
+
+    exclude(...fieldNames) {
+        this.fieldPolicy().exclude(...fieldNames);
+        return this;
+    }
+
+    getFilterMode() {
+        return this.fieldPolicy().getFilterMode();
+    }
+
+    getFieldNames() {
+        return this.fieldPolicy().getFieldNames();
+    }
+
+    clearFieldNames() {
+        this.fieldPolicy().clearFieldNames();
+        return this;
+    }
+
+    virtualFields(...virtualFields) {
+        this.fieldPolicy().virtualFields(...virtualFields);
+        return this;
+    }
+
+    getVirtualFields() {
+        return this.fieldPolicy().getVirtualFields();
+    }
+
+    clearVirtualFields() {
+        this.fieldPolicy().clearVirtualFields();
+        return this;
+    }
+
+    virtualField(virtualFieldName, expression) {
+        this.fieldPolicy().virtualField(virtualFieldName, expression);
+        return this;
+    }
+
+    ignoreNull(ignoreNull) {
+        this.fieldPolicy().ignoreNull(ignoreNull);
+        return this;
+    }
+
+    ignoreNull_(fieldName, ignoreNull) {
+        this.fieldPolicy().ignoreNull_(fieldName, ignoreNull);
+        return this;
+    }
+
+    assignFields(...assignFields) {
+        this.fieldPolicy().assignFields(...assignFields);
+        return this;
+    }
+
+    getIgnoreNull() {
+        return this.fieldPolicy().getIgnoreNull();
+    }
+
+    getIgnoreNulls() {
+        return this.fieldPolicy().getIgnoreNulls();
+    }
+
+    getAssignFields() {
+        return this.fieldPolicy().getAssignFields();
+    }
+
+    clearIgnoreNulls() {
+        this.fieldPolicy().clearIgnoreNulls();
+        return this;
+    }
+
+    clearAssignFields() {
+        this.fieldPolicy().clearAssignFields();
+        return this;
+    }
+
+    removeIgnoreNull(fieldName) {
+        this.fieldPolicy().removeIgnoreNull(fieldName);
+        return this;
+    }
+
+    assignField(fieldName, expression) {
+        this.fieldPolicy().assignField(fieldName, expression);
+        return this;
+    }
+
+    toFieldPolicy() {
+
+    }
+
+}
+
+export {
+    FieldPolicyLike,
+};

package/field_policy/VirtualField.js

@@ -0,0 +1,39 @@
+import {FieldPolicyLike} from "./FieldPolicyLike.js";
+import {FieldPolicyImpl} from "./FieldPolicyImpl.js";
+import {EXCLUDED} from "./FilterMode.js";
+
+class VirtualField extends FieldPolicyLike {
+
+    #virtualFieldName;
+    #expression;
+
+    constructor(virtualFieldName, expression) {
+        super();
+        if (virtualFieldName == null) {
+            throw new Error("virtualFieldName is null");
+        }
+        if (expression == null) {
+            throw new Error("expression is null");
+        }
+        this.#virtualFieldName = virtualFieldName;
+        this.#expression = expression;
+    }
+
+    virtualFieldName() {
+        return this.#virtualFieldName;
+    }
+
+    expression() {
+        return this.#expression;
+    }
+
+    toFieldPolicy() {
+        //排除 0个 就是包含所有
+        return new FieldPolicyImpl(EXCLUDED).virtualFields(this);
+    }
+
+}
+
+export {
+    VirtualField,
+};

package/field_policy/serializer/FieldPolicySerializer.js

@@ -12,11 +12,36 @@ class FieldPolicySerializer {
     serializeFieldPolicy(fieldPolicy) {
         return {
             "@type": "FieldPolicy",
-            "filterMode": fieldPolicy.filterMode(),
-            "fieldNames": fieldPolicy.fieldNames(),
-            "ignoreNull": fieldPolicy.ignoreNull_(),
-            "ignoreNulls": fieldPolicy.ignoreNulls(),
-            "expressions": fieldPolicy.expressions(),
+            "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(),
         };
     }
 

package/index.js

@@ -1,13 +1,12 @@
 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";
 export * from "./field_policy/FieldPolicyImpl.js";
+export * from "./field_policy/FieldPolicyLike.js";
 export * from "./field_policy/FilterMode.js";
-export * from "./query/serializer/GroupBySerializer.js";
-export * from "./query/serializer/OrderBySerializer.js";
+export * from "./field_policy/VirtualField.js";
 export * from "./query/serializer/QuerySerializer.js";
-export * from "./query/serializer/WhereSerializer.js";
-export * from "./query/GroupBy.js";
 export * from "./query/Junction.js";
 export * from "./query/And.js";
 export * from "./query/Or.js";
@@ -18,7 +17,7 @@ export * from "./query/Query.js";
 export * from "./query/QueryBuilder.js";
 export * from "./query/QueryImpl.js";
 export * from "./query/QueryLike.js";
-export * from "./query/QueryOption.js";
-export * from "./query/Where.js";
+export * from "./query/BuildControl.js";
+export * from "./query/Condition.js";
 export * from "./query/WhereClause.js";
-export * from "./query/WhereType.js";
+export * from "./query/ConditionType.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scx-js/scx-data",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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.0"
+    "@scx-js/scx-common": "0.2.2"
   }
 }

package/query/BuildControl.js

@@ -0,0 +1,45 @@
+class BuildControl {
+
+    #value;
+
+    constructor(value) {
+        this.#value = value;
+    }
+
+}
+
+const SKIP_IF_NULL = new BuildControl("SKIP_IF_NULL");
+const SKIP_IF_EMPTY_LIST = new BuildControl("SKIP_IF_EMPTY_LIST");
+const SKIP_IF_EMPTY_STRING = new BuildControl("SKIP_IF_EMPTY_STRING");
+const SKIP_IF_BLANK_STRING = new BuildControl("SKIP_IF_BLANK_STRING");
+const USE_EXPRESSION = new BuildControl("USE_EXPRESSION");
+const USE_EXPRESSION_VALUE = new BuildControl("USE_EXPRESSION_VALUE");
+
+
+function checkUseExpression(...controls) {
+    for (let control of controls) {
+        if (control === USE_EXPRESSION) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function checkUseExpressionValue(...controls) {
+    for (let control of controls) {
+        if (control === USE_EXPRESSION_VALUE) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export {
+    BuildControl,
+    SKIP_IF_NULL,
+    SKIP_IF_EMPTY_LIST,
+    SKIP_IF_BLANK_STRING,
+    SKIP_IF_EMPTY_STRING,
+    checkUseExpression,
+    checkUseExpressionValue,
+};