@flusys/nestjs-localization 4.0.0-rc

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LocalizationDataSourceProvider", {
+    enumerable: true,
+    get: function() {
+        return LocalizationDataSourceProvider;
+    }
+});
+const _modules = require("@flusys/nestjs-shared/modules");
+const _constants = require("@flusys/nestjs-shared/constants");
+const _common = require("@nestjs/common");
+const _core = require("@nestjs/core");
+const _express = require("express");
+const _entities = require("../entities");
+const _localizationconfigservice = require("./localization-config.service");
+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 LocalizationDataSourceProvider = class LocalizationDataSourceProvider extends _modules.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 = (0, _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 _common.InternalServerErrorException({
+                message: 'No database config available. Provide defaultDatabaseConfig or tenantDefaultDatabaseConfig.',
+                messageKey: _constants.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([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)(_localizationconfigservice.LocalizationConfigService)),
+    _ts_param(1, (0, _common.Optional)()),
+    _ts_param(1, (0, _common.Inject)(_core.REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _localizationconfigservice.LocalizationConfigService === "undefined" ? Object : _localizationconfigservice.LocalizationConfigService,
+        typeof _express.Request === "undefined" ? Object : _express.Request
+    ])
+], LocalizationDataSourceProvider);

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

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TranslationKeyService", {
+    enumerable: true,
+    get: function() {
+        return TranslationKeyService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _config = require("../config");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _typeorm = require("typeorm");
+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 TranslationKeyService = class TranslationKeyService extends _classes.RequestScopedApiService {
+    resolveEntity() {
+        return _entities.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: (0, _typeorm.In)(ids),
+                deletedAt: (0, _typeorm.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 _common.ForbiddenException({
+                    message: `Cannot modify key or module of readonly translation key "${existing.key}"`,
+                    messageKey: _config.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: (0, _typeorm.In)(ids),
+                isReadonly: true,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (readonlyKeys.length > 0) {
+            const keys = readonlyKeys.map((k)=>k.key).join(', ');
+            throw new _common.ForbiddenException({
+                message: `Cannot delete readonly translation keys: ${keys}`,
+                messageKey: _config.TRANSLATION_KEY_MESSAGES.READONLY_DELETE_FORBIDDEN,
+                messageParams: {
+                    keys
+                }
+            });
+        }
+    }
+    async findByModule(module) {
+        await this.ensureRepositoryInitialized();
+        return this.repository.find({
+            where: {
+                module,
+                isActive: true,
+                deletedAt: (0, _typeorm.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 _common.BadRequestException({
+                    message: `Translation key "${key}" already exists in module "${module}"`,
+                    messageKey: _config.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([
+    (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
+    ])
+], TranslationKeyService);

package/cjs/services/translation.service.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TranslationService", {
+    enumerable: true,
+    get: function() {
+        return TranslationService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _typeorm = require("typeorm");
+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 TranslationService = class TranslationService extends _classes.RequestScopedApiService {
+    resolveEntity() {
+        return _entities.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(_entities.Language);
+            this.translationKeyRepo = ds.getRepository(_entities.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(_entities.Translation, {
+                        id: update.id
+                    }, {
+                        value: update.value,
+                        isVerified: update.isVerified ?? false
+                    });
+                    resultIds.push(update.id);
+                } else {
+                    // Create new translation
+                    const newTranslation = queryRunner.manager.create(_entities.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: (0, _typeorm.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: (0, _typeorm.IsNull)()
+            }
+        });
+        const existingTranslations = await this.repository.find({
+            where: {
+                languageId: language.id,
+                isActive: true,
+                deletedAt: (0, _typeorm.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: (0, _typeorm.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([
+    (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
+    ])
+], TranslationService);

package/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './localization.constants';
+export * from './message-keys';

package/config/localization.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const LOCALIZATION_MODULE_OPTIONS = "LOCALIZATION_MODULE_OPTIONS";
+export declare const DEFAULT_LANGUAGE_CODE = "en";

package/config/message-keys.d.ts

@@ -0,0 +1,96 @@
+export declare const LANGUAGE_MESSAGES: {
+    readonly CREATE_SUCCESS: "language.create.success";
+    readonly CREATE_MANY_SUCCESS: "language.create.many.success";
+    readonly GET_SUCCESS: "language.get.success";
+    readonly GET_ALL_SUCCESS: "language.get.all.success";
+    readonly UPDATE_SUCCESS: "language.update.success";
+    readonly UPDATE_MANY_SUCCESS: "language.update.many.success";
+    readonly DELETE_SUCCESS: "language.delete.success";
+    readonly RESTORE_SUCCESS: "language.restore.success";
+    readonly NOT_FOUND: "language.not.found";
+    readonly ACTIVE_SUCCESS: "language.active.success";
+    readonly SET_DEFAULT_SUCCESS: "language.set.default.success";
+    readonly GET_DEFAULT_SUCCESS: "language.get.default.success";
+};
+export declare const TRANSLATION_KEY_MESSAGES: {
+    readonly CREATE_SUCCESS: "translation.key.create.success";
+    readonly CREATE_MANY_SUCCESS: "translation.key.create.many.success";
+    readonly GET_SUCCESS: "translation.key.get.success";
+    readonly GET_ALL_SUCCESS: "translation.key.get.all.success";
+    readonly UPDATE_SUCCESS: "translation.key.update.success";
+    readonly UPDATE_MANY_SUCCESS: "translation.key.update.many.success";
+    readonly DELETE_SUCCESS: "translation.key.delete.success";
+    readonly RESTORE_SUCCESS: "translation.key.restore.success";
+    readonly NOT_FOUND: "translation.key.not.found";
+    readonly IMPORT_SUCCESS: "translation.key.import.success";
+    readonly EXPORT_SUCCESS: "translation.key.export.success";
+    readonly MODULES_SUCCESS: "translation.key.modules.success";
+    readonly READONLY_DELETE_FORBIDDEN: "translation.key.readonly.delete.forbidden";
+    readonly READONLY_UPDATE_FORBIDDEN: "translation.key.readonly.update.forbidden";
+    readonly DUPLICATE_KEY_IN_MODULE: "translation.key.duplicate.key.in.module";
+};
+export declare const TRANSLATION_MESSAGES: {
+    readonly CREATE_SUCCESS: "translation.create.success";
+    readonly CREATE_MANY_SUCCESS: "translation.create.many.success";
+    readonly GET_SUCCESS: "translation.get.success";
+    readonly GET_ALL_SUCCESS: "translation.get.all.success";
+    readonly UPDATE_SUCCESS: "translation.update.success";
+    readonly UPDATE_MANY_SUCCESS: "translation.update.many.success";
+    readonly DELETE_SUCCESS: "translation.delete.success";
+    readonly RESTORE_SUCCESS: "translation.restore.success";
+    readonly NOT_FOUND: "translation.not.found";
+    readonly BY_LANGUAGE_SUCCESS: "translation.by.language.success";
+    readonly BY_MODULE_SUCCESS: "translation.by.module.success";
+    readonly MISSING_SUCCESS: "translation.missing.success";
+    readonly SYNC_SUCCESS: "translation.sync.success";
+    readonly UPDATE_VALUES_SUCCESS: "translation.update.values.success";
+};
+export declare const LOCALIZATION_MODULE_MESSAGES: {
+    readonly LANGUAGE: {
+        readonly CREATE_SUCCESS: "language.create.success";
+        readonly CREATE_MANY_SUCCESS: "language.create.many.success";
+        readonly GET_SUCCESS: "language.get.success";
+        readonly GET_ALL_SUCCESS: "language.get.all.success";
+        readonly UPDATE_SUCCESS: "language.update.success";
+        readonly UPDATE_MANY_SUCCESS: "language.update.many.success";
+        readonly DELETE_SUCCESS: "language.delete.success";
+        readonly RESTORE_SUCCESS: "language.restore.success";
+        readonly NOT_FOUND: "language.not.found";
+        readonly ACTIVE_SUCCESS: "language.active.success";
+        readonly SET_DEFAULT_SUCCESS: "language.set.default.success";
+        readonly GET_DEFAULT_SUCCESS: "language.get.default.success";
+    };
+    readonly TRANSLATION_KEY: {
+        readonly CREATE_SUCCESS: "translation.key.create.success";
+        readonly CREATE_MANY_SUCCESS: "translation.key.create.many.success";
+        readonly GET_SUCCESS: "translation.key.get.success";
+        readonly GET_ALL_SUCCESS: "translation.key.get.all.success";
+        readonly UPDATE_SUCCESS: "translation.key.update.success";
+        readonly UPDATE_MANY_SUCCESS: "translation.key.update.many.success";
+        readonly DELETE_SUCCESS: "translation.key.delete.success";
+        readonly RESTORE_SUCCESS: "translation.key.restore.success";
+        readonly NOT_FOUND: "translation.key.not.found";
+        readonly IMPORT_SUCCESS: "translation.key.import.success";
+        readonly EXPORT_SUCCESS: "translation.key.export.success";
+        readonly MODULES_SUCCESS: "translation.key.modules.success";
+        readonly READONLY_DELETE_FORBIDDEN: "translation.key.readonly.delete.forbidden";
+        readonly READONLY_UPDATE_FORBIDDEN: "translation.key.readonly.update.forbidden";
+        readonly DUPLICATE_KEY_IN_MODULE: "translation.key.duplicate.key.in.module";
+    };
+    readonly TRANSLATION: {
+        readonly CREATE_SUCCESS: "translation.create.success";
+        readonly CREATE_MANY_SUCCESS: "translation.create.many.success";
+        readonly GET_SUCCESS: "translation.get.success";
+        readonly GET_ALL_SUCCESS: "translation.get.all.success";
+        readonly UPDATE_SUCCESS: "translation.update.success";
+        readonly UPDATE_MANY_SUCCESS: "translation.update.many.success";
+        readonly DELETE_SUCCESS: "translation.delete.success";
+        readonly RESTORE_SUCCESS: "translation.restore.success";
+        readonly NOT_FOUND: "translation.not.found";
+        readonly BY_LANGUAGE_SUCCESS: "translation.by.language.success";
+        readonly BY_MODULE_SUCCESS: "translation.by.module.success";
+        readonly MISSING_SUCCESS: "translation.missing.success";
+        readonly SYNC_SUCCESS: "translation.sync.success";
+        readonly UPDATE_VALUES_SUCCESS: "translation.update.values.success";
+    };
+};

package/controllers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './language.controller';
+export * from './translation-key.controller';
+export * from './translation.controller';

package/controllers/language.controller.d.ts

@@ -0,0 +1,25 @@
+import { ListResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { CreateLanguageDto, LanguageResponseDto, UpdateLanguageDto } from '../dtos';
+import { ILanguage } from '../interfaces';
+import { LanguageService } from '../services';
+declare const LanguageController_base: abstract new (service: LanguageService) => {
+    service: LanguageService;
+    insert(addDto: CreateLanguageDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<LanguageResponseDto>>;
+    insertMany(addDto: CreateLanguageDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<LanguageResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared/dtos").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<LanguageResponseDto>>;
+    update(updateDto: UpdateLanguageDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<LanguageResponseDto>>;
+    updateMany(updateDtos: UpdateLanguageDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").BulkResponseDto<LanguageResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared/dtos").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<ListResponseDto<LanguageResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared/dtos").DeleteDto, user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared/dtos").MessageResponseDto>;
+};
+export declare class LanguageController extends LanguageController_base {
+    service: LanguageService;
+    constructor(service: LanguageService);
+    getActive(): Promise<ListResponseDto<ILanguage>>;
+    getDefault(): Promise<SingleResponseDto<ILanguage>>;
+    setDefault(body: {
+        id: string;
+    }, _user: ILoggedUserInfo): Promise<SingleResponseDto<ILanguage>>;
+}
+export {};