@ackplus/nest-crud-request 1.1.1 → 1.1.2

package/src/lib/query-builder.ts

@@ -1,189 +0,0 @@
-import { RelationBuilder } from './relation-builder';
-import { QueryBuilderOptions, OrderDirectionEnum } from './types';
-import { deepMerge } from './utils';
-import { WhereBuilder, WhereBuilderCondition } from './where-builder';
-
-
-export class QueryBuilder {
-
-    private options: QueryBuilderOptions = {};
-
-    private whereBuilder: WhereBuilder = new WhereBuilder();
-
-    private relationBuilder: RelationBuilder = new RelationBuilder();
-
-    constructor(options?: QueryBuilderOptions) {
-        if (options) {
-            this.setOptions(options);
-        }
-    }
-
-    setOptions(options: QueryBuilderOptions): this {
-        this.options = options;
-        this.whereBuilder = new WhereBuilder(options.where);
-        this.relationBuilder = new RelationBuilder(options.relations);
-        return this;
-    }
-
-    mergeOptions(options: QueryBuilderOptions, deep = false): this {
-        let updatedOptions = {};
-        if (deep) {
-            updatedOptions = deepMerge(this.options, options);
-        } else {
-            updatedOptions = {
-                ...this.options,
-                ...options,
-            };
-        }
-        this.setOptions(updatedOptions);
-        return this;
-    }
-
-    addSelect(fields: string | string[]): this {
-        // Ensure select is always an array
-        if (!this.options.select || typeof this.options.select === 'string') {
-            this.options.select = [];
-        }
-        if (Array.isArray(fields)) {
-            this.options.select.push(...fields);
-        } else {
-            this.options.select.push(fields);
-        }
-        return this;
-    }
-
-    removeSelect(fields: string | string[]): this {
-        // Ensure select is an array before filtering
-        if (this.options.select && Array.isArray(this.options.select)) {
-            if (Array.isArray(fields)) {
-                this.options.select = this.options.select.filter(field => !fields.includes(field));
-            } else {
-                this.options.select = this.options.select.filter(field => field !== fields);
-            }
-        }
-        return this;
-    }
-
-    addRelation(relation: string, select?: string[], where?: Record<string, any>): this {
-        this.relationBuilder.add(relation, select, where);
-        return this;
-    }
-
-    removeRelation(relation: string): this {
-        this.relationBuilder.remove(relation);
-        return this;
-    }
-
-    where(...args: WhereBuilderCondition): this {
-        this.whereBuilder.where(...args);
-        return this;
-    }
-
-    andWhere(...args: WhereBuilderCondition): this {
-        this.whereBuilder.andWhere(...args);
-        return this;
-    }
-
-    orWhere(...args: WhereBuilderCondition): this {
-        this.whereBuilder.orWhere(...args);
-        return this;
-    }
-
-    addOrder(orderBy: string, order: OrderDirectionEnum): this {
-        if (!this.options.order) {
-            this.options.order = {};
-        }
-        this.options.order[orderBy] = order;
-        return this;
-    }
-
-    removeOrder(orderBy: string): this {
-        if (this.options.order) {
-            delete this.options.order[orderBy];
-        }
-        return this;
-    }
-
-    setSkip(skip: number): this {
-        this.options.skip = skip;
-        return this;
-    }
-
-    setTake(take: number): this {
-        this.options.take = take;
-        return this;
-    }
-
-    setWithDeleted(withDeleted: boolean): this {
-        this.options.withDeleted = withDeleted;
-        return this;
-    }
-
-    setOnlyDeleted(onlyDeleted: boolean): this {
-        this.options.onlyDeleted = onlyDeleted;
-        return this;
-    }
-
-    set(key: string, value: any): this {
-        this.options[key] = value;
-        return this;
-    }
-
-    toObject(constrainToNestedObject = false) {
-        const options = {
-            ...this.options,
-        };
-
-        // Convert where conditions to JSON string
-        if (this.whereBuilder.hasConditions()) {
-            if (constrainToNestedObject) {
-                options.where = this.whereBuilder.toObject();
-            } else {
-                options.where = JSON.stringify(this.whereBuilder.toObject());
-            }
-        } else {
-            delete options.where;
-        }
-
-        // Convert relations to JSON string
-        if (this.relationBuilder.hasRelations()) {
-            if (constrainToNestedObject) {
-                options.relations = this.relationBuilder.toObject();
-            } else {
-                options.relations = JSON.stringify(this.relationBuilder.toObject());
-            }
-        } else {
-            delete options.relations;
-        }
-
-        // Convert order to JSON string if it exists
-        if (options.order && Object.keys(options.order).length > 0) {
-            if (constrainToNestedObject) {
-                options.order = options.order;
-            } else {
-                options.order = JSON.stringify(options.order);
-            }
-        } else {
-            delete options.order;
-        }
-
-        // Convert select to JSON string if it exists
-        if (options.select && options.select.length > 0) {
-            if (constrainToNestedObject) {
-                options.select = options.select;
-            } else {
-                options.select = JSON.stringify(options.select);
-            }
-        } else {
-            delete options.select;
-        }
-
-        return options;
-    }
-
-    toJson() {
-        const obj = this.toObject(true);
-        return JSON.stringify(obj);
-    }
-
-}

