@ackplus/nest-crud-request 0.0.1

package/README.md

@@ -0,0 +1,11 @@
+# nest-crud-request
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build nest-crud-request` to build the library.
+
+## Running unit tests
+
+Run `nx test nest-crud-request` to execute the unit tests via [Jest](https://jestjs.io).

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './lib/query-builder';
+export * from './lib/where-builder';
+export * from './lib/types';

package/index.js

@@ -0,0 +1,137 @@
+var w = (i, e) => () => (e || i((e = { exports: {} }).exports, e), e.exports);
+var B = w((r) => {
+  Object.defineProperty(r, "__esModule", { value: !0 });
+  r.QueryBuilder = void 0;
+  const c = require("./relation-builder"), b = require("./utils"), a = require("./where-builder");
+  class j {
+    constructor(e) {
+      this.options = {}, this.whereBuilder = new a.WhereBuilder(), this.relationBuilder = new c.RelationBuilder(), this.options = e, this.setOptions(e);
+    }
+    setOptions(e) {
+      return this.options = e, this.whereBuilder = new a.WhereBuilder(e.where), this.relationBuilder = new c.RelationBuilder(e.relations), this;
+    }
+    mergeOptions(e, t = !1) {
+      let s = {};
+      return t ? s = (0, b.deepMerge)(this.options, e) : s = {
+        ...this.options,
+        ...e
+      }, this.setOptions(s), this;
+    }
+    addSelect(e) {
+      return this.options.select || (this.options.select = []), Array.isArray(e) ? this.options.select.push(...e) : this.options.select.push(e), this;
+    }
+    removeSelect(e) {
+      return this.options.select && (Array.isArray(e) ? this.options.select = this.options.select.filter((t) => !e.includes(t)) : this.options.select = this.options.select.filter((t) => t !== e)), this;
+    }
+    addRelation(e, t, s) {
+      return this.relationBuilder.add(e, t, s), this;
+    }
+    removeRelation(e) {
+      return this.relationBuilder.remove(e), this;
+    }
+    where(...e) {
+      return this.whereBuilder.where(...e), this;
+    }
+    andWhere(...e) {
+      return this.whereBuilder.andWhere(...e), this;
+    }
+    orWhere(...e) {
+      return this.whereBuilder.orWhere(...e), this;
+    }
+    addOrder(e, t) {
+      return this.options.order || (this.options.order = {}), this.options.order[e] = t, this;
+    }
+    removeOrder(e) {
+      return this.options.order && delete this.options.order[e], this;
+    }
+    setSkip(e) {
+      return this.options.skip = e, this;
+    }
+    setTake(e) {
+      return this.options.take = e, this;
+    }
+    toObject() {
+      const e = {
+        ...this.options
+      };
+      return this.whereBuilder.hasConditions() ? e.where = this.whereBuilder.toObject() : delete e.where, this.relationBuilder.hasRelations() ? e.relations = this.relationBuilder.toObject() : delete e.relations, e;
+    }
+    toJson() {
+      const e = this.toObject();
+      return JSON.stringify(e);
+    }
+  }
+  r.QueryBuilder = j;
+  Object.defineProperty(r, "__esModule", { value: !0 });
+  r.WhereBuilder = void 0;
+  const l = require("./types");
+  class u {
+    constructor(e) {
+      this.whereObject = {}, this.whereObject = e || {};
+    }
+    clear() {
+      return this.whereObject = {}, this;
+    }
+    where(...e) {
+      return this.parseCondition(null, ...e), this;
+    }
+    andWhere(...e) {
+      return this.parseCondition(l.WhereLogicalOperatorEnum.AND, ...e), this;
+    }
+    orWhere(...e) {
+      return this.parseCondition(l.WhereLogicalOperatorEnum.OR, ...e), this;
+    }
+    removeWhere(e) {
+      const t = e.split(".");
+      let s = this.whereObject;
+      for (let n = 0; n < t.length - 1; n++) {
+        if (!s[t[n]])
+          return this;
+        s = s[t[n]];
+      }
+      return delete s[t[t.length - 1]], this;
+    }
+    hasConditions() {
+      return Object.keys(this.whereObject).length > 0;
+    }
+    toObject() {
+      return this.whereObject;
+    }
+    toJson() {
+      return JSON.stringify(this.whereObject);
+    }
+    parseCondition(e, ...t) {
+      let s, n, o;
+      if (t.length !== 0) if (t.length === 1) {
+        const h = t[0];
+        if (typeof h == "function") {
+          const d = new u();
+          h(d), this.updateCondition(d.toObject(), e);
+        } else h instanceof u ? this.updateCondition(h.toObject(), e) : this.updateCondition(h, e);
+      } else (t.length === 2 || t.length === 3) && (t.length === 2 ? (s = t[0], o = t[1], typeof o == "object" ? Object.keys(o)[0].startsWith("$") ? this.updateCondition({ [s]: o }, e) : this.updateCondition({ [s]: { [l.WhereOperatorEnum.EQ]: o } }, e) : this.updateCondition({ [s]: { [l.WhereOperatorEnum.EQ]: o } }, e)) : (s = t[0], n = t[1], o = t[2], this.updateCondition({ [s]: { [n]: o } }, e)));
+      return this;
+    }
+    updateCondition(e, t) {
+      t === null ? this.whereObject = {
+        ...this.whereObject,
+        ...e
+      } : this.whereObject[t] = [...this.whereObject[t] || [], e].filter(Boolean);
+    }
+  }
+  r.WhereBuilder = u;
+  Object.defineProperty(r, "__esModule", { value: !0 });
+  r.OrderDirectionEnum = r.WhereOperatorEnum = r.WhereLogicalOperatorEnum = void 0;
+  var f;
+  (function(i) {
+    i.AND = "$and", i.OR = "$or";
+  })(f || (r.WhereLogicalOperatorEnum = f = {}));
+  var O;
+  (function(i) {
+    i.EQ = "$eq", i.NOT_EQ = "$ne", i.GT = "$gt", i.GT_OR_EQ = "$gte", i.LT = "$lt", i.LT_OR_EQ = "$lte", i.IN = "$in", i.NOT_IN = "$notIn", i.LIKE = "$like", i.NOT_LIKE = "$notLike", i.ILIKE = "$iLike", i.NOT_ILIKE = "$notIlike", i.IS_NULL = "$isNull", i.IS_NOT_NULL = "$isNotNull", i.BETWEEN = "$between", i.NOT_BETWEEN = "$notBetween", i.NULL = "$null", i.NOT_NULL = "$notNull", i.IS_TRUE = "$isTrue", i.IS_FALSE = "$isFalse";
+  })(O || (r.WhereOperatorEnum = O = {}));
+  var p;
+  (function(i) {
+    i.ASC = "ASC", i.DESC = "DESC";
+  })(p || (r.OrderDirectionEnum = p = {}));
+});
+export default B();

package/lib/query-builder.d.ts

@@ -0,0 +1,30 @@
+import { QueryBuilderOptions, OrderDirectionEnum } from './types';
+import { WhereBuilderCondition } from './where-builder';
+export declare class QueryBuilder {
+    private options;
+    private whereBuilder;
+    private relationBuilder;
+    constructor(options: QueryBuilderOptions);
+    setOptions(options: QueryBuilderOptions): this;
+    mergeOptions(options: QueryBuilderOptions, deep?: boolean): this;
+    addSelect(fields: string | string[]): this;
+    removeSelect(fields: string | string[]): this;
+    addRelation(relation: string, select?: string[], where?: Record<string, any>): this;
+    removeRelation(relation: string): this;
+    where(...args: WhereBuilderCondition): this;
+    andWhere(...args: WhereBuilderCondition): this;
+    orWhere(...args: WhereBuilderCondition): this;
+    addOrder(orderBy: string, order: OrderDirectionEnum): this;
+    removeOrder(orderBy: string): this;
+    setSkip(skip: number): this;
+    setTake(take: number): this;
+    toObject(): {
+        select?: string[];
+        relations?: string[] | import('./types').Relation[];
+        where?: Record<string, any>;
+        order?: Record<string, OrderDirectionEnum>;
+        skip?: number;
+        take?: number;
+    };
+    toJson(): string;
+}

package/lib/relation-builder.d.ts

@@ -0,0 +1,12 @@
+import { Relation } from './types';
+export declare class RelationBuilder {
+    private relations;
+    constructor(relations?: Relation[] | string[] | string);
+    setRelations(relations: Relation[] | string[] | string): this;
+    clear(): this;
+    add(relation: string, select?: string[], where?: Record<string, any>): this;
+    remove(relation: string): this;
+    hasRelations(): boolean;
+    toObject(): Relation[];
+    toJson(): string;
+}

package/lib/types.d.ts

@@ -0,0 +1,43 @@
+export interface QueryBuilderOptions {
+    select?: string[];
+    relations?: string[] | Relation[];
+    where?: Record<string, any>;
+    order?: Record<string, OrderDirectionEnum>;
+    skip?: number;
+    take?: number;
+}
+export declare enum WhereLogicalOperatorEnum {
+    AND = "$and",
+    OR = "$or"
+}
+export declare enum WhereOperatorEnum {
+    EQ = "$eq",
+    NOT_EQ = "$ne",
+    GT = "$gt",
+    GT_OR_EQ = "$gte",
+    LT = "$lt",
+    LT_OR_EQ = "$lte",
+    IN = "$in",
+    NOT_IN = "$notIn",
+    LIKE = "$like",
+    NOT_LIKE = "$notLike",
+    ILIKE = "$iLike",
+    NOT_ILIKE = "$notIlike",
+    IS_NULL = "$isNull",
+    IS_NOT_NULL = "$isNotNull",
+    BETWEEN = "$between",
+    NOT_BETWEEN = "$notBetween",
+    NULL = "$null",
+    NOT_NULL = "$notNull",
+    IS_TRUE = "$isTrue",
+    IS_FALSE = "$isFalse"
+}
+export declare enum OrderDirectionEnum {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export interface Relation {
+    relation: string;
+    select?: string[];
+    where?: Record<string, any>;
+}

package/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare function deepMerge(target: any, source: any): any;

package/lib/where-builder.d.ts

@@ -0,0 +1,16 @@
+import { WhereOperatorEnum } from './types';
+export type WhereBuilderCondition = [string, any] | [string, WhereOperatorEnum, any] | [Record<string, any>] | [(builder: WhereBuilder) => void];
+export declare class WhereBuilder {
+    private whereObject;
+    constructor(where?: Record<string, any>);
+    clear(): this;
+    where(...args: WhereBuilderCondition): this;
+    andWhere(...args: WhereBuilderCondition): this;
+    orWhere(...args: WhereBuilderCondition): this;
+    removeWhere(field: string): this;
+    hasConditions(): boolean;
+    toObject(): Record<string, any>;
+    toJson(): string;
+    private parseCondition;
+    private updateCondition;
+}

package/package.json

@@ -0,0 +1,10 @@
+{
+    "name": "@ackplus/nest-crud-request",
+    "version": "0.0.1",
+    "type": "module",
+    "main": "./index.js",
+    "types": "./index.d.ts",
+    "dependencies": {
+        "tslib": "^2.3.0"
+    }
+}