@flusys/nestjs-localization 4.0.0-rc

package/fesm/modules/localization.module.js

@@ -0,0 +1,105 @@
+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;
+}
+import { CacheModule, UtilsModule } from '@flusys/nestjs-shared/modules';
+import { Module } from '@nestjs/common';
+import { LOCALIZATION_MODULE_OPTIONS } from '../config/localization.constants';
+import { LanguageController, TranslationKeyController, TranslationController } from '../controllers';
+import { LanguageService, LocalizationConfigService, LocalizationDataSourceProvider, TranslationKeyService, TranslationService } from '../services';
+const CONTROLLERS = [
+    LanguageController,
+    TranslationKeyController,
+    TranslationController
+];
+const EXPORTED_SERVICES = [
+    LocalizationConfigService,
+    LocalizationDataSourceProvider,
+    LanguageService,
+    TranslationKeyService,
+    TranslationService
+];
+export class LocalizationModule {
+    static forRoot(options) {
+        return {
+            module: LocalizationModule,
+            global: options.global ?? false,
+            imports: [
+                CacheModule,
+                UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: this.buildProviders(options),
+            exports: EXPORTED_SERVICES
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: LocalizationModule,
+            global: options.global ?? false,
+            imports: [
+                ...options.imports || [],
+                CacheModule,
+                UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                ...this.buildProviders()
+            ],
+            exports: EXPORTED_SERVICES
+        };
+    }
+    static buildProviders(options) {
+        const providers = [
+            ...EXPORTED_SERVICES
+        ];
+        if (options) {
+            providers.unshift({
+                provide: LOCALIZATION_MODULE_OPTIONS,
+                useValue: options
+            });
+        }
+        return providers;
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: LOCALIZATION_MODULE_OPTIONS,
+                    useFactory: async (...args)=>({
+                            ...options,
+                            config: await options.useFactory(...args)
+                        }),
+                    inject: options.inject || []
+                }
+            ];
+        }
+        const factoryClass = options.useClass || options.useExisting;
+        if (!factoryClass) return [];
+        const providers = [
+            {
+                provide: LOCALIZATION_MODULE_OPTIONS,
+                useFactory: async (factory)=>({
+                        ...options,
+                        config: await factory.createLocalizationOptions()
+                    }),
+                inject: [
+                    factoryClass
+                ]
+            }
+        ];
+        if (options.useClass) {
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass
+            });
+        }
+        return providers;
+    }
+}
+LocalizationModule = _ts_decorate([
+    Module({})
+], LocalizationModule);

package/fesm/services/index.js

@@ -0,0 +1,5 @@
+export * from './localization-config.service';
+export * from './localization-datasource.provider';
+export * from './language.service';
+export * from './translation-key.service';
+export * from './translation.service';

package/fesm/services/language.service.js

@@ -0,0 +1,98 @@
+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 { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { IsNull } from 'typeorm';
+import { Language } from '../entities';
+import { LocalizationDataSourceProvider } from './localization-datasource.provider';
+export class LanguageService extends RequestScopedApiService {
+    resolveEntity() {
+        return Language;
+    }
+    getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    async getDefaultLanguage() {
+        await this.ensureRepositoryInitialized();
+        return this.repository.findOne({
+            where: {
+                isDefault: true,
+                deletedAt: IsNull()
+            }
+        });
+    }
+    async getActiveLanguages() {
+        await this.ensureRepositoryInitialized();
+        return this.repository.find({
+            where: {
+                isActive: true,
+                deletedAt: IsNull()
+            },
+            order: {
+                serial: 'ASC',
+                name: 'ASC'
+            }
+        });
+    }
+    async setAsDefault(id) {
+        await this.ensureRepositoryInitialized();
+        await this.repository.update({
+            isDefault: true
+        }, {
+            isDefault: false
+        });
+        await this.repository.update({
+            id
+        }, {
+            isDefault: true
+        });
+        return this.repository.findOne({
+            where: {
+                id
+            }
+        });
+    }
+    constructor(cacheManager, utilsService, dataSourceProvider){
+        super('language', null, cacheManager, utilsService, LanguageService.name, true, 'localization'), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider;
+    }
+}
+LanguageService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(LocalizationDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof LocalizationDataSourceProvider === "undefined" ? Object : LocalizationDataSourceProvider
+    ])
+], LanguageService);

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

