@scx-js/scx-data 0.0.1

package/field_filter/FieldFilter.js

@@ -0,0 +1,40 @@
+class FieldFilter {
+
+    addIncluded(...fieldNames) {
+        return this;
+    }
+
+    addExcluded(...fieldNames) {
+        return this;
+    }
+
+    removeIncluded(...fieldNames) {
+        return this;
+    }
+
+    removeExcluded(...fieldNames) {
+        return this;
+    }
+
+    ignoreNullValue(ignoreNullValue) {
+        return this;
+    }
+
+    getFilterMode() {
+    }
+
+    getFieldNames() {
+    }
+
+    getIgnoreNullValue() {
+    }
+
+    clear() {
+        return this;
+    }
+
+}
+
+export {
+    FieldFilter,
+};

package/field_filter/FieldFilterBuilder.js

@@ -0,0 +1,25 @@
+import {FieldFilterImpl} from "./FieldFilterImpl.js";
+import {EXCLUDED, INCLUDED} from "./FilterMode.js";
+
+/**
+ *
+ * @param fieldNames
+ * @return {FieldFilter}
+ */
+function ofIncluded(...fieldNames) {
+    return new FieldFilterImpl(INCLUDED).addIncluded(...fieldNames);
+}
+
+/**
+ *
+ * @param fieldNames
+ * @return {FieldFilter}
+ */
+function ofExcluded(...fieldNames) {
+    return new FieldFilterImpl(EXCLUDED).addExcluded(...fieldNames);
+}
+
+export {
+    ofIncluded,
+    ofExcluded,
+};

package/field_filter/FieldFilterImpl.js

@@ -0,0 +1,81 @@
+import {EXCLUDED, INCLUDED} from "./FilterMode.js";
+import {FieldFilter} from "./FieldFilter.js";
+
+class FieldFilterImpl extends FieldFilter {
+
+    #filterMode;
+    #fieldNames;
+    #ignoreNullValue;
+
+    constructor(filterMode) {
+        super();
+        this.#filterMode = filterMode;
+        this.#fieldNames = new Set();
+        this.#ignoreNullValue = true;
+    }
+
+    addIncluded(...fieldNames) {
+        if (this.#filterMode === INCLUDED) {
+            this.addFieldNames(...fieldNames);
+        } else if (this.#filterMode === EXCLUDED) {
+            this.removeFieldNames(...fieldNames);
+        }
+        return this;
+    }
+
+    addExcluded(...fieldNames) {
+        if (this.#filterMode === EXCLUDED) {
+            this.addFieldNames(...fieldNames);
+        } else if (this.#filterMode === INCLUDED) {
+            this.removeFieldNames(...fieldNames);
+        }
+        return this;
+    }
+
+    removeIncluded(...fieldNames) {
+        return this.addExcluded(...fieldNames);
+    }
+
+    removeExcluded(...fieldNames) {
+        return this.addIncluded(...fieldNames);
+    }
+
+    ignoreNullValue(ignoreNullValue) {
+        this.#ignoreNullValue = ignoreNullValue;
+        return this;
+    }
+
+    getFilterMode() {
+        return this.#filterMode;
+    }
+
+    getFieldNames() {
+        return Array.from(this.#fieldNames);
+    }
+
+    getIgnoreNullValue() {
+        return this.#ignoreNullValue;
+    }
+
+    clear() {
+        this.#fieldNames.clear();
+        return this;
+    }
+
+    addFieldNames(...fieldNames) {
+        for (let fieldName of fieldNames) {
+            this.#fieldNames.add(fieldName);
+        }
+        return this;
+    }
+
+    removeFieldNames(...fieldNames) {
+        for (let fieldName of fieldNames) {
+            this.#fieldNames.delete(fieldName);
+        }
+        return this;
+    }
+
+}
+
+export {FieldFilterImpl};

package/field_filter/FilterMode.js

@@ -0,0 +1,5 @@
+const INCLUDED = "INCLUDED";
+
+const EXCLUDED = "EXCLUDED";
+
+export {INCLUDED, EXCLUDED};

package/field_filter/serializer/FieldFilterSerializer.js

@@ -0,0 +1,28 @@
+import {FieldFilter} from "../FieldFilter.js";
+
+class FieldFilterSerializer {
+
+    serialize(obj) {
+        if (obj instanceof FieldFilter) {
+            return this.serializeFieldFilter(obj);
+        }
+        return obj;
+    }
+
+    serializeFieldFilter(fieldFilter) {
+        return {
+            "@type": "FieldFilter",
+            "filterMode": fieldFilter.getFilterMode(),
+            "fieldNames": fieldFilter.getFieldNames(),
+            "ignoreNullValue": fieldFilter.getIgnoreNullValue(),
+        };
+    }
+
+}
+
+const FIELD_FILTER_SERIALIZER = new FieldFilterSerializer();
+
+export {
+    FIELD_FILTER_SERIALIZER,
+    FieldFilterSerializer,
+};

package/index.js

@@ -0,0 +1,6 @@
+export * from "./field_filter/FieldFilterBuilder.js";
+export * from "./field_filter/FilterMode.js";
+export * from "./query/GroupBy.js";
+export * from "./query/OrderBy.js";
+export * from "./query/QueryBuilder.js";
+export * from "./query/QueryOption.js";

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@scx-js/scx-data",
+  "version": "0.0.1",
+  "description": "SCX Data",
+  "license": "MIT",
+  "author": "scx567888",
+  "main": "index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/scx567888/scx-js.git"
+  }
+}

