@flusys/nestjs-localization 9.1.2 → 9.2.0

package/fesm/{692.js → 901.js}

@@ -5,8 +5,9 @@ import * as __rspack_external__flusys_nestjs_shared_modules_24702bee from "@flus
 import * as __rspack_external__nestjs_common_a04939da from "@nestjs/common";
 import * as __rspack_external_typeorm from "typeorm";
 import * as __rspack_external__nestjs_core_d7b00a1a from "@nestjs/core";
-export const __rspack_esm_id = 692;
-export const __rspack_esm_ids = [692];
+import * as __rspack_external__flusys_nestjs_shared_constants_81f33d5b from "@flusys/nestjs-shared/constants";
+export const __rspack_esm_id = 901;
+export const __rspack_esm_ids = [901];
 export const __webpack_modules__ = {
 102(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /**
@@ -459,7 +460,7 @@ function getLocalizationEntities() {
 
 
 },
-367(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+140(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -601,6 +602,8 @@ LocalizationDataSourceProvider = localization_datasource_provider_ts_decorate([
 
 // EXTERNAL MODULE: external "@flusys/nestjs-shared/classes"
 var classes_ = __webpack_require__(937);
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/constants"
+
 // EXTERNAL MODULE: external "typeorm"
 var external_typeorm_ = __webpack_require__(158);
 // EXTERNAL MODULE: ./projects/nestjs-localization/src/config/event-actions.ts
@@ -638,19 +641,30 @@ function language_service_ts_param(paramIndex, decorator) {
 
 
 
+
 class LanguageService extends classes_.ApiService {
     cacheManager;
     utilsService;
     constructor(cacheManager, utilsService, dataSourceProvider){
         super(event_actions/* .LOCALIZATION_EVENT_ENTITIES.LANGUAGE */.JX.LANGUAGE, cacheManager, utilsService, LanguageService.name, true, event_actions/* .LOCALIZATION_EVENT_MODULE */.ec, dataSourceProvider, src_entities/* .Language */.TM), this.cacheManager = cacheManager, this.utilsService = utilsService;
     }