@@ -0,0 +1,56 @@
+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-datasource.provider.js

@@ -0,0 +1,112 @@
+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 { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
+import { Inject, Injectable, InternalServerErrorException, 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);
+    }
+    async getSingleDataSource() {
+        if (LocalizationDataSourceProvider.singleDataSource?.isInitialized) {
+            return LocalizationDataSourceProvider.singleDataSource;
+        }
+        if (LocalizationDataSourceProvider.singleConnectionLock) {
+            return LocalizationDataSourceProvider.singleConnectionLock;
+        }
+        const config = this.getDefaultDatabaseConfig();
+        if (!config) {
+            throw new InternalServerErrorException({
+                message: 'No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.',
+                messageKey: SYSTEM_MESSAGES.DATABASE_CONFIG_NOT_AVAILABLE
+            });
+        }
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        LocalizationDataSourceProvider.singleConnectionLock = connectionPromise;
+        try {
+            const dataSource = await connectionPromise;
+            LocalizationDataSourceProvider.singleDataSource = dataSource;
+            return dataSource;
+        } finally{
+            LocalizationDataSourceProvider.singleConnectionLock = null;
+        }
+    }
+    async getOrCreateTenantConnection(tenant) {
+        const existing = LocalizationDataSourceProvider.tenantConnections.get(tenant.id);
+        if (existing?.isInitialized) {
+            return existing;
+        }
+        const pendingConnection = LocalizationDataSourceProvider.connectionLocks.get(tenant.id);
+        if (pendingConnection) {
+            return pendingConnection;
+        }
+        const config = this.buildTenantDatabaseConfig(tenant);
+        const connectionPromise = this.createDataSourceFromConfig(config);
+        LocalizationDataSourceProvider.connectionLocks.set(tenant.id, connectionPromise);
+        try {
+            const dataSource = await connectionPromise;
+            LocalizationDataSourceProvider.tenantConnections.set(tenant.id, dataSource);
+            return dataSource;
+        } finally{
+            LocalizationDataSourceProvider.connectionLocks.delete(tenant.id);
+        }
+    }
+    constructor(configService, request){
+        super(LocalizationDataSourceProvider.buildParentOptions(configService.getOptions()), request);
+    }
+}
+_define_property(LocalizationDataSourceProvider, "tenantConnections", new Map());
+_define_property(LocalizationDataSourceProvider, "singleDataSource", null);
+_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/translation-key.service.js

