@flusys/nestjs-localization 6.4.0 → 7.0.0-beta.1

package/cjs/config/event-actions.js

@@ -0,0 +1,29 @@
+/**
+ * Domain event actions published by the localization module, alongside the CRUD
+ * lifecycle actions every ApiService emits.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get LOCALIZATION_EVENT_ACTIONS () {
+        return LOCALIZATION_EVENT_ACTIONS;
+    },
+    get LOCALIZATION_EVENT_ENTITIES () {
+        return LOCALIZATION_EVENT_ENTITIES;
+    }
+});
+const LOCALIZATION_EVENT_ACTIONS = {
+    BULK_UPDATED: 'bulk-updated'
+};
+const LOCALIZATION_EVENT_ENTITIES = {
+    LANGUAGE: 'language',
+    TRANSLATION_KEY: 'translationKey',
+    TRANSLATION: 'translation'
+};

package/cjs/config/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
+_export_star(require("./event-actions"), exports);
 _export_star(require("./localization.constants"), exports);
 _export_star(require("./message-keys"), exports);
 function _export_star(from, to) {

package/cjs/config/message-keys.js

@@ -23,7 +23,10 @@ _export(exports, {
 const LANGUAGE_MESSAGES = {
     ACTIVE_SUCCESS: 'language.active.success',
     SET_DEFAULT_SUCCESS: 'language.set.default.success',
-    GET_DEFAULT_SUCCESS: 'language.get.default.success'
+    GET_DEFAULT_SUCCESS: 'language.get.default.success',
+    READONLY_UPDATE_FORBIDDEN: 'language.readonly.update.forbidden',
+    READONLY_DELETE_FORBIDDEN: 'language.readonly.delete.forbidden',
+    DEFAULT_DELETE_FORBIDDEN: 'language.default.delete.forbidden'
 };
 const TRANSLATION_KEY_MESSAGES = {
     MODULES_SUCCESS: 'translation.key.modules.success',

package/cjs/dtos/language.dto.js

@@ -144,7 +144,7 @@ _ts_decorate([
 ], UpdateLanguageDto.prototype, "id", void 0);
 let LanguageResponseDto = class LanguageResponseDto extends _dtos.IdentityResponseDto {
     constructor(...args){
-        super(...args), _define_property(this, "code", void 0), _define_property(this, "name", void 0), _define_property(this, "nativeName", void 0), _define_property(this, "direction", void 0), _define_property(this, "isActive", void 0), _define_property(this, "isDefault", void 0), _define_property(this, "serial", void 0);
+        super(...args), _define_property(this, "code", void 0), _define_property(this, "name", void 0), _define_property(this, "nativeName", void 0), _define_property(this, "direction", void 0), _define_property(this, "isActive", void 0), _define_property(this, "isDefault", void 0), _define_property(this, "isReadonly", void 0), _define_property(this, "serial", void 0);
     }
 };
 _ts_decorate([
@@ -193,6 +193,14 @@ _ts_decorate([
     (0, _classtransformer.Expose)(),
     _ts_metadata("design:type", Boolean)
 ], LanguageResponseDto.prototype, "isDefault", void 0);
+_ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: false,
+        description: 'System language: cannot be renamed or deleted'
+    }),
+    (0, _classtransformer.Expose)(),
+    _ts_metadata("design:type", Boolean)
+], LanguageResponseDto.prototype, "isReadonly", void 0);
 _ts_decorate([
     (0, _swagger.ApiPropertyOptional)({
         example: 1

package/cjs/modules/localization.module.js

@@ -72,6 +72,7 @@ let LocalizationModule = class LocalizationModule {
                 useValue: options
             });
         }
+        providers.push((0, _modules.createModuleEventsProvider)('localization', _localizationconstants.LOCALIZATION_MODULE_OPTIONS));
         return providers;
     }
     static createAsyncProviders(options) {

package/cjs/services/language.service.js

@@ -12,6 +12,7 @@ const _classes = require("@flusys/nestjs-shared/classes");
 const _modules = require("@flusys/nestjs-shared/modules");
 const _common = require("@nestjs/common");
 const _typeorm = require("typeorm");
+const _config = require("../config");
 const _entities = require("../entities");
 const _localizationdatasourceprovider = require("./localization-datasource.provider");
 function _define_property(obj, key, value) {
@@ -42,6 +43,69 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let LanguageService = class LanguageService extends _classes.ApiService {
+    async beforeUpdateOperation(dto, _user, _queryRunner) {
+        const dtos = Array.isArray(dto) ? dto : [
+            dto
+        ];
+        const ids = dtos.map((d)=>d.id);
+        await this.ensureDataSourceRepository();
+        const existingLanguages = await this.repository.find({
+            where: {
+                id: (0, _typeorm.In)(ids),
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        for (const d of dtos){
+            const existing = existingLanguages.find((e)=>e.id === d.id);
+            if (!existing) {
+                continue;
+            }
+            const changesIdentity = d.code !== undefined && d.code !== existing.code || d.name !== undefined && d.name !== existing.name || d.nativeName !== undefined && d.nativeName !== (existing.nativeName ?? undefined) || d.direction !== undefined && d.direction !== existing.direction;
+            if (existing.isReadonly && changesIdentity) {
+                throw new _common.ForbiddenException({
+                    message: `Cannot modify code/name of readonly language "${existing.name}"`,
+                    messageKey: _config.LANGUAGE_MESSAGES.READONLY_UPDATE_FORBIDDEN,
+                    messageVariables: {
+                        name: existing.name
+                    }
+                });
+            }
+        }
+    }
+    async beforeDeleteOperation(dto, _user, _queryRunner) {
+        const ids = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        await this.ensureDataSourceRepository();
+        const languages = await this.repository.find({
+            where: {
+                id: (0, _typeorm.In)(ids),
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        const readonlyLanguages = languages.filter((l)=>l.isReadonly);
+        if (readonlyLanguages.length > 0) {
+            const names = readonlyLanguages.map((l)=>l.name).join(', ');
+            throw new _common.ForbiddenException({
+                message: `Cannot delete readonly language(s): ${names}`,
+                messageKey: _config.LANGUAGE_MESSAGES.READONLY_DELETE_FORBIDDEN,
+                messageVariables: {
+                    names
+                }
+            });
+        }
+        const defaultLanguages = languages.filter((l)=>l.isDefault);
+        if (defaultLanguages.length > 0) {
+            const names = defaultLanguages.map((l)=>l.name).join(', ');
+            throw new _common.ForbiddenException({
+                message: `Cannot delete the default language(s): ${names}. Set another language as default first.`,
+                messageKey: _config.LANGUAGE_MESSAGES.DEFAULT_DELETE_FORBIDDEN,
+                messageVariables: {
+                    names
+                }
+            });
+        }
+    }
     async getDefaultLanguage() {
         await this.ensureDataSourceRepository();
         return this.repository.findOne({
@@ -66,6 +130,11 @@ let LanguageService = class LanguageService extends _classes.ApiService {
     }
     async setAsDefault(id) {
         await this.ensureDataSourceRepository();
+        const previousDefaults = await this.repository.find({
+            where: {
+                isDefault: true
+            }
+        });
         await this.repository.update({
             isDefault: true
         }, {
@@ -76,11 +145,21 @@ let LanguageService = class LanguageService extends _classes.ApiService {
         }, {
             isDefault: true
         });
-        return this.repository.findOne({
+        const language = await this.repository.findOne({
             where: {
                 id
             }
         });
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                ...previousDefaults,
+                {
+                    id
+                }
+            ])
+        ]);
+        return language;
     }
     constructor(cacheManager, utilsService, dataSourceProvider){
         super('language', cacheManager, utilsService, LanguageService.name, true, 'localization', _entities.Language, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService;

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

@@ -30,6 +30,15 @@ function buildLanguage(overrides = {}) {
 describe('LanguageService', ()=>{
     let service;
     let mockRepo;
+    const mockUtilsService = {
+        clearCache: jest.fn(),
+        getCacheKey: jest.fn().mockReturnValue('cache-key'),
+        trackCacheKey: jest.fn()
+    };
+    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
+    beforeEach(()=>{
+        mockUtilsService.clearCache.mockClear();
+    });
     beforeEach(async ()=>{
         mockRepo = (0, _repositorymock.createMockRepository)();
         const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
@@ -42,7 +51,7 @@ describe('LanguageService', ()=>{
                 },
                 {
                     provide: _modules.UtilsService,
-                    useValue: {}
+                    useValue: mockUtilsService
                 },
                 {
                     provide: _localizationdatasourceprovider.LocalizationDataSourceProvider,
@@ -108,6 +117,9 @@ describe('LanguageService', ()=>{
         });
     });
     describe('setAsDefault', ()=>{
+        beforeEach(()=>{
+            mockRepo.find.mockResolvedValue([]);
+        });
         it('unsets the previous default and sets the requested language as default', async ()=>{
             const newDefault = buildLanguage({
                 id: 'lang-2',
@@ -133,6 +145,24 @@ describe('LanguageService', ()=>{
             });
             expect(result).toEqual(newDefault);
         });
+        it('invalidates the language list cache and both the old and new default entries', async ()=>{
+            const previousDefault = buildLanguage({
+                id: 'lang-1',
+                isDefault: true,
+                code: 'en'
+            });
+            mockRepo.find.mockResolvedValue([
+                previousDefault
+            ]);
+            mockRepo.findOne.mockResolvedValue(buildLanguage({
+                id: 'lang-2',
+                isDefault: true
+            }));
+            await service.setAsDefault('lang-2');
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('language', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('language', expect.anything(), 'lang-1');
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('language', expect.anything(), 'lang-2');
+        });
         it('returns null when the id does not correspond to any language after the update', async ()=>{
             mockRepo.findOne.mockResolvedValue(null);
             const result = await service.setAsDefault('non-existent-id');
@@ -148,4 +178,79 @@ describe('LanguageService', ()=>{
             });
         });
     });
+    describe('beforeUpdateOperation', ()=>{
+        it('rejects renaming the code of a readonly language', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: true,
+                    code: 'en'
+                })
+            ]);
+            await expect(service.beforeUpdateOperation({
+                id: 'language-uuid-1',
+                code: 'fr'
+            }, null, {})).rejects.toThrow('Cannot modify code/name of readonly language');
+        });
+        it('allows updating isActive on a readonly language when identity fields are unchanged', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: true,
+                    code: 'en',
+                    name: 'English'
+                })
+            ]);
+            await expect(service.beforeUpdateOperation({
+                id: 'language-uuid-1',
+                code: 'en',
+                name: 'English',
+                isActive: false
+            }, null, {})).resolves.toBeUndefined();
+        });
+        it('allows any field change on a non-readonly language', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: false,
+                    code: 'en'
+                })
+            ]);
+            await expect(service.beforeUpdateOperation({
+                id: 'language-uuid-1',
+                code: 'fr'
+            }, null, {})).resolves.toBeUndefined();
+        });
+    });
+    describe('beforeDeleteOperation', ()=>{
+        it('rejects deleting a readonly language', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: true
+                })
+            ]);
+            await expect(service.beforeDeleteOperation({
+                id: 'language-uuid-1'
+            }, null, {})).rejects.toThrow('Cannot delete readonly language');
+        });
+        it('rejects deleting the default language', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: false,
+                    isDefault: true
+                })
+            ]);
+            await expect(service.beforeDeleteOperation({
+                id: 'language-uuid-1'
+            }, null, {})).rejects.toThrow('Cannot delete the default language');
+        });
+        it('allows deleting a non-readonly, non-default language', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: false,
+                    isDefault: false
+                })
+            ]);
+            await expect(service.beforeDeleteOperation({
+                id: 'language-uuid-1'
+            }, null, {})).resolves.toBeUndefined();
+        });
+    });
 });

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

@@ -67,7 +67,8 @@ let TranslationKeyService = class TranslationKeyService extends _classes.ApiServ
         // 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)) {
+            const changesIdentity = d.key !== undefined && d.key !== existing?.key || d.module !== undefined && d.module !== existing?.module;
+            if (existing?.isReadonly && changesIdentity) {
                 throw new _common.ForbiddenException({
                     message: `Cannot modify key or module of readonly translation key "${existing.key}"`,
                     messageKey: _config.TRANSLATION_KEY_MESSAGES.READONLY_UPDATE_FORBIDDEN,

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

@@ -217,6 +217,27 @@ describe('TranslationKeyService', ()=>{
                 defaultMessage: 'Updated readonly message'
             }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.buildMockUser)())).resolves.toBeDefined();
+        });
         it('rejects with BadRequestException when the new key/module already exists on another row', async ()=>{
             const existing = buildTranslationKey({
                 id: 'tkey-1',

package/cjs/services/translation.service.js

@@ -12,6 +12,7 @@ const _classes = require("@flusys/nestjs-shared/classes");
 const _modules = require("@flusys/nestjs-shared/modules");
 const _common = require("@nestjs/common");
 const _typeorm = require("typeorm");
+const _config = require("../config");
 const _entities = require("../entities");
 const _localizationdatasourceprovider = require("./localization-datasource.provider");
 function _define_property(obj, key, value) {
@@ -132,11 +133,22 @@ let TranslationService = class TranslationService extends _classes.ApiService {
                 }
             }
             await queryRunner.commitTransaction();
-            return this.repository.find({
+            const saved = await this.repository.find({
                 where: {
                     id: (0, _typeorm.In)(resultIds)
                 }
             });
+            await Promise.all([
+                this.clearCacheForAll(),
+                this.clearCacheForId(saved)
+            ]);
+            await this.publishDomainAction(_config.LOCALIZATION_EVENT_ACTIONS.BULK_UPDATED, {
+                ids: saved.map((translation)=>translation.id),
+                metadata: {
+                    count: saved.length
+                }
+            });
+            return saved;
         } catch (error) {
             await queryRunner.rollbackTransaction();
             throw error;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 const _testing = require("@nestjs/testing");
+const _classes = require("@flusys/nestjs-shared/classes");
 const _modules = require("@flusys/nestjs-shared/modules");
 const _repositorymock = require("@test-utils/mocks/repository.mock");
 const _entities = require("../entities");
@@ -66,6 +67,15 @@ function buildTranslation(overrides = {}) {
     };
 }
 describe('TranslationService', ()=>{
+    const mockUtilsService = {
+        clearCache: jest.fn(),
+        getCacheKey: jest.fn().mockReturnValue('cache-key'),
+        trackCacheKey: jest.fn()
+    };
+    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
+    beforeEach(()=>{
+        mockUtilsService.clearCache.mockClear();
+    });
     let service;
     let mockRepo;
     // `TranslationService` uses joins/aggregate query-builder methods (innerJoin, innerJoinAndSelect,
@@ -98,11 +108,6 @@ describe('TranslationService', ()=>{
             createQueryRunner: jest.fn()
         };
         mockDataSourceProvider.getDataSource.mockResolvedValue(fakeDataSource);
-        const mockUtilsService = {
-            clearCache: jest.fn(),
-            getCacheKey: jest.fn().mockReturnValue('cache-key'),
-            trackCacheKey: jest.fn()
-        };
         const module = await _testing.Test.createTestingModule({
             providers: [
                 _translationservice.TranslationService,
@@ -275,6 +280,25 @@ describe('TranslationService', ()=>{
             });
             expect(result).toHaveLength(1);
         });
+        it('invalidates the translation list cache and each written entry after committing', async ()=>{
+            const queryRunner = buildQueryRunner();
+            fakeDataSource.createQueryRunner.mockReturnValue(queryRunner);
+            mockRepo.find.mockResolvedValue([
+                buildTranslation({
+                    id: 'translation-1'
+                })
+            ]);
+            await service.bulkUpdate([
+                {
+                    id: 'translation-1',
+                    languageId: 'lang-en',
+                    translationKeyId: 'tkey-1',
+                    value: 'Updated'
+                }
+            ]);
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('translation', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('translation', expect.anything(), 'translation-1');
+        });
         it('creates new translations when no id is provided', async ()=>{
             const queryRunner = buildQueryRunner();
             fakeDataSource.createQueryRunner.mockReturnValue(queryRunner);
@@ -423,4 +447,84 @@ describe('TranslationService', ()=>{
             expect(qb.andWhere).not.toHaveBeenCalled();
         });
     });
+    describe('domain events', ()=>{
+        let publish;
+        function buildEventQueryRunner() {
+            return {
+                connect: jest.fn(),
+                startTransaction: jest.fn(),
+                commitTransaction: jest.fn(),
+                rollbackTransaction: jest.fn(),
+                release: jest.fn(),
+                manager: {
+                    update: jest.fn(),
+                    create: jest.fn((_entity, data)=>({
+                            id: 'new-translation-id',
+                            ...data
+                        })),
+                    save: jest.fn(async (entity)=>entity)
+                }
+            };
+        }
+        beforeEach(()=>{
+            publish = jest.fn().mockResolvedValue(undefined);
+            _classes.EventBusRegistry.reset();
+            _classes.EventBusRegistry.setBus({
+                publish,
+                subscribe: jest.fn(),
+                close: jest.fn()
+            });
+            _classes.EventBusRegistry.configureModule('localization', {
+                enabled: true
+            });
+            fakeDataSource.createQueryRunner.mockReturnValue(buildEventQueryRunner());
+            mockRepo.find.mockResolvedValue([
+                buildTranslation({
+                    id: 'translation-1'
+                })
+            ]);
+        });
+        afterEach(()=>{
+            _classes.EventBusRegistry.reset();
+        });
+        it('publishes localization.translation.bulk-updated with the written count', async ()=>{
+            await service.bulkUpdate([
+                {
+                    id: 'translation-1',
+                    languageId: 'lang-en',
+                    translationKeyId: 'tkey-1',
+                    value: 'x'
+                }
+            ]);
+            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'localization.translation.bulk-updated',
+                payload: expect.objectContaining({
+                    ids: [
+                        'translation-1'
+                    ],
+                    metadata: {
+                        count: 1
+                    }
+                })
+            }));
+        });
+        it('does not publish when the localization module has events disabled', async ()=>{
+            _classes.EventBusRegistry.configureModule('localization', {
+                enabled: false
+            });
+            await service.bulkUpdate([
+                {
+                    id: 'translation-1',
+                    languageId: 'lang-en',
+                    translationKeyId: 'tkey-1',
+                    value: 'x'
+                }
+            ]);
+            expect(publish).not.toHaveBeenCalled();
+        });
+        it('publishes nothing when there is nothing to update', async ()=>{
+            await service.bulkUpdate([]);
+            expect(publish).not.toHaveBeenCalled();
+        });
+    });
 });

package/config/event-actions.d.ts

@@ -0,0 +1,8 @@
+export declare const LOCALIZATION_EVENT_ACTIONS: {
+    readonly BULK_UPDATED: "bulk-updated";
+};
+export declare const LOCALIZATION_EVENT_ENTITIES: {
+    readonly LANGUAGE: "language";
+    readonly TRANSLATION_KEY: "translationKey";
+    readonly TRANSLATION: "translation";
+};

package/config/index.d.ts

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

package/config/message-keys.d.ts

@@ -2,6 +2,9 @@ export declare const LANGUAGE_MESSAGES: {
     readonly ACTIVE_SUCCESS: "language.active.success";
     readonly SET_DEFAULT_SUCCESS: "language.set.default.success";
     readonly GET_DEFAULT_SUCCESS: "language.get.default.success";
+    readonly READONLY_UPDATE_FORBIDDEN: "language.readonly.update.forbidden";
+    readonly READONLY_DELETE_FORBIDDEN: "language.readonly.delete.forbidden";
+    readonly DEFAULT_DELETE_FORBIDDEN: "language.default.delete.forbidden";
 };
 export declare const TRANSLATION_KEY_MESSAGES: {
     readonly MODULES_SUCCESS: "translation.key.modules.success";

package/dtos/language.dto.d.ts

@@ -19,6 +19,7 @@ export declare class LanguageResponseDto extends IdentityResponseDto {
     direction: 'ltr' | 'rtl' | null;
     isActive: boolean;
     isDefault: boolean;
+    isReadonly: boolean;
     serial: number | null;
 }
 export {};

package/fesm/config/event-actions.js

@@ -0,0 +1,11 @@
+/**
+ * Domain event actions published by the localization module, alongside the CRUD
+ * lifecycle actions every ApiService emits.
+ */ export const LOCALIZATION_EVENT_ACTIONS = {
+    BULK_UPDATED: 'bulk-updated'
+};
+/** Every entity the localization module publishes under */ export const LOCALIZATION_EVENT_ENTITIES = {
+    LANGUAGE: 'language',
+    TRANSLATION_KEY: 'translationKey',
+    TRANSLATION: 'translation'
+};

