@flusys/nestjs-shared 6.0.1 → 6.1.0

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

@@ -0,0 +1,805 @@
+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 { 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 {
+};
+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, undefined, TestEntity, dataSourceProvider);
+    }
+    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, undefined, TestEntity, dataSourceProvider);
+            }
+            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');
+        });
+    });
+});