@flusys/nestjs-localization 7.0.2 → 8.0.0-beta.1

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

@@ -1,169 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { BadRequestException, ForbiddenException, Inject, Injectable, Scope } from '@nestjs/common';
-import { In, IsNull } from 'typeorm';
-import { LOCALIZATION_EVENT_ENTITIES, LOCALIZATION_EVENT_MODULE, TRANSLATION_KEY_MESSAGES } from '../config';
-import { TranslationKey } from '../entities';
-import { LocalizationDataSourceProvider } from './localization-datasource.provider';
-export class TranslationKeyService extends ApiService {
-    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.ensureDataSourceRepository();
-        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);
-            const changesIdentity = d.key !== undefined && d.key !== existing?.key || d.module !== undefined && d.module !== existing?.module;
-            if (existing?.isReadonly && changesIdentity) {
-                throw new ForbiddenException({
-                    message: `Cannot modify key or module of readonly translation key "${existing.key}"`,
-                    messageKey: TRANSLATION_KEY_MESSAGES.READONLY_UPDATE_FORBIDDEN,
-                    messageVariables: {
-                        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.ensureDataSourceRepository();
-        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,
-                messageVariables: {
-                    keys
-                }
-            });
-        }
-    }
-    async findByModule(module) {
-        await this.ensureDataSourceRepository();
-        return this.repository.find({
-            where: {
-                module,
-                isActive: true,
-                deletedAt: IsNull()
-            },
-            order: {
-                serial: 'ASC',
-                key: 'ASC'
-            }
-        });
-    }
-    async getModules() {
-        await this.ensureDataSourceRepository();
-        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.ensureDataSourceRepository();
-        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,
-                    messageVariables: {
-                        key,
-                        module
-                    }
-                });
-            }
-        }
-    }
-    constructor(cacheManager, utilsService, dataSourceProvider){
-        super(LOCALIZATION_EVENT_ENTITIES.TRANSLATION_KEY, cacheManager, utilsService, TranslationKeyService.name, true, LOCALIZATION_EVENT_MODULE, dataSourceProvider, TranslationKey), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService;
-    }
-}
-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);

package/fesm/services/translation-key.service.spec.js

