@flusys/nestjs-localization 6.0.2 → 6.1.1

package/fesm/services/translation-key.service.spec.js

@@ -0,0 +1,278 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { ForbiddenException, BadRequestException } from '@nestjs/common';
+import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { TranslationKeyService } from './translation-key.service';
+import { LocalizationDataSourceProvider } from './localization-datasource.provider';
+function buildTranslationKey(overrides = {}) {
+    return {
+        id: 'tkey-uuid-1',
+        module: 'auth',
+        key: 'auth.login.success',
+        defaultMessage: 'Login successful',
+        description: null,
+        variables: null,
+        isActive: true,
+        isReadonly: false,
+        serial: 1,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+describe('TranslationKeyService', ()=>{
+    let service;
+    let mockRepo;
+    let qb;
+    let queryRunner;
+    beforeEach(async ()=>{
+        mockRepo = createMockRepository();
+        qb = mockRepo.createQueryBuilder();
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        // executeInTransaction()/delete() always grab a QueryRunner off repository.manager.connection
+        // before running the before*Operation hooks, so every test (success or rejection) needs one.
+        queryRunner = {
+            connect: jest.fn(),
+            startTransaction: jest.fn(),
+            commitTransaction: jest.fn(),
+            rollbackTransaction: jest.fn(),
+            release: jest.fn(),
+            manager: {
+                save: jest.fn(),
+                softDelete: jest.fn(),
+                update: jest.fn(),
+                delete: jest.fn(),
+                restore: jest.fn()
+            }
+        };
+        mockRepo.manager.connection.createQueryRunner.mockReturnValue(queryRunner);
+        const mockUtilsService = {
+            clearCache: jest.fn(),
+            getCacheKey: jest.fn().mockReturnValue('cache-key'),
+            trackCacheKey: jest.fn()
+        };
+        const module = await Test.createTestingModule({
+            providers: [
+                TranslationKeyService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {
+                        get: jest.fn(),
+                        set: jest.fn()
+                    }
+                },
+                {
+                    provide: UtilsService,
+                    useValue: mockUtilsService
+                },
+                {
+                    provide: LocalizationDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(TranslationKeyService);
+    });
+    describe('findByModule', ()=>{
+        it('returns active, non-deleted keys for the module ordered by serial then key', async ()=>{
+            const keys = [
+                buildTranslationKey({
+                    key: 'auth.login.success',
+                    serial: 1
+                })
+            ];
+            mockRepo.find.mockResolvedValue(keys);
+            const result = await service.findByModule('auth');
+            expect(mockRepo.find).toHaveBeenCalledWith({
+                where: {
+                    module: 'auth',
+                    isActive: true,
+                    deletedAt: expect.anything()
+                },
+                order: {
+                    serial: 'ASC',
+                    key: 'ASC'
+                }
+            });
+            expect(result).toEqual(keys);
+        });
+        it('returns an empty array for an unknown module', async ()=>{
+            mockRepo.find.mockResolvedValue([]);
+            const result = await service.findByModule('does-not-exist');
+            expect(result).toEqual([]);
+        });
+    });
+    describe('getModules', ()=>{
+        it('returns distinct module names', async ()=>{
+            // `getRawMany` isn't part of the shared MockQueryBuilder — attach it for this raw-query path.
+            const getRawMany = jest.fn().mockResolvedValue([
+                {
+                    module: 'auth'
+                },
+                {
+                    module: 'shared'
+                }
+            ]);
+            qb.getRawMany = getRawMany;
+            const result = await service.getModules();
+            expect(result).toEqual([
+                'auth',
+                'shared'
+            ]);
+        });
+        it('returns an empty array when there are no translation keys yet', async ()=>{
+            const getRawMany = jest.fn().mockResolvedValue([]);
+            qb.getRawMany = getRawMany;
+            const result = await service.getModules();
+            expect(result).toEqual([]);
+        });
+    });
+    describe('beforeInsertOperation (via insert) — duplicate key validation', ()=>{
+        it('allows insert when no key with the same module+key exists', async ()=>{
+            qb.getOne.mockResolvedValue(null);
+            const created = buildTranslationKey();
+            mockRepo.create.mockReturnValue({});
+            queryRunner.manager.save.mockResolvedValue(created);
+            await expect(service.insert({
+                module: 'auth',
+                key: 'auth.login.success',
+                defaultMessage: 'Login successful'
+            }, buildMockUser())).resolves.toBeDefined();
+        });
+        it('rejects with BadRequestException + messageKey when the module+key combination already exists', async ()=>{
+            qb.getOne.mockResolvedValue(buildTranslationKey());
+            await expect(service.insert({
+                module: 'auth',
+                key: 'auth.login.success',
+                defaultMessage: 'Login successful'
+            }, buildMockUser())).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: 'translation.key.duplicate.key.in.module'
+                })
+            });
+        });
+        it('rejects with BadRequestException for duplicate module+key in insertMany', async ()=>{
+            qb.getOne.mockResolvedValueOnce(null).mockResolvedValueOnce(buildTranslationKey({
+                key: 'auth.logout.success'
+            }));
+            await expect(service.insertMany([
+                {
+                    module: 'auth',
+                    key: 'auth.login.success',
+                    defaultMessage: 'A'
+                },
+                {
+                    module: 'auth',
+                    key: 'auth.logout.success',
+                    defaultMessage: 'B'
+                }
+            ], buildMockUser())).rejects.toBeInstanceOf(BadRequestException);
+        });
+    });
+    describe('beforeUpdateOperation (via update)', ()=>{
+        it('rejects with ForbiddenException when modifying key/module of a readonly translation key', async ()=>{
+            const existing = buildTranslationKey({
+                id: 'tkey-1',
+                isReadonly: true,
+                key: 'system.ready'
+            });
+            mockRepo.find.mockResolvedValue([
+                existing
+            ]);
+            await expect(service.update({
+                id: 'tkey-1',
+                key: 'system.changed'
+            }, buildMockUser())).rejects.toBeInstanceOf(ForbiddenException);
+            await expect(service.update({
+                id: 'tkey-1',
+                key: 'system.changed'
+            }, buildMockUser())).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: 'translation.key.readonly.update.forbidden'
+                })
+            });
+        });
+        it('allows updating non key/module fields of a readonly translation key', async ()=>{
+            const existing = buildTranslationKey({
+                id: 'tkey-1',
+                isReadonly: true,
+                key: 'system.ready'
+            });
+            mockRepo.find.mockResolvedValue([
+                existing
+            ]);
+            mockRepo.findOne.mockResolvedValue(existing);
+            queryRunner.manager.save.mockResolvedValue(existing);
+            await expect(service.update({
+                id: 'tkey-1',
+                defaultMessage: 'Updated readonly message'
+            }, buildMockUser())).resolves.toBeDefined();
+        });
+        it('rejects with BadRequestException when the new key/module already exists on another row', async ()=>{
+            const existing = buildTranslationKey({
+                id: 'tkey-1',
+                isReadonly: false,
+                key: 'auth.old',
+                module: 'auth'
+            });
+            mockRepo.find.mockResolvedValue([
+                existing
+            ]);
+            qb.getOne.mockResolvedValue(buildTranslationKey({
+                id: 'tkey-other',
+                key: 'auth.new'
+            }));
+            await expect(service.update({
+                id: 'tkey-1',
+                key: 'auth.new'
+            }, buildMockUser())).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: 'translation.key.duplicate.key.in.module'
+                })
+            });
+            // excludeId must be used so the row being updated doesn't collide with itself
+            expect(qb.andWhere).toHaveBeenCalledWith('tk.id != :excludeId', {
+                excludeId: 'tkey-1'
+            });
+        });
+    });
+    describe('beforeDeleteOperation (via delete)', ()=>{
+        it('rejects with ForbiddenException + messageKey when any target id is readonly', async ()=>{
+            const readonlyKey = buildTranslationKey({
+                id: 'tkey-1',
+                isReadonly: true,
+                key: 'system.core'
+            });
+            mockRepo.find.mockResolvedValue([
+                readonlyKey
+            ]);
+            const dto = {
+                id: [
+                    'tkey-1'
+                ],
+                type: 'delete'
+            };
+            await expect(service.delete(dto, buildMockUser())).rejects.toMatchObject({
+                response: expect.objectContaining({
+                    messageKey: 'translation.key.readonly.delete.forbidden'
+                })
+            });
+        });
+        it('allows delete when none of the targeted ids are readonly', async ()=>{
+            mockRepo.find.mockResolvedValue([]);
+            const dto = {
+                id: [
+                    'tkey-1'
+                ],
+                type: 'delete'
+            };
+            await expect(service.delete(dto, buildMockUser())).resolves.toBeNull();
+            expect(queryRunner.manager.softDelete).toHaveBeenCalled();
+        });
+    });
+});