package/query/GroupBy.js

@@ -0,0 +1,36 @@
+import {isBlank} from "../../scx-common/index.js";
+import {QueryImpl} from "./QueryImpl.js";
+import {QueryLike} from "./QueryLike.js";
+import {ofInfo} from "./QueryOption.js";
+
+class GroupBy extends QueryLike {
+
+    #name;
+    #info;
+
+    constructor(name, ...options) {
+        super();
+        if (isBlank(name)) {
+            throw new Error("GroupBy 参数错误 : 名称 不能为空 !!!");
+        }
+        this.#name = name;
+        this.#info = ofInfo(...options);
+    }
+
+    name() {
+        return this.#name;
+    }
+
+    info() {
+        return this.#info;
+    }
+
+    toQuery() {
+        return new QueryImpl().groupBy(this);
+    }
+
+}
+
+export {
+    GroupBy,
+};

package/query/Logic.js

@@ -0,0 +1,144 @@
+import {QueryLike} from "./QueryLike.js";
+import {
+    BETWEEN,
+    EQUAL,
+    GREATER_THAN,
+    GREATER_THAN_OR_EQUAL,
+    IN,
+    IS_NOT_NULL,
+    IS_NULL,
+    JSON_CONTAINS,
+    JSON_OVERLAPS,
+    LESS_THAN,
+    LESS_THAN_OR_EQUAL,
+    LIKE,
+    LIKE_REGEX,
+    NOT_BETWEEN,
+    NOT_EQUAL,
+    NOT_IN,
+    NOT_LIKE,
+    NOT_LIKE_REGEX,
+} from "./WhereType.js";
+import {Where} from "./Where.js";
+import {QueryImpl} from "./QueryImpl.js";
+
+class Logic extends QueryLike {
+
+    #logicType;
+    #clauses;
+
+    constructor(logicType) {
+        super();
+        this.#logicType = logicType;
+        this.#clauses = [];
+    }
+
+    logicType() {
+        return this.#logicType;
+    }
+
+    clauses() {
+        return this.#clauses;
+    }
+
+    add(...logicCauses) {
+        for (let logicCause of logicCauses) {
+            if (logicCause == null) {
+                continue;
+            }
+            if (Array.isArray(logicCause)) {
+                this.add(...logicCause);
+                continue;
+            }
+            this.#clauses.push(logicCause);
+        }
+        return this;
+    }
+
+    clear() {
+        this.#clauses = [];
+        return this;
+    }
+
+    eq(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, EQUAL, value, null, ...options));
+    }
+
+    ne(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, NOT_EQUAL, value, null, ...options));
+    }
+
+    lt(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, LESS_THAN, value, null, ...options));
+    }
+
+    le(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, LESS_THAN_OR_EQUAL, value, null, ...options));
+    }
+
+    gt(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, GREATER_THAN, value, null, ...options));
+    }
+
+    ge(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, GREATER_THAN_OR_EQUAL, value, null, ...options));
+    }
+
+
+    isNull(fieldName, ...options) {
+        return this.add(new Where(fieldName, IS_NULL, null, null, ...options));
+    }
+
+    isNotNull(fieldName, ...options) {
+        return this.add(new Where(fieldName, IS_NOT_NULL, null, null, ...options));
+    }
+
+    like(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, LIKE, value, null, ...options));
+    }
+
+    notLike(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, NOT_LIKE, value, null, ...options));
+    }
+
+    likeRegex(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, LIKE_REGEX, value, null, ...options));
+    }
+
+    notLikeRegex(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, NOT_LIKE_REGEX, value, null, ...options));
+    }
+
+    in(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, IN, value, null, ...options));
+    }
+
+    notIn(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, NOT_IN, value, null, ...options));
+    }
+
+    between(fieldName, value1, value2, ...options) {
+        return this.add(new Where(fieldName, BETWEEN, value1, value2, ...options));
+    }
+
+    notBetween(fieldName, value1, value2, ...options) {
+        return this.add(new Where(fieldName, NOT_BETWEEN, value1, value2, ...options));
+    }
+
+    jsonContains(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, JSON_CONTAINS, value, null, ...options));
+    }
+
+    jsonOverlaps(fieldName, value, ...options) {
+        return this.add(new Where(fieldName, JSON_OVERLAPS, value, null, ...options));
+    }
+
+    toQuery() {
+        return new QueryImpl().where(this);
+    }
+
+}
+
+export {
+    Logic,
+};

