@ackplus/nest-crud-request 1.1.1 → 1.1.2

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

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

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

@@ -1,32 +0,0 @@
-import { RelationBuilder } from '../lib/relation-builder';
-
-
-describe('RelationBuilder', () => {
-    let relationBuilder: RelationBuilder;
-
-    beforeEach(() => {
-        relationBuilder = new RelationBuilder();
-    });
-
-    it('should handle empty relations', () => {
-        // Initially, the relations should be empty
-        expect(relationBuilder.toObject()).toEqual({});
-
-        // Clear any relations if set
-        relationBuilder.clear();
-        expect(relationBuilder.toObject()).toEqual({});
-    });
-
-    it('should handle setting empty relations', () => {
-        // Set empty relations
-        relationBuilder.setRelations([]);
-        expect(relationBuilder.toObject()).toEqual({});
-    });
-
-    it('should handle clearing relations', () => {
-        // Add some relations and then clear them
-        relationBuilder.setRelations(['relation1', 'relation2']);
-        relationBuilder.clear();
-        expect(relationBuilder.toObject()).toEqual({});
-    });
-});

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

@@ -1,173 +0,0 @@
-import { WhereBuilder } from '../lib/where-builder';
-import { WhereOperatorEnum } from '../lib/types';
-
-describe('WhereBuilder - Complex Nested Structures', () => {
-    let whereBuilder: WhereBuilder;
-
-    beforeEach(() => {
-        whereBuilder = new WhereBuilder();
-    });
-
-    it('should create complex nested where structure with mixed conditions', () => {
-        // Target structure:
-        // {
-        //   customerId: { $in: ['cust_123', 'cust_456'] },
-        //   $or: [
-        //     { status: { $eq: 'pending' } },
-        //     { status: { $eq: 'processing' } },
-        //     {
-        //       $and: [
-        //         { total: { $gt: 1000 } },
-        //         { tax: { $lte: 200 } },
-        //       ],
-        //     },
-        //   ],
-        // }
-
-        whereBuilder
-            .where('customerId', WhereOperatorEnum.IN, ['cust_123', 'cust_456'])
-            .orWhere('status', WhereOperatorEnum.EQ, 'pending')
-            .orWhere('status', WhereOperatorEnum.EQ, 'processing')
-            .orWhere((builder) => {
-                builder.where('total', WhereOperatorEnum.GT, 1000)
-                    .where('tax', WhereOperatorEnum.LT_OR_EQ, 200);
-            });
-
-        const result = whereBuilder.toObject();
-
-        expect(result).toEqual({
-            customerId: { $in: ['cust_123', 'cust_456'] },
-            $or: [
-                { status: { $eq: 'pending' } },
-                { status: { $eq: 'processing' } },
-                {
-                    total: { $gt: 1000 },
-                    tax: { $lte: 200 },
-                },
-            ],
-        });
-    });
-
-    it('should handle multiple field conditions with same logical operator', () => {
-        whereBuilder
-            .where('name', 'John')
-            .orWhere('age', WhereOperatorEnum.GT, 18)
-            .orWhere('status', 'active')
-            .where('country', 'USA');
-
-        const result = whereBuilder.toObject();
-
-        expect(result).toEqual({
-            name: { $eq: 'John' },
-            country: { $eq: 'USA' },
-            $or: [
-                { age: { $gt: 18 } },
-                { status: { $eq: 'active' } },
-            ],
-        });
-    });
-
-    it('should handle nested $and and $or conditions', () => {
-        whereBuilder
-            .where('userId', '123')
-            .orWhere((builder) => {
-                builder.where('role', 'admin')
-                    .where('department', 'IT');
-            })
-            .orWhere((builder) => {
-                builder.where('role', 'manager')
-                    .where('level', WhereOperatorEnum.GT, 5);
-            });
-
-        const result = whereBuilder.toObject();
-
-        expect(result).toEqual({
-            userId: { $eq: '123' },
-            $or: [
-                {
-                    role: { $eq: 'admin' },
-                    department: { $eq: 'IT' },
-                },
-                {
-                    role: { $eq: 'manager' },
-                    level: { $gt: 5 },
-                },
-            ],
-        });
-    });
-
-    it('should handle direct object conditions', () => {
-        whereBuilder
-            .where({
-                name: { $eq: 'John' },
-                age: { $gt: 18 },
-            })
-            .orWhere({
-                status: { $eq: 'active' },
-                verified: { $eq: true },
-            });
-
-        const result = whereBuilder.toObject();
-
-        expect(result).toEqual({
-            name: { $eq: 'John' },
-            age: { $gt: 18 },
-            $or: [
-                {
-                    status: { $eq: 'active' },
-                    verified: { $eq: true },
-                },
-            ],
-        });
-    });
-
-    it('should merge multiple $or conditions correctly', () => {
-        whereBuilder
-            .orWhere('category', 'tech')
-            .orWhere('category', 'design')
-            .where('published', true)
-            .orWhere('priority', WhereOperatorEnum.GT, 5);
-
-        const result = whereBuilder.toObject();
-
-        expect(result).toEqual({
-            published: { $eq: true },
-            $or: [
-                { category: { $eq: 'tech' } },
-                { category: { $eq: 'design' } },
-                { priority: { $gt: 5 } },
-            ],
-        });
-    });
-
-    it('should handle complex nested logical operations', () => {
-        whereBuilder
-            .where('companyId', '456')
-            .orWhere((builder) => {
-                builder.where('department', 'Sales')
-                    .orWhere((innerBuilder) => {
-                        innerBuilder.where('region', 'North')
-                            .where('quota', WhereOperatorEnum.GT, 100000);
-                    });
-            })
-            .where('active', true);
-
-        const result = whereBuilder.toObject();
-
-        expect(result).toEqual({
-            companyId: { $eq: '456' },
-            active: { $eq: true },
-            $or: [
-                {
-                    department: { $eq: 'Sales' },
-                    $or: [
-                        {
-                            region: { $eq: 'North' },
-                            quota: { $gt: 100000 },
-                        },
-                    ],
-                },
-            ],
-        });
-    });
-});

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "forceConsistentCasingInFileNames": true
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
-}

package/tsconfig.spec.json

@@ -1,15 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "module": "commonjs",
-    "moduleResolution": "node10",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "jest.config.ts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.d.ts"
-  ]
-}