package/fesm/config/index.js

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

package/fesm/config/message-keys.js

@@ -2,7 +2,10 @@
 export const LANGUAGE_MESSAGES = {
     ACTIVE_SUCCESS: 'language.active.success',
     SET_DEFAULT_SUCCESS: 'language.set.default.success',
-    GET_DEFAULT_SUCCESS: 'language.get.default.success'
+    GET_DEFAULT_SUCCESS: 'language.get.default.success',
+    READONLY_UPDATE_FORBIDDEN: 'language.readonly.update.forbidden',
+    READONLY_DELETE_FORBIDDEN: 'language.readonly.delete.forbidden',
+    DEFAULT_DELETE_FORBIDDEN: 'language.default.delete.forbidden'
 };
 export const TRANSLATION_KEY_MESSAGES = {
     MODULES_SUCCESS: 'translation.key.modules.success',

package/fesm/dtos/language.dto.js

@@ -123,7 +123,7 @@ _ts_decorate([
 ], UpdateLanguageDto.prototype, "id", void 0);
 export class LanguageResponseDto extends IdentityResponseDto {
     constructor(...args){
-        super(...args), _define_property(this, "code", void 0), _define_property(this, "name", void 0), _define_property(this, "nativeName", void 0), _define_property(this, "direction", void 0), _define_property(this, "isActive", void 0), _define_property(this, "isDefault", void 0), _define_property(this, "serial", void 0);
+        super(...args), _define_property(this, "code", void 0), _define_property(this, "name", void 0), _define_property(this, "nativeName", void 0), _define_property(this, "direction", void 0), _define_property(this, "isActive", void 0), _define_property(this, "isDefault", void 0), _define_property(this, "isReadonly", void 0), _define_property(this, "serial", void 0);
     }
 }
 _ts_decorate([
@@ -172,6 +172,14 @@ _ts_decorate([
     Expose(),
     _ts_metadata("design:type", Boolean)
 ], LanguageResponseDto.prototype, "isDefault", void 0);
+_ts_decorate([
+    ApiProperty({
+        example: false,
+        description: 'System language: cannot be renamed or deleted'
+    }),
+    Expose(),
+    _ts_metadata("design:type", Boolean)
+], LanguageResponseDto.prototype, "isReadonly", void 0);
 _ts_decorate([
     ApiPropertyOptional({
         example: 1

package/fesm/modules/localization.module.js

@@ -4,7 +4,7 @@ function _ts_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 { CacheModule, UtilsModule, createModuleEventsProvider } from '@flusys/nestjs-shared/modules';
 import { Module } from '@nestjs/common';
 import { LOCALIZATION_MODULE_OPTIONS } from '../config/localization.constants';
 import { LanguageController, TranslationKeyController, TranslationController } from '../controllers';
@@ -62,6 +62,7 @@ export class LocalizationModule {
                 useValue: options
             });
         }
+        providers.push(createModuleEventsProvider('localization', LOCALIZATION_MODULE_OPTIONS));
         return providers;
     }
     static createAsyncProviders(options) {

package/fesm/services/language.service.js

@@ -27,11 +27,75 @@ function _ts_param(paramIndex, decorator) {
 }
 import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { Inject, Injectable, Scope } from '@nestjs/common';
-import { IsNull } from 'typeorm';
+import { ForbiddenException, Inject, Injectable, Scope } from '@nestjs/common';
+import { In, IsNull } from 'typeorm';
+import { LANGUAGE_MESSAGES } from '../config';
 import { Language } from '../entities';
 import { LocalizationDataSourceProvider } from './localization-datasource.provider';
 export class LanguageService extends ApiService {
+    async beforeUpdateOperation(dto, _user, _queryRunner) {
+        const dtos = Array.isArray(dto) ? dto : [
+            dto
+        ];
+        const ids = dtos.map((d)=>d.id);
+        await this.ensureDataSourceRepository();
+        const existingLanguages = await this.repository.find({
+            where: {
+                id: In(ids),
+                deletedAt: IsNull()
+            }
+        });
+        for (const d of dtos){
+            const existing = existingLanguages.find((e)=>e.id === d.id);
+            if (!existing) {
+                continue;
+            }
+            const changesIdentity = d.code !== undefined && d.code !== existing.code || d.name !== undefined && d.name !== existing.name || d.nativeName !== undefined && d.nativeName !== (existing.nativeName ?? undefined) || d.direction !== undefined && d.direction !== existing.direction;
+            if (existing.isReadonly && changesIdentity) {
+                throw new ForbiddenException({
+                    message: `Cannot modify code/name of readonly language "${existing.name}"`,
+                    messageKey: LANGUAGE_MESSAGES.READONLY_UPDATE_FORBIDDEN,
+                    messageVariables: {
+                        name: existing.name
+                    }
+                });
+            }
+        }
+    }
+    async beforeDeleteOperation(dto, _user, _queryRunner) {
+        const ids = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        await this.ensureDataSourceRepository();
+        const languages = await this.repository.find({
+            where: {
+                id: In(ids),
+                deletedAt: IsNull()
+            }
+        });
+        const readonlyLanguages = languages.filter((l)=>l.isReadonly);
+        if (readonlyLanguages.length > 0) {
+            const names = readonlyLanguages.map((l)=>l.name).join(', ');
+            throw new ForbiddenException({
+                message: `Cannot delete readonly language(s): ${names}`,
+                messageKey: LANGUAGE_MESSAGES.READONLY_DELETE_FORBIDDEN,
+                messageVariables: {
+                    names
+                }
+            });
+        }
+        const defaultLanguages = languages.filter((l)=>l.isDefault);
+        if (defaultLanguages.length > 0) {
+            const names = defaultLanguages.map((l)=>l.name).join(', ');
+            throw new ForbiddenException({
+                message: `Cannot delete the default language(s): ${names}. Set another language as default first.`,
+                messageKey: LANGUAGE_MESSAGES.DEFAULT_DELETE_FORBIDDEN,
+                messageVariables: {
+                    names
+                }
+            });
+        }
+    }
     async getDefaultLanguage() {
         await this.ensureDataSourceRepository();
         return this.repository.findOne({
@@ -56,6 +120,11 @@ export class LanguageService extends ApiService {
     }
     async setAsDefault(id) {
         await this.ensureDataSourceRepository();
+        const previousDefaults = await this.repository.find({
+            where: {
+                isDefault: true
+            }
+        });
         await this.repository.update({
             isDefault: true
         }, {
@@ -66,11 +135,21 @@ export class LanguageService extends ApiService {
         }, {
             isDefault: true
         });
-        return this.repository.findOne({
+        const language = await this.repository.findOne({
             where: {
                 id
             }
         });
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                ...previousDefaults,
+                {
+                    id
+                }
+            ])
+        ]);
+        return language;
     }
     constructor(cacheManager, utilsService, dataSourceProvider){
         super('language', cacheManager, utilsService, LanguageService.name, true, 'localization', Language, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService;

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

@@ -26,6 +26,15 @@ function buildLanguage(overrides = {}) {
 describe('LanguageService', ()=>{
     let service;
     let mockRepo;
+    const mockUtilsService = {
+        clearCache: jest.fn(),
+        getCacheKey: jest.fn().mockReturnValue('cache-key'),
+        trackCacheKey: jest.fn()
+    };
+    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
+    beforeEach(()=>{
+        mockUtilsService.clearCache.mockClear();
+    });
     beforeEach(async ()=>{
         mockRepo = createMockRepository();
         const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
@@ -38,7 +47,7 @@ describe('LanguageService', ()=>{
                 },
                 {
                     provide: UtilsService,
-                    useValue: {}
+                    useValue: mockUtilsService
                 },
                 {
                     provide: LocalizationDataSourceProvider,
@@ -104,6 +113,9 @@ describe('LanguageService', ()=>{
         });
     });
     describe('setAsDefault', ()=>{
+        beforeEach(()=>{
+            mockRepo.find.mockResolvedValue([]);
+        });
         it('unsets the previous default and sets the requested language as default', async ()=>{
             const newDefault = buildLanguage({
                 id: 'lang-2',
@@ -129,6 +141,24 @@ describe('LanguageService', ()=>{
             });
             expect(result).toEqual(newDefault);
         });
+        it('invalidates the language list cache and both the old and new default entries', async ()=>{
+            const previousDefault = buildLanguage({
+                id: 'lang-1',
+                isDefault: true,
+                code: 'en'
+            });
+            mockRepo.find.mockResolvedValue([
+                previousDefault
+            ]);
+            mockRepo.findOne.mockResolvedValue(buildLanguage({
+                id: 'lang-2',
+                isDefault: true
+            }));
+            await service.setAsDefault('lang-2');
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('language', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('language', expect.anything(), 'lang-1');
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('language', expect.anything(), 'lang-2');
+        });
         it('returns null when the id does not correspond to any language after the update', async ()=>{
             mockRepo.findOne.mockResolvedValue(null);
             const result = await service.setAsDefault('non-existent-id');
@@ -144,4 +174,79 @@ describe('LanguageService', ()=>{
             });
         });
     });
+    describe('beforeUpdateOperation', ()=>{
+        it('rejects renaming the code of a readonly language', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: true,
+                    code: 'en'
+                })
+            ]);
+            await expect(service.beforeUpdateOperation({
+                id: 'language-uuid-1',
+                code: 'fr'
+            }, null, {})).rejects.toThrow('Cannot modify code/name of readonly language');
+        });
+        it('allows updating isActive on a readonly language when identity fields are unchanged', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: true,
+                    code: 'en',
+                    name: 'English'
+                })
+            ]);
+            await expect(service.beforeUpdateOperation({
+                id: 'language-uuid-1',
+                code: 'en',
+                name: 'English',
+                isActive: false
+            }, null, {})).resolves.toBeUndefined();
+        });
+        it('allows any field change on a non-readonly language', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: false,
+                    code: 'en'
+                })
+            ]);
+            await expect(service.beforeUpdateOperation({
+                id: 'language-uuid-1',
+                code: 'fr'
+            }, null, {})).resolves.toBeUndefined();
+        });
+    });
+    describe('beforeDeleteOperation', ()=>{
+        it('rejects deleting a readonly language', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: true
+                })
+            ]);
+            await expect(service.beforeDeleteOperation({
+                id: 'language-uuid-1'
+            }, null, {})).rejects.toThrow('Cannot delete readonly language');
+        });
+        it('rejects deleting the default language', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: false,
+                    isDefault: true
+                })
+            ]);
+            await expect(service.beforeDeleteOperation({
+                id: 'language-uuid-1'
+            }, null, {})).rejects.toThrow('Cannot delete the default language');
+        });
+        it('allows deleting a non-readonly, non-default language', async ()=>{
+            mockRepo.find.mockResolvedValue([
+                buildLanguage({
+                    isReadonly: false,
+                    isDefault: false
+                })
+            ]);
+            await expect(service.beforeDeleteOperation({
+                id: 'language-uuid-1'
+            }, null, {})).resolves.toBeUndefined();
+        });
+    });
 });

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