package/query/LogicType.js

@@ -0,0 +1,7 @@
+const OR = "OR";
+const AND = "AND";
+
+export {
+    OR,
+    AND,
+};

package/query/OrderBy.js

@@ -0,0 +1,42 @@
+import {isBlank} from "../../scx-common/index.js";
+import {QueryImpl} from "./QueryImpl.js";
+import {ofInfo} from "./QueryOption.js";
+
+class OrderBy {
+
+    #name;
+    #orderByType;
+    #info;
+
+    constructor(name, orderByType, ...options) {
+        if (isBlank(name)) {
+            throw new Error("OrderBy 参数错误 : 名称 不能为空 !!!");
+        }
+        if (orderByType == null) {
+            throw new Error("OrderBy 参数错误 : orderByType 不能为空 !!!");
+        }
+        this.#name = name;
+        this.#orderByType = orderByType;
+        this.#info = ofInfo(...options);
+    }
+
+
+    name() {
+        return this.#name;
+    }
+
+    orderByType() {
+        return this.#orderByType;
+    }
+
+    info() {
+        return this.#info;
+    }
+
+    toQuery() {
+        return new QueryImpl().orderBy(this);
+    }
+
+}
+
+export {OrderBy};

package/query/OrderByType.js

@@ -0,0 +1,8 @@
+const ASC = "ASC";
+
+const DESC = "DESC";
+
+export {
+    ASC,
+    DESC,
+};

package/query/Query.js

@@ -0,0 +1,60 @@
+class Query {
+
+    where(...whereClauses) {
+        return this;
+    }
+
+    groupBy(...groupByClauses) {
+        return this;
+    }
+
+    orderBy(...orderByClauses) {
+        return this;
+    }
+
+    offset(limitOffset) {
+        return this;
+    }
+
+    limit(numberOfRows) {
+        return this;
+    }
+
+    getWhere() {
+    }
+
+    getGroupBy() {
+    }
+
+    getOrderBy() {
+    }
+
+    getOffset() {
+    }
+
+    getLimit() {
+    }
+
+    clearWhere() {
+        return this;
+    }
+
+    clearGroupBy() {
+        return this;
+    }
+
+    clearOrderBy() {
+        return this;
+    }
+
+    clearOffset() {
+        return this;
+    }
+
+    clearLimit() {
+        return this;
+    }
+
+}
+
+export {Query};

package/query/QueryBuilder.js

