@ackplus/nest-crud-request 0.1.51 → 1.1.1

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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,173 @@
+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

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

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "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

@@ -0,0 +1,15 @@
+{
+  "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"
+  ]
+}

package/src/index.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./lib/query-builder"), exports);
-tslib_1.__exportStar(require("./lib/where-builder"), exports);
-tslib_1.__exportStar(require("./lib/types"), exports);

package/src/lib/utils.js

@@ -1,11 +0,0 @@
-"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 Object.assign(Object.assign({}, target), source);
-}

package/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"version":"5.8.3"}