@nest-util/nest-crud 0.1.1 → 1.0.1

package/dist/lib/services/nest-crud.service.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NestCrudService = void 0;
 const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
-const nest_audit_1 = require("@nest-util/nest-audit");
+const audit_log_entity_1 = require("../entities/audit-log.entity");
 const filter_helper_1 = require("../helpers/filter.helper");
 const pagination_helper_1 = require("../helpers/pagination.helper");
+const cursor_pagination_helper_1 = require("../helpers/cursor-pagination.helper");
 let NestCrudService = class NestCrudService {
     constructor(options) {
         this.repo = options.repository;
@@ -17,6 +18,12 @@ let NestCrudService = class NestCrudService {
         this.createDtoClass = options.createDtoClass;
         this.updateDtoClass = options.updateDtoClass;
         this.disabledEndpoints = options.disabledEndpoints ?? [];
+        this.cursorStrategy =
+            options.cursorStrategy ?? (0, cursor_pagination_helper_1.detectCursorStrategy)(this.repo);
+        this.hooks = options.hooks ?? {};
+        this.transactionConfig = options.transactionConfig ?? {};
+        this.userOwnershipField = options.userOwnershipField;
+        this.findMineQuery = options.findMineQuery;
     }
     async resolveRelations(payload) {
         if (!this.relations.length)
@@ -39,6 +46,32 @@ let NestCrudService = class NestCrudService {
         }
         return payload;
     }
+    async executeInTransaction(fn, isolationLevel) {
+        const queryRunner = this.repo.manager.connection.createQueryRunner();
+        await queryRunner.startTransaction(isolationLevel);
+        try {
+            const result = await fn();
+            await queryRunner.commitTransaction();
+            return result;
+        }
+        catch (error) {
+            await queryRunner.rollbackTransaction();
+            throw error;
+        }
+        finally {
+            await queryRunner.release();
+        }
+    }
+    async executeHook(hook, context) {
+        if (!hook)
+            return;
+        if (hook.transaction) {
+            await this.executeInTransaction(() => hook.handler(context), this.transactionConfig?.isolationLevel);
+        }
+        else {
+            await hook.handler(context);
+        }
+    }
     async findAll(query) {
         const qb = this.repo.createQueryBuilder('e');
         if (this.include.length > 0) {
@@ -72,7 +105,115 @@ let NestCrudService = class NestCrudService {
             ? { data, meta: { ...paginationMeta, total } }
             : { data };
     }
+    async findMine(userId, query) {
+        if (!this.userOwnershipField && !this.findMineQuery) {
+            throw new common_1.BadRequestException('findMine not configured');
+        }
+        const qb = this.repo.createQueryBuilder('e');
+        if (this.findMineQuery) {
+            this.findMineQuery(qb, userId);
+        }
+        else if (this.userOwnershipField) {
+            qb.where(`e.${String(this.userOwnershipField)} = :userId`, { userId });
+        }
+        if (this.include.length > 0) {
+            this.include.forEach((relation) => {
+                const parts = relation.split('.');
+                if (parts.length === 1) {
+                    qb.leftJoinAndSelect(`e.${parts[0]}`, parts[0]);
+                }
+                else {
+                    const parentAlias = parts.slice(0, -1).join('_');
+                    const field = parts[parts.length - 1];
+                    const alias = parts.join('_');
+                    qb.leftJoinAndSelect(`${parentAlias}.${field}`, alias);
+                }
+            });
+        }
+        (0, filter_helper_1.applyFilters)(qb, query.filter, this.allowedFilters);
+        const paginationMeta = (0, pagination_helper_1.applyPagination)(qb, query);
+        if (query.orderBy) {
+            const orderDirection = query.orderDirection === 'ASC' ? 'ASC' : 'DESC';
+            if (this.allowedSortFields.length === 0 ||
+                this.allowedSortFields.includes(query.orderBy)) {
+                qb.orderBy(`e.${query.orderBy}`, orderDirection);
+            }
+        }
+        const [entities, total] = await qb.getManyAndCount();
+        const data = this.toResponseDto
+            ? this.toResponseDto(entities)
+            : entities;
+        return paginationMeta
+            ? { data, meta: { ...paginationMeta, total } }
+            : { data };
+    }
+    async findAllWithCursor(query) {
+        const limit = query.limit ?? 10;
+        const strategy = this.cursorStrategy;
+        const orderDirection = 'DESC';
+        const qb = this.repo.createQueryBuilder('e');
+        // Join relations
+        if (this.include.length > 0) {
+            this.include.forEach((relation) => {
+                const parts = relation.split('.');
+                if (parts.length === 1) {
+                    qb.leftJoinAndSelect(`e.${parts[0]}`, parts[0]);
+                }
+                else {
+                    const parentAlias = parts.slice(0, -1).join('_');
+                    const field = parts[parts.length - 1];
+                    const alias = parts.join('_');
+                    qb.leftJoinAndSelect(`${parentAlias}.${field}`, alias);
+                }
+            });
+        }
+        // Apply filters
+        (0, filter_helper_1.applyFilters)(qb, query.filter, this.allowedFilters);
+        // Apply cursor filter
+        if (query.cursor) {
+            const decoded = (0, cursor_pagination_helper_1.decodeCursor)(query.cursor, strategy);
+            (0, cursor_pagination_helper_1.applyCursorFilter)(qb, decoded, strategy, orderDirection);
+        }
+        // Default ordering by id
+        qb.orderBy(`e.id`, orderDirection);
+        // Fetch limit + 1 to detect hasMore
+        const take = limit + 1;
+        const entities = await qb.take(take).getMany();
+        const hasMore = entities.length > limit;
+        const data = hasMore ? entities.slice(0, limit) : entities;
+        // Build next cursor from last entity
+        const nextCursor = hasMore ? (0, cursor_pagination_helper_1.buildNextCursor)(data, strategy) : null;
+        // Optionally compute total count
+        let total;
+        if (query.includeTotal) {
+            // Build a clean count query (reuse same filters but no cursor/order/take)
+            const countQb = this.repo.createQueryBuilder('e');
+            if (this.include.length > 0) {
+                this.include.forEach((relation) => {
+                    const parts = relation.split('.');
+                    if (parts.length === 1) {
+                        countQb.leftJoin(`e.${parts[0]}`, parts[0]);
+                    }
+                });
+            }
+            (0, filter_helper_1.applyFilters)(countQb, query.filter, this.allowedFilters);
+            total = await countQb.getCount();
+        }
+        const response = this.toResponseDto
+            ? this.toResponseDto(data)
+            : data;
+        return {
+            data: response,
+            meta: {
+                limit,
+                hasMore,
+                nextCursor,
+                ...(total !== undefined ? { total } : {}),
+            },
+        };
+    }
     async findOne(id) {
+        await this.executeHook(this.hooks.beforeFindOne, { id });
         const entity = await this.repo.findOne({
             where: { id },
             relations: this.include,
@@ -80,16 +221,21 @@ let NestCrudService = class NestCrudService {
         if (!entity) {
             throw new common_1.NotFoundException('Resource not found');
         }
-        return this.toResponseDto
+        const result = this.toResponseDto
             ? this.toResponseDto(entity)
             : entity;
+        await this.executeHook(this.hooks.afterFindOne, { entity, id });
+        return result;
     }
     async create(payload) {
+        await this.executeHook(this.hooks.beforeCreate, { payload });
         const resolved = await this.resolveRelations(payload);
         const entity = await this.repo.save(resolved);
-        return this.toResponseDto
+        const result = this.toResponseDto
             ? this.toResponseDto(entity)
             : entity;
+        await this.executeHook(this.hooks.afterCreate, { entity, payload });
+        return result;
     }
     async update(id, payload) {
         const existing = await this.repo.findOneBy({
@@ -98,23 +244,32 @@ let NestCrudService = class NestCrudService {
         if (!existing) {
             throw new common_1.NotFoundException('Resource not found');
         }
+        await this.executeHook(this.hooks.beforeUpdate, { payload, entity: existing, id });
         const resolved = await this.resolveRelations(payload);
         this.repo.merge(existing, resolved);
         await this.repo.save(existing);
-        return this.findOne(id);
+        const result = await this.findOne(id);
+        await this.executeHook(this.hooks.afterUpdate, { entity: result, payload, id });
+        return result;
     }
     async remove(id) {
-        const result = await this.repo.delete(id);
-        if (result.affected === 0) {
+        const existing = await this.repo.findOneBy({
+            id,
+        });
+        if (!existing) {
             throw new common_1.NotFoundException('Resource not found');
         }
-        return true;
+        await this.executeHook(this.hooks.beforeRemove, { entity: existing, id });
+        const result = await this.repo.delete(id);
+        const deleted = result.affected !== 0;
+        await this.executeHook(this.hooks.afterRemove, { id, deleted });
+        return deleted;
     }
     async findAuditLogs(query) {
         const page = query.page ?? 1;
         const limit = query.limit ?? 10;
         const qb = this.repo.manager
-            .getRepository(nest_audit_1.AuditLogEntity)
+            .getRepository(audit_log_entity_1.AuditLogEntity)
             .createQueryBuilder('auditLog')
             .where('auditLog.entity = :entity', {
             entity: this.repo.metadata.name,

package/dist/lib/testing/crud-controller.test-suites.d.ts

@@ -0,0 +1,4 @@
+import { ObjectLiteral } from 'typeorm';
+import { CrudControllerTestConfig, CrudTestContext } from './testing.interface';
+export declare function crudControllerTests<TEntity extends ObjectLiteral, TCreateDto, TUpdateDto, TResponseDto>(config: CrudControllerTestConfig<TEntity, TCreateDto, TUpdateDto, TResponseDto>): CrudTestContext;
+//# sourceMappingURL=crud-controller.test-suites.d.ts.map

package/dist/lib/testing/crud-controller.test-suites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud-controller.test-suites.d.ts","sourceRoot":"","sources":["../../../src/lib/testing/crud-controller.test-suites.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAMxC,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGhF,wBAAgB,mBAAmB,CACjC,OAAO,SAAS,aAAa,EAC7B,UAAU,EACV,UAAU,EACV,YAAY,EAEZ,MAAM,EAAE,wBAAwB,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,CAAC,GAC9E,eAAe,CAoNjB"}

package/dist/lib/testing/crud-controller.test-suites.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crudControllerTests = crudControllerTests;
+const testing_1 = require("@nestjs/testing");
+const common_1 = require("@nestjs/common");
+const nest_crud_controller_1 = require("../controllers/nest-crud.controller");
+const mock_repository_1 = require("./mock-repository");
+function crudControllerTests(config) {
+    let controller;
+    let service;
+    let ControllerBase;
+    let moduleRef;
+    beforeEach(async () => {
+        service = {
+            disabledEndpoints: [],
+            findAll: jest.fn(),
+            findOne: jest.fn(),
+            create: jest.fn(),
+            update: jest.fn(),
+            remove: jest.fn(),
+            findAuditLogs: jest.fn(),
+            findMine: jest.fn(),
+        };
+        ControllerBase = config.controllerFactory();
+        class TestController extends ControllerBase {
+            constructor() {
+                super(service);
+            }
+        }
+        moduleRef = await testing_1.Test.createTestingModule({
+            controllers: [TestController],
+        }).compile();
+        controller = moduleRef.get(TestController);
+    });
+    describe('findAll', () => {
+        it('should call service.findAll with query params', async () => {
+            const query = { page: 1, limit: 10 };
+            const expected = { data: [], meta: { total: 0 } };
+            service.findAll.mockResolvedValue(expected);
+            const result = await controller.findAll(query);
+            expect(service.findAll).toHaveBeenCalledWith(query);
+            expect(result).toEqual(expected);
+        });
+        it('should handle pagination parameters', async () => {
+            const query = { page: 5, limit: 100 };
+            service.findAll.mockResolvedValue({ data: [] });
+            await controller.findAll(query);
+            expect(service.findAll).toHaveBeenCalledWith(expect.objectContaining({ page: 5, limit: 100 }));
+        });
+        it('should handle complex filter objects', async () => {
+            const query = {
+                filter: { name_cont: 'Alice', isActive_eq: 'true' },
+            };
+            service.findAll.mockResolvedValue({ data: [] });
+            await controller.findAll(query);
+            expect(service.findAll).toHaveBeenCalledWith(expect.objectContaining({
+                filter: { name_cont: 'Alice', isActive_eq: 'true' },
+            }));
+        });
+        it('should work with no query parameters', async () => {
+            service.findAll.mockResolvedValue({ data: [] });
+            await controller.findAll({});
+            expect(service.findAll).toHaveBeenCalledWith({});
+        });
+    });
+    describe('findOne', () => {
+        it('should call service.findOne with correct id', async () => {
+            const expectedResult = { id: 1, name: 'Test' };
+            service.findOne.mockResolvedValue(expectedResult);
+            const result = await controller.findOne(1);
+            expect(service.findOne).toHaveBeenCalledWith(1);
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe('create', () => {
+        it('should call service.create with dto', async () => {
+            const dto = config.test.createPayload;
+            const expectedResult = { id: 1 };
+            service.create.mockResolvedValue(expectedResult);
+            const result = await controller.create(dto);
+            expect(service.create).toHaveBeenCalledWith(dto);
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe('update', () => {
+        it('should call service.update with id and dto', async () => {
+            const dto = config.test.updatePayload;
+            const expectedResult = { id: 1 };
+            service.update.mockResolvedValue(expectedResult);
+            const result = await controller.update(1, dto);
+            expect(service.update).toHaveBeenCalledWith(1, dto);
+            expect(result).toEqual(expectedResult);
+        });
+    });
+    describe('remove', () => {
+        it('should call service.remove', async () => {
+            service.remove.mockResolvedValue(true);
+            const result = await controller.remove(1);
+            expect(service.remove).toHaveBeenCalledWith(1);
+            expect(result).toBe(true);
+        });
+    });
+    describe('findMine', () => {
+        it('should call service.findMine with user id', async () => {
+            const query = { page: 1, limit: 10 };
+            const expected = { data: [] };
+            service.findMine.mockResolvedValue(expected);
+            const mockUser = { id: 42 };
+            const result = await controller.findMine(mockUser, query);
+            expect(service.findMine).toHaveBeenCalledWith(42, query);
+            expect(result).toEqual(expected);
+        });
+    });
+    describe('disabledEndpoints', () => {
+        it('should block disabled endpoints', async () => {
+            service.disabledEndpoints = ['create'];
+            expect(() => controller.create({})).toThrow(common_1.NotFoundException);
+            expect(service.create).not.toHaveBeenCalled();
+        });
+    });
+    describe('findAuditLogs', () => {
+        it('should call service.findAuditLogs with query params', async () => {
+            const query = { page: 1, limit: 5, user_id: '1' };
+            const expected = { data: [], meta: { total: 0, page: 1, limit: 5 } };
+            service.findAuditLogs.mockResolvedValue(expected);
+            const result = await controller.findAuditLogs?.(query);
+            expect(service.findAuditLogs).toHaveBeenCalledWith(query);
+            expect(result).toEqual(expected);
+        });
+        it('should throw when audit logs endpoint is not available', () => {
+            service.findAuditLogs = undefined;
+            expect(() => controller.findAuditLogs?.({})).toThrow(common_1.NotFoundException);
+        });
+    });
+    describe('permissions', () => {
+        it('should attach auth permission metadata to configured handlers', () => {
+            if (!config.permissions)
+                return;
+            const PermissionedBase = config.controllerFactory();
+            class PermissionedCtrl extends PermissionedBase {
+                constructor() {
+                    super(service);
+                }
+            }
+            for (const [endpoint, permission] of Object.entries(config.permissions)) {
+                const method = PermissionedCtrl.prototype[endpoint];
+                if (!method)
+                    continue;
+                const metadata = Reflect.getMetadata(nest_crud_controller_1.AUTH_PERMISSIONS_METADATA_KEY, method);
+                const expected = Array.isArray(permission)
+                    ? permission
+                    : [permission];
+                expect(metadata).toEqual(expected);
+            }
+        });
+    });
+    const ctx = {
+        get module() {
+            return moduleRef;
+        },
+        repository: null,
+        createMockQb: mock_repository_1.createMockQb,
+    };
+    return ctx;
+}

package/dist/lib/testing/crud-service.test-suites.d.ts

@@ -0,0 +1,4 @@
+import { ObjectLiteral } from 'typeorm';
+import { CrudTestConfig, CrudTestContext } from './testing.interface';
+export declare function crudServiceTests<TEntity extends ObjectLiteral, TCreateDto, TUpdateDto, TResponseDto>(config: CrudTestConfig<TEntity, TCreateDto, TUpdateDto, TResponseDto>): CrudTestContext;
+//# sourceMappingURL=crud-service.test-suites.d.ts.map

package/dist/lib/testing/crud-service.test-suites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud-service.test-suites.d.ts","sourceRoot":"","sources":["../../../src/lib/testing/crud-service.test-suites.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtE,wBAAgB,gBAAgB,CAC9B,OAAO,SAAS,aAAa,EAC7B,UAAU,EACV,UAAU,EACV,YAAY,EACZ,MAAM,EAAE,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,CAAC,GAAG,eAAe,CAqVxF"}