package/src/lib/relation-builder.ts

@@ -1,68 +0,0 @@
-import { RelationObject, RelationObjectValue, RelationOptions } from './types';
-
-
-export class RelationBuilder {
-
-    private relations: RelationObject = {};
-
-    constructor(relations?: RelationOptions | string) {
-        if (relations) {
-            const relationOptions = typeof relations === 'string' ? JSON.parse(relations) : relations;
-            this.setRelations(relationOptions);
-        }
-    }
-
-    setRelations(relations: RelationOptions): this {
-        if (relations) {
-            if (Array.isArray(relations)) {
-                relations.forEach(relation => {
-                    this.add(relation);
-                });
-            } else if (typeof relations === 'string') {
-                this.add(relations);
-            } else {
-                this.relations = relations;
-            }
-        }
-        return this;
-    }
-
-    clear(): this {
-        this.relations = {};
-        return this;
-    }
-
-    add(relation: string, select?: string[], where?: Record<string, any>): this {
-        if (!select && !where) {
-            this.relations[relation] = true;
-        } else {
-            const obj: any = {};
-            if (select) {
-                obj.select = select;
-            }
-            if (where) {
-                obj.where = where;
-            }
-            this.relations[relation] = obj;
-        }
-        return this;
-    }
-
-    remove(relation: string): this {
-        delete this.relations[relation];
-        return this;
-    }
-
-    hasRelations(): boolean {
-        return Object.keys(this.relations).length > 0;
-    }
-
-    toObject(): RelationObject {
-        return this.relations;
-    }
-
-    toJson(): string {
-        return JSON.stringify(this.relations);
-    }
-
-}