package/fesm/services/translation.service.spec.js

@@ -0,0 +1,422 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { Language, Translation, TranslationKey } from '../entities';
+import { TranslationService } from './translation.service';
+import { LocalizationDataSourceProvider } from './localization-datasource.provider';
+function buildLanguage(overrides = {}) {
+    return {
+        id: 'lang-en',
+        code: 'en',
+        name: 'English',
+        nativeName: 'English',
+        direction: 'ltr',
+        isActive: true,
+        isDefault: true,
+        serial: 1,
+        isReadonly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function buildTranslationKey(overrides = {}) {
+    return {
+        id: 'tkey-1',
+        module: 'auth',
+        key: 'auth.login.success',
+        defaultMessage: 'Login successful',
+        description: null,
+        variables: null,
+        isActive: true,
+        isReadonly: false,
+        serial: 1,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function buildTranslation(overrides = {}) {
+    return {
+        id: 'translation-1',
+        languageId: 'lang-en',
+        translationKeyId: 'tkey-1',
+        value: 'Login successful',
+        isVerified: false,
+        isActive: true,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+describe('TranslationService', ()=>{
+    let service;
+    let mockRepo;
+    // `TranslationService` uses joins/aggregate query-builder methods (innerJoin, innerJoinAndSelect,
+    // groupBy, addSelect, getRawMany) that aren't part of the shared MockQueryBuilder — extend loosely.
+    let qb;
+    let languageRepo;
+    let translationKeyRepo;
+    let fakeDataSource;
+    beforeEach(async ()=>{
+        mockRepo = createMockRepository();
+        qb = mockRepo.createQueryBuilder();
+        qb.innerJoin = jest.fn().mockReturnThis();
+        qb.innerJoinAndSelect = jest.fn().mockReturnThis();
+        qb.groupBy = jest.fn().mockReturnThis();
+        qb.addSelect = jest.fn().mockReturnThis();
+        qb.getRawMany = jest.fn().mockResolvedValue([]);
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        languageRepo = {
+            findOne: jest.fn()
+        };
+        translationKeyRepo = {
+            find: jest.fn()
+        };
+        fakeDataSource = {
+            getRepository: jest.fn((entity)=>{
+                if (entity === Language) return languageRepo;
+                if (entity === TranslationKey) return translationKeyRepo;
+                return mockRepo;
+            }),
+            createQueryRunner: jest.fn()
+        };
+        mockDataSourceProvider.getDataSource.mockResolvedValue(fakeDataSource);
+        const mockUtilsService = {
+            clearCache: jest.fn(),
+            getCacheKey: jest.fn().mockReturnValue('cache-key'),
+            trackCacheKey: jest.fn()
+        };
+        const module = await Test.createTestingModule({
+            providers: [
+                TranslationService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: UtilsService,
+                    useValue: mockUtilsService
+                },
+                {
+                    provide: LocalizationDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(TranslationService);
+    });
+    describe('getByLanguageCode', ()=>{
+        it('returns an empty translations map when the language code is unknown', async ()=>{
+            languageRepo.findOne.mockResolvedValue(null);
+            const result = await service.getByLanguageCode('xx');
+            expect(result).toEqual({});
+            expect(qb.getMany).not.toHaveBeenCalled();
+        });
+        it('builds a translations map keyed by translation key, scoped to the active language', async ()=>{
+            languageRepo.findOne.mockResolvedValue(buildLanguage());
+            const translations = [
+                {
+                    ...buildTranslation({
+                        value: 'Login successful'
+                    }),
+                    translationKey: buildTranslationKey({
+                        key: 'auth.login.success'
+                    })
+                },
+                {
+                    ...buildTranslation({
+                        id: 'translation-2',
+                        value: 'Logout successful'
+                    }),
+                    translationKey: buildTranslationKey({
+                        id: 'tkey-2',
+                        key: 'auth.logout.success'
+                    })
+                }
+            ];
+            qb.getMany.mockResolvedValue(translations);
+            const result = await service.getByLanguageCode('en');
+            expect(languageRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    code: 'en',
+                    isActive: true,
+                    deletedAt: expect.anything()
+                }
+            });
+            expect(result).toEqual({
+                'auth.login.success': 'Login successful',
+                'auth.logout.success': 'Logout successful'
+            });
+        });
+        it('scopes translations by module when modules are supplied (module-based lazy loading)', async ()=>{
+            languageRepo.findOne.mockResolvedValue(buildLanguage());
+            qb.getMany.mockResolvedValue([]);
+            await service.getByLanguageCode('en', [
+                'auth',
+                'shared'
+            ]);
+            expect(qb.andWhere).toHaveBeenCalledWith('tk.module IN (:...modules)', {
+                modules: [
+                    'auth',
+                    'shared'
+                ]
+            });
+        });
+        it('does not apply a module filter when the modules array is empty', async ()=>{
+            languageRepo.findOne.mockResolvedValue(buildLanguage());
+            qb.getMany.mockResolvedValue([]);
+            await service.getByLanguageCode('en', []);
+            expect(qb.andWhere).not.toHaveBeenCalledWith(expect.stringContaining('tk.module IN'), expect.anything());
+        });
+        it('silently drops translations whose translationKey relation failed to join (fallback: key omitted, no throw)', async ()=>{
+            languageRepo.findOne.mockResolvedValue(buildLanguage());
+            qb.getMany.mockResolvedValue([
+                {
+                    ...buildTranslation(),
+                    translationKey: undefined
+                }
+            ]);
+            const result = await service.getByLanguageCode('en');
+            expect(result).toEqual({});
+        });
+    });
+    describe('getByModuleAndLanguage', ()=>{
+        it('returns an empty map for an unknown language code', async ()=>{
+            languageRepo.findOne.mockResolvedValue(null);
+            const result = await service.getByModuleAndLanguage('auth', 'xx');
+            expect(result).toEqual({});
+        });
+        it('filters translations to the requested module only', async ()=>{
+            languageRepo.findOne.mockResolvedValue(buildLanguage());
+            qb.getMany.mockResolvedValue([
+                {
+                    ...buildTranslation(),
+                    translationKey: buildTranslationKey({
+                        key: 'auth.login.success'
+                    })
+                }
+            ]);
+            const result = await service.getByModuleAndLanguage('auth', 'en');
+            expect(qb.andWhere).toHaveBeenCalledWith('tk.module = :module', {
+                module: 'auth'
+            });
+            expect(result).toEqual({
+                'auth.login.success': 'Login successful'
+            });
+        });
+    });
+    describe('bulkUpdate', ()=>{
+        function buildQueryRunner() {
+            return {
+                connect: jest.fn(),
+                startTransaction: jest.fn(),
+                commitTransaction: jest.fn(),
+                rollbackTransaction: jest.fn(),
+                release: jest.fn(),
+                manager: {
+                    update: jest.fn(),
+                    create: jest.fn((_entity, data)=>({
+                            id: 'new-translation-id',
+                            ...data
+                        })),
+                    save: jest.fn(async (entity)=>entity)
+                }
+            };
+        }
+        it('returns an empty array without opening a transaction when there are no updates', async ()=>{
+            const result = await service.bulkUpdate([]);
+            expect(result).toEqual([]);
+            expect(fakeDataSource.createQueryRunner).not.toHaveBeenCalled();
+        });
+        it('updates existing translations by id and defaults isVerified to false', async ()=>{
+            const queryRunner = buildQueryRunner();
+            fakeDataSource.createQueryRunner.mockReturnValue(queryRunner);
+            mockRepo.find.mockResolvedValue([
+                buildTranslation({
+                    id: 'translation-1'
+                })
+            ]);
+            const result = await service.bulkUpdate([
+                {
+                    id: 'translation-1',
+                    languageId: 'lang-en',
+                    translationKeyId: 'tkey-1',
+                    value: 'Updated'
+                }
+            ]);
+            expect(queryRunner.manager.update).toHaveBeenCalledWith(Translation, {
+                id: 'translation-1'
+            }, {
+                value: 'Updated',
+                isVerified: false
+            });
+            expect(queryRunner.commitTransaction).toHaveBeenCalled();
+            expect(mockRepo.find).toHaveBeenCalledWith({
+                where: {
+                    id: expect.anything()
+                }
+            });
+            expect(result).toHaveLength(1);
+        });
+        it('creates new translations when no id is provided', async ()=>{
+            const queryRunner = buildQueryRunner();
+            fakeDataSource.createQueryRunner.mockReturnValue(queryRunner);
+            mockRepo.find.mockResolvedValue([
+                buildTranslation({
+                    id: 'new-translation-id'
+                })
+            ]);
+            await service.bulkUpdate([
+                {
+                    languageId: 'lang-en',
+                    translationKeyId: 'tkey-1',
+                    value: 'Brand new',
+                    isVerified: true
+                }
+            ]);
+            expect(queryRunner.manager.create).toHaveBeenCalledWith(Translation, {
+                languageId: 'lang-en',
+                translationKeyId: 'tkey-1',
+                value: 'Brand new',
+                isVerified: true,
+                isActive: true
+            });
+            expect(queryRunner.manager.save).toHaveBeenCalled();
+            expect(queryRunner.commitTransaction).toHaveBeenCalled();
+        });
+        it('rolls back the transaction and rethrows the original error when a write fails', async ()=>{
+            const queryRunner = buildQueryRunner();
+            queryRunner.manager.update.mockRejectedValue(new Error('db write failed'));
+            fakeDataSource.createQueryRunner.mockReturnValue(queryRunner);
+            await expect(service.bulkUpdate([
+                {
+                    id: 'translation-1',
+                    languageId: 'lang-en',
+                    translationKeyId: 'tkey-1',
+                    value: 'x'
+                }
+            ])).rejects.toThrow('db write failed');
+            expect(queryRunner.rollbackTransaction).toHaveBeenCalled();
+            expect(queryRunner.release).toHaveBeenCalled();
+            expect(queryRunner.commitTransaction).not.toHaveBeenCalled();
+        });
+    });
+    describe('getMissingTranslations', ()=>{
+        it('returns an empty array for an unknown language code', async ()=>{
+            languageRepo.findOne.mockResolvedValue(null);
+            const result = await service.getMissingTranslations('xx');
+            expect(result).toEqual([]);
+            expect(translationKeyRepo.find).not.toHaveBeenCalled();
+        });
+        it('returns translation keys that have no translation row yet for the language', async ()=>{
+            languageRepo.findOne.mockResolvedValue(buildLanguage());
+            const allKeys = [
+                buildTranslationKey({
+                    id: 'tkey-1',
+                    key: 'auth.login.success'
+                }),
+                buildTranslationKey({
+                    id: 'tkey-2',
+                    key: 'auth.logout.success'
+                })
+            ];
+            translationKeyRepo.find.mockResolvedValue(allKeys);
+            mockRepo.find.mockResolvedValue([
+                {
+                    translationKeyId: 'tkey-1'
+                }
+            ]);
+            const result = await service.getMissingTranslations('en');
+            expect(result).toEqual([
+                allKeys[1]
+            ]);
+        });
+        it('returns an empty array when every translation key already has a translation', async ()=>{
+            languageRepo.findOne.mockResolvedValue(buildLanguage());
+            const allKeys = [
+                buildTranslationKey({
+                    id: 'tkey-1'
+                })
+            ];
+            translationKeyRepo.find.mockResolvedValue(allKeys);
+            mockRepo.find.mockResolvedValue([
+                {
+                    translationKeyId: 'tkey-1'
+                }
+            ]);
+            const result = await service.getMissingTranslations('en');
+            expect(result).toEqual([]);
+        });
+    });
+    describe('getTranslationCounts', ()=>{
+        it('returns a map of translationKeyId -> translation count', async ()=>{
+            qb.getRawMany = jest.fn().mockResolvedValue([
+                {
+                    keyId: 'tkey-1',
+                    count: '3'
+                },
+                {
+                    keyId: 'tkey-2',
+                    count: '1'
+                }
+            ]);
+            const result = await service.getTranslationCounts();
+            expect(result).toEqual({
+                'tkey-1': 3,
+                'tkey-2': 1
+            });
+        });
+        it('returns an empty object when there are no translations', async ()=>{
+            qb.getRawMany = jest.fn().mockResolvedValue([]);
+            const result = await service.getTranslationCounts();
+            expect(result).toEqual({});
+        });
+    });
+    describe('getFilterQuery (module/language/key filtering)', ()=>{
+        it('joins translation_key and filters by module when filter.module is provided', async ()=>{
+            const { query, isRaw } = await service.getFilterQuery(qb, {
+                module: 'auth'
+            }, null);
+            expect(qb.innerJoin).toHaveBeenCalledWith('translation.translationKey', 'tk');
+            expect(qb.andWhere).toHaveBeenCalledWith('tk.module = :module', {
+                module: 'auth'
+            });
+            expect(isRaw).toBe(false);
+            expect(query).toBe(qb);
+        });
+        it('filters by languageId without requiring a join', async ()=>{
+            await service.getFilterQuery(qb, {
+                languageId: 'lang-en'
+            }, null);
+            expect(qb.andWhere).toHaveBeenCalledWith('translation.languageId = :languageId', {
+                languageId: 'lang-en'
+            });
+        });
+        it('filters by translationKeyId', async ()=>{
+            await service.getFilterQuery(qb, {
+                translationKeyId: 'tkey-1'
+            }, null);
+            expect(qb.andWhere).toHaveBeenCalledWith('translation.translationKeyId = :translationKeyId', {
+                translationKeyId: 'tkey-1'
+            });
+        });
+        it('applies no filters when the filter object is empty', async ()=>{
+            await service.getFilterQuery(qb, {}, null);
+            expect(qb.innerJoin).not.toHaveBeenCalled();
+            expect(qb.andWhere).not.toHaveBeenCalled();
+        });
+    });
+});