@ackplus/nest-crud-request 0.0.1 → 0.0.6

package/src/lib/types.js

@@ -0,0 +1,37 @@
+"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["NULL"] = "$null";
+    WhereOperatorEnum["NOT_NULL"] = "$notNull";
+    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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":";;;AASA,IAAY,wBAGX;AAHD,WAAY,wBAAwB;IAChC,wCAAY,CAAA;IACZ,sCAAU,CAAA;AACd,CAAC,EAHW,wBAAwB,wCAAxB,wBAAwB,QAGnC;AAED,IAAY,iBAqBX;AArBD,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,mCAAc,CAAA;IACd,0CAAqB,CAAA;IACrB,wCAAmB,CAAA;IACnB,0CAAqB,CAAA;AACzB,CAAC,EArBW,iBAAiB,iCAAjB,iBAAiB,QAqB5B;AAED,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC1B,iCAAW,CAAA;IACX,mCAAa,CAAA;AACjB,CAAC,EAHW,kBAAkB,kCAAlB,kBAAkB,QAG7B"}

package/src/lib/types.ts

@@ -0,0 +1,48 @@
+export interface QueryBuilderOptions {
+    select?: string[];
+    relations?: string[] | Relation[];
+    where?: Record<string, any>;
+    order?: Record<string, OrderDirectionEnum>;
+    skip?: number;
+    take?: number;
+}
+
+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',
+    NULL = '$null',
+    NOT_NULL = '$notNull',
+    IS_TRUE = '$isTrue',
+    IS_FALSE = '$isFalse',
+}
+
+export enum OrderDirectionEnum {
+    ASC = 'ASC',
+    DESC = 'DESC',
+}
+
+
+export interface Relation {
+    relation: string;
+    select?: string[];
+    where?: Record<string, any>;
+}

package/src/lib/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepMerge = deepMerge;
+function deepMerge(target, source) {
+    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,
+    };
+}
+//# sourceMappingURL=utils.js.map

package/src/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":";;AAAA,8BAUC;AAVD,SAAgB,SAAS,CAAC,MAAW,EAAE,MAAW;IAC9C,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QACvB,IAAI,MAAM,CAAC,GAAG,CAAC,YAAY,MAAM,IAAI,GAAG,IAAI,MAAM,EAAE,CAAC;YACjD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACpE,CAAC;IACL,CAAC;IACD,OAAO;QACH,GAAG,MAAM;QACT,GAAG,MAAM;KACZ,CAAC;AACN,CAAC"}

package/src/lib/utils.ts