package/src/lib/types.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OrderDirectionEnum = exports.WhereOperatorEnum = exports.WhereLogicalOperatorEnum = void 0;
-var WhereLogicalOperatorEnum;
-(function (WhereLogicalOperatorEnum) {
-    WhereLogicalOperatorEnum["AND"] = "$and";
-    WhereLogicalOperatorEnum["OR"] = "$or";
-})(WhereLogicalOperatorEnum || (exports.WhereLogicalOperatorEnum = WhereLogicalOperatorEnum = {}));
-var WhereOperatorEnum;
-(function (WhereOperatorEnum) {
-    WhereOperatorEnum["EQ"] = "$eq";
-    WhereOperatorEnum["NOT_EQ"] = "$ne";
-    WhereOperatorEnum["GT"] = "$gt";
-    WhereOperatorEnum["GT_OR_EQ"] = "$gte";
-    WhereOperatorEnum["LT"] = "$lt";
-    WhereOperatorEnum["LT_OR_EQ"] = "$lte";
-    WhereOperatorEnum["IN"] = "$in";
-    WhereOperatorEnum["NOT_IN"] = "$notIn";
-    WhereOperatorEnum["LIKE"] = "$like";
-    WhereOperatorEnum["NOT_LIKE"] = "$notLike";
-    WhereOperatorEnum["ILIKE"] = "$iLike";
-    WhereOperatorEnum["NOT_ILIKE"] = "$notIlike";
-    WhereOperatorEnum["IS_NULL"] = "$isNull";
-    WhereOperatorEnum["IS_NOT_NULL"] = "$isNotNull";
-    WhereOperatorEnum["BETWEEN"] = "$between";
-    WhereOperatorEnum["NOT_BETWEEN"] = "$notBetween";
-    WhereOperatorEnum["IS_TRUE"] = "$isTrue";
-    WhereOperatorEnum["IS_FALSE"] = "$isFalse";
-})(WhereOperatorEnum || (exports.WhereOperatorEnum = WhereOperatorEnum = {}));
-var OrderDirectionEnum;
-(function (OrderDirectionEnum) {
-    OrderDirectionEnum["ASC"] = "ASC";
-    OrderDirectionEnum["DESC"] = "DESC";
-})(OrderDirectionEnum || (exports.OrderDirectionEnum = OrderDirectionEnum = {}));
-//# sourceMappingURL=types.js.map

package/src/lib/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":";;;AAYA,IAAY,wBAGX;AAHD,WAAY,wBAAwB;IAChC,wCAAY,CAAA;IACZ,sCAAU,CAAA;AACd,CAAC,EAHW,wBAAwB,wCAAxB,wBAAwB,QAGnC;AAED,IAAY,iBAmBX;AAnBD,WAAY,iBAAiB;IACzB,+BAAU,CAAA;IACV,mCAAc,CAAA;IACd,+BAAU,CAAA;IACV,sCAAiB,CAAA;IACjB,+BAAU,CAAA;IACV,sCAAiB,CAAA;IACjB,+BAAU,CAAA;IACV,sCAAiB,CAAA;IACjB,mCAAc,CAAA;IACd,0CAAqB,CAAA;IACrB,qCAAgB,CAAA;IAChB,4CAAuB,CAAA;IACvB,wCAAmB,CAAA;IACnB,+CAA0B,CAAA;IAC1B,yCAAoB,CAAA;IACpB,gDAA2B,CAAA;IAC3B,wCAAmB,CAAA;IACnB,0CAAqB,CAAA;AACzB,CAAC,EAnBW,iBAAiB,iCAAjB,iBAAiB,QAmB5B;AAED,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC1B,iCAAW,CAAA;IACX,mCAAa,CAAA;AACjB,CAAC,EAHW,kBAAkB,kCAAlB,kBAAkB,QAG7B"}

package/src/lib/types.ts

@@ -1,61 +0,0 @@
-export interface QueryBuilderOptions {
-    [key: string]: any;
-    select?: string[] | string;
-    relations?: RelationOptions | string;
-    where?: WhereOptions | string;
-    order?: Record<string, OrderDirectionEnum> | string;
-    skip?: number;
-    take?: number;
-    withDeleted?: boolean;
-    onlyDeleted?: boolean;
-}
-
-export enum WhereLogicalOperatorEnum {
-    AND = '$and',
-    OR = '$or',
-}
-
-export 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',
-    IS_TRUE = '$isTrue',
-    IS_FALSE = '$isFalse',
-}
-
-export enum OrderDirectionEnum {
-    ASC = 'ASC',
-    DESC = 'DESC',
-}
-
-export type WhereObject = {
-    [key: string]: any;
-    $and?: WhereObject | WhereObject[];
-    $or?: WhereObject | WhereObject[];
-};
-
-export type WhereOptions = WhereObject | WhereObject[];
-
-
-export type RelationObjectValue = {
-    select?: string[];
-    where?: WhereObject | WhereObject[];
-    joinType?: 'left' | 'inner';
-};
-
-export type RelationObject = Record<string, RelationObjectValue | boolean>;
-
-export type RelationOptions = string | string[] | RelationObject;

