@flusys/nestjs-localization 7.1.0 → 8.0.0

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

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

package/cjs/services/index.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./localization-config.service"), exports);
-_export_star(require("./localization-datasource.provider"), exports);
-_export_star(require("./language.service"), exports);
-_export_star(require("./translation-key.service"), exports);
-_export_star(require("./translation.service"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/services/language.service.js

@@ -1,181 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "LanguageService", {
-    enumerable: true,
-    get: function() {
-        return LanguageService;
-    }
-});
-const _classes = require("@flusys/nestjs-shared/classes");
-const _modules = require("@flusys/nestjs-shared/modules");
-const _common = require("@nestjs/common");
-const _typeorm = require("typeorm");
-const _config = require("../config");
-const _entities = require("../entities");
-const _localizationdatasourceprovider = require("./localization-datasource.provider");
-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);
-    };
-}
-let LanguageService = class LanguageService extends _classes.ApiService {
-    async beforeUpdateOperation(dto, _user, _queryRunner) {
-        const dtos = Array.isArray(dto) ? dto : [
-            dto
-        ];
-        const ids = dtos.map((d)=>d.id);
-        await this.ensureDataSourceRepository();
-        const existingLanguages = await this.repository.find({
-            where: {
-                id: (0, _typeorm.In)(ids),
-                deletedAt: (0, _typeorm.IsNull)()
-            }
-        });
-        for (const d of dtos){
-            const existing = existingLanguages.find((e)=>e.id === d.id);
-            if (!existing) {
-                continue;
-            }
-            const changesIdentity = d.code !== undefined && d.code !== existing.code || d.name !== undefined && d.name !== existing.name || d.nativeName !== undefined && d.nativeName !== (existing.nativeName ?? undefined) || d.direction !== undefined && d.direction !== existing.direction;
-            if (existing.isReadonly && changesIdentity) {
-                throw new _common.ForbiddenException({
-                    message: `Cannot modify code/name of readonly language "${existing.name}"`,
-                    messageKey: _config.LANGUAGE_MESSAGES.READONLY_UPDATE_FORBIDDEN,
-                    messageVariables: {
-                        name: existing.name
-                    }
-                });
-            }
-        }
-    }
-    async beforeDeleteOperation(dto, _user, _queryRunner) {
-        const ids = Array.isArray(dto.id) ? dto.id : [
-            dto.id
-        ];
-        await this.ensureDataSourceRepository();
-        const languages = await this.repository.find({
-            where: {
-                id: (0, _typeorm.In)(ids),
-                deletedAt: (0, _typeorm.IsNull)()
-            }
-        });
-        const readonlyLanguages = languages.filter((l)=>l.isReadonly);
-        if (readonlyLanguages.length > 0) {
-            const names = readonlyLanguages.map((l)=>l.name).join(', ');
-            throw new _common.ForbiddenException({
-                message: `Cannot delete readonly language(s): ${names}`,
-                messageKey: _config.LANGUAGE_MESSAGES.READONLY_DELETE_FORBIDDEN,
-                messageVariables: {
-                    names
-                }
-            });
-        }
-        const defaultLanguages = languages.filter((l)=>l.isDefault);
-        if (defaultLanguages.length > 0) {
-            const names = defaultLanguages.map((l)=>l.name).join(', ');
-            throw new _common.ForbiddenException({
-                message: `Cannot delete the default language(s): ${names}. Set another language as default first.`,
-                messageKey: _config.LANGUAGE_MESSAGES.DEFAULT_DELETE_FORBIDDEN,
-                messageVariables: {
-                    names
-                }
-            });
-        }
-    }
-    async getDefaultLanguage() {
-        await this.ensureDataSourceRepository();
-        return this.repository.findOne({
-            where: {
-                isDefault: true,
-                deletedAt: (0, _typeorm.IsNull)()
-            }
-        });
-    }
-    async getActiveLanguages() {
-        await this.ensureDataSourceRepository();
-        return this.repository.find({
-            where: {
-                isActive: true,
-                deletedAt: (0, _typeorm.IsNull)()
-            },
-            order: {
-                serial: 'ASC',
-                name: 'ASC'
-            }
-        });
-    }
-    async setAsDefault(id) {
-        await this.ensureDataSourceRepository();
-        const previousDefaults = await this.repository.find({
-            where: {
-                isDefault: true
-            }
-        });
-        await this.repository.update({
-            isDefault: true
-        }, {
-            isDefault: false
-        });
-        await this.repository.update({
-            id
-        }, {
-            isDefault: true
-        });
-        const language = await this.repository.findOne({
-            where: {
-                id
-            }
-        });
-        await Promise.all([
-            this.clearCacheForAll(),
-            this.clearCacheForId([
-                ...previousDefaults,
-                {
-                    id
-                }
-            ])
-        ]);
-        return language;
-    }
-    constructor(cacheManager, utilsService, dataSourceProvider){
-        super(_config.LOCALIZATION_EVENT_ENTITIES.LANGUAGE, cacheManager, utilsService, LanguageService.name, true, _config.LOCALIZATION_EVENT_MODULE, dataSourceProvider, _entities.Language), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService;
-    }
-};
-LanguageService = _ts_decorate([
-    (0, _common.Injectable)({
-        scope: _common.Scope.REQUEST
-    }),
-    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
-    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
-    _ts_param(2, (0, _common.Inject)(_localizationdatasourceprovider.LocalizationDataSourceProvider)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
-        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
-        typeof _localizationdatasourceprovider.LocalizationDataSourceProvider === "undefined" ? Object : _localizationdatasourceprovider.LocalizationDataSourceProvider
-    ])
-], LanguageService);

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

@@ -1,256 +0,0 @@
-"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;
-    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 = (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: mockUtilsService
-                },
-                {
-                    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', ()=>{
-        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/cjs/services/localization-config.service.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "LocalizationConfigService", {
-    enumerable: true,
-    get: function() {
-        return LocalizationConfigService;
-    }
-});
-const _common = require("@nestjs/common");
-const _localizationconstants = require("../config/localization.constants");
-const _interfaces = require("../interfaces");
-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);
-    };
-}
-let LocalizationConfigService = 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([
-    (0, _common.Injectable)(),
-    _ts_param(0, (0, _common.Inject)(_localizationconstants.LOCALIZATION_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _interfaces.LocalizationModuleOptions === "undefined" ? Object : _interfaces.LocalizationModuleOptions
-    ])
-], LocalizationConfigService);