@@ -57,7 +57,8 @@ export class TranslationKeyService extends ApiService {
         // 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)) {
+            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,

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

@@ -213,6 +213,27 @@ describe('TranslationKeyService', ()=>{
                 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',

package/fesm/services/translation.service.js

@@ -29,6 +29,7 @@ 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 } from '../config';
 import { Language, Translation, TranslationKey } from '../entities';
 import { LocalizationDataSourceProvider } from './localization-datasource.provider';
 export class TranslationService extends ApiService {
@@ -122,11 +123,22 @@ export class TranslationService extends ApiService {
                 }
             }
             await queryRunner.commitTransaction();
-            return this.repository.find({
+            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;

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

@@ -1,4 +1,5 @@
 import { Test } from '@nestjs/testing';
+import { EventBusRegistry } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
 import { Language, Translation, TranslationKey } from '../entities';
@@ -62,6 +63,15 @@ function buildTranslation(overrides = {}) {
     };
 }
 describe('TranslationService', ()=>{
+    const mockUtilsService = {
+        clearCache: jest.fn(),
+        getCacheKey: jest.fn().mockReturnValue('cache-key'),
+        trackCacheKey: jest.fn()
+    };
+    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
+    beforeEach(()=>{
+        mockUtilsService.clearCache.mockClear();
+    });
     let service;
     let mockRepo;
     // `TranslationService` uses joins/aggregate query-builder methods (innerJoin, innerJoinAndSelect,
@@ -94,11 +104,6 @@ describe('TranslationService', ()=>{
             createQueryRunner: jest.fn()
         };
         mockDataSourceProvider.getDataSource.mockResolvedValue(fakeDataSource);
-        const mockUtilsService = {
-            clearCache: jest.fn(),
-            getCacheKey: jest.fn().mockReturnValue('cache-key'),
-            trackCacheKey: jest.fn()
-        };
         const module = await Test.createTestingModule({
             providers: [
                 TranslationService,
@@ -271,6 +276,25 @@ describe('TranslationService', ()=>{
             });
             expect(result).toHaveLength(1);
         });
+        it('invalidates the translation list cache and each written entry after committing', async ()=>{
+            const queryRunner = buildQueryRunner();
+            fakeDataSource.createQueryRunner.mockReturnValue(queryRunner);
+            mockRepo.find.mockResolvedValue([
+                buildTranslation({
+                    id: 'translation-1'
+                })
+            ]);
+            await service.bulkUpdate([
+                {
+                    id: 'translation-1',
+                    languageId: 'lang-en',
+                    translationKeyId: 'tkey-1',
+                    value: 'Updated'
+                }
+            ]);
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('translation', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('translation', expect.anything(), 'translation-1');
+        });
         it('creates new translations when no id is provided', async ()=>{
             const queryRunner = buildQueryRunner();
             fakeDataSource.createQueryRunner.mockReturnValue(queryRunner);
@@ -419,4 +443,84 @@ describe('TranslationService', ()=>{
             expect(qb.andWhere).not.toHaveBeenCalled();
         });
     });
+    describe('domain events', ()=>{
+        let publish;
+        function buildEventQueryRunner() {
+            return {
+                connect: jest.fn(),
+                startTransaction: jest.fn(),
+                commitTransaction: jest.fn(),
+                rollbackTransaction: jest.fn(),
+                release: jest.fn(),
+                manager: {
+                    update: jest.fn(),
+                    create: jest.fn((_entity, data)=>({
+                            id: 'new-translation-id',
+                            ...data
+                        })),
+                    save: jest.fn(async (entity)=>entity)
+                }
+            };
+        }
+        beforeEach(()=>{
+            publish = jest.fn().mockResolvedValue(undefined);
+            EventBusRegistry.reset();
+            EventBusRegistry.setBus({
+                publish,
+                subscribe: jest.fn(),
+                close: jest.fn()
+            });
+            EventBusRegistry.configureModule('localization', {
+                enabled: true
+            });
+            fakeDataSource.createQueryRunner.mockReturnValue(buildEventQueryRunner());
+            mockRepo.find.mockResolvedValue([
+                buildTranslation({
+                    id: 'translation-1'
+                })
+            ]);
+        });
+        afterEach(()=>{
+            EventBusRegistry.reset();
+        });
+        it('publishes localization.translation.bulk-updated with the written count', async ()=>{
+            await service.bulkUpdate([
+                {
+                    id: 'translation-1',
+                    languageId: 'lang-en',
+                    translationKeyId: 'tkey-1',
+                    value: 'x'
+                }
+            ]);
+            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'localization.translation.bulk-updated',
+                payload: expect.objectContaining({
+                    ids: [
+                        'translation-1'
+                    ],
+                    metadata: {
+                        count: 1
+                    }
+                })
+            }));
+        });
+        it('does not publish when the localization module has events disabled', async ()=>{
+            EventBusRegistry.configureModule('localization', {
+                enabled: false
+            });
+            await service.bulkUpdate([
+                {
+                    id: 'translation-1',
+                    languageId: 'lang-en',
+                    translationKeyId: 'tkey-1',
+                    value: 'x'
+                }
+            ]);
+            expect(publish).not.toHaveBeenCalled();
+        });
+        it('publishes nothing when there is nothing to update', async ()=>{
+            await service.bulkUpdate([]);
+            expect(publish).not.toHaveBeenCalled();
+        });
+    });
 });

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

@@ -1,9 +1,11 @@
 import { IBootstrapAppConfig, IDataSourceServiceOptions, IDynamicModuleConfig, IModuleOptionsFactory } from '@flusys/nestjs-core';
+import { IModuleEventsConfig } from '@flusys/nestjs-shared/interfaces';
 import { ModuleMetadata, Type } from '@nestjs/common';
 export interface ILocalizationModuleConfig extends IDataSourceServiceOptions {
     defaultLanguageCode?: string;
     enableCaching?: boolean;
     cacheTtlSeconds?: number;
+    events?: IModuleEventsConfig;
 }
 export interface LocalizationModuleOptions extends IDynamicModuleConfig {
     bootstrapAppConfig?: IBootstrapAppConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-localization",
-  "version": "6.4.0",
+  "version": "7.0.0-beta.1",
   "description": "Localization module for multi-language support",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -80,7 +80,7 @@
     "express": "^5.0.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "6.4.0",
-    "@flusys/nestjs-shared": "6.4.0"
+    "@flusys/nestjs-core": "7.0.0-beta.1",
+    "@flusys/nestjs-shared": "7.0.0-beta.1"
   }
 }

package/services/language.service.d.ts

@@ -1,5 +1,8 @@
 import { HybridCache, ApiService } 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 { QueryRunner } from 'typeorm';
 import { CreateLanguageDto, UpdateLanguageDto } from '../dtos';
 import { Language } from '../entities';
 import { ILanguage } from '../interfaces';
@@ -8,6 +11,8 @@ export declare class LanguageService extends ApiService<CreateLanguageDto, Updat
     protected cacheManager: HybridCache;
     protected utilsService: UtilsService;
     constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: LocalizationDataSourceProvider);
+    protected beforeUpdateOperation(dto: UpdateLanguageDto | UpdateLanguageDto[], _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
+    protected beforeDeleteOperation(dto: DeleteDto, _user: ILoggedUserInfo | null, _queryRunner: QueryRunner): Promise<void>;
     getDefaultLanguage(): Promise<Language | null>;
     getActiveLanguages(): Promise<Language[]>;
     setAsDefault(id: string): Promise<Language | null>;