@flusys/nestjs-localization 7.1.0 → 8.0.0

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

@@ -1,252 +0,0 @@
-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;
-    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();
-    });
-    beforeEach(async ()=>{
-        mockRepo = createMockRepository();
-        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
-        const module = await Test.createTestingModule({
-            providers: [
-                LanguageService,
-                {
-                    provide: 'CACHE_INSTANCE',
-                    useValue: {}
-                },
-                {
-                    provide: UtilsService,
-                    useValue: mockUtilsService
-                },
-                {
-                    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', ()=>{
-        beforeEach(()=>{
-            mockRepo.find.mockResolvedValue([]);
-        });
-        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('invalidates the language list cache and both the old and new default entries', async ()=>{
-            const previousDefault = buildLanguage({
-                id: 'lang-1',
-                isDefault: true,
-                code: 'en'
-            });
-            mockRepo.find.mockResolvedValue([
-                previousDefault
-            ]);
-            mockRepo.findOne.mockResolvedValue(buildLanguage({
-                id: 'lang-2',
-                isDefault: true
-            }));
-            await service.setAsDefault('lang-2');
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('language', expect.anything());
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('language', expect.anything(), 'lang-1');
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('language', expect.anything(), 'lang-2');
-        });
-        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
-            });
-        });
-    });
-    describe('beforeUpdateOperation', ()=>{
-        it('rejects renaming the code of a readonly language', async ()=>{
-            mockRepo.find.mockResolvedValue([
-                buildLanguage({
-                    isReadonly: true,
-                    code: 'en'
-                })
-            ]);
-            await expect(service.beforeUpdateOperation({
-                id: 'language-uuid-1',
-                code: 'fr'
-            }, null, {})).rejects.toThrow('Cannot modify code/name of readonly language');
-        });
-        it('allows updating isActive on a readonly language when identity fields are unchanged', async ()=>{
-            mockRepo.find.mockResolvedValue([
-                buildLanguage({
-                    isReadonly: true,
-                    code: 'en',
-                    name: 'English'
-                })
-            ]);
-            await expect(service.beforeUpdateOperation({
-                id: 'language-uuid-1',
-                code: 'en',
-                name: 'English',
-                isActive: false
-            }, null, {})).resolves.toBeUndefined();
-        });
-        it('allows any field change on a non-readonly language', async ()=>{
-            mockRepo.find.mockResolvedValue([
-                buildLanguage({
-                    isReadonly: false,
-                    code: 'en'
-                })
-            ]);
-            await expect(service.beforeUpdateOperation({
-                id: 'language-uuid-1',
-                code: 'fr'
-            }, null, {})).resolves.toBeUndefined();
-        });
-    });
-    describe('beforeDeleteOperation', ()=>{
-        it('rejects deleting a readonly language', async ()=>{
-            mockRepo.find.mockResolvedValue([
-                buildLanguage({
-                    isReadonly: true
-                })
-            ]);
-            await expect(service.beforeDeleteOperation({
-                id: 'language-uuid-1'
-            }, null, {})).rejects.toThrow('Cannot delete readonly language');
-        });
-        it('rejects deleting the default language', async ()=>{
-            mockRepo.find.mockResolvedValue([
-                buildLanguage({
-                    isReadonly: false,
-                    isDefault: true
-                })
-            ]);
-            await expect(service.beforeDeleteOperation({
-                id: 'language-uuid-1'
-            }, null, {})).rejects.toThrow('Cannot delete the default language');
-        });
-        it('allows deleting a non-readonly, non-default language', async ()=>{
-            mockRepo.find.mockResolvedValue([
-                buildLanguage({
-                    isReadonly: false,
-                    isDefault: false
-                })
-            ]);
-            await expect(service.beforeDeleteOperation({
-                id: 'language-uuid-1'
-            }, null, {})).resolves.toBeUndefined();
-        });
-    });
-});

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

@@ -1,56 +0,0 @@
-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 _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { Inject, Injectable } from '@nestjs/common';
-import { LOCALIZATION_MODULE_OPTIONS } from '../config/localization.constants';
-import { LocalizationModuleOptions } from '../interfaces';
-export class LocalizationConfigService {
-    isCompanyFeatureEnabled() {
-        return false;
-    }
-    getDatabaseMode() {
-        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
-    }
-    isMultiTenant() {
-        return this.getDatabaseMode() === 'multi-tenant';
-    }
-    getOptions() {
-        return this.options;
-    }
-    constructor(options){
-        _define_property(this, "options", void 0);
-        this.options = options;
-    }
-}
-LocalizationConfigService = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(LOCALIZATION_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof LocalizationModuleOptions === "undefined" ? Object : LocalizationModuleOptions
-    ])
-], LocalizationConfigService);

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

@@ -1,76 +0,0 @@
-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.js

@@ -1,69 +0,0 @@
-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 _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
-import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
-import { REQUEST } from '@nestjs/core';
-import { Request } from 'express';
-import { getLocalizationEntities } from '../entities';
-import { LocalizationConfigService } from './localization-config.service';
-export class LocalizationDataSourceProvider extends MultiTenantDataSourceService {
-    static buildParentOptions(options) {
-        return {
-            bootstrapAppConfig: options.bootstrapAppConfig,
-            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
-            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
-            tenants: options.config?.tenants
-        };
-    }
-    async createDataSourceFromConfig(config) {
-        const entities = getLocalizationEntities();
-        return super.createDataSourceFromConfig(config, entities);
-    }
-    constructor(configService, request){
-        super(LocalizationDataSourceProvider.buildParentOptions(configService.getOptions()), request);
-    }
-}
-_define_property(LocalizationDataSourceProvider, "tenantConnections", new Map());
-_define_property(LocalizationDataSourceProvider, "singleDataSource", null);
-_define_property(LocalizationDataSourceProvider, "tenantsRegistry", new Map());
-_define_property(LocalizationDataSourceProvider, "initialized", false);
-_define_property(LocalizationDataSourceProvider, "connectionLocks", new Map());
-_define_property(LocalizationDataSourceProvider, "singleConnectionLock", null);
-LocalizationDataSourceProvider = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject(LocalizationConfigService)),
-    _ts_param(1, Optional()),
-    _ts_param(1, Inject(REQUEST)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof LocalizationConfigService === "undefined" ? Object : LocalizationConfigService,
-        typeof Request === "undefined" ? Object : Request
-    ])
-], LocalizationDataSourceProvider);

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

@@ -1,81 +0,0 @@
-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();
-    });
-});