@flusys/nestjs-localization 6.0.2 → 6.1.1

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

@@ -0,0 +1,165 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { TranslationController } from './translation.controller';
+import { TranslationService } from '../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 Test.createTestingModule({
+            controllers: [
+                TranslationController
+            ],
+            providers: [
+                {
+                    provide: TranslationService,
+                    useValue: mockService
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {}
+                }
+            ]
+        }).compile();
+        controller = module.get(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'
+                    }
+                ]
+            }, 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: []
+            }, 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: []
+            }, 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(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(buildMockUser());
+            expect(result.data).toEqual({});
+        });
+    });
+});

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

@@ -0,0 +1,26 @@
+import { localizationSwaggerConfig } from './localization-swagger.config';
+describe('localizationSwaggerConfig', ()=>{
+    it('should build a static config with no multi-tenant note by default', ()=>{
+        const config = 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 = localizationSwaggerConfig({
+            databaseMode: 'multi-tenant'
+        });
+        const single = 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 = localizationSwaggerConfig({
+            databaseMode: 'unexpected-value'
+        });
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+    });
+});

package/fesm/entities/index.spec.js

@@ -0,0 +1,14 @@
+import { getLocalizationEntities, LocalizationEntities } from './index';
+import { Language } from './language.entity';
+import { TranslationKey } from './translation-key.entity';
+import { Translation } from './translation.entity';
+describe('getLocalizationEntities', ()=>{
+    it('returns the fixed entity list (no company/core split for localization)', ()=>{
+        expect(getLocalizationEntities()).toBe(LocalizationEntities);
+        expect(getLocalizationEntities()).toEqual([
+            Language,
+            TranslationKey,
+            Translation
+        ]);
+    });
+});

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

@@ -0,0 +1,128 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { LocalizationModule } from './localization.module';
+import { LOCALIZATION_MODULE_OPTIONS } from '../config/localization.constants';
+import { LanguageController, TranslationKeyController, TranslationController } from '../controllers';
+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.forRoot({});
+            expect(dynamicModule.module).toBe(LocalizationModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                LanguageController,
+                TranslationKeyController,
+                TranslationController
+            ]);
+        });
+        it('should respect global: true', ()=>{
+            expect(LocalizationModule.forRoot({
+                global: true
+            }).global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            expect(LocalizationModule.forRoot({
+                includeController: false
+            }).controllers).toEqual([]);
+        });
+        it('should register a LOCALIZATION_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {}
+            };
+            const dynamicModule = LocalizationModule.forRoot(options);
+            const provider = dynamicModule.providers.find((p)=>p.provide === LOCALIZATION_MODULE_OPTIONS);
+            expect(provider.useValue).toBe(options);
+        });
+        it('should always export the same fixed set of services', ()=>{
+            expect(LocalizationModule.forRoot({}).exports).toHaveLength(5);
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = 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.forRootAsync({
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const provider = dynamicModule.providers.find((p)=>p.provide === 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.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 === 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.forRootAsync({
+                useExisting: MyOptionsFactory
+            });
+            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === 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.forRootAsync({});
+            expect(providerTokens(dynamicModule.providers)).not.toContain(LOCALIZATION_MODULE_OPTIONS);
+        });
+    });
+});

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