@@ -0,0 +1,176 @@
+import {WhereClause} from "./WhereClause.js";
+import {
+    BETWEEN,
+    EQUAL,
+    GREATER_THAN,
+    GREATER_THAN_OR_EQUAL,
+    IN,
+    IS_NOT_NULL,
+    IS_NULL,
+    JSON_CONTAINS,
+    JSON_OVERLAPS,
+    LESS_THAN,
+    LESS_THAN_OR_EQUAL,
+    LIKE,
+    LIKE_REGEX,
+    NOT_BETWEEN,
+    NOT_EQUAL,
+    NOT_IN,
+    NOT_LIKE,
+    NOT_LIKE_REGEX,
+} from "./WhereType.js";
+import {Where} from "./Where.js";
+import {QueryImpl} from "./QueryImpl.js";
+import {AND, OR} from "./LogicType.js";
+import {OrderBy} from "./OrderBy.js";
+import {ASC, DESC} from "./OrderByType.js";
+import {Logic} from "./Logic.js";
+
+function query(oldQuery) {
+    return new QueryImpl(oldQuery);
+}
+
+function where(...whereClauses) {
+    return new QueryImpl().where(...whereClauses);
+}
+
+function groupBy(...groupByClauses) {
+    return new QueryImpl().groupBy(...groupByClauses);
+}
+
+function orderBy(...orderByClauses) {
+    return new QueryImpl().orderBy(...orderByClauses);
+}
+
+function offset(limitOffset) {
+    return new QueryImpl().offset(limitOffset);
+}
+
+function limit(numberOfRows) {
+    return new QueryImpl().limit(numberOfRows);
+}
+
+function and(...clauses) {
+    return new Logic(AND).add(...clauses);
+}
+
+function or(...clauses) {
+    return new Logic(OR).add(...clauses);
+}
+
+function asc(name, ...options) {
+    return new OrderBy(name, ASC, ...options);
+}
+
+function desc(name, ...options) {
+    return new OrderBy(name, DESC, ...options);
+}
+
+function eq(fieldName, value, ...options) {
+    return new Where(fieldName, EQUAL, value, null, ...options);
+}
+
+function ne(fieldName, value, ...options) {
+    return new Where(fieldName, NOT_EQUAL, value, null, ...options);
+}
+
+
+function lt(fieldName, value, ...options) {
+    return new Where(fieldName, LESS_THAN, value, null, ...options);
+}
+
+function le(fieldName, value, ...options) {
+    return new Where(fieldName, LESS_THAN_OR_EQUAL, value, null, ...options);
+}
+
+function gt(fieldName, value, ...options) {
+    return new Where(fieldName, GREATER_THAN, value, null, ...options);
+}
+
+function ge(fieldName, value, ...options) {
+    return new Where(fieldName, GREATER_THAN_OR_EQUAL, value, null, ...options);
+}
+
+function isNull(fieldName, ...options) {
+    return new Where(fieldName, IS_NULL, null, null, ...options);
+}
+
+function isNotNull(fieldName, ...options) {
+    return new Where(fieldName, IS_NOT_NULL, null, null, ...options);
+}
+
+function like(fieldName, value, ...options) {
+    return new Where(fieldName, LIKE, value, null, ...options);
+}
+
+function notLike(fieldName, value, ...options) {
+    return new Where(fieldName, NOT_LIKE, value, null, ...options);
+}
+
+function likeRegex(fieldName, value, ...options) {
+    return new Where(fieldName, LIKE_REGEX, value, null, ...options);
+}
+
+function notLikeRegex(fieldName, value, ...options) {
+    return new Where(fieldName, NOT_LIKE_REGEX, value, null, ...options);
+}
+
+function in_(fieldName, value, ...options) {
+    return new Where(fieldName, IN, value, null, ...options);
+}
+
+function notIn(fieldName, value, ...options) {
+    return new Where(fieldName, NOT_IN, value, null, ...options);
+}
+
+function between(fieldName, value1, value2, ...options) {
+    return new Where(fieldName, BETWEEN, value1, value2, ...options);
+}
+
+function notBetween(fieldName, value1, value2, ...options) {
+    return new Where(fieldName, NOT_BETWEEN, value1, value2, ...options);
+}
+
+function jsonContains(fieldName, value, ...options) {
+    return new Where(fieldName, JSON_CONTAINS, value, null, ...options);
+}
+
+function jsonOverlaps(fieldName, value, ...options) {
+    return new Where(fieldName, JSON_OVERLAPS, value, null, ...options);
+}
+
+function whereClause(whereClause, params) {
+    return new WhereClause(whereClause, params);
+}
+
+
+export {
+    query,
+    where,
+    groupBy,
+    orderBy,
+    offset,
+    limit,
+    and,
+    or,
+    asc,
+    desc,
+    eq,
+    ne,
+    lt,
+    le,
+    gt,
+    ge,
+    isNull,
+    isNotNull,
+    like,
+    notLike,
+    likeRegex,
+    notLikeRegex,
+    in_,
+    notIn,
+    between,
+    notBetween,
+    jsonContains,
+    whereClause,
+};