@ackplus/nest-crud-request 0.1.17 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ackplus/nest-crud-request",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "type": "commonjs",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/lib/query-builder.d.ts

@@ -4,7 +4,7 @@ export declare class QueryBuilder {
     private options;
     private whereBuilder;
     private relationBuilder;
-    constructor(options: QueryBuilderOptions);
+    constructor(options?: QueryBuilderOptions);
     setOptions(options: QueryBuilderOptions): this;
     mergeOptions(options: QueryBuilderOptions, deep?: boolean): this;
     addSelect(fields: string | string[]): this;
@@ -24,8 +24,8 @@ export declare class QueryBuilder {
     toObject(): {
         [x: string]: any;
         select?: string[];
-        relations?: string[] | import("./types").Relation[];
-        where?: Record<string, any>;
+        relations?: import("./types").RelationOptions;
+        where?: import("./types").WhereOptions;
         order?: Record<string, OrderDirectionEnum>;
         skip?: number;
         take?: number;

package/src/lib/query-builder.js

@@ -9,8 +9,9 @@ class QueryBuilder {
         this.options = {};
         this.whereBuilder = new where_builder_1.WhereBuilder();
         this.relationBuilder = new relation_builder_1.RelationBuilder();
-        this.options = options;
-        this.setOptions(options);
+        if (options) {
+            this.setOptions(options);
+        }
     }
     setOptions(options) {
         this.options = options;

package/src/lib/relation-builder.d.ts

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

package/src/lib/relation-builder.js

@@ -12,12 +12,7 @@ class RelationBuilder {
         if (relations) {
             if (Array.isArray(relations)) {
                 relations.forEach(relation => {
-                    if (typeof relation === 'string') {
-                        this.add(relation);
-                    }
-                    else {
-                        this.add(relation.relation, relation.select, relation.where);
-                    }
+                    this.add(relation);
                 });
             }
             else if (typeof relations === 'string') {
@@ -34,11 +29,19 @@ class RelationBuilder {
         return this;
     }
     add(relation, select, where) {
-        this.relations[relation] = {
-            relation,
-            select,
-            where,
-        };
+        if (!select && !where) {
+            this.relations[relation] = true;
+        }
+        else {
+            const obj = {};
+            if (select) {
+                obj.select = select;
+            }
+            if (where) {
+                obj.where = where;
+            }
+            this.relations[relation] = obj;
+        }
         return this;
     }
     remove(relation) {
@@ -49,7 +52,7 @@ class RelationBuilder {
         return Object.keys(this.relations).length > 0;
     }
     toObject() {
-        return Object.values(this.relations);
+        return this.relations;
     }
     toJson() {
         return JSON.stringify(this.relations);

package/src/lib/types.d.ts

@@ -1,8 +1,8 @@
 export interface QueryBuilderOptions {
     [key: string]: any;
     select?: string[];
-    relations?: string[] | Relation[];
-    where?: Record<string, any>;
+    relations?: RelationOptions;
+    where?: WhereOptions;
     order?: Record<string, OrderDirectionEnum>;
     skip?: number;
     take?: number;
@@ -39,8 +39,16 @@ export declare enum OrderDirectionEnum {
     ASC = "ASC",
     DESC = "DESC"
 }
-export interface Relation {
-    relation: string;
+export type WhereObject = {
+    [key: string]: any;
+    $and?: WhereObject | WhereObject[];
+    $or?: WhereObject | WhereObject[];
+};
+export type WhereOptions = WhereObject | WhereObject[];
+export type RelationObjectValue = {
     select?: string[];
-    where?: Record<string, any>;
-}
+    where?: WhereObject | WhereObject[];
+    joinType?: 'left' | 'inner';
+};
+export type RelationObject = Record<string, RelationObjectValue | boolean>;
+export type RelationOptions = string | string[] | RelationObject;

package/src/lib/where-builder.d.ts

@@ -3,6 +3,7 @@ export type WhereBuilderCondition = [string, any] | [string, WhereOperatorEnum,
 export declare class WhereBuilder {
     private whereObject;
     constructor(where?: Record<string, any>);
+    private isOperator;
     clear(): this;
     where(...args: WhereBuilderCondition): this;
     andWhere(...args: WhereBuilderCondition): this;
@@ -13,4 +14,5 @@ export declare class WhereBuilder {
     toJson(): string;
     private parseCondition;
     private updateCondition;
+    private mergeConditions;
 }

package/src/lib/where-builder.js

@@ -7,6 +7,9 @@ class WhereBuilder {
         this.whereObject = {};
         this.whereObject = where || {};
     }
+    isOperator(value) {
+        return `${value}`.startsWith('$');
+    }
     clear() {
         this.whereObject = {};
         return this;
@@ -77,6 +80,9 @@ class WhereBuilder {
                         this.updateCondition({ [field]: { [types_1.WhereOperatorEnum.EQ]: value } }, type);
                     }
                 }
+                else if (this.isOperator(value)) {
+                    this.updateCondition({ [field]: { [value]: true } }, type);
+                }
                 else {
                     this.updateCondition({ [field]: { [types_1.WhereOperatorEnum.EQ]: value } }, type);
                 }
@@ -92,11 +98,32 @@ class WhereBuilder {
     }
     updateCondition(condition, type) {
         if (type === null) {
-            this.whereObject = Object.assign(Object.assign({}, this.whereObject), condition);
+            this.mergeConditions(this.whereObject, condition);
         }
         else {
             this.whereObject[type] = [...(this.whereObject[type] || []), condition].filter(Boolean);
         }
     }
+    mergeConditions(target, source) {
+        for (const key in source) {
+            const sourceValue = source[key];
+            if (key === '$and' || key === '$or') {
+                if (target[key]) {
+                    target[key] = [...(target[key] || []), ...(Array.isArray(sourceValue) ? sourceValue : [sourceValue])];
+                }
+                else {
+                    target[key] = Array.isArray(sourceValue) ? sourceValue : [sourceValue];
+                }
+            }
+            else {
+                if (target[key] && typeof target[key] === 'object' && typeof sourceValue === 'object') {
+                    target[key] = Object.assign(Object.assign({}, target[key]), sourceValue);
+                }
+                else {
+                    target[key] = sourceValue;
+                }
+            }
+        }
+    }
 }
 exports.WhereBuilder = WhereBuilder;