@@ -0,0 +1,11 @@
+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.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhereBuilder = void 0;
+const types_1 = require("./types");
+class WhereBuilder {
+    constructor(where) {
+        this.whereObject = {};
+        this.whereObject = where || {};
+    }
+    clear() {
+        this.whereObject = {};
+        return this;
+    }
+    where(...args) {
+        this.parseCondition(null, ...args);
+        return this;
+    }
+    andWhere(...args) {
+        this.parseCondition(types_1.WhereLogicalOperatorEnum.AND, ...args);
+        return this;
+    }
+    orWhere(...args) {
+        this.parseCondition(types_1.WhereLogicalOperatorEnum.OR, ...args);
+        return this;
+    }
+    removeWhere(field) {
+        const keys = field.split('.');
+        let current = this.whereObject;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!current[keys[i]]) {
+                return this;
+            }
+            current = current[keys[i]];
+        }
+        delete current[keys[keys.length - 1]];
+        return this;
+    }
+    hasConditions() {
+        return Object.keys(this.whereObject).length > 0;
+    }
+    toObject() {
+        return this.whereObject;
+    }
+    toJson() {
+        return JSON.stringify(this.whereObject);
+    }
+    parseCondition(type, ...args) {
+        let field;
+        let operator;
+        let value;
+        if (args.length === 0) {
+        }
+        else if (args.length === 1) {
+            const condition = args[0];
+            if (typeof condition === 'function') {
+                const builder = new WhereBuilder();
+                condition(builder);
+                this.updateCondition(builder.toObject(), type);
+            }
+            else if (condition instanceof WhereBuilder) {
+                this.updateCondition(condition.toObject(), type);
+            }
+            else {
+                this.updateCondition(condition, type);
+            }
+        }
+        else if (args.length === 2 || args.length === 3) {
+            if (args.length === 2) {
+                field = args[0];
+                value = args[1];
+                if (typeof value === 'object') {
+                    const firstKey = Object.keys(value)[0];
+                    if (firstKey.startsWith('$')) {
+                        this.updateCondition({ [field]: value }, type);
+                    }
+                    else {
+                        this.updateCondition({ [field]: { [types_1.WhereOperatorEnum.EQ]: value } }, type);
+                    }
+                }
+                else {
+                    this.updateCondition({ [field]: { [types_1.WhereOperatorEnum.EQ]: value } }, type);
+                }
+            }
+            else {
+                field = args[0];
+                operator = args[1];
+                value = args[2];
+                this.updateCondition({ [field]: { [operator]: value } }, type);
+            }
+        }
+        return this;
+    }
+    updateCondition(condition, type) {
+        if (type === null) {
+            this.whereObject = {
+                ...this.whereObject,
+                ...condition,
+            };
+        }
+        else {
+            this.whereObject[type] = [...(this.whereObject[type] || []), condition].filter(Boolean);
+        }
+    }
+}
+exports.WhereBuilder = WhereBuilder;
+//# sourceMappingURL=where-builder.js.map

package/src/lib/where-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"where-builder.js","sourceRoot":"","sources":["where-builder.ts"],"names":[],"mappings":"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"}

package/src/lib/where-builder.ts

@@ -0,0 +1,124 @@
+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>) {
+        this.whereObject = where || {};
+    }
+
+    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 {
+                    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) {
+            this.whereObject = {
+                ...this.whereObject,
+                ...condition,
+            };
+        } else {
+            this.whereObject[type] = [...(this.whereObject[type] || []), condition].filter(Boolean);
+        }
+    }
+
+}

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

@@ -0,0 +1,173 @@
+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().where).toEqual({ age: { $eq: 25 } });
+    });
+
+    it('should add or where conditions', () => {
+        queryBuilder.orWhere('age', 25);
+        expect(queryBuilder.toObject().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().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().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().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().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().where).toEqual(undefined);
+    });
+
+    it('should handle single condition without nesting', () => {
+        queryBuilder.where('age', 30);
+
+        expect(queryBuilder.toObject().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().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().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().where).toEqual({
+            age: { $gte: 18 },
+            $or: [
+                {
+                    name: { $eq: 'Bob' },
+                    status: { $ne: 'inactive' },
+                },
+            ],
+            country: { $in: ['USA', 'Canada'] },
+        });
+    });
+});

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