package/src/lib/utils.ts

@@ -1,11 +0,0 @@
-export function deepMerge(target: any, source: any): any {
-    for (const key in source) {
-        if (source[key] instanceof Object && key in target) {
-            Object.assign(source[key], deepMerge(target[key], source[key]));
-        }
-    }
-    return {
-        ...target,
-        ...source,
-    };
-}

package/src/lib/where-builder.ts

@@ -1,159 +0,0 @@
-import { WhereLogicalOperatorEnum, WhereOperatorEnum } from './types';
-
-
-export type WhereBuilderCondition = [string, any] | [string, WhereOperatorEnum, any] | [Record<string, any>] | [(builder: WhereBuilder) => void];
-
-export class WhereBuilder {
-
-    private whereObject: Record<string, any> = {};
-
-    constructor(where?: Record<string, any> | string) {
-        this.whereObject = typeof where === 'string' ? JSON.parse(where) : where || {};
-    }
-
-    private isOperator(value: any): boolean {
-        return `${value}`.startsWith('$');
-    }
-
-    clear(): this {
-        this.whereObject = {};
-        return this;
-    }
-
-    where(...args: WhereBuilderCondition): this {
-        this.parseCondition(null, ...args);
-        return this;
-    }
-
-    andWhere(...args: WhereBuilderCondition): this {
-        this.parseCondition(WhereLogicalOperatorEnum.AND, ...args);
-        return this;
-    }
-
-    orWhere(...args: WhereBuilderCondition): this {
-        this.parseCondition(WhereLogicalOperatorEnum.OR, ...args);
-        return this;
-    }
-
-    removeWhere(field: string): this {
-        const keys = field.split('.');
-        let current = this.whereObject;
-
-        for (let i = 0; i < keys.length - 1; i++) {
-            if (!current[keys[i]]) {
-                return this; // If the path doesn't exist, do nothing
-            }
-            current = current[keys[i]];
-        }
-
-        delete current[keys[keys.length - 1]];
-        return this;
-    }
-
-    hasConditions(): boolean {
-        return Object.keys(this.whereObject).length > 0;
-    }
-
-    toObject(): Record<string, any> {
-        return this.whereObject;
-    }
-
-    toJson(): string {
-        return JSON.stringify(this.whereObject);
-    }
-
-    private parseCondition(type: WhereLogicalOperatorEnum | null, ...args: any[]): Record<string, any> {
-        let field: string;
-        let operator: WhereOperatorEnum;
-        let value: any;
-
-        if (args.length === 0) {
-            // Do nothing
-        } else if (args.length === 1) {
-            const condition = args[0];
-            if (typeof condition === 'function') {
-                // If the condition is a function, create a new WhereBuilder and call the function with it
-                const builder = new WhereBuilder();
-                condition(builder);
-                this.updateCondition(builder.toObject(), type);
-            } else if (condition instanceof WhereBuilder) {
-                // If the condition is a WhereBuilder
-                this.updateCondition(condition.toObject(), type);
-            } else {
-                // If the condition is a simple object
-                this.updateCondition(condition, type);
-            }
-        } else if (args.length === 2 || args.length === 3) {
-            if (args.length === 2) {
-                // if there are only two arguments, the operator is EQ
-                field = args[0];
-                value = args[1];
-
-                if (typeof value === 'object') {
-                    const firstKey = Object.keys(value)[0];
-                    // if the first key is a operator, update the value with the operator
-                    if (firstKey.startsWith('$')) {
-                        this.updateCondition({ [field]: value }, type);
-                    } else {
-                        this.updateCondition({ [field]: { [WhereOperatorEnum.EQ]: value } }, type);
-                    }
-                } else if (this.isOperator(value)) {
-                    this.updateCondition({ [field]: { [value]: true } }, type);
-                } else {
-                    this.updateCondition({ [field]: { [WhereOperatorEnum.EQ]: value } }, type);
-                }
-            } else {
-                // if there are three arguments, the operator is the second argument
-                field = args[0];
-                operator = args[1];
-                value = args[2];
-                this.updateCondition({ [field]: { [operator]: value } }, type);
-            }
-        }
-        return this;
-    }
-
-    // private updateCondition(condition: Record<string, any>, type: '$and' | '$or'): void {
-    //     this.whereObject[type] = [...(this.whereObject[type] || []), condition].filter(Boolean);
-    // }
-
-    private updateCondition(condition: Record<string, any>, type: WhereLogicalOperatorEnum | null): void {
-        if (type === null) {
-            // For direct where conditions, we need to merge intelligently
-            this.mergeConditions(this.whereObject, condition);
-        } else {
-            // For logical operators ($and, $or), add to the array
-            this.whereObject[type] = [...(this.whereObject[type] || []), condition].filter(Boolean);
-        }
-    }
-
-    /**
-     * Intelligently merge two condition objects, handling logical operators properly
-     */
-    private mergeConditions(target: Record<string, any>, source: Record<string, any>): void {
-        for (const key in source) {
-            const sourceValue = source[key];
-
-            if (key === '$and' || key === '$or') {
-                // Handle logical operators - merge arrays
-                if (target[key]) {
-                    // If target already has this logical operator, merge the arrays
-                    target[key] = [...(target[key] || []), ...(Array.isArray(sourceValue) ? sourceValue : [sourceValue])];
-                } else {
-                    // If target doesn't have this logical operator, set it
-                    target[key] = Array.isArray(sourceValue) ? sourceValue : [sourceValue];
-                }
-            } else {
-                // Handle regular field conditions
-                if (target[key] && typeof target[key] === 'object' && typeof sourceValue === 'object') {
-                    // If both target and source have the same field with object values, merge them
-                    target[key] = { ...target[key], ...sourceValue };
-                } else {
-                    // Otherwise, simply assign the value
-                    target[key] = sourceValue;
-                }
-            }
-        }
-    }
-
-}

