@flusys/nestjs-localization 4.0.0-rc

package/fesm/services/translation.service.js

@@ -0,0 +1,212 @@
+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 { In, IsNull } from 'typeorm';
+import { Translation, Language, TranslationKey } from '../entities';
+import { LocalizationDataSourceProvider } from './localization-datasource.provider';
+export class TranslationService extends RequestScopedApiService {
+    resolveEntity() {
+        return Translation;
+    }
+    getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    async getFilterQuery(query, filter, _user) {
+        // Handle module filter by joining to translation_key table
+        if (filter.module) {
+            query.innerJoin('translation.translationKey', 'tk');
+            query.andWhere('tk.module = :module', {
+                module: filter.module
+            });
+        }
+        // Handle standard filters on translation table
+        if (filter.languageId) {
+            query.andWhere('translation.languageId = :languageId', {
+                languageId: filter.languageId
+            });
+        }
+        if (filter.translationKeyId) {
+            query.andWhere('translation.translationKeyId = :translationKeyId', {
+                translationKeyId: filter.translationKeyId
+            });
+        }
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async ensureAllReposInitialized() {
+        await this.ensureRepositoryInitialized();
+        if (!this.languageRepo) {
+            const ds = await this.dataSourceProvider.getDataSource();
+            this.languageRepo = ds.getRepository(Language);
+            this.translationKeyRepo = ds.getRepository(TranslationKey);
+        }
+    }
+    async getByLanguageCode(languageCode, modules) {
+        await this.ensureAllReposInitialized();
+        const language = await this.findActiveLanguageByCode(languageCode);
+        if (!language) return {};
+        const qb = this.repository.createQueryBuilder('t').innerJoinAndSelect('t.translationKey', 'tk').where('t.language_id = :languageId', {
+            languageId: language.id
+        }).andWhere('t.is_active = true').andWhere('t.deleted_at IS NULL').andWhere('tk.is_active = true').andWhere('tk.deleted_at IS NULL');
+        if (modules && modules.length > 0) {
+            qb.andWhere('tk.module IN (:...modules)', {
+                modules
+            });
+        }
+        return this.toTranslationsMap(await qb.getMany());
+    }
+    async getByModuleAndLanguage(module, languageCode) {
+        await this.ensureAllReposInitialized();
+        const language = await this.findActiveLanguageByCode(languageCode);
+        if (!language) return {};
+        const translations = await this.repository.createQueryBuilder('t').innerJoinAndSelect('t.translationKey', 'tk').where('t.language_id = :languageId', {
+            languageId: language.id
+        }).andWhere('tk.module = :module', {
+            module
+        }).andWhere('t.is_active = true').andWhere('t.deleted_at IS NULL').andWhere('tk.is_active = true').andWhere('tk.deleted_at IS NULL').getMany();
+        return this.toTranslationsMap(translations);
+    }
+    async bulkUpdate(updates) {
+        await this.ensureRepositoryInitialized();
+        if (updates.length === 0) return [];
+        const ds = await this.dataSourceProvider.getDataSource();
+        const queryRunner = ds.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            const resultIds = [];
+            for (const update of updates){
+                if (update.id) {
+                    // Update existing translation
+                    await queryRunner.manager.update(Translation, {
+                        id: update.id
+                    }, {
+                        value: update.value,
+                        isVerified: update.isVerified ?? false
+                    });
+                    resultIds.push(update.id);
+                } else {
+                    // Create new translation
+                    const newTranslation = queryRunner.manager.create(Translation, {
+                        languageId: update.languageId,
+                        translationKeyId: update.translationKeyId,
+                        value: update.value,
+                        isVerified: update.isVerified ?? false,
+                        isActive: true
+                    });
+                    const saved = await queryRunner.manager.save(newTranslation);
+                    resultIds.push(saved.id);
+                }
+            }
+            await queryRunner.commitTransaction();
+            return this.repository.find({
+                where: {
+                    id: In(resultIds)
+                }
+            });
+        } catch (error) {
+            await queryRunner.rollbackTransaction();
+            throw error;
+        } finally{
+            await queryRunner.release();
+        }
+    }
+    async getMissingTranslations(languageCode) {
+        await this.ensureAllReposInitialized();
+        const language = await this.findActiveLanguageByCode(languageCode);
+        if (!language) return [];
+        if (!this.translationKeyRepo) return [];
+        const allKeys = await this.translationKeyRepo.find({
+            where: {
+                isActive: true,
+                deletedAt: IsNull()
+            }
+        });
+        const existingTranslations = await this.repository.find({
+            where: {
+                languageId: language.id,
+                isActive: true,
+                deletedAt: IsNull()
+            },
+            select: [
+                'translationKeyId'
+            ]
+        });
+        const existingKeyIds = new Set(existingTranslations.map((t)=>t.translationKeyId));
+        return allKeys.filter((k)=>!existingKeyIds.has(k.id));
+    }
+    async getTranslationCounts() {
+        await this.ensureRepositoryInitialized();
+        const counts = await this.repository.createQueryBuilder('t').select('t.translation_key_id', 'keyId').addSelect('COUNT(t.id)', 'count').where('t.is_active = true').andWhere('t.deleted_at IS NULL').groupBy('t.translation_key_id').getRawMany();
+        const result = {};
+        for (const row of counts){
+            result[row.keyId] = parseInt(row.count, 10);
+        }
+        return result;
+    }
+    async findActiveLanguageByCode(code) {
+        if (!this.languageRepo) return null;
+        return this.languageRepo.findOne({
+            where: {
+                code,
+                isActive: true,
+                deletedAt: IsNull()
+            }
+        });
+    }
+    toTranslationsMap(translations) {
+        const result = {};
+        for (const t of translations){
+            if (t.translationKey) {
+                result[t.translationKey.key] = t.value;
+            }
+        }
+        return result;
+    }
+    constructor(cacheManager, utilsService, dataSourceProvider){
+        super('translation', null, cacheManager, utilsService, TranslationService.name, true, 'localization'), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "languageRepo", void 0), _define_property(this, "translationKeyRepo", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider, this.languageRepo = null, this.translationKeyRepo = null;
+    }
+}
+TranslationService = _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
+    ])
+], TranslationService);

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from './config';
+export * from './controllers';
+export * from './dtos';
+export * from './entities';
+export * from './interfaces';
+export * from './modules';
+export * from './services';