@@ -0,0 +1,147 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { LanguageService } from './language.service';
+import { LocalizationDataSourceProvider } from './localization-datasource.provider';
+function buildLanguage(overrides = {}) {
+    return {
+        id: 'language-uuid-1',
+        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('LanguageService', ()=>{
+    let service;
+    let mockRepo;
+    beforeEach(async ()=>{
+        mockRepo = createMockRepository();
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        const module = await Test.createTestingModule({
+            providers: [
+                LanguageService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: LocalizationDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(LanguageService);
+    });
+    describe('getDefaultLanguage', ()=>{
+        it('returns the language flagged as default', async ()=>{
+            const defaultLanguage = buildLanguage({
+                id: 'default-lang',
+                isDefault: true,
+                code: 'en'
+            });
+            mockRepo.findOne.mockResolvedValue(defaultLanguage);
+            const result = await service.getDefaultLanguage();
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    isDefault: true,
+                    deletedAt: expect.anything()
+                }
+            });
+            expect(result).toEqual(defaultLanguage);
+        });
+        it('returns null when no language is marked default', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            const result = await service.getDefaultLanguage();
+            expect(result).toBeNull();
+        });
+    });
+    describe('getActiveLanguages', ()=>{
+        it('returns active, non-deleted languages ordered by serial then name', async ()=>{
+            const languages = [
+                buildLanguage({
+                    code: 'en',
+                    serial: 1
+                }),
+                buildLanguage({
+                    code: 'bn',
+                    serial: 2
+                })
+            ];
+            mockRepo.find.mockResolvedValue(languages);
+            const result = await service.getActiveLanguages();
+            expect(mockRepo.find).toHaveBeenCalledWith({
+                where: {
+                    isActive: true,
+                    deletedAt: expect.anything()
+                },
+                order: {
+                    serial: 'ASC',
+                    name: 'ASC'
+                }
+            });
+            expect(result).toHaveLength(2);
+        });
+        it('returns an empty array when no languages are active', async ()=>{
+            mockRepo.find.mockResolvedValue([]);
+            const result = await service.getActiveLanguages();
+            expect(result).toEqual([]);
+        });
+    });
+    describe('setAsDefault', ()=>{
+        it('unsets the previous default and sets the requested language as default', async ()=>{
+            const newDefault = buildLanguage({
+                id: 'lang-2',
+                isDefault: true,
+                code: 'bn'
+            });
+            mockRepo.findOne.mockResolvedValue(newDefault);
+            const result = await service.setAsDefault('lang-2');
+            expect(mockRepo.update).toHaveBeenNthCalledWith(1, {
+                isDefault: true
+            }, {
+                isDefault: false
+            });
+            expect(mockRepo.update).toHaveBeenNthCalledWith(2, {
+                id: 'lang-2'
+            }, {
+                isDefault: true
+            });
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    id: 'lang-2'
+                }
+            });
+            expect(result).toEqual(newDefault);
+        });
+        it('returns null when the id does not correspond to any language after the update', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            const result = await service.setAsDefault('non-existent-id');
+            expect(result).toBeNull();
+        });
+        it('still unsets other defaults first even when the target id is unknown (no exception thrown)', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await service.setAsDefault('unknown-id');
+            expect(mockRepo.update).toHaveBeenCalledWith({
+                isDefault: true
+            }, {
+                isDefault: false
+            });
+        });
+    });
+});

package/fesm/services/localization-config.service.spec.js

@@ -0,0 +1,76 @@
+import { LocalizationConfigService } from './localization-config.service';
+function buildOptions(overrides = {}) {
+    return {
+        bootstrapAppConfig: undefined,
+        config: undefined,
+        ...overrides
+    };
+}
+describe('LocalizationConfigService', ()=>{
+    describe('isCompanyFeatureEnabled', ()=>{
+        it('always returns false — localization module has no company scoping', ()=>{
+            const service = new LocalizationConfigService(buildOptions());
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('returns false even when bootstrapAppConfig enables the company feature elsewhere', ()=>{
+            const service = new LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+    });
+    describe('getDatabaseMode', ()=>{
+        it('returns the configured database mode', ()=>{
+            const service = new LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.getDatabaseMode()).toBe('multi-tenant');
+        });
+        it('defaults to "single" when bootstrapAppConfig is missing', ()=>{
+            const service = new LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+        it('defaults to "single" when databaseMode is not set on bootstrapAppConfig', ()=>{
+            const service = new LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: {}
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+    });
+    describe('isMultiTenant', ()=>{
+        it('returns true when database mode is multi-tenant', ()=>{
+            const service = new LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('returns false when database mode is single', ()=>{
+            const service = new LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single'
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(false);
+        });
+    });
+    describe('getOptions', ()=>{
+        it('returns the exact options object it was constructed with', ()=>{
+            const options = buildOptions({
+                config: {
+                    defaultLanguageCode: 'en'
+                }
+            });
+            const service = new LocalizationConfigService(options);
+            expect(service.getOptions()).toBe(options);
+        });
+    });
+});

package/fesm/services/localization-datasource.provider.spec.js

@@ -0,0 +1,81 @@
+import { LocalizationDataSourceProvider } from './localization-datasource.provider';
+import { Language, Translation, TranslationKey } from '../entities';
+function buildConfigService(overrides = {}) {
+    const options = {
+        bootstrapAppConfig: {
+            databaseMode: 'single'
+        },
+        config: {
+            defaultDatabaseConfig: {
+                type: 'mysql',
+                host: 'localhost',
+                port: 3306,
+                username: 'root',
+                password: 'password',
+                database: 'flusys_test'
+            },
+            tenantDefaultDatabaseConfig: undefined,
+            tenants: []
+        },
+        ...overrides
+    };
+    return {
+        getOptions: jest.fn().mockReturnValue(options)
+    };
+}
+describe('LocalizationDataSourceProvider', ()=>{
+    afterEach(()=>{
+        // Reset the isolated static caches this provider owns so tests don't leak state between runs.
+        LocalizationDataSourceProvider.tenantConnections = new Map();
+        LocalizationDataSourceProvider.singleDataSource = null;
+        LocalizationDataSourceProvider.tenantsRegistry = new Map();
+        LocalizationDataSourceProvider.initialized = false;
+        LocalizationDataSourceProvider.connectionLocks = new Map();
+        LocalizationDataSourceProvider.singleConnectionLock = null;
+    });
+    it('constructs and forwards bootstrap/database config to the base class', ()=>{
+        const configService = buildConfigService();
+        const provider = new LocalizationDataSourceProvider(configService, undefined);
+        expect(configService.getOptions).toHaveBeenCalled();
+        expect(provider.getDatabaseMode()).toBe('single');
+        expect(provider.isMultiTenant()).toBe(false);
+    });
+    it('reflects multi-tenant mode from bootstrapAppConfig', ()=>{
+        const configService = buildConfigService({
+            bootstrapAppConfig: {
+                databaseMode: 'multi-tenant'
+            }
+        });
+        const provider = new LocalizationDataSourceProvider(configService, undefined);
+        expect(provider.isMultiTenant()).toBe(true);
+    });
+    it('owns isolated static caches, separate from the base MultiTenantDataSourceService', ()=>{
+        // Each DataSource Provider must override BOTH static cache properties and the
+        // methods that read them — otherwise modules would share connections (see FLUSYS_NEST/CLAUDE.md).
+        expect(LocalizationDataSourceProvider.tenantConnections).not.toBe(Object.getPrototypeOf(LocalizationDataSourceProvider).tenantConnections);
+    });
+    it('createDataSourceFromConfig builds a DataSource using all localization entities', async ()=>{
+        const configService = buildConfigService();
+        const provider = new LocalizationDataSourceProvider(configService, undefined);
+        const fakeDataSource = {
+            isInitialized: true
+        };
+        const superSpy = jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(provider)), 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+        const config = {
+            type: 'mysql',
+            host: 'localhost',
+            port: 3306,
+            username: 'root',
+            password: 'password',
+            database: 'flusys_test'
+        };
+        const result = await provider.createDataSourceFromConfig(config);
+        expect(superSpy).toHaveBeenCalledWith(config, [
+            Language,
+            TranslationKey,
+            Translation
+        ]);
+        expect(result).toBe(fakeDataSource);
+        superSpy.mockRestore();
+    });
+});