@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

package/fesm/classes/api-service.class.spec.js

@@ -1,1133 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { Logger, InternalServerErrorException, NotFoundException } from '@nestjs/common';
-import { createMockRepository, createMockDataSourceProvider } from '@test-utils/mocks/repository.mock';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { ApiService } from './api-service.class';
-import { EventBusRegistry } from './event-bus.registry';
-import { UtilsService } from '../modules/utils/utils.service';
-import { Identity } from '../entities';
-let TestEntity = class TestEntity extends Identity {
-    constructor(...args){
-        super(...args), _define_property(this, "name", void 0);
-    }
-};
-let TestApiService = class TestApiService extends ApiService {
-    /** `publishDomainAction` is protected - feature services reach it as subclasses do */ publishAction(action, metadata) {
-        return this.publishDomainAction(action, {
-            ids: [
-                '1'
-            ],
-            metadata
-        });
-    }
-};
-function createMockQueryRunner() {
-    return {
-        connect: jest.fn(),
-        startTransaction: jest.fn(),
-        commitTransaction: jest.fn(),
-        rollbackTransaction: jest.fn(),
-        release: jest.fn(),
-        manager: {
-            save: jest.fn(),
-            update: jest.fn(),
-            delete: jest.fn(),
-            softDelete: jest.fn(),
-            restore: jest.fn()
-        }
-    };
-}
-describe('ApiService', ()=>{
-    let mockRepo;
-    let mockCache;
-    let utilsService;
-    let mockQueryRunner;
-    let mockUser;
-    let debugSpy;
-    let errorLogSpy;
-    function makeService(isCacheable = false) {
-        const dataSourceProvider = createMockDataSourceProvider(mockRepo);
-        return new TestApiService('test-entity', mockCache, utilsService, 'TestApiService', isCacheable, 'app', dataSourceProvider, TestEntity);
-    }
-    beforeEach(()=>{
-        mockRepo = createMockRepository();
-        mockRepo.create.mockReturnValue({});
-        mockQueryRunner = createMockQueryRunner();
-        mockRepo.manager.connection.createQueryRunner = jest.fn().mockReturnValue(mockQueryRunner);
-        mockCache = {
-            get: jest.fn(),
-            set: jest.fn(),
-            del: jest.fn()
-        };
-        utilsService = new UtilsService();
-        mockUser = buildMockUser();
-        // LogAction falls back to a real Nest Logger when no moduleName is set — silence it.
-        debugSpy = jest.spyOn(Logger.prototype, 'debug').mockImplementation(()=>undefined);
-        errorLogSpy = jest.spyOn(Logger.prototype, 'error').mockImplementation(()=>undefined);
-    });
-    afterEach(()=>{
-        debugSpy.mockRestore();
-        errorLogSpy.mockRestore();
-        jest.clearAllMocks();
-    });
-    describe('insert', ()=>{
-        it('should save a new entity and return the converted response dto', async ()=>{
-            const service = makeService();
-            const created = {
-                id: undefined,
-                name: 'x'
-            };
-            mockRepo.create.mockReturnValue(created);
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: 'new-1',
-                name: 'Widget'
-            });
-            const result = await service.insert({
-                name: 'Widget'
-            }, mockUser);
-            expect(mockQueryRunner.connect).toHaveBeenCalled();
-            expect(mockQueryRunner.startTransaction).toHaveBeenCalled();
-            expect(mockQueryRunner.manager.save).toHaveBeenCalledWith(mockRepo.target, [
-                expect.objectContaining({
-                    name: 'Widget'
-                })
-            ]);
-            expect(mockQueryRunner.commitTransaction).toHaveBeenCalled();
-            expect(mockQueryRunner.release).toHaveBeenCalled();
-            expect(result).toEqual({
-                id: 'new-1',
-                name: 'Widget'
-            });
-        });
-        it('should look up and merge onto the existing entity when the dto carries an id', async ()=>{
-            const service = makeService();
-            const existing = {
-                id: 'existing-1',
-                name: 'Old'
-            };
-            mockRepo.findOne.mockResolvedValue(existing);
-            mockQueryRunner.manager.save.mockImplementation((_target, entities)=>entities);
-            await service.insert({
-                id: 'existing-1',
-                name: 'New'
-            }, mockUser);
-            expect(mockRepo.findOne).toHaveBeenCalledWith({
-                where: {
-                    id: 'existing-1'
-                }
-            });
-            expect(mockQueryRunner.manager.save).toHaveBeenCalledWith(mockRepo.target, [
-                expect.objectContaining({
-                    id: 'existing-1',
-                    name: 'New'
-                })
-            ]);
-        });
-        it('should throw NotFoundException and roll back when the dto id does not match any entity', async ()=>{
-            const service = makeService();
-            mockRepo.findOne.mockResolvedValue(null);
-            await expect(service.insert({
-                id: 'missing',
-                name: 'x'
-            }, mockUser)).rejects.toThrow(NotFoundException);
-            expect(mockQueryRunner.rollbackTransaction).toHaveBeenCalled();
-            expect(mockQueryRunner.release).toHaveBeenCalled();
-        });
-        it('should roll back and rethrow when save fails', async ()=>{
-            const service = makeService();
-            mockQueryRunner.manager.save.mockRejectedValue(new Error('db down'));
-            await expect(service.insert({
-                name: 'Widget'
-            }, mockUser)).rejects.toThrow('db down');
-            expect(mockQueryRunner.rollbackTransaction).toHaveBeenCalled();
-            expect(mockQueryRunner.commitTransaction).not.toHaveBeenCalled();
-        });
-        it('should wrap a non-Error rejection in InternalServerErrorException', async ()=>{
-            const service = makeService();
-            mockQueryRunner.manager.save.mockRejectedValue('raw string failure');
-            await expect(service.insert({
-                name: 'Widget'
-            }, mockUser)).rejects.toThrow(InternalServerErrorException);
-        });
-        it('should clear cache entries only when the service is cacheable', async ()=>{
-            const cacheableService = makeService(true);
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: 'new-1',
-                name: 'Widget'
-            });
-            mockCache.get.mockResolvedValue([]);
-            await cacheableService.insert({
-                name: 'Widget'
-            }, mockUser);
-            expect(mockCache.del).toHaveBeenCalled();
-        });
-        it('should not touch the cache when the service is not cacheable', async ()=>{
-            const service = makeService(false);
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: 'new-1',
-                name: 'Widget'
-            });
-            await service.insert({
-                name: 'Widget'
-            }, mockUser);
-            expect(mockCache.get).not.toHaveBeenCalled();
-            expect(mockCache.del).not.toHaveBeenCalled();
-        });
-    });
-    describe('insertMany', ()=>{
-        it('should save every dto and return one response entry per saved entity', async ()=>{
-            const service = makeService();
-            mockQueryRunner.manager.save.mockResolvedValue([
-                {
-                    id: '1',
-                    name: 'A'
-                },
-                {
-                    id: '2',
-                    name: 'B'
-                }
-            ]);
-            const result = await service.insertMany([
-                {
-                    name: 'A'
-                },
-                {
-                    name: 'B'
-                }
-            ], mockUser);
-            expect(result).toEqual([
-                {
-                    id: '1',
-                    name: 'A'
-                },
-                {
-                    id: '2',
-                    name: 'B'
-                }
-            ]);
-        });
-    });
-    describe('update / updateMany', ()=>{
-        it('should update a single entity in place', async ()=>{
-            const service = makeService();
-            mockRepo.findOne.mockResolvedValue({
-                id: '1',
-                name: 'Old'
-            });
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: '1',
-                name: 'Updated'
-            });
-            const result = await service.update({
-                id: '1',
-                name: 'Updated'
-            }, mockUser);
-            expect(result).toEqual({
-                id: '1',
-                name: 'Updated'
-            });
-        });
-        it('should update multiple entities and return all of them', async ()=>{
-            const service = makeService();
-            mockRepo.findOne.mockResolvedValue({
-                id: 'x',
-                name: 'Old'
-            });
-            mockQueryRunner.manager.save.mockResolvedValue([
-                {
-                    id: '1',
-                    name: 'A2'
-                },
-                {
-                    id: '2',
-                    name: 'B2'
-                }
-            ]);
-            const result = await service.updateMany([
-                {
-                    id: '1',
-                    name: 'A2'
-                },
-                {
-                    id: '2',
-                    name: 'B2'
-                }
-            ], mockUser);
-            expect(result).toHaveLength(2);
-        });
-        it('should throw NotFoundException when the id to update does not exist', async ()=>{
-            const service = makeService();
-            mockRepo.findOne.mockResolvedValue(null);
-            await expect(service.update({
-                id: 'missing',
-                name: 'x'
-            }, mockUser)).rejects.toThrow(NotFoundException);
-            expect(mockQueryRunner.rollbackTransaction).toHaveBeenCalled();
-        });
-    });
-    describe('bulkUpsert', ()=>{
-        it('should run insert and update phases and combine the results', async ()=>{
-            const service = makeService();
-            mockRepo.findOne.mockResolvedValue({
-                id: 'existing-1',
-                name: 'Old'
-            });
-            mockQueryRunner.manager.save.mockResolvedValueOnce([
-                {
-                    id: 'new-1',
-                    name: 'Inserted'
-                }
-            ]).mockResolvedValueOnce([
-                {
-                    id: 'existing-1',
-                    name: 'Updated'
-                }
-            ]);
-            const result = await service.bulkUpsert([
-                {
-                    name: 'Inserted'
-                }
-            ], [
-                {
-                    id: 'existing-1',
-                    name: 'Updated'
-                }
-            ], mockUser);
-            expect(result).toEqual([
-                {
-                    id: 'new-1',
-                    name: 'Inserted'
-                },
-                {
-                    id: 'existing-1',
-                    name: 'Updated'
-                }
-            ]);
-            expect(mockQueryRunner.manager.save).toHaveBeenCalledTimes(2);
-        });
-        it('should skip the insert phase entirely when there is nothing to insert', async ()=>{
-            const service = makeService();
-            mockRepo.findOne.mockResolvedValue({
-                id: 'existing-1',
-                name: 'Old'
-            });
-            mockQueryRunner.manager.save.mockResolvedValue([
-                {
-                    id: 'existing-1',
-                    name: 'Updated'
-                }
-            ]);
-            await service.bulkUpsert([], [
-                {
-                    id: 'existing-1',
-                    name: 'Updated'
-                }
-            ], mockUser);
-            expect(mockQueryRunner.manager.save).toHaveBeenCalledTimes(1);
-        });
-        it('should skip the update phase entirely when there is nothing to update', async ()=>{
-            const service = makeService();
-            mockQueryRunner.manager.save.mockResolvedValue([
-                {
-                    id: 'new-1',
-                    name: 'Inserted'
-                }
-            ]);
-            await service.bulkUpsert([
-                {
-                    name: 'Inserted'
-                }
-            ], [], mockUser);
-            expect(mockQueryRunner.manager.save).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('findByIds', ()=>{
-        it('should return converted results for matching ids', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getMany.mockResolvedValue([
-                {
-                    id: '1',
-                    name: 'A'
-                },
-                {
-                    id: '2',
-                    name: 'B'
-                }
-            ]);
-            const result = await service.findByIds([
-                '1',
-                '2'
-            ], mockUser);
-            const whereArg = qb.where.mock.calls[0][0];
-            expect(whereArg.id._type).toBe('in');
-            expect(whereArg.id._value).toEqual([
-                '1',
-                '2'
-            ]);
-            expect(result).toEqual([
-                {
-                    id: '1',
-                    name: 'A'
-                },
-                {
-                    id: '2',
-                    name: 'B'
-                }
-            ]);
-        });
-        it('should accept a comma-separated select string and split it', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getMany.mockResolvedValue([
-                {
-                    id: '1',
-                    name: 'A'
-                }
-            ]);
-            await service.findByIds([
-                '1'
-            ], mockUser, 'id, name');
-            expect(qb.select).toHaveBeenCalledWith([
-                'test-entity.id',
-                'test-entity.name'
-            ]);
-        });
-        it('should throw NotFoundException when no rows match', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getMany.mockResolvedValue([]);
-            await expect(service.findByIds([
-                'missing'
-            ], mockUser)).rejects.toThrow(NotFoundException);
-        });
-        it('should wrap unexpected errors via handleError', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getMany.mockRejectedValue('boom');
-            await expect(service.findByIds([
-                '1'
-            ], mockUser)).rejects.toThrow(InternalServerErrorException);
-        });
-    });
-    describe('findById', ()=>{
-        it('should return the converted entity when found', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getOne.mockResolvedValue({
-                id: '1',
-                name: 'A'
-            });
-            const result = await service.findById('1', mockUser);
-            expect(qb.where).toHaveBeenCalledWith({
-                id: '1'
-            });
-            expect(result).toEqual({
-                id: '1',
-                name: 'A'
-            });
-        });
-        it('should throw NotFoundException when nothing matches the id', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getOne.mockResolvedValue(null);
-            await expect(service.findById('missing', mockUser)).rejects.toThrow(NotFoundException);
-        });
-        it('should return the cached value without querying when isCacheable and the cache hits', async ()=>{
-            const service = makeService(true);
-            mockCache.get.mockResolvedValue({
-                id: '1',
-                name: 'Cached'
-            });
-            const qb = mockRepo.createQueryBuilder();
-            const result = await service.findById('1', mockUser);
-            expect(result).toEqual({
-                id: '1',
-                name: 'Cached'
-            });
-            expect(qb.getOne).not.toHaveBeenCalled();
-        });
-        it('should query, then populate the cache on a miss when isCacheable', async ()=>{
-            const service = makeService(true);
-            mockCache.get.mockResolvedValue(undefined);
-            const qb = mockRepo.createQueryBuilder();
-            qb.getOne.mockResolvedValue({
-                id: '1',
-                name: 'Fresh'
-            });
-            const result = await service.findById('1', mockUser);
-            expect(result).toEqual({
-                id: '1',
-                name: 'Fresh'
-            });
-            expect(mockCache.set).toHaveBeenCalledWith(expect.any(String), {
-                id: '1',
-                name: 'Fresh'
-            });
-        });
-        it('should never touch the cache when the service is not cacheable', async ()=>{
-            const service = makeService(false);
-            const qb = mockRepo.createQueryBuilder();
-            qb.getOne.mockResolvedValue({
-                id: '1',
-                name: 'A'
-            });
-            await service.findById('1', mockUser);
-            expect(mockCache.get).not.toHaveBeenCalled();
-            expect(mockCache.set).not.toHaveBeenCalled();
-        });
-    });
-    describe('getAll', ()=>{
-        it('should return paginated, converted results', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getManyAndCount.mockResolvedValue([
-                [
-                    {
-                        id: '1',
-                        name: 'A'
-                    }
-                ],
-                1
-            ]);
-            const result = await service.getAll('', {
-                pagination: {
-                    currentPage: 0,
-                    pageSize: 10
-                }
-            }, mockUser);
-            expect(result.data).toEqual([
-                {
-                    id: '1',
-                    name: 'A'
-                }
-            ]);
-            expect(result.total).toBe(1);
-            expect(qb.skip).toHaveBeenCalledWith(0);
-            expect(qb.take).toHaveBeenCalledWith(10);
-        });
-        it('should compute the correct offset for page > 0', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getManyAndCount.mockResolvedValue([
-                [],
-                0
-            ]);
-            await service.getAll('', {
-                pagination: {
-                    currentPage: 2,
-                    pageSize: 25
-                }
-            }, mockUser);
-            expect(qb.skip).toHaveBeenCalledWith(50);
-            expect(qb.take).toHaveBeenCalledWith(25);
-        });
-        it('should apply filter conditions via andWhere', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getManyAndCount.mockResolvedValue([
-                [],
-                0
-            ]);
-            await service.getAll('', {
-                filter: {
-                    isActive: true
-                }
-            }, mockUser);
-            expect(qb.andWhere).toHaveBeenCalledWith('test-entity.isActive = :value', {
-                value: true
-            });
-        });
-        it('should apply a global search filter when a search term is given', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getManyAndCount.mockResolvedValue([
-                [],
-                0
-            ]);
-            await service.getAll('widget', {}, mockUser);
-            expect(qb.andWhere).toHaveBeenCalledWith('test-entity.name LIKE :search', {
-                search: '%widget%'
-            });
-        });
-        it('should apply sort as addOrderBy', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getManyAndCount.mockResolvedValue([
-                [],
-                0
-            ]);
-            await service.getAll('', {
-                sort: {
-                    name: 'DESC'
-                }
-            }, mockUser);
-            expect(qb.addOrderBy).toHaveBeenCalledWith('test-entity.name', 'DESC');
-        });
-        it('should include soft-deleted rows only when withDeleted is set', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getManyAndCount.mockResolvedValue([
-                [],
-                0
-            ]);
-            qb.withDeleted = jest.fn().mockReturnThis();
-            await service.getAll('', {
-                withDeleted: true
-            }, mockUser);
-            expect(qb.withDeleted).toHaveBeenCalled();
-        });
-        it('should return the cached page without querying on a cache hit', async ()=>{
-            const service = makeService(true);
-            const cached = {
-                data: [
-                    {
-                        id: '1',
-                        name: 'Cached'
-                    }
-                ],
-                total: 1
-            };
-            mockCache.get.mockResolvedValue(cached);
-            const qb = mockRepo.createQueryBuilder();
-            const result = await service.getAll('', {}, mockUser);
-            expect(result).toBe(cached);
-            expect(qb.getManyAndCount).not.toHaveBeenCalled();
-        });
-        it('should populate the cache after a fresh query on a miss', async ()=>{
-            const service = makeService(true);
-            mockCache.get.mockResolvedValue(undefined);
-            const qb = mockRepo.createQueryBuilder();
-            qb.getManyAndCount.mockResolvedValue([
-                [
-                    {
-                        id: '1',
-                        name: 'A'
-                    }
-                ],
-                1
-            ]);
-            await service.getAll('', {}, mockUser);
-            expect(mockCache.set).toHaveBeenCalledWith(expect.any(String), {
-                data: [
-                    {
-                        id: '1',
-                        name: 'A'
-                    }
-                ],
-                total: 1
-            });
-        });
-        it('should wrap query errors via handleError', async ()=>{
-            const service = makeService();
-            const qb = mockRepo.createQueryBuilder();
-            qb.getManyAndCount.mockRejectedValue(new Error('query failed'));
-            await expect(service.getAll('', {}, mockUser)).rejects.toThrow('query failed');
-        });
-        describe('raw query mode', ()=>{
-            let RawTestApiService = class RawTestApiService extends ApiService {
-                async getSelectQuery(query) {
-                    return {
-                        query,
-                        isRaw: true
-                    };
-                }
-            };
-            function makeRawService(dbType) {
-                mockRepo.manager.connection.options.type = dbType;
-                const dataSourceProvider = createMockDataSourceProvider(mockRepo);
-                return new RawTestApiService('test-entity', mockCache, utilsService, 'RawTestApiService', false, 'app', dataSourceProvider, TestEntity);
-            }
-            function primeRawQueryBuilder(qb) {
-                qb.expressionMap = {
-                    orderBys: {
-                        x: 'ASC'
-                    }
-                };
-                qb.getQuery.mockReturnValue('SELECT * FROM test_entity');
-                qb.getQueryAndParameters.mockReturnValue([
-                    'SELECT 1',
-                    []
-                ]);
-                qb.getParameters.mockReturnValue({});
-            }
-            it('should build a postgres-style positional count query and use getRawMany for data', async ()=>{
-                const service = makeRawService('postgres');
-                const qb = mockRepo.createQueryBuilder();
-                primeRawQueryBuilder(qb);
-                qb.getRawMany.mockResolvedValue([
-                    {
-                        id: '1',
-                        name: 'Raw'
-                    }
-                ]);
-                mockRepo.query.mockResolvedValue([
-                    {
-                        count: '3'
-                    }
-                ]);
-                const result = await service.getAll('', {}, mockUser);
-                expect(mockRepo.query).toHaveBeenCalledWith(expect.stringContaining('SELECT COUNT(*)'), []);
-                expect(result.total).toBe(3);
-                expect(result.data).toEqual([
-                    {
-                        id: '1',
-                        name: 'Raw'
-                    }
-                ]);
-            });
-            it('should convert ? placeholders positionally for postgres and throw on a missing parameter', async ()=>{
-                const service = makeRawService('postgres');
-                const qb = mockRepo.createQueryBuilder();
-                primeRawQueryBuilder(qb);
-                // simulate a parameter referenced in SQL but absent from getParameters()
-                qb.getQuery = jest.fn().mockReturnValue('SELECT * FROM t WHERE id = :missingKey');
-                qb.getParameters = jest.fn().mockReturnValue({});
-                await expect(service.getAll('', {}, mockUser)).rejects.toThrow(InternalServerErrorException);
-            });
-            it('should use ? placeholders (unchanged) for mysql', async ()=>{
-                const service = makeRawService('mysql');
-                const qb = mockRepo.createQueryBuilder();
-                primeRawQueryBuilder(qb);
-                qb.getRawMany.mockResolvedValue([]);
-                mockRepo.query.mockResolvedValue([
-                    {
-                        count: '0'
-                    }
-                ]);
-                await service.getAll('', {}, mockUser);
-                const [sql] = mockRepo.query.mock.calls[0];
-                expect(sql).not.toContain('$1');
-            });
-        });
-    });
-    describe('delete', ()=>{
-        it('should soft-delete and stamp deletedById for type "delete"', async ()=>{
-            const service = makeService();
-            await service.delete({
-                id: '1',
-                type: 'delete',
-                deletedById: 'user-1'
-            }, mockUser);
-            expect(mockQueryRunner.manager.softDelete).toHaveBeenCalledWith(mockRepo.target, '1');
-            expect(mockQueryRunner.manager.update).toHaveBeenCalledWith(mockRepo.target, '1', {
-                deletedById: 'user-1'
-            });
-            expect(mockQueryRunner.commitTransaction).toHaveBeenCalled();
-        });
-        it('should restore and stamp deletedById for type "restore"', async ()=>{
-            const service = makeService();
-            await service.delete({
-                id: '1',
-                type: 'restore'
-            }, mockUser);
-            expect(mockQueryRunner.manager.restore).toHaveBeenCalledWith(mockRepo.target, '1');
-            expect(mockQueryRunner.manager.update).toHaveBeenCalled();
-        });
-        it('should hard-delete for any other type', async ()=>{
-            const service = makeService();
-            await service.delete({
-                id: '1',
-                type: 'permanent'
-            }, mockUser);
-            expect(mockQueryRunner.manager.delete).toHaveBeenCalledWith(mockRepo.target, '1');
-            expect(mockQueryRunner.manager.softDelete).not.toHaveBeenCalled();
-        });
-        it('should support deleting multiple ids at once', async ()=>{
-            const service = makeService();
-            await service.delete({
-                id: [
-                    '1',
-                    '2'
-                ],
-                type: 'permanent'
-            }, mockUser);
-            expect(mockQueryRunner.manager.delete).toHaveBeenCalledWith(mockRepo.target, [
-                '1',
-                '2'
-            ]);
-        });
-        it('should roll back and rethrow when the delete operation fails', async ()=>{
-            const service = makeService();
-            mockQueryRunner.manager.delete.mockRejectedValue(new Error('fk violation'));
-            await expect(service.delete({
-                id: '1',
-                type: 'permanent'
-            }, mockUser)).rejects.toThrow('fk violation');
-            expect(mockQueryRunner.rollbackTransaction).toHaveBeenCalled();
-            expect(mockQueryRunner.release).toHaveBeenCalled();
-        });
-        it('should always attempt cache invalidation, even when the service is not cacheable', async ()=>{
-            const service = makeService(false);
-            mockCache.get.mockResolvedValue([]);
-            await service.delete({
-                id: '1',
-                type: 'permanent'
-            }, mockUser);
-            expect(mockCache.del).toHaveBeenCalled();
-        });
-        it('should always release the query runner even after a successful commit', async ()=>{
-            const service = makeService();
-            await service.delete({
-                id: '1',
-                type: 'permanent'
-            }, mockUser);
-            expect(mockQueryRunner.release).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('clearCacheForAll / clearCacheForId', ()=>{
-        it('clearCacheForAll should delegate to utilsService.clearCache with the entity name', async ()=>{
-            const service = makeService();
-            const clearSpy = jest.spyOn(utilsService, 'clearCache');
-            mockCache.get.mockResolvedValue([]);
-            await service.clearCacheForAll();
-            expect(clearSpy).toHaveBeenCalledWith('test-entity', mockCache);
-        });
-        it('clearCacheForId should clear cache per entity id', async ()=>{
-            const service = makeService();
-            const clearSpy = jest.spyOn(utilsService, 'clearCache');
-            mockCache.get.mockResolvedValue([]);
-            await service.clearCacheForId([
-                {
-                    id: 'a'
-                },
-                {
-                    id: 'b'
-                }
-            ]);
-            expect(clearSpy).toHaveBeenCalledWith('test-entity', mockCache, 'a');
-            expect(clearSpy).toHaveBeenCalledWith('test-entity', mockCache, 'b');
-        });
-    });
-    describe('domain events', ()=>{
-        let publish;
-        function makeEventService(moduleName = 'test-module') {
-            const dataSourceProvider = createMockDataSourceProvider(mockRepo);
-            return new TestApiService('test-entity', mockCache, utilsService, 'TestApiService', false, moduleName, dataSourceProvider, TestEntity);
-        }
-        beforeEach(()=>{
-            publish = jest.fn().mockResolvedValue(undefined);
-            EventBusRegistry.reset();
-            EventBusRegistry.setBus({
-                publish,
-                subscribe: jest.fn(),
-                close: jest.fn()
-            });
-            EventBusRegistry.configureModule('test-module', {
-                enabled: true
-            });
-        });
-        afterEach(()=>{
-            EventBusRegistry.reset();
-        });
-        it('should publish a created event after insert commits', async ()=>{
-            const service = makeEventService();
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: 'new-1',
-                name: 'Widget'
-            });
-            await service.insert({
-                name: 'Widget'
-            }, mockUser);
-            expect(publish).toHaveBeenCalledTimes(1);
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'test-module.test-entity.created',
-                module: 'test-module',
-                entity: 'test-entity',
-                action: 'created',
-                payload: expect.objectContaining({
-                    ids: [
-                        'new-1'
-                    ]
-                })
-            }));
-        });
-        it('should carry the acting user on the envelope', async ()=>{
-            const service = makeEventService();
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: 'new-1',
-                name: 'Widget'
-            });
-            await service.insert({
-                name: 'Widget'
-            }, mockUser);
-            expect(publish.mock.calls[0][0].actor).toEqual(expect.objectContaining({
-                userId: mockUser.id
-            }));
-        });
-        it('should publish one created event carrying every id for insertMany', async ()=>{
-            const service = makeEventService();
-            mockQueryRunner.manager.save.mockResolvedValue([
-                {
-                    id: 'new-1',
-                    name: 'A'
-                },
-                {
-                    id: 'new-2',
-                    name: 'B'
-                }
-            ]);
-            await service.insertMany([
-                {
-                    name: 'A'
-                },
-                {
-                    name: 'B'
-                }
-            ], mockUser);
-            expect(publish).toHaveBeenCalledTimes(1);
-            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
-                action: 'created',
-                payload: expect.objectContaining({
-                    ids: [
-                        'new-1',
-                        'new-2'
-                    ]
-                })
-            }));
-        });
-        it('should publish one updated event carrying every id for updateMany', async ()=>{
-            const service = makeEventService();
-            mockRepo.findOne.mockResolvedValue({
-                id: '1',
-                name: 'Old'
-            });
-            mockQueryRunner.manager.save.mockResolvedValue([
-                {
-                    id: '1',
-                    name: 'A'
-                },
-                {
-                    id: '2',
-                    name: 'B'
-                }
-            ]);
-            await service.updateMany([
-                {
-                    id: '1',
-                    name: 'A'
-                },
-                {
-                    id: '2',
-                    name: 'B'
-                }
-            ], mockUser);
-            expect(publish).toHaveBeenCalledTimes(1);
-            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
-                action: 'updated',
-                payload: expect.objectContaining({
-                    ids: [
-                        '1',
-                        '2'
-                    ]
-                })
-            }));
-        });
-        it('should publish an updated event after update commits', async ()=>{
-            const service = makeEventService();
-            mockRepo.findOne.mockResolvedValue({
-                id: '1',
-                name: 'Old'
-            });
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: '1',
-                name: 'New'
-            });
-            await service.update({
-                id: '1',
-                name: 'New'
-            }, mockUser);
-            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
-                action: 'updated'
-            }));
-        });
-        it('should publish created and updated separately for a bulk upsert', async ()=>{
-            const service = makeEventService();
-            mockRepo.findOne.mockResolvedValue({
-                id: '1',
-                name: 'Old'
-            });
-            mockQueryRunner.manager.save.mockResolvedValueOnce([
-                {
-                    id: 'new-1',
-                    name: 'A'
-                }
-            ]).mockResolvedValueOnce([
-                {
-                    id: '1',
-                    name: 'B'
-                }
-            ]);
-            await service.bulkUpsert([
-                {
-                    name: 'A'
-                }
-            ], [
-                {
-                    id: '1',
-                    name: 'B'
-                }
-            ], mockUser);
-            expect(publish.mock.calls.map(([event])=>event.action)).toEqual([
-                'created',
-                'updated'
-            ]);
-        });
-        it.each([
-            [
-                'delete',
-                'deleted'
-            ],
-            [
-                'restore',
-                'restored'
-            ],
-            [
-                'permanent',
-                'purged'
-            ]
-        ])('should publish %s as the %s action', async (type, action)=>{
-            const service = makeEventService();
-            await service.delete({
-                id: '1',
-                type
-            }, mockUser);
-            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
-                action
-            }));
-        });
-        it('should carry only the ids for a delete, with no row data to duplicate them', async ()=>{
-            const service = makeEventService();
-            await service.delete({
-                id: '1',
-                type: 'delete'
-            }, mockUser);
-            expect(publish.mock.calls[0][0].payload).toEqual({
-                ids: [
-                    '1'
-                ]
-            });
-        });
-        it('should publish a domain action under this service module and entity', async ()=>{
-            const service = makeEventService();
-            await service.publishAction('submitted', {
-                formId: 'form-1'
-            });
-            expect(publish.mock.calls[0][0]).toEqual(expect.objectContaining({
-                name: 'test-module.test-entity.submitted',
-                module: 'test-module',
-                entity: 'test-entity',
-                action: 'submitted',
-                payload: {
-                    ids: [
-                        '1'
-                    ],
-                    metadata: {
-                        formId: 'form-1'
-                    }
-                }
-            }));
-        });
-        it('should hold a domain action to the same allowlist as the CRUD actions', async ()=>{
-            EventBusRegistry.configureModule('test-module', {
-                enabled: true,
-                actions: [
-                    'test-entity.submitted'
-                ]
-            });
-            const service = makeEventService();
-            await service.publishAction('submitted');
-            await service.publishAction('draft-saved');
-            expect(publish).toHaveBeenCalledTimes(1);
-            expect(publish.mock.calls[0][0].action).toBe('submitted');
-        });
-        it('should not publish when the module has events disabled', async ()=>{
-            EventBusRegistry.configureModule('test-module', {
-                enabled: false
-            });
-            const service = makeEventService();
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: 'new-1',
-                name: 'Widget'
-            });
-            await service.insert({
-                name: 'Widget'
-            }, mockUser);
-            expect(publish).not.toHaveBeenCalled();
-        });
-        it('should not publish for an action the module excluded', async ()=>{
-            EventBusRegistry.configureModule('test-module', {
-                enabled: true,
-                actions: [
-                    'deleted'
-                ]
-            });
-            const service = makeEventService();
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: 'new-1',
-                name: 'Widget'
-            });
-            await service.insert({
-                name: 'Widget'
-            }, mockUser);
-            expect(publish).not.toHaveBeenCalled();
-        });
-        it('should omit the row data when the module opts out of payloads', async ()=>{
-            EventBusRegistry.configureModule('test-module', {
-                enabled: true,
-                includePayload: false
-            });
-            const service = makeEventService();
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: 'new-1',
-                name: 'Widget'
-            });
-            await service.insert({
-                name: 'Widget'
-            }, mockUser);
-            expect(publish.mock.calls[0][0].payload).toEqual({
-                ids: [
-                    'new-1'
-                ]
-            });
-        });
-        it('should not fail the write when publishing throws', async ()=>{
-            publish.mockRejectedValue(new Error('broker down'));
-            const service = makeEventService();
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: 'new-1',
-                name: 'Widget'
-            });
-            await expect(service.insert({
-                name: 'Widget'
-            }, mockUser)).resolves.toEqual({
-                id: 'new-1',
-                name: 'Widget'
-            });
-        });
-        it('should do nothing when no bus is registered', async ()=>{
-            EventBusRegistry.reset();
-            const service = makeEventService();
-            mockQueryRunner.manager.save.mockResolvedValue({
-                id: 'new-1',
-                name: 'Widget'
-            });
-            await expect(service.insert({
-                name: 'Widget'
-            }, mockUser)).resolves.toBeDefined();
-            expect(publish).not.toHaveBeenCalled();
-        });
-    });
-});