@@ -0,0 +1,174 @@
+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 { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
+import { TRANSLATION_KEY_MESSAGES } from '../config';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { BadRequestException, ForbiddenException, Inject, Injectable, Scope } from '@nestjs/common';
+import { In, IsNull } from 'typeorm';
+import { TranslationKey } from '../entities';
+import { LocalizationDataSourceProvider } from './localization-datasource.provider';
+export class TranslationKeyService extends RequestScopedApiService {
+    resolveEntity() {
+        return TranslationKey;
+    }
+    getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    async beforeInsertOperation(dto, _user, _queryRunner) {
+        const dtos = Array.isArray(dto) ? dto : [
+            dto
+        ];
+        await this.validateNoDuplicateKeys(dtos.map((d)=>({
+                module: d.module,
+                key: d.key
+            })));
+    }
+    async beforeUpdateOperation(dto, _user, _queryRunner) {
+        const dtos = Array.isArray(dto) ? dto : [
+            dto
+        ];
+        const ids = dtos.map((d)=>d.id);
+        await this.ensureRepositoryInitialized();
+        const existingKeys = await this.repository.find({
+            where: {
+                id: In(ids),
+                deletedAt: IsNull()
+            }
+        });
+        // Check if any readonly keys are being updated with key/module changes
+        for (const d of dtos){
+            const existing = existingKeys.find((e)=>e.id === d.id);
+            if (existing?.isReadonly && (d.key || d.module)) {
+                throw new ForbiddenException({
+                    message: `Cannot modify key or module of readonly translation key "${existing.key}"`,
+                    messageKey: TRANSLATION_KEY_MESSAGES.READONLY_UPDATE_FORBIDDEN,
+                    messageParams: {
+                        key: existing.key
+                    }
+                });
+            }
+        }
+        // Validate no duplicates for keys being changed
+        const keysToValidate = dtos.filter((d)=>d.key || d.module).map((d)=>{
+            const existing = existingKeys.find((e)=>e.id === d.id);
+            return {
+                module: d.module ?? existing?.module ?? '',
+                key: d.key ?? existing?.key ?? '',
+                excludeId: d.id
+            };
+        });
+        if (keysToValidate.length > 0) {
+            await this.validateNoDuplicateKeys(keysToValidate);
+        }
+    }
+    async beforeDeleteOperation(option, _user, _queryRunner) {
+        const ids = Array.isArray(option.id) ? option.id : [
+            option.id
+        ];
+        await this.ensureRepositoryInitialized();
+        const readonlyKeys = await this.repository.find({
+            where: {
+                id: In(ids),
+                isReadonly: true,
+                deletedAt: IsNull()
+            }
+        });
+        if (readonlyKeys.length > 0) {
+            const keys = readonlyKeys.map((k)=>k.key).join(', ');
+            throw new ForbiddenException({
+                message: `Cannot delete readonly translation keys: ${keys}`,
+                messageKey: TRANSLATION_KEY_MESSAGES.READONLY_DELETE_FORBIDDEN,
+                messageParams: {
+                    keys
+                }
+            });
+        }
+    }
+    async findByModule(module) {
+        await this.ensureRepositoryInitialized();
+        return this.repository.find({
+            where: {
+                module,
+                isActive: true,
+                deletedAt: IsNull()
+            },
+            order: {
+                serial: 'ASC',
+                key: 'ASC'
+            }
+        });
+    }
+    async getModules() {
+        await this.ensureRepositoryInitialized();
+        const result = await this.repository.createQueryBuilder('tk').select('DISTINCT tk.module', 'module').where('tk.deleted_at IS NULL').getRawMany();
+        return result.map((r)=>r.module);
+    }
+    async validateNoDuplicateKeys(keys) {
+        await this.ensureRepositoryInitialized();
+        for (const { module, key, excludeId } of keys){
+            const query = this.repository.createQueryBuilder('tk').where('tk.module = :module', {
+                module
+            }).andWhere('tk.key = :key', {
+                key
+            }).andWhere('tk.deleted_at IS NULL');
+            if (excludeId) {
+                query.andWhere('tk.id != :excludeId', {
+                    excludeId
+                });
+            }
+            const existing = await query.getOne();
+            if (existing) {
+                throw new BadRequestException({
+                    message: `Translation key "${key}" already exists in module "${module}"`,
+                    messageKey: TRANSLATION_KEY_MESSAGES.DUPLICATE_KEY_IN_MODULE,
+                    messageParams: {
+                        key,
+                        module
+                    }
+                });
+            }
+        }
+    }
+    constructor(cacheManager, utilsService, dataSourceProvider){
+        super('translationKey', null, cacheManager, utilsService, TranslationKeyService.name, true, 'localization'), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider;
+    }
+}
+TranslationKeyService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(LocalizationDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof LocalizationDataSourceProvider === "undefined" ? Object : LocalizationDataSourceProvider
+    ])
+], TranslationKeyService);