package/interfaces/index.d.ts

@@ -0,0 +1,4 @@
+export * from './language.interface';
+export * from './translation-key.interface';
+export * from './translation.interface';
+export * from './localization-module-options.interface';

package/interfaces/language.interface.d.ts

@@ -0,0 +1,10 @@
+import { IIdentity } from '@flusys/nestjs-shared/interfaces';
+export interface ILanguage extends IIdentity {
+    code: string;
+    name: string;
+    nativeName: string | null;
+    direction: 'ltr' | 'rtl' | null;
+    isActive: boolean;
+    isDefault: boolean;
+    serial: number | null;
+}

package/interfaces/localization-module-options.interface.d.ts

@@ -0,0 +1,21 @@
+import { IBootstrapAppConfig, IDataSourceServiceOptions, IDynamicModuleConfig, IModuleOptionsFactory } from '@flusys/nestjs-core';
+import { ModuleMetadata, Type } from '@nestjs/common';
+export interface ILocalizationModuleConfig extends IDataSourceServiceOptions {
+    defaultLanguageCode?: string;
+    enableCaching?: boolean;
+    cacheTtlSeconds?: number;
+}
+export interface LocalizationModuleOptions extends IDynamicModuleConfig {
+    bootstrapAppConfig?: IBootstrapAppConfig;
+    config?: ILocalizationModuleConfig;
+}
+export interface LocalizationOptionsFactory extends IModuleOptionsFactory<ILocalizationModuleConfig> {
+    createLocalizationOptions(): Promise<ILocalizationModuleConfig> | ILocalizationModuleConfig;
+}
+export interface LocalizationModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'>, IDynamicModuleConfig {
+    bootstrapAppConfig: IBootstrapAppConfig;
+    useFactory?: (...args: any[]) => Promise<ILocalizationModuleConfig> | ILocalizationModuleConfig;
+    inject?: any[];
+    useClass?: Type<LocalizationOptionsFactory>;
+    useExisting?: Type<LocalizationOptionsFactory>;
+}

package/interfaces/translation-key.interface.d.ts

@@ -0,0 +1,11 @@
+import { IIdentity } from '@flusys/nestjs-shared/interfaces';
+export interface ITranslationKey extends IIdentity {
+    module: string;
+    key: string;
+    defaultMessage: string;
+    description: string | null;
+    variables: string[] | null;
+    isActive: boolean;
+    isReadonly: boolean;
+    serial: number | null;
+}

package/interfaces/translation.interface.d.ts