@@ -0,0 +1,149 @@
+import { QueryBuilder } from '../lib/query-builder';
+import { OrderDirectionEnum } from '../lib/types';
+
+
+describe('QueryBuilder', () => {
+    let queryBuilder: QueryBuilder;
+
+    beforeEach(() => {
+        queryBuilder = new QueryBuilder({});
+    });
+
+    it('should set options', () => {
+        const options = { select: ['name', 'age'] };
+        queryBuilder.setOptions(options);
+        expect(queryBuilder.toObject().select).toEqual(options.select);
+    });
+
+    it('should merge options shallowly', () => {
+        queryBuilder.setOptions({ select: ['name'] });
+        queryBuilder.mergeOptions({ select: ['age'] });
+        expect(queryBuilder.toObject().select).toEqual(['age']);
+    });
+
+    it('should merge options deeply', () => {
+        queryBuilder.setOptions({ where: { age: { $gt: 18 } } });
+        queryBuilder.mergeOptions({ where: { name: { $eq: 'John' } } }, true);
+        expect(queryBuilder.toObject().where).toEqual({
+            age: { $gt: 18 },
+            name: { $eq: 'John' },
+        });
+    });
+
+    it('should add select fields', () => {
+        queryBuilder.addSelect('name');
+        queryBuilder.addSelect(['age', 'email']);
+        expect(queryBuilder.toObject().select).toEqual([
+            'name',
+            'age',
+            'email',
+        ]);
+    });
+
+    it('should remove select fields', () => {
+        queryBuilder.addSelect([
+            'name',
+            'age',
+            'email',
+        ]);
+        queryBuilder.removeSelect('age');
+        expect(queryBuilder.toObject().select).toEqual(['name', 'email']);
+    });
+
+    it('should add and remove relations as array of objects', () => {
+        queryBuilder.addRelation('profile', ['id', 'bio']);
+        queryBuilder.addRelation('posts', ['title', 'content']);
+
+        const relations = queryBuilder.toObject().relations;
+        expect(relations).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    relation: 'profile',
+                    select: ['id', 'bio'],
+                }),
+                expect.objectContaining({
+                    relation: 'posts',
+                    select: ['title', 'content'],
+                }),
+            ]),
+        );
+
+        queryBuilder.removeRelation('profile');
+        const updatedRelations = queryBuilder.toObject().relations;
+        expect(updatedRelations).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    relation: 'posts',
+                    select: ['title', 'content'],
+                }),
+            ]),
+        );
+        expect(updatedRelations).not.toEqual(
+            expect.arrayContaining([expect.objectContaining({ relation: 'profile' })]),
+        );
+    });
+
+    it('should handle null or empty relations', () => {
+        queryBuilder.addRelation('profile');
+        expect(queryBuilder.toObject().relations).not.toEqual(undefined);
+
+        queryBuilder.addRelation('profile');
+        queryBuilder.removeRelation('profile');
+        expect(queryBuilder.toObject().relations).toEqual(undefined);
+    });
+
+    it('should add and remove relations as array of strings', () => {
+        queryBuilder.addRelation('profile');
+        queryBuilder.addRelation('posts');
+
+        const relations = queryBuilder.toObject().relations;
+        expect(relations).toEqual(
+            expect.arrayContaining([expect.objectContaining({ relation: 'profile' }), expect.objectContaining({ relation: 'posts' })]),
+        );
+
+        queryBuilder.removeRelation('profile');
+        const updatedRelations = queryBuilder.toObject().relations;
+        expect(updatedRelations).toEqual(
+            expect.arrayContaining([expect.objectContaining({ relation: 'posts' })]),
+        );
+        expect(updatedRelations).not.toEqual(
+            expect.arrayContaining([expect.objectContaining({ relation: 'profile' })]),
+        );
+    });
+
+    it('should add where conditions', () => {
+        queryBuilder.where('age', 25);
+        expect(queryBuilder.toObject().where).toEqual({ age: { $eq: 25 } });
+    });
+
+    it('should handle empty where conditions', () => {
+        queryBuilder.where(() => {
+            // Do nothing
+        });
+        expect(queryBuilder.toObject().where).toEqual(undefined);
+    });
+
+    it('should add order', () => {
+        queryBuilder.addOrder('name', OrderDirectionEnum.ASC);
+        expect(queryBuilder.toObject().order).toEqual({ name: OrderDirectionEnum.ASC });
+    });
+
+    it('should remove order', () => {
+        queryBuilder.addOrder('name', OrderDirectionEnum.ASC);
+        queryBuilder.removeOrder('name');
+        expect(queryBuilder.toObject().order).toEqual({});
+    });
+
+    it('should set skip and take', () => {
+        queryBuilder.setSkip(10);
+        queryBuilder.setTake(5);
+        expect(queryBuilder.toObject().skip).toBe(10);
+        expect(queryBuilder.toObject().take).toBe(5);
+    });
+
+    it('should convert to JSON', () => {
+        queryBuilder.setOptions({ select: ['name'] });
+        const json = queryBuilder.toJson();
+        expect(json).toBe(JSON.stringify(queryBuilder.toObject()));
+    });
+});