@flusys/nestjs-localization 6.0.2 → 6.1.1

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

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _languagecontroller = require("./language.controller");
+const _services = require("../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 _testing.Test.createTestingModule({
+            controllers: [
+                _languagecontroller.LanguageController
+            ],
+            providers: [
+                {
+                    provide: _services.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: _modules.UtilsService,
+                    useValue: {}
+                }
+            ]
+        }).compile();
+        controller = module.get(_languagecontroller.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'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow('database unavailable');
+        });
+    });
+});

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _translationkeycontroller = require("./translation-key.controller");
+const _services = require("../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 _testing.Test.createTestingModule({
+            controllers: [
+                _translationkeycontroller.TranslationKeyController
+            ],
+            providers: [
+                {
+                    provide: _services.TranslationKeyService,
+                    useValue: mockService
+                },
+                {
+                    provide: _modules.UtilsService,
+                    useValue: {}
+                }
+            ]
+        }).compile();
+        controller = module.get(_translationkeycontroller.TranslationKeyController);
+    });
+    describe('getModules', ()=>{
+        it('returns the distinct module names from the service', async ()=>{
+            mockService.getModules.mockResolvedValue([
+                'auth',
+                'shared',
+                'storage'
+            ]);
+            const result = await controller.getModules((0, _loggedusermock.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((0, _loggedusermock.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((0, _loggedusermock.buildMockUser)())).rejects.toThrow('query failed');
+        });
+    });
+});

package/cjs/controllers/translation.controller.spec.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _translationcontroller = require("./translation.controller");
+const _services = require("../services");
+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('TranslationController', ()=>{
+    let controller;
+    let mockService;
+    beforeEach(async ()=>{
+        mockService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+            getByLanguageCode: jest.fn(),
+            bulkUpdate: jest.fn(),
+            getTranslationCounts: jest.fn()
+        };
+        const module = await _testing.Test.createTestingModule({
+            controllers: [
+                _translationcontroller.TranslationController
+            ],
+            providers: [
+                {
+                    provide: _services.TranslationService,
+                    useValue: mockService
+                },
+                {
+                    provide: _modules.UtilsService,
+                    useValue: {}
+                }
+            ]
+        }).compile();
+        controller = module.get(_translationcontroller.TranslationController);
+    });
+    describe('getByLanguage', ()=>{
+        it('returns the translations map for the requested language and modules', async ()=>{
+            mockService.getByLanguageCode.mockResolvedValue({
+                'auth.login.success': 'Login successful'
+            });
+            const result = await controller.getByLanguage({
+                languageCode: 'en',
+                modules: [
+                    'auth'
+                ]
+            });
+            expect(mockService.getByLanguageCode).toHaveBeenCalledWith('en', [
+                'auth'
+            ]);
+            expect(result).toEqual({
+                success: true,
+                message: 'Translations retrieved successfully',
+                messageKey: 'translation.by.language.success',
+                data: {
+                    'auth.login.success': 'Login successful'
+                }
+            });
+        });
+        it('returns an empty map (fallback) for an unknown language code without throwing', async ()=>{
+            mockService.getByLanguageCode.mockResolvedValue({});
+            const result = await controller.getByLanguage({
+                languageCode: 'xx'
+            });
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({});
+        });
+        it('requests translations for all modules when modules is omitted', async ()=>{
+            mockService.getByLanguageCode.mockResolvedValue({});
+            await controller.getByLanguage({
+                languageCode: 'en'
+            });
+            expect(mockService.getByLanguageCode).toHaveBeenCalledWith('en', undefined);
+        });
+    });
+    describe('updateManyValues', ()=>{
+        it('bulk updates translations and reports the updated count', async ()=>{
+            const updated = [
+                buildTranslation(),
+                buildTranslation({
+                    id: 'translation-2'
+                })
+            ];
+            mockService.bulkUpdate.mockResolvedValue(updated);
+            const result = await controller.updateManyValues({
+                translations: [
+                    {
+                        languageId: 'lang-en',
+                        translationKeyId: 'tkey-1',
+                        value: 'Login successful'
+                    }
+                ]
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result).toEqual({
+                success: true,
+                message: '2 translations updated',
+                messageKey: 'translation.update.many.success',
+                messageVariables: {
+                    count: 2
+                },
+                data: updated,
+                meta: {
+                    count: 2
+                }
+            });
+        });
+        it('reports zero updates for an empty batch without calling the service twice', async ()=>{
+            mockService.bulkUpdate.mockResolvedValue([]);
+            const result = await controller.updateManyValues({
+                translations: []
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockService.bulkUpdate).toHaveBeenCalledTimes(1);
+            expect(result.meta).toEqual({
+                count: 0
+            });
+            expect(result.message).toBe('0 translations updated');
+        });
+        it('propagates errors raised during the bulk transaction (e.g. rollback surfaced as a rejection)', async ()=>{
+            mockService.bulkUpdate.mockRejectedValue(new Error('transaction rolled back'));
+            await expect(controller.updateManyValues({
+                translations: []
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow('transaction rolled back');
+        });
+    });
+    describe('getCounts', ()=>{
+        it('returns translation counts keyed by translation key id', async ()=>{
+            mockService.getTranslationCounts.mockResolvedValue({
+                'tkey-1': 3,
+                'tkey-2': 1
+            });
+            const result = await controller.getCounts((0, _loggedusermock.buildMockUser)());
+            expect(result).toEqual({
+                success: true,
+                message: 'Translation counts retrieved successfully',
+                messageKey: 'translation.get.all.success',
+                data: {
+                    'tkey-1': 3,
+                    'tkey-2': 1
+                }
+            });
+        });
+        it('returns an empty object when there are no translations yet', async ()=>{
+            mockService.getTranslationCounts.mockResolvedValue({});
+            const result = await controller.getCounts((0, _loggedusermock.buildMockUser)());
+            expect(result.data).toEqual({});
+        });
+    });
+});

package/cjs/docs/localization-swagger.config.spec.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _localizationswaggerconfig = require("./localization-swagger.config");
+describe('localizationSwaggerConfig', ()=>{
+    it('should build a static config with no multi-tenant note by default', ()=>{
+        const config = (0, _localizationswaggerconfig.localizationSwaggerConfig)();
+        expect(config.title).toBe('Localization API');
+        expect(config.path).toBe('api/docs/localization');
+        expect(config.bearerAuth).toBe(true);
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+    });
+    it('should include the multi-tenant note only for multi-tenant database mode', ()=>{
+        const multiTenant = (0, _localizationswaggerconfig.localizationSwaggerConfig)({
+            databaseMode: 'multi-tenant'
+        });
+        const single = (0, _localizationswaggerconfig.localizationSwaggerConfig)({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+    it('should treat any non-"multi-tenant" value as single-database mode', ()=>{
+        const config = (0, _localizationswaggerconfig.localizationSwaggerConfig)({
+            databaseMode: 'unexpected-value'
+        });
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+    });
+});

package/cjs/entities/index.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _index = require("./index");
+const _languageentity = require("./language.entity");
+const _translationkeyentity = require("./translation-key.entity");
+const _translationentity = require("./translation.entity");
+describe('getLocalizationEntities', ()=>{
+    it('returns the fixed entity list (no company/core split for localization)', ()=>{
+        expect((0, _index.getLocalizationEntities)()).toBe(_index.LocalizationEntities);
+        expect((0, _index.getLocalizationEntities)()).toEqual([
+            _languageentity.Language,
+            _translationkeyentity.TranslationKey,
+            _translationentity.Translation
+        ]);
+    });
+});

package/cjs/modules/localization.module.spec.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _localizationmodule = require("./localization.module");
+const _localizationconstants = require("../config/localization.constants");
+const _controllers = require("../controllers");
+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;
+}
+function providerTokens(providers) {
+    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
+}
+describe('LocalizationModule', ()=>{
+    describe('forRoot', ()=>{
+        it('should default to a non-global module with all controllers registered', ()=>{
+            const dynamicModule = _localizationmodule.LocalizationModule.forRoot({});
+            expect(dynamicModule.module).toBe(_localizationmodule.LocalizationModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                _controllers.LanguageController,
+                _controllers.TranslationKeyController,
+                _controllers.TranslationController
+            ]);
+        });
+        it('should respect global: true', ()=>{
+            expect(_localizationmodule.LocalizationModule.forRoot({
+                global: true
+            }).global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            expect(_localizationmodule.LocalizationModule.forRoot({
+                includeController: false
+            }).controllers).toEqual([]);
+        });
+        it('should register a LOCALIZATION_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {}
+            };
+            const dynamicModule = _localizationmodule.LocalizationModule.forRoot(options);
+            const provider = dynamicModule.providers.find((p)=>p.provide === _localizationconstants.LOCALIZATION_MODULE_OPTIONS);
+            expect(provider.useValue).toBe(options);
+        });
+        it('should always export the same fixed set of services', ()=>{
+            expect(_localizationmodule.LocalizationModule.forRoot({}).exports).toHaveLength(5);
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = _localizationmodule.LocalizationModule.forRootAsync({
+                imports: [
+                    FakeImportedModule
+                ]
+            });
+            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
+                FakeImportedModule
+            ]));
+        });
+        it('useFactory: builds a LOCALIZATION_MODULE_OPTIONS provider merging resolved config', async ()=>{
+            const useFactory = jest.fn().mockResolvedValue({
+                foo: 'bar'
+            });
+            const dynamicModule = _localizationmodule.LocalizationModule.forRootAsync({
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const provider = dynamicModule.providers.find((p)=>p.provide === _localizationconstants.LOCALIZATION_MODULE_OPTIONS);
+            expect(provider.inject).toEqual([
+                'SOME_TOKEN'
+            ]);
+            const resolved = await provider.useFactory('injected');
+            expect(useFactory).toHaveBeenCalledWith('injected');
+            expect(resolved.config).toEqual({
+                foo: 'bar'
+            });
+        });
+        it('useClass: registers both the class provider and an options provider calling createLocalizationOptions()', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createLocalizationOptions", jest.fn().mockResolvedValue({
+                        foo: 'from-class'
+                    }));
+                }
+            };
+            const dynamicModule = _localizationmodule.LocalizationModule.forRootAsync({
+                useClass: MyOptionsFactory
+            });
+            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
+            expect(classProvider.useClass).toBe(MyOptionsFactory);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _localizationconstants.LOCALIZATION_MODULE_OPTIONS);
+            const instance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(instance);
+            expect(instance.createLocalizationOptions).toHaveBeenCalled();
+            expect(resolved.config).toEqual({
+                foo: 'from-class'
+            });
+        });
+        it('useExisting: registers a single options provider without a duplicate class registration', ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createLocalizationOptions", jest.fn());
+                }
+            };
+            const dynamicModule = _localizationmodule.LocalizationModule.forRootAsync({
+                useExisting: MyOptionsFactory
+            });
+            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _localizationconstants.LOCALIZATION_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+        });
+        it('should register no LOCALIZATION_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
+            const dynamicModule = _localizationmodule.LocalizationModule.forRootAsync({});
+            expect(providerTokens(dynamicModule.providers)).not.toContain(_localizationconstants.LOCALIZATION_MODULE_OPTIONS);
+        });
+    });
+});