@@ -0,0 +1,13 @@
+import { IIdentity } from '@flusys/nestjs-shared/interfaces';
+import { ILanguage } from './language.interface';
+import { ITranslationKey } from './translation-key.interface';
+export interface ITranslation extends IIdentity {
+    languageId: string;
+    translationKeyId: string;
+    value: string;
+    isVerified: boolean;
+    isActive: boolean;
+    language?: ILanguage;
+    translationKey?: ITranslationKey;
+}
+export type ITranslationsMap = Record<string, string>;

package/modules/index.d.ts

@@ -0,0 +1 @@
+export * from './localization.module';

package/modules/localization.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { LocalizationModuleAsyncOptions, LocalizationModuleOptions } from '../interfaces';
+export declare class LocalizationModule {
+    static forRoot(options: LocalizationModuleOptions): DynamicModule;
+    static forRootAsync(options: LocalizationModuleAsyncOptions): DynamicModule;
+    private static buildProviders;
+    private static createAsyncProviders;
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@flusys/nestjs-localization",
+  "version": "4.0.0-rc",
+  "description": "Localization module for multi-language support",
+  "main": "cjs/index.js",
+  "module": "fesm/index.js",
+  "types": "index.d.ts",
+  "sideEffects": false,
+  "keywords": [
+    "nestjs",
+    "localization",
+    "i18n",
+    "translation",
+    "multi-language",
+    "@flusys"
+  ],
+  "license": "UNLICENSED",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./fesm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./config": {
+      "types": "./config/index.d.ts",
+      "import": "./fesm/config/index.js",
+      "require": "./cjs/config/index.js"
+    },
+    "./controllers": {
+      "types": "./controllers/index.d.ts",
+      "import": "./fesm/controllers/index.js",
+      "require": "./cjs/controllers/index.js"
+    },
+    "./dtos": {
+      "types": "./dtos/index.d.ts",
+      "import": "./fesm/dtos/index.js",
+      "require": "./cjs/dtos/index.js"
+    },
+    "./entities": {
+      "types": "./entities/index.d.ts",
+      "import": "./fesm/entities/index.js",
+      "require": "./cjs/entities/index.js"
+    },
+    "./interfaces": {
+      "types": "./interfaces/index.d.ts",
+      "import": "./fesm/interfaces/index.js",
+      "require": "./cjs/interfaces/index.js"
+    },
+    "./modules": {
+      "types": "./modules/index.d.ts",
+      "import": "./fesm/modules/index.js",
+      "require": "./cjs/modules/index.js"
+    },
+    "./services": {
+      "types": "./services/index.d.ts",
+      "import": "./fesm/services/index.js",
+      "require": "./cjs/services/index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js",
+      "require": "./*.js"
+    }
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/config": "^3.0.0 || ^4.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/platform-express": "^10.0.0 || ^11.0.0",
+    "@nestjs/swagger": "^7.0.0 || ^11.0.0",
+    "@nestjs/typeorm": "^10.0.0 || ^11.0.0",
+    "class-transformer": "^0.5.0",
+    "class-validator": "^0.14.0",
+    "typeorm": "^0.3.0"
+  },
+  "dependencies": {
+    "@flusys/nestjs-core": "4.0.0-rc",
+    "@flusys/nestjs-shared": "4.0.0-rc"
+  }
+}

package/services/index.d.ts

@@ -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/services/language.service.d.ts

@@ -0,0 +1,18 @@
+import { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { EntityTarget, Repository } from 'typeorm';
+import { CreateLanguageDto, UpdateLanguageDto } from '../dtos';
+import { Language } from '../entities';
+import { ILanguage } from '../interfaces';
+import { LocalizationDataSourceProvider } from './localization-datasource.provider';
+export declare class LanguageService extends RequestScopedApiService<CreateLanguageDto, UpdateLanguageDto, ILanguage, Language, Repository<Language>> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly dataSourceProvider;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: LocalizationDataSourceProvider);
+    protected resolveEntity(): EntityTarget<Language>;
+    protected getDataSourceProvider(): LocalizationDataSourceProvider;
+    getDefaultLanguage(): Promise<Language | null>;
+    getActiveLanguages(): Promise<Language[]>;
+    setAsDefault(id: string): Promise<Language | null>;
+}

package/services/localization-config.service.d.ts