package/src/test/query-builder-where.spec.ts

@@ -1,173 +0,0 @@
-import { QueryBuilder } from '../lib/query-builder';
-import { WhereOperatorEnum } from '../lib/types';
-
-
-describe('QueryBuilder - Where Conditions', () => {
-    let queryBuilder: QueryBuilder;
-
-    beforeEach(() => {
-        queryBuilder = new QueryBuilder({});
-    });
-
-    it('should add where conditions', () => {
-        queryBuilder.where('age', 25);
-        expect(queryBuilder.toObject(true).where).toEqual({ age: { $eq: 25 } });
-    });
-
-    it('should add or where conditions', () => {
-        queryBuilder.orWhere('age', 25);
-        expect(queryBuilder.toObject(true).where).toEqual({ $or: [{ age: { $eq: 25 } }] });
-    });
-
-    it('should add where conditions with a function', () => {
-        queryBuilder.where((builder) => {
-            builder.where('age', 25);
-            builder.orWhere('name', 'John');
-        });
-
-        expect(queryBuilder.toObject(true).where).toEqual({
-            age: { $eq: 25 },
-            $or: [{ name: { $eq: 'John' } }],
-        });
-    });
-
-    it('should add or where conditions with a function', () => {
-        queryBuilder.orWhere((builder) => {
-            builder.where('age', 25);
-            builder.orWhere('name', 'John');
-        });
-
-        expect(queryBuilder.toObject(true).where).toEqual({
-            $or: [
-                {
-                    age: { $eq: 25 },
-                    $or: [{ name: { $eq: 'John' } }],
-                },
-            ],
-        });
-    });
-
-    it('should handle complex where conditions with multiple nested functions', () => {
-        queryBuilder.where((builder) => {
-            builder.where('age', 25);
-            builder.orWhere((innerBuilder) => {
-                innerBuilder.where('name', 'John');
-                innerBuilder.where('status', 'active');
-            });
-            builder.where('country', 'USA');
-        });
-
-        expect(queryBuilder.toObject(true).where).toEqual({
-            age: { $eq: 25 },
-            $or: [
-                {
-                    name: { $eq: 'John' },
-                    status: { $eq: 'active' },
-                },
-            ],
-            country: { $eq: 'USA' },
-        });
-    });
-
-    it('should handle complex or where conditions with multiple nested functions', () => {
-        queryBuilder.orWhere((builder) => {
-            builder.where('age', 25);
-            builder.orWhere((innerBuilder) => {
-                innerBuilder.where('name', 'John');
-                innerBuilder.orWhere('status', 'active');
-            });
-            builder.orWhere('country', 'USA');
-        });
-
-        expect(queryBuilder.toObject(true).where).toEqual({
-            $or: [
-                {
-                    age: { $eq: 25 },
-                    $or: [
-                        {
-                            name: { $eq: 'John' },
-                            $or: [{ status: { $eq: 'active' } }],
-                        },
-                        { country: { $eq: 'USA' } },
-                    ],
-                },
-            ],
-        });
-    });
-
-    it('should handle empty where conditions', () => {
-        queryBuilder.where(() => {
-            // Do nothing
-        });
-
-        expect(queryBuilder.toObject(true).where).toEqual(undefined);
-    });
-
-    it('should handle single condition without nesting', () => {
-        queryBuilder.where('age', 30);
-
-        expect(queryBuilder.toObject(true).where).toEqual({
-            age: { $eq: 30 },
-        });
-    });
-
-    it('should handle multiple conditions with different operators', () => {
-        queryBuilder.where((builder) => {
-            builder.where('age', 30);
-            builder.where('salary', WhereOperatorEnum.GT, 50000);
-            builder.orWhere('status', 'employed');
-        });
-
-        expect(queryBuilder.toObject(true).where).toEqual({
-            age: { $eq: 30 },
-            salary: { $gt: 50000 },
-            $or: [{ status: { $eq: 'employed' } }],
-        });
-    });
-
-    it('should handle nested orWhere with multiple conditions', () => {
-        queryBuilder.orWhere((builder) => {
-            builder.where('age', 30);
-            builder.orWhere((innerBuilder) => {
-                innerBuilder.where('name', 'Alice');
-                innerBuilder.orWhere('city', 'New York');
-            });
-        });
-
-        expect(queryBuilder.toObject(true).where).toEqual({
-            $or: [
-                {
-                    age: { $eq: 30 },
-                    $or: [
-                        {
-                            name: { $eq: 'Alice' },
-                            $or: [{ city: { $eq: 'New York' } }],
-                        },
-                    ],
-                },
-            ],
-        });
-    });
-
-    it('should handle complex conditions with mixed operators', () => {
-        queryBuilder.where((builder) => {
-            builder.where('age', { $gte: 18 });
-            builder.orWhere((innerBuilder) => {
-                innerBuilder.where('name', 'Bob');
-                innerBuilder.where('status', { $ne: 'inactive' });
-            });
-            builder.where('country', { $in: ['USA', 'Canada'] });
-        });
-
-        expect(queryBuilder.toObject(true).where).toEqual({
-            age: { $gte: 18 },
-            $or: [
-                {
-                    name: { $eq: 'Bob' },
-                    status: { $ne: 'inactive' },
-                },
-            ],
-            country: { $in: ['USA', 'Canada'] },
-        });
-    });
-});