@@ -1,299 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { ForbiddenException, BadRequestException } from '@nestjs/common';
-import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { TranslationKeyService } from './translation-key.service';
-import { LocalizationDataSourceProvider } from './localization-datasource.provider';
-function buildTranslationKey(overrides = {}) {
-    return {
-        id: 'tkey-uuid-1',
-        module: 'auth',
-        key: 'auth.login.success',
-        defaultMessage: 'Login successful',
-        description: null,
-        variables: null,
-        isActive: true,
-        isReadonly: false,
-        serial: 1,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-describe('TranslationKeyService', ()=>{
-    let service;
-    let mockRepo;
-    let qb;
-    let queryRunner;
-    beforeEach(async ()=>{
-        mockRepo = createMockRepository();
-        qb = mockRepo.createQueryBuilder();
-        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
-        // executeInTransaction()/delete() always grab a QueryRunner off repository.manager.connection
-        // before running the before*Operation hooks, so every test (success or rejection) needs one.
-        queryRunner = {
-            connect: jest.fn(),
-            startTransaction: jest.fn(),
-            commitTransaction: jest.fn(),
-            rollbackTransaction: jest.fn(),
-            release: jest.fn(),
-            manager: {
-                save: jest.fn(),
-                softDelete: jest.fn(),
-                update: jest.fn(),
-                delete: jest.fn(),
-                restore: jest.fn()
-            }
-        };
-        mockRepo.manager.connection.createQueryRunner.mockReturnValue(queryRunner);
-        const mockUtilsService = {
-            clearCache: jest.fn(),
-            getCacheKey: jest.fn().mockReturnValue('cache-key'),
-            trackCacheKey: jest.fn()
-        };
-        const module = await Test.createTestingModule({
-            providers: [
-                TranslationKeyService,
-                {
-                    provide: 'CACHE_INSTANCE',
-                    useValue: {
-                        get: jest.fn(),
-                        set: jest.fn()
-                    }
-                },
-                {
-                    provide: UtilsService,
-                    useValue: mockUtilsService
-                },
-                {
-                    provide: LocalizationDataSourceProvider,
-                    useValue: mockDataSourceProvider
-                }
-            ]
-        }).compile();
-        service = await module.resolve(TranslationKeyService);
-    });
-    describe('findByModule', ()=>{
-        it('returns active, non-deleted keys for the module ordered by serial then key', async ()=>{
-            const keys = [
-                buildTranslationKey({
-                    key: 'auth.login.success',
-                    serial: 1
-                })
-            ];
-            mockRepo.find.mockResolvedValue(keys);
-            const result = await service.findByModule('auth');
-            expect(mockRepo.find).toHaveBeenCalledWith({
-                where: {
-                    module: 'auth',
-                    isActive: true,
-                    deletedAt: expect.anything()
-                },
-                order: {
-                    serial: 'ASC',
-                    key: 'ASC'
-                }
-            });
-            expect(result).toEqual(keys);
-        });
-        it('returns an empty array for an unknown module', async ()=>{
-            mockRepo.find.mockResolvedValue([]);
-            const result = await service.findByModule('does-not-exist');
-            expect(result).toEqual([]);
-        });
-    });
-    describe('getModules', ()=>{
-        it('returns distinct module names', async ()=>{
-            // `getRawMany` isn't part of the shared MockQueryBuilder — attach it for this raw-query path.
-            const getRawMany = jest.fn().mockResolvedValue([
-                {
-                    module: 'auth'
-                },
-                {
-                    module: 'shared'
-                }
-            ]);
-            qb.getRawMany = getRawMany;
-            const result = await service.getModules();
-            expect(result).toEqual([
-                'auth',
-                'shared'
-            ]);
-        });
-        it('returns an empty array when there are no translation keys yet', async ()=>{
-            const getRawMany = jest.fn().mockResolvedValue([]);
-            qb.getRawMany = getRawMany;
-            const result = await service.getModules();
-            expect(result).toEqual([]);
-        });
-    });
-    describe('beforeInsertOperation (via insert) — duplicate key validation', ()=>{
-        it('allows insert when no key with the same module+key exists', async ()=>{
-            qb.getOne.mockResolvedValue(null);
-            const created = buildTranslationKey();
-            mockRepo.create.mockReturnValue({});
-            queryRunner.manager.save.mockResolvedValue(created);
-            await expect(service.insert({
-                module: 'auth',
-                key: 'auth.login.success',
-                defaultMessage: 'Login successful'
-            }, buildMockUser())).resolves.toBeDefined();
-        });
-        it('rejects with BadRequestException + messageKey when the module+key combination already exists', async ()=>{
-            qb.getOne.mockResolvedValue(buildTranslationKey());
-            await expect(service.insert({
-                module: 'auth',
-                key: 'auth.login.success',
-                defaultMessage: 'Login successful'
-            }, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'translation.key.duplicate.key.in.module'
-                })
-            });
-        });
-        it('rejects with BadRequestException for duplicate module+key in insertMany', async ()=>{
-            qb.getOne.mockResolvedValueOnce(null).mockResolvedValueOnce(buildTranslationKey({
-                key: 'auth.logout.success'
-            }));
-            await expect(service.insertMany([
-                {
-                    module: 'auth',
-                    key: 'auth.login.success',
-                    defaultMessage: 'A'
-                },
-                {
-                    module: 'auth',
-                    key: 'auth.logout.success',
-                    defaultMessage: 'B'
-                }
-            ], buildMockUser())).rejects.toBeInstanceOf(BadRequestException);
-        });
-    });
-    describe('beforeUpdateOperation (via update)', ()=>{
-        it('rejects with ForbiddenException when modifying key/module of a readonly translation key', async ()=>{
-            const existing = buildTranslationKey({
-                id: 'tkey-1',
-                isReadonly: true,
-                key: 'system.ready'
-            });
-            mockRepo.find.mockResolvedValue([
-                existing
-            ]);
-            await expect(service.update({
-                id: 'tkey-1',
-                key: 'system.changed'
-            }, buildMockUser())).rejects.toBeInstanceOf(ForbiddenException);
-            await expect(service.update({
-                id: 'tkey-1',
-                key: 'system.changed'
-            }, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'translation.key.readonly.update.forbidden'
-                })
-            });
-        });
-        it('allows updating non key/module fields of a readonly translation key', async ()=>{
-            const existing = buildTranslationKey({
-                id: 'tkey-1',
-                isReadonly: true,
-                key: 'system.ready'
-            });
-            mockRepo.find.mockResolvedValue([
-                existing
-            ]);
-            mockRepo.findOne.mockResolvedValue(existing);
-            queryRunner.manager.save.mockResolvedValue(existing);
-            await expect(service.update({
-                id: 'tkey-1',
-                defaultMessage: 'Updated readonly message'
-            }, buildMockUser())).resolves.toBeDefined();
-        });
-        it('allows resubmitting the same unchanged key/module of a readonly translation key', async ()=>{
-            // Regression test: the edit form always resends key + module even when only
-            // other fields changed, so the check must compare values, not just presence.
-            const existing = buildTranslationKey({
-                id: 'tkey-1',
-                isReadonly: true,
-                key: 'system.ready',
-                module: 'system'
-            });
-            mockRepo.find.mockResolvedValue([
-                existing
-            ]);
-            mockRepo.findOne.mockResolvedValue(existing);
-            queryRunner.manager.save.mockResolvedValue(existing);
-            await expect(service.update({
-                id: 'tkey-1',
-                key: 'system.ready',
-                module: 'system',
-                defaultMessage: 'Updated readonly message'
-            }, buildMockUser())).resolves.toBeDefined();
-        });
-        it('rejects with BadRequestException when the new key/module already exists on another row', async ()=>{
-            const existing = buildTranslationKey({
-                id: 'tkey-1',
-                isReadonly: false,
-                key: 'auth.old',
-                module: 'auth'
-            });
-            mockRepo.find.mockResolvedValue([
-                existing
-            ]);
-            qb.getOne.mockResolvedValue(buildTranslationKey({
-                id: 'tkey-other',
-                key: 'auth.new'
-            }));
-            await expect(service.update({
-                id: 'tkey-1',
-                key: 'auth.new'
-            }, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'translation.key.duplicate.key.in.module'
-                })
-            });
-            // excludeId must be used so the row being updated doesn't collide with itself
-            expect(qb.andWhere).toHaveBeenCalledWith('tk.id != :excludeId', {
-                excludeId: 'tkey-1'
-            });
-        });
-    });
-    describe('beforeDeleteOperation (via delete)', ()=>{
-        it('rejects with ForbiddenException + messageKey when any target id is readonly', async ()=>{
-            const readonlyKey = buildTranslationKey({
-                id: 'tkey-1',
-                isReadonly: true,
-                key: 'system.core'
-            });
-            mockRepo.find.mockResolvedValue([
-                readonlyKey
-            ]);
-            const dto = {
-                id: [
-                    'tkey-1'
-                ],
-                type: 'delete'
-            };
-            await expect(service.delete(dto, buildMockUser())).rejects.toMatchObject({
-                response: expect.objectContaining({
-                    messageKey: 'translation.key.readonly.delete.forbidden'
-                })
-            });
-        });
-        it('allows delete when none of the targeted ids are readonly', async ()=>{
-            mockRepo.find.mockResolvedValue([]);
-            const dto = {
-                id: [
-                    'tkey-1'
-                ],
-                type: 'delete'
-            };
-            await expect(service.delete(dto, buildMockUser())).resolves.toBeNull();
-            expect(queryRunner.manager.softDelete).toHaveBeenCalled();
-        });
-    });
-});