@@ -0,0 +1,11 @@
+import { DatabaseMode } from '@flusys/nestjs-core';
+import { IModuleConfigService } from '@flusys/nestjs-shared/interfaces';
+import { LocalizationModuleOptions } from '../interfaces';
+export declare class LocalizationConfigService implements IModuleConfigService {
+    private readonly options;
+    constructor(options: LocalizationModuleOptions);
+    isCompanyFeatureEnabled(): boolean;
+    getDatabaseMode(): DatabaseMode;
+    isMultiTenant(): boolean;
+    getOptions(): LocalizationModuleOptions;
+}

package/services/localization-datasource.provider.d.ts

@@ -0,0 +1,16 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { IDatabaseConfig, ITenantDatabaseConfig } from '@flusys/nestjs-core';
+import { Request } from 'express';
+import { DataSource } from 'typeorm';
+import { LocalizationConfigService } from './localization-config.service';
+export declare class LocalizationDataSourceProvider extends MultiTenantDataSourceService {
+    protected static readonly tenantConnections: Map<string, DataSource>;
+    protected static singleDataSource: DataSource | null;
+    protected static readonly connectionLocks: Map<string, Promise<DataSource>>;
+    protected static singleConnectionLock: Promise<DataSource> | null;
+    constructor(configService: LocalizationConfigService, request?: Request);
+    private static buildParentOptions;
+    protected createDataSourceFromConfig(config: IDatabaseConfig): Promise<DataSource>;
+    protected getSingleDataSource(): Promise<DataSource>;
+    protected getOrCreateTenantConnection(tenant: ITenantDatabaseConfig): Promise<DataSource>;
+}

package/services/translation-key.service.d.ts

@@ -0,0 +1,23 @@
+import { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
+import { DeleteDto } from '@flusys/nestjs-shared/dtos';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { EntityTarget, QueryRunner, Repository } from 'typeorm';
+import { CreateTranslationKeyDto, UpdateTranslationKeyDto } from '../dtos';
+import { TranslationKey } from '../entities';
+import { ITranslationKey } from '../interfaces';
+import { LocalizationDataSourceProvider } from './localization-datasource.provider';
+export declare class TranslationKeyService extends RequestScopedApiService<CreateTranslationKeyDto, UpdateTranslationKeyDto, ITranslationKey, TranslationKey, Repository<TranslationKey>> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly dataSourceProvider;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: LocalizationDataSourceProvider);
+    protected resolveEntity(): EntityTarget<TranslationKey>;
+    protected getDataSourceProvider(): LocalizationDataSourceProvider;
+    protected beforeInsertOperation(dto: CreateTranslationKeyDto | CreateTranslationKeyDto[], _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected beforeUpdateOperation(dto: UpdateTranslationKeyDto | UpdateTranslationKeyDto[], _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected beforeDeleteOperation(option: DeleteDto, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    findByModule(module: string): Promise<TranslationKey[]>;
+    getModules(): Promise<string[]>;
+    private validateNoDuplicateKeys;
+}

package/services/translation.service.d.ts

@@ -0,0 +1,30 @@
+import { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { EntityTarget, Repository, SelectQueryBuilder } from 'typeorm';
+import { CreateTranslationDto, UpdateTranslationDto, BulkUpdateTranslationDto } from '../dtos';
+import { Translation, TranslationKey } from '../entities';
+import { ITranslation, ITranslationsMap } from '../interfaces';
+import { LocalizationDataSourceProvider } from './localization-datasource.provider';
+export declare class TranslationService extends RequestScopedApiService<CreateTranslationDto, UpdateTranslationDto, ITranslation, Translation, Repository<Translation>> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly dataSourceProvider;
+    private languageRepo;
+    private translationKeyRepo;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: LocalizationDataSourceProvider);
+    protected resolveEntity(): EntityTarget<Translation>;
+    protected getDataSourceProvider(): LocalizationDataSourceProvider;
+    protected getFilterQuery(query: SelectQueryBuilder<Translation>, filter: Record<string, unknown>, _user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<Translation>;
+        isRaw: boolean;
+    }>;
+    private ensureAllReposInitialized;
+    getByLanguageCode(languageCode: string, modules?: string[]): Promise<ITranslationsMap>;
+    getByModuleAndLanguage(module: string, languageCode: string): Promise<ITranslationsMap>;
+    bulkUpdate(updates: BulkUpdateTranslationDto[]): Promise<Translation[]>;
+    getMissingTranslations(languageCode: string): Promise<TranslationKey[]>;
+    getTranslationCounts(): Promise<Record<string, number>>;
+    private findActiveLanguageByCode;
+    private toTranslationsMap;
+}