-    async beforeUpdateOperation(dto, _user, _queryRunner) {
+    async beforeInsertOperation(dto, _user, queryRunner) {
+        const dtos = Array.isArray(dto) ? dto : [
+            dto
+        ];
+        if (dtos.some((d)=>d.isDefault === true)) {
+            await this.lockLanguages(queryRunner.manager);
+        }
+    }
+    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({
+        if (dtos.some((d)=>d.isDefault === true)) {
+            await this.lockLanguages(queryRunner.manager);
+        }
+        const existingLanguages = await queryRunner.manager.find(src_entities/* .Language */.TM, {
             where: {
                 id: (0,external_typeorm_.In)(ids),
                 deletedAt: (0,external_typeorm_.IsNull)()
@@ -673,12 +687,52 @@ class LanguageService extends classes_.ApiService {
             }
         }
     }
-    async beforeDeleteOperation(dto, _user, _queryRunner) {
+    async afterInsertOperation(entities, _dto, _user, queryRunner) {
+        await this.keepSingleDefault(entities, queryRunner);
+    }
+    async afterUpdateOperation(entities, _dto, _user, queryRunner) {
+        await this.keepSingleDefault(entities, queryRunner);
+    }
+    async keepSingleDefault(entities, queryRunner) {
+        const newDefault = entities.findLast((entity)=>entity.isDefault);
+        if (!newDefault) {
+            return;
+        }
+        await queryRunner.manager.update(src_entities/* .Language */.TM, {
+            isDefault: true,
+            id: (0,external_typeorm_.Not)(newDefault.id)
+        }, {
+            isDefault: false
+        });
+        for (const entity of entities){
+            if (entity !== newDefault) {
+                entity.isDefault = false;
+            }
+        }
+    }
+    // Every default switch and delete takes this lock first (same row order), so concurrent
+    // callers serialize: none can demote a stale snapshot and leave two defaults, or delete
+    // a language that has just become the default.
+    async lockLanguages(manager) {
+        await manager.find(src_entities/* .Language */.TM, {
+            select: {
+                id: true
+            },
+            order: {
+                id: 'ASC'
+            },
+            withDeleted: true,
+            lock: {
+                mode: 'pessimistic_write'
+            }
+        });
+    }
+    async beforeDeleteOperation(dto, _user, queryRunner) {
         const ids = Array.isArray(dto.id) ? dto.id : [
             dto.id
         ];
-        await this.ensureDataSourceRepository();
-        const languages = await this.repository.find({
+        await this.lockLanguages(queryRunner.manager);
+        const languages = await queryRunner.manager.find(src_entities/* .Language */.TM, {
             where: {
                 id: (0,external_typeorm_.In)(ids),
                 deletedAt: (0,external_typeorm_.IsNull)()
@@ -707,6 +761,14 @@ class LanguageService extends classes_.ApiService {
             });
         }
     }
+    // A permanent delete cascades (FK) to the language's translations
+    async delete(option, user) {
+        const result = await super.delete(option, user);
+        if (option.type === 'permanent') {
+            await this.utilsService.clearCache(event_actions/* .LOCALIZATION_EVENT_ENTITIES.TRANSLATION */.JX.TRANSLATION, this.cacheManager, this.cacheTenant());
+        }
+        return result;
+    }
     async getDefaultLanguage() {
         await this.ensureDataSourceRepository();
         return this.repository.findOne({
@@ -731,36 +793,38 @@ class LanguageService extends classes_.ApiService {
     }
     async setAsDefault(id) {
         await this.ensureDataSourceRepository();
-        const previousDefaults = await this.repository.find({
-            where: {
-                isDefault: true
+        await this.repository.manager.transaction(async (manager)=>{
+            await this.lockLanguages(manager);
+            const target = await manager.findOne(src_entities/* .Language */.TM, {
+                where: {
+                    id,
+                    deletedAt: (0,external_typeorm_.IsNull)()
+                }
+            });
+            if (!target) {
+                throw new common_.NotFoundException({
+                    message: 'Language not found',
+                    messageKey: __rspack_external__flusys_nestjs_shared_constants_81f33d5b.ERROR_MESSAGES.NOT_FOUND
+                });
             }
+            await manager.update(src_entities/* .Language */.TM, {
+                isDefault: true,
+                id: (0,external_typeorm_.Not)(id)
+            }, {
+                isDefault: false
+            });
+            await manager.update(src_entities/* .Language */.TM, {
+                id
+            }, {
+                isDefault: true
+            });
         });
-        await this.repository.update({
-            isDefault: true
-        }, {
-            isDefault: false
-        });
-        await this.repository.update({
-            id
-        }, {
-            isDefault: true
-        });
-        const language = await this.repository.findOne({
+        await this.invalidateCache();
+        return this.repository.findOne({
             where: {
                 id
             }
         });
-        await Promise.all([
-            this.clearCacheForAll(),
-            this.clearCacheForId([
-                ...previousDefaults,
-                {
-                    id
-                }
-            ])
-        ]);
-        return language;
     }
 }
 LanguageService = language_service_ts_decorate([
@@ -886,6 +950,14 @@ class TranslationKeyService extends classes_.ApiService {
             });
         }
     }
+    // A permanent delete cascades (FK) to the key's translations
+    async delete(option, user) {
+        const result = await super.delete(option, user);
+        if (option.type === 'permanent') {
+            await this.utilsService.clearCache(event_actions/* .LOCALIZATION_EVENT_ENTITIES.TRANSLATION */.JX.TRANSLATION, this.cacheManager, this.cacheTenant());
+        }
+        return result;
+    }
     async findByModule(module) {
         await this.ensureDataSourceRepository();
         return this.repository.find({
@@ -987,6 +1059,14 @@ class TranslationService extends classes_.ApiService {
     constructor(cacheManager, utilsService, dataSourceProvider){
         super(event_actions/* .LOCALIZATION_EVENT_ENTITIES.TRANSLATION */.JX.TRANSLATION, cacheManager, utilsService, TranslationService.name, true, event_actions/* .LOCALIZATION_EVENT_MODULE */.ec, dataSourceProvider, src_entities/* .Translation */.wD), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider;
     }
+    // The module filter joins translation_key; a permanent language/key delete cascades rows away
+    cacheDependencies() {
+        return [
+            event_actions/* .LOCALIZATION_EVENT_ENTITIES.TRANSLATION */.JX.TRANSLATION,
+            event_actions/* .LOCALIZATION_EVENT_ENTITIES.TRANSLATION_KEY */.JX.TRANSLATION_KEY,
+            event_actions/* .LOCALIZATION_EVENT_ENTITIES.LANGUAGE */.JX.LANGUAGE
+        ];
+    }
     async getFilterQuery(query, filter, _user) {
         // Handle module filter by joining to translation_key table
         if (filter.module) {
@@ -1051,11 +1131,10 @@ class TranslationService extends classes_.ApiService {
         const queryRunner = ds.createQueryRunner();
         await queryRunner.connect();
         await queryRunner.startTransaction();
+        const resultIds = [];
         try {
-            const resultIds = [];
             for (const update of updates){
                 if (update.id) {
-                    // Update existing translation
                     await queryRunner.manager.update(src_entities/* .Translation */.wD, {
                         id: update.id
                     }, {
@@ -1064,7 +1143,6 @@ class TranslationService extends classes_.ApiService {
                     });
                     resultIds.push(update.id);
                 } else {
-                    // Create new translation
                     const newTranslation = queryRunner.manager.create(src_entities/* .Translation */.wD, {
                         languageId: update.languageId,
                         translationKeyId: update.translationKeyId,
@@ -1077,28 +1155,25 @@ class TranslationService extends classes_.ApiService {
                 }
             }
             await queryRunner.commitTransaction();
-            const saved = await this.repository.find({
-                where: {
-                    id: (0,external_typeorm_.In)(resultIds)
-                }
-            });
-            await Promise.all([
-                this.clearCacheForAll(),
-                this.clearCacheForId(saved)
-            ]);
-            await this.publishDomainAction(event_actions/* .LOCALIZATION_EVENT_ACTIONS.BULK_UPDATED */.f_.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();
         }
+        await this.invalidateCache();
+        const saved = await this.repository.find({
+            where: {
+                id: (0,external_typeorm_.In)(resultIds)
+            }
+        });
+        await this.publishDomainAction(event_actions/* .LOCALIZATION_EVENT_ACTIONS.BULK_UPDATED */.f_.BULK_UPDATED, {
+            ids: saved.map((translation)=>translation.id),
+            metadata: {
+                count: saved.length
+            }
+        });
+        return saved;
     }
     async getMissingTranslations(languageCode) {
         await this.ensureAllReposInitialized();

package/fesm/controllers/index.js

@@ -3,7 +3,7 @@ export const __rspack_esm_ids = [24];
 export const __webpack_modules__ = {};
 import { __webpack_require__ } from '../runtime.js';
 var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); }
-import * as __rspack_chunk_1 from '../692.js';
+import * as __rspack_chunk_1 from '../901.js';
 __webpack_require__.C(__rspack_chunk_1);
 import * as __rspack_chunk_2 from '../349.js';
 __webpack_require__.C(__rspack_chunk_2);

package/fesm/docs/index.js

@@ -37,7 +37,6 @@ Database-driven internationalization system. Manage languages, translation keys,
 - Store translated values per language per key
 - Mark translations as verified
 - Bulk upsert in a single transaction — create or update in one call
-- Detect missing translations for a given language
 - Track translation counts per key
 
 ### 🚀 Angular Lazy Loading
@@ -79,11 +78,10 @@ Keys are grouped by \`module\` so the frontend loads translations on demand:
 - POST /localization/language/get-active
 - POST /localization/language/get-default
 - POST /localization/translation/get-by-language
-- POST /localization/translation/get-by-module
 
 **Authenticated** (require JWT + permission):
 - All create, update, delete operations
-- get-missing, get-counts, update-many-values
+- get-modules, get-counts, update-many-values, set-default
 
 ## Bulk Update