package/fesm/services/translation.service.js

@@ -1,218 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { HybridCache, ApiService } 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 { LOCALIZATION_EVENT_ACTIONS, LOCALIZATION_EVENT_ENTITIES, LOCALIZATION_EVENT_MODULE } from '../config';
-import { Language, Translation, TranslationKey } from '../entities';
-import { LocalizationDataSourceProvider } from './localization-datasource.provider';
-export class TranslationService extends ApiService {
-    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.ensureDataSourceRepository();
-        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.ensureDataSourceRepository();
-        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();
-            const saved = await this.repository.find({
-                where: {
-                    id: In(resultIds)
-                }
-            });
-            await Promise.all([
-                this.clearCacheForAll(),
-                this.clearCacheForId(saved)
-            ]);
-            await this.publishDomainAction(LOCALIZATION_EVENT_ACTIONS.BULK_UPDATED, {
-                ids: saved.map((translation)=>translation.id),
-                metadata: {
-                    count: saved.length
-                }
-            });
-            return saved;
-        } 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.ensureDataSourceRepository();
-        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(LOCALIZATION_EVENT_ENTITIES.TRANSLATION, cacheManager, utilsService, TranslationService.name, true, LOCALIZATION_EVENT_MODULE, dataSourceProvider, Translation), _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);