@flusys/nestjs-localization 6.0.2 → 6.1.1

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

@@ -0,0 +1,426 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _entities = require("../entities");
+const _translationservice = require("./translation.service");
+const _localizationdatasourceprovider = require("./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 = (0, _repositorymock.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 = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
+        languageRepo = {
+            findOne: jest.fn()
+        };
+        translationKeyRepo = {
+            find: jest.fn()
+        };
+        fakeDataSource = {
+            getRepository: jest.fn((entity)=>{
+                if (entity === _entities.Language) return languageRepo;
+                if (entity === _entities.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 _testing.Test.createTestingModule({
+            providers: [
+                _translationservice.TranslationService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: _modules.UtilsService,
+                    useValue: mockUtilsService
+                },
+                {
+                    provide: _localizationdatasourceprovider.LocalizationDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(_translationservice.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(_entities.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(_entities.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();
+        });
+    });
+});

package/fesm/controllers/language.controller.spec.js

@@ -0,0 +1,150 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { LanguageController } from './language.controller';
+import { LanguageService } from '../services';
+function buildLanguage(overrides = {}) {
+    return {
+        id: 'lang-en',
+        code: 'en',
+        name: 'English',
+        nativeName: 'English',
+        direction: 'ltr',
+        isActive: true,
+        isDefault: false,
+        serial: 1,
+        isReadonly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+describe('LanguageController', ()=>{
+    let controller;
+    let mockService;
+    beforeEach(async ()=>{
+        mockService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+            getActiveLanguages: jest.fn(),
+            getDefaultLanguage: jest.fn(),
+            setAsDefault: jest.fn()
+        };
+        const module = await Test.createTestingModule({
+            controllers: [
+                LanguageController
+            ],
+            providers: [
+                {
+                    provide: LanguageService,
+                    useValue: mockService
+                },
+                // The base ApiController wires the Slug interceptor (needs UtilsService) on several
+                // inherited endpoints, so it must be resolvable even though these tests only hit custom routes.
+                {
+                    provide: UtilsService,
+                    useValue: {}
+                }
+            ]
+        }).compile();
+        controller = module.get(LanguageController);
+    });
+    describe('getActive', ()=>{
+        it('returns all active languages with a full-length meta block', async ()=>{
+            const languages = [
+                buildLanguage({
+                    code: 'en'
+                }),
+                buildLanguage({
+                    id: 'lang-bn',
+                    code: 'bn'
+                })
+            ];
+            mockService.getActiveLanguages.mockResolvedValue(languages);
+            const result = await controller.getActive();
+            expect(result).toEqual({
+                success: true,
+                message: 'Active languages retrieved successfully',
+                messageKey: 'language.active.success',
+                data: languages,
+                meta: {
+                    total: 2,
+                    page: 0,
+                    pageSize: 2,
+                    count: 2
+                }
+            });
+        });
+        it('returns an empty list with zeroed meta when no languages are active', async ()=>{
+            mockService.getActiveLanguages.mockResolvedValue([]);
+            const result = await controller.getActive();
+            expect(result.data).toEqual([]);
+            expect(result.meta).toEqual({
+                total: 0,
+                page: 0,
+                pageSize: 0,
+                count: 0
+            });
+        });
+    });
+    describe('getDefault', ()=>{
+        it('returns the default language', async ()=>{
+            const defaultLanguage = buildLanguage({
+                isDefault: true
+            });
+            mockService.getDefaultLanguage.mockResolvedValue(defaultLanguage);
+            const result = await controller.getDefault();
+            expect(result).toEqual({
+                success: true,
+                message: 'Default language retrieved successfully',
+                messageKey: 'language.get.default.success',
+                data: defaultLanguage
+            });
+        });
+        it('falls back to undefined data when no default language is configured', async ()=>{
+            mockService.getDefaultLanguage.mockResolvedValue(null);
+            const result = await controller.getDefault();
+            expect(result.data).toBeUndefined();
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('setDefault', ()=>{
+        it('sets the given language id as default and returns it', async ()=>{
+            const updated = buildLanguage({
+                id: 'lang-bn',
+                isDefault: true
+            });
+            mockService.setAsDefault.mockResolvedValue(updated);
+            const result = await controller.setDefault({
+                id: 'lang-bn'
+            }, buildMockUser());
+            expect(mockService.setAsDefault).toHaveBeenCalledWith('lang-bn');
+            expect(result).toEqual({
+                success: true,
+                message: 'Default language updated successfully',
+                messageKey: 'language.set.default.success',
+                data: updated
+            });
+        });
+        it('returns undefined data when the id does not match any language', async ()=>{
+            mockService.setAsDefault.mockResolvedValue(null);
+            const result = await controller.setDefault({
+                id: 'unknown-id'
+            }, buildMockUser());
+            expect(result.data).toBeUndefined();
+        });
+        it('propagates errors raised by the service unchanged', async ()=>{
+            mockService.setAsDefault.mockRejectedValue(new Error('database unavailable'));
+            await expect(controller.setDefault({
+                id: 'lang-en'
+            }, buildMockUser())).rejects.toThrow('database unavailable');
+        });
+    });
+});

package/fesm/controllers/translation-key.controller.spec.js

@@ -0,0 +1,66 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { TranslationKeyController } from './translation-key.controller';
+import { TranslationKeyService } from '../services';
+describe('TranslationKeyController', ()=>{
+    let controller;
+    let mockService;
+    beforeEach(async ()=>{
+        mockService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+            getModules: jest.fn(),
+            findByModule: jest.fn()
+        };
+        const module = await Test.createTestingModule({
+            controllers: [
+                TranslationKeyController
+            ],
+            providers: [
+                {
+                    provide: TranslationKeyService,
+                    useValue: mockService
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {}
+                }
+            ]
+        }).compile();
+        controller = module.get(TranslationKeyController);
+    });
+    describe('getModules', ()=>{
+        it('returns the distinct module names from the service', async ()=>{
+            mockService.getModules.mockResolvedValue([
+                'auth',
+                'shared',
+                'storage'
+            ]);
+            const result = await controller.getModules(buildMockUser());
+            expect(result).toEqual({
+                success: true,
+                message: 'Modules retrieved successfully',
+                messageKey: 'translation.key.modules.success',
+                data: [
+                    'auth',
+                    'shared',
+                    'storage'
+                ]
+            });
+        });
+        it('returns an empty array when no translation keys have been created yet', async ()=>{
+            mockService.getModules.mockResolvedValue([]);
+            const result = await controller.getModules(buildMockUser());
+            expect(result.data).toEqual([]);
+            expect(result.success).toBe(true);
+        });
+        it('propagates unexpected errors from the service', async ()=>{
+            mockService.getModules.mockRejectedValue(new Error('query failed'));
+            await expect(controller.getModules(buildMockUser())).rejects.toThrow('query failed');
+        });
+    });
+});