@flusys/nestjs-localization 7.1.0 → 8.0.0

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

@@ -1,530 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _testing = require("@nestjs/testing");
-const _classes = require("@flusys/nestjs-shared/classes");
-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', ()=>{
-    const mockUtilsService = {
-        clearCache: jest.fn(),
-        getCacheKey: jest.fn().mockReturnValue('cache-key'),
-        trackCacheKey: jest.fn()
-    };
-    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
-    beforeEach(()=>{
-        mockUtilsService.clearCache.mockClear();
-    });
-    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 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('invalidates the translation list cache and each written entry after committing', async ()=>{
-            const queryRunner = buildQueryRunner();
-            fakeDataSource.createQueryRunner.mockReturnValue(queryRunner);
-            mockRepo.find.mockResolvedValue([
-                buildTranslation({
-                    id: 'translation-1'
-                })
-            ]);
-            await service.bulkUpdate([
-                {
-                    id: 'translation-1',
-                    languageId: 'lang-en',
-                    translationKeyId: 'tkey-1',
-                    value: 'Updated'
-                }
-            ]);
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('translation', expect.anything());
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('translation', expect.anything(), 'translation-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();
-        });
-    });
-    describe('domain events', ()=>{
-        let publish;
-        function buildEventQueryRunner() {
-            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)
-                }
-            };
-        }
-        beforeEach(()=>{
-            publish = jest.fn().mockResolvedValue(undefined);
-            _classes.EventBusRegistry.reset();
-            _classes.EventBusRegistry.setBus({
-                publish,
-                subscribe: jest.fn(),
-                close: jest.fn()
-            });
-            _classes.EventBusRegistry.configureModule('localization', {
-                enabled: true
-            });
-            fakeDataSource.createQueryRunner.mockReturnValue(buildEventQueryRunner());
-            mockRepo.find.mockResolvedValue([
-                buildTranslation({
-                    id: 'translation-1'
-                })
-            ]);
-        });
-        afterEach(()=>{
-            _classes.EventBusRegistry.reset();
-        });
-        it('publishes localization.translation.bulk-updated with the written count', async ()=>{
-            await service.bulkUpdate([
-                {
-                    id: 'translation-1',
-                    languageId: 'lang-en',
-                    translationKeyId: 'tkey-1',
-                    value: 'x'
-                }
-            ]);
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'localization.translation.bulk-updated',
-                payload: expect.objectContaining({
-                    ids: [
-                        'translation-1'
-                    ],
-                    metadata: {
-                        count: 1
-                    }
-                })
-            }));
-        });
-        it('does not publish when the localization module has events disabled', async ()=>{
-            _classes.EventBusRegistry.configureModule('localization', {
-                enabled: false
-            });
-            await service.bulkUpdate([
-                {
-                    id: 'translation-1',
-                    languageId: 'lang-en',
-                    translationKeyId: 'tkey-1',
-                    value: 'x'
-                }
-            ]);
-            expect(publish).not.toHaveBeenCalled();
-        });
-        it('publishes nothing when there is nothing to update', async ()=>{
-            await service.bulkUpdate([]);
-            expect(publish).not.toHaveBeenCalled();
-        });
-    });
-});

package/fesm/config/event-actions.js

@@ -1,12 +0,0 @@
-/**
- * Domain event actions published by the localization module, alongside the CRUD
- * lifecycle actions every ApiService emits.
- */ export const LOCALIZATION_EVENT_ACTIONS = {
-    BULK_UPDATED: 'bulk-updated'
-};
-/** Every entity the localization module publishes under */ export const LOCALIZATION_EVENT_ENTITIES = {
-    LANGUAGE: 'language',
-    TRANSLATION_KEY: 'translationKey',
-    TRANSLATION: 'translation'
-};
-export const LOCALIZATION_EVENT_MODULE = 'localization';

package/fesm/config/localization.constants.js

@@ -1 +0,0 @@
-export const LOCALIZATION_MODULE_OPTIONS = 'LOCALIZATION_MODULE_OPTIONS';

package/fesm/config/message-keys.js

@@ -1,20 +0,0 @@
-// ==================== LOCALIZATION MODULE MESSAGE KEYS ====================
-export const LANGUAGE_MESSAGES = {
-    ACTIVE_SUCCESS: 'language.active.success',
-    SET_DEFAULT_SUCCESS: 'language.set.default.success',
-    GET_DEFAULT_SUCCESS: 'language.get.default.success',
-    READONLY_UPDATE_FORBIDDEN: 'language.readonly.update.forbidden',
-    READONLY_DELETE_FORBIDDEN: 'language.readonly.delete.forbidden',
-    DEFAULT_DELETE_FORBIDDEN: 'language.default.delete.forbidden'
-};
-export const TRANSLATION_KEY_MESSAGES = {
-    MODULES_SUCCESS: 'translation.key.modules.success',
-    READONLY_DELETE_FORBIDDEN: 'translation.key.readonly.delete.forbidden',
-    READONLY_UPDATE_FORBIDDEN: 'translation.key.readonly.update.forbidden',
-    DUPLICATE_KEY_IN_MODULE: 'translation.key.duplicate.key.in.module'
-};
-export const TRANSLATION_MESSAGES = {
-    GET_ALL_SUCCESS: 'translation.get.all.success',
-    UPDATE_MANY_SUCCESS: 'translation.update.many.success',
-    BY_LANGUAGE_SUCCESS: 'translation.by.language.success'
-};