@flusys/nestjs-localization 6.0.2 → 6.1.1

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

@@ -0,0 +1,151 @@
+"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 _languageservice = require("./language.service");
+const _localizationdatasourceprovider = require("./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 = (0, _repositorymock.createMockRepository)();
+        const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
+        const module = await _testing.Test.createTestingModule({
+            providers: [
+                _languageservice.LanguageService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: _modules.UtilsService,
+                    useValue: {}
+                },
+                {
+                    provide: _localizationdatasourceprovider.LocalizationDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(_languageservice.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/cjs/services/localization-config.service.spec.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _localizationconfigservice = require("./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.LocalizationConfigService(buildOptions());
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('returns false even when bootstrapAppConfig enables the company feature elsewhere', ()=>{
+            const service = new _localizationconfigservice.LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+    });
+    describe('getDatabaseMode', ()=>{
+        it('returns the configured database mode', ()=>{
+            const service = new _localizationconfigservice.LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.getDatabaseMode()).toBe('multi-tenant');
+        });
+        it('defaults to "single" when bootstrapAppConfig is missing', ()=>{
+            const service = new _localizationconfigservice.LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+        it('defaults to "single" when databaseMode is not set on bootstrapAppConfig', ()=>{
+            const service = new _localizationconfigservice.LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: {}
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+    });
+    describe('isMultiTenant', ()=>{
+        it('returns true when database mode is multi-tenant', ()=>{
+            const service = new _localizationconfigservice.LocalizationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('returns false when database mode is single', ()=>{
+            const service = new _localizationconfigservice.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.LocalizationConfigService(options);
+            expect(service.getOptions()).toBe(options);
+        });
+    });
+});

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _localizationdatasourceprovider = require("./localization-datasource.provider");
+const _entities = require("../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.LocalizationDataSourceProvider.tenantConnections = new Map();
+        _localizationdatasourceprovider.LocalizationDataSourceProvider.singleDataSource = null;
+        _localizationdatasourceprovider.LocalizationDataSourceProvider.tenantsRegistry = new Map();
+        _localizationdatasourceprovider.LocalizationDataSourceProvider.initialized = false;
+        _localizationdatasourceprovider.LocalizationDataSourceProvider.connectionLocks = new Map();
+        _localizationdatasourceprovider.LocalizationDataSourceProvider.singleConnectionLock = null;
+    });
+    it('constructs and forwards bootstrap/database config to the base class', ()=>{
+        const configService = buildConfigService();
+        const provider = new _localizationdatasourceprovider.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.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.LocalizationDataSourceProvider.tenantConnections).not.toBe(Object.getPrototypeOf(_localizationdatasourceprovider.LocalizationDataSourceProvider).tenantConnections);
+    });
+    it('createDataSourceFromConfig builds a DataSource using all localization entities', async ()=>{
+        const configService = buildConfigService();
+        const provider = new _localizationdatasourceprovider.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, [
+            _entities.Language,
+            _entities.TranslationKey,
+            _entities.Translation
+        ]);
+        expect(result).toBe(fakeDataSource);
+        superSpy.mockRestore();
+    });
+});

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

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