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

package/fesm/692.js

@@ -0,0 +1,1205 @@
+import * as __rspack_external__flusys_nestjs_shared_classes_6076a329 from "@flusys/nestjs-shared/classes";
+import * as __rspack_external__flusys_nestjs_shared_modules_24702bee from "@flusys/nestjs-shared/modules";
+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";
+import * as __rspack_external__flusys_nestjs_shared_entities_420e6d19 from "@flusys/nestjs-shared/entities";
+import * as __rspack_external__flusys_nestjs_shared_393d2cae from "@flusys/nestjs-shared";
+export const __rspack_esm_id = 692;
+export const __rspack_esm_ids = [692];
+export const __webpack_modules__ = {
+102(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Domain event actions published by the localization module, alongside the CRUD
+ * lifecycle actions every ApiService emits.
+ */ const LOCALIZATION_EVENT_ACTIONS = {
+    BULK_UPDATED: 'bulk-updated'
+};
+/** Every entity the localization module publishes under */ const LOCALIZATION_EVENT_ENTITIES = {
+    LANGUAGE: 'language',
+    TRANSLATION_KEY: 'translationKey',
+    TRANSLATION: 'translation'
+};
+const LOCALIZATION_EVENT_MODULE = 'localization';
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  JX: LOCALIZATION_EVENT_ENTITIES,
+  ec: LOCALIZATION_EVENT_MODULE,
+  f_: LOCALIZATION_EVENT_ACTIONS
+});
+
+
+},
+88(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+const LOCALIZATION_MODULE_OPTIONS = 'LOCALIZATION_MODULE_OPTIONS';
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  A: LOCALIZATION_MODULE_OPTIONS
+});
+
+
+},
+68(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+// ==================== LOCALIZATION MODULE MESSAGE KEYS ====================
+const LANGUAGE_MESSAGES = {
+    ACTIVE_SUCCESS: 'language.active.success',
+    SET_DEFAULT_SUCCESS: 'language.set.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',
+    READONLY_DELETE_FORBIDDEN: 'translation.key.readonly.delete.forbidden',
+    READONLY_UPDATE_FORBIDDEN: 'translation.key.readonly.update.forbidden',
+    DUPLICATE_KEY_IN_MODULE: 'translation.key.duplicate.key.in.module'
+};
+const TRANSLATION_MESSAGES = {
+    GET_ALL_SUCCESS: 'translation.get.all.success',
+    UPDATE_MANY_SUCCESS: 'translation.update.many.success',
+    BY_LANGUAGE_SUCCESS: 'translation.by.language.success'
+};
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  Bc: TRANSLATION_KEY_MESSAGES,
+  Ju: TRANSLATION_MESSAGES,
+  ew: LANGUAGE_MESSAGES
+});
+
+
+},
+710(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  TM: () => (/* reexport */ Language),
+  VZ: () => (/* binding */ LocalizationEntities),
+  wD: () => (/* reexport */ Translation),
+  Br: () => (/* reexport */ TranslationKey),
+  pw: () => (/* binding */ getLocalizationEntities)
+});
+
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/entities"
+
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+;// CONCATENATED MODULE: ./projects/nestjs-localization/src/entities/language.entity.ts
+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(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+class Language extends __rspack_external__flusys_nestjs_shared_entities_420e6d19.Identity {
+    code;
+    name;
+    nativeName;
+    direction;
+    isActive;
+    isDefault;
+    serial;
+    isReadonly;
+    translations;
+}
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 10,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], Language.prototype, "code", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 100,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], Language.prototype, "name", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 100,
+        nullable: true,
+        name: 'native_name'
+    }),
+    _ts_metadata("design:type", Object)
+], Language.prototype, "nativeName", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 3,
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Language.prototype, "direction", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: true,
+        name: 'is_active'
+    }),
+    _ts_metadata("design:type", Boolean)
+], Language.prototype, "isActive", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: false,
+        name: 'is_default'
+    }),
+    _ts_metadata("design:type", Boolean)
+], Language.prototype, "isDefault", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'int',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Language.prototype, "serial", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: false,
+        name: 'is_readonly'
+    }),
+    _ts_metadata("design:type", Boolean)
+], Language.prototype, "isReadonly", void 0);
+_ts_decorate([
+    (0,external_typeorm_.OneToMany)('Translation', 'language'),
+    _ts_metadata("design:type", Array)
+], Language.prototype, "translations", void 0);
+Language = _ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'language'
+    }),
+    (0,external_typeorm_.Index)([
+        'code'
+    ], {
+        unique: true
+    }),
+    (0,external_typeorm_.Index)([
+        'isActive'
+    ]),
+    (0,external_typeorm_.Index)([
+        'isDefault'
+    ]),
+    (0,external_typeorm_.Index)([
+        'isReadonly'
+    ])
+], Language);
+
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared"
+
+;// CONCATENATED MODULE: ./projects/nestjs-localization/src/entities/translation-key.entity.ts
+function translation_key_entity_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 translation_key_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+class TranslationKey extends __rspack_external__flusys_nestjs_shared_entities_420e6d19.Identity {
+    module;
+    key;
+    defaultMessage;
+    description;
+    variables;
+    isActive;
+    isReadonly;
+    serial;
+    translations;
+}
+translation_key_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 100,
+        nullable: false
+    }),
+    translation_key_entity_ts_metadata("design:type", String)
+], TranslationKey.prototype, "module", void 0);
+translation_key_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    translation_key_entity_ts_metadata("design:type", String)
+], TranslationKey.prototype, "key", void 0);
+translation_key_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 500,
+        nullable: false,
+        name: 'default_message'
+    }),
+    translation_key_entity_ts_metadata("design:type", String)
+], TranslationKey.prototype, "defaultMessage", void 0);
+translation_key_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'text',
+        nullable: true
+    }),
+    translation_key_entity_ts_metadata("design:type", Object)
+], TranslationKey.prototype, "description", void 0);
+translation_key_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: (0,__rspack_external__flusys_nestjs_shared_393d2cae.getJsonColumnType)(),
+        nullable: true
+    }),
+    translation_key_entity_ts_metadata("design:type", Object)
+], TranslationKey.prototype, "variables", void 0);
+translation_key_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: true,
+        name: 'is_active'
+    }),
+    translation_key_entity_ts_metadata("design:type", Boolean)
+], TranslationKey.prototype, "isActive", void 0);
+translation_key_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: false,
+        name: 'is_readonly'
+    }),
+    translation_key_entity_ts_metadata("design:type", Boolean)
+], TranslationKey.prototype, "isReadonly", void 0);
+translation_key_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'int',
+        nullable: true
+    }),
+    translation_key_entity_ts_metadata("design:type", Object)
+], TranslationKey.prototype, "serial", void 0);
+translation_key_entity_ts_decorate([
+    (0,external_typeorm_.OneToMany)('Translation', 'translationKey'),
+    translation_key_entity_ts_metadata("design:type", Array)
+], TranslationKey.prototype, "translations", void 0);
+TranslationKey = translation_key_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'translation_key'
+    }),
+    (0,external_typeorm_.Index)([
+        'module'
+    ]),
+    (0,external_typeorm_.Index)([
+        'module',
+        'key'
+    ], {
+        unique: true
+    }),
+    (0,external_typeorm_.Index)([
+        'isActive'
+    ]),
+    (0,external_typeorm_.Index)([
+        'isReadonly'
+    ])
+], TranslationKey);
+
+;// CONCATENATED MODULE: ./projects/nestjs-localization/src/entities/translation.entity.ts
+function translation_entity_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 translation_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+
+class Translation extends __rspack_external__flusys_nestjs_shared_entities_420e6d19.Identity {
+    languageId;
+    translationKeyId;
+    value;
+    isVerified;
+    isActive;
+    language;
+    translationKey;
+}
+translation_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        name: 'language_id',
+        nullable: false
+    }),
+    translation_entity_ts_metadata("design:type", String)
+], Translation.prototype, "languageId", void 0);
+translation_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        name: 'translation_key_id',
+        nullable: false
+    }),
+    translation_entity_ts_metadata("design:type", String)
+], Translation.prototype, "translationKeyId", void 0);
+translation_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'text',
+        nullable: false
+    }),
+    translation_entity_ts_metadata("design:type", String)
+], Translation.prototype, "value", void 0);
+translation_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: false,
+        name: 'is_verified'
+    }),
+    translation_entity_ts_metadata("design:type", Boolean)
+], Translation.prototype, "isVerified", void 0);
+translation_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: true,
+        name: 'is_active'
+    }),
+    translation_entity_ts_metadata("design:type", Boolean)
+], Translation.prototype, "isActive", void 0);
+translation_entity_ts_decorate([
+    (0,external_typeorm_.ManyToOne)(()=>Language, {
+        nullable: false,
+        onDelete: 'CASCADE'
+    }),
+    (0,external_typeorm_.JoinColumn)({
+        name: 'language_id'
+    }),
+    translation_entity_ts_metadata("design:type", typeof Language === "undefined" ? Object : Language)
+], Translation.prototype, "language", void 0);
+translation_entity_ts_decorate([
+    (0,external_typeorm_.ManyToOne)(()=>TranslationKey, {
+        nullable: false,
+        onDelete: 'CASCADE'
+    }),
+    (0,external_typeorm_.JoinColumn)({
+        name: 'translation_key_id'
+    }),
+    translation_entity_ts_metadata("design:type", typeof TranslationKey === "undefined" ? Object : TranslationKey)
+], Translation.prototype, "translationKey", void 0);
+Translation = translation_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'translation'
+    }),
+    (0,external_typeorm_.Index)([
+        'languageId',
+        'translationKeyId'
+    ], {
+        unique: true
+    }),
+    (0,external_typeorm_.Index)([
+        'languageId'
+    ]),
+    (0,external_typeorm_.Index)([
+        'translationKeyId'
+    ]),
+    (0,external_typeorm_.Index)([
+        'isActive'
+    ])
+], Translation);
+
+;// CONCATENATED MODULE: ./projects/nestjs-localization/src/entities/index.ts
+
+
+
+
+
+
+const LocalizationEntities = [
+    Language,
+    TranslationKey,
+    Translation
+];
+function getLocalizationEntities() {
+    return LocalizationEntities;
+}
+
+
+},
+367(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  gw: () => (/* reexport */ LanguageService),
+  lg: () => (/* reexport */ LocalizationConfigService),
+  ue: () => (/* reexport */ LocalizationDataSourceProvider),
+  q3: () => (/* reexport */ TranslationKeyService),
+  L0: () => (/* reexport */ TranslationService)
+});
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: ./projects/nestjs-localization/src/config/localization.constants.ts
+var localization_constants = __webpack_require__(88);
+;// CONCATENATED MODULE: ./projects/nestjs-localization/src/services/localization-config.service.ts
+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(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+class LocalizationConfigService {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    isCompanyFeatureEnabled() {
+        return false;
+    }
+    getDatabaseMode() {
+        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
+    }
+    isMultiTenant() {
+        return this.getDatabaseMode() === 'multi-tenant';
+    }
+    getOptions() {
+        return this.options;
+    }
+}
+LocalizationConfigService = _ts_decorate([
+    (0,common_.Injectable)(),
+    _ts_param(0, (0,common_.Inject)(localization_constants/* .LOCALIZATION_MODULE_OPTIONS */.A)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof LocalizationModuleOptions === "undefined" ? Object : LocalizationModuleOptions
+    ])
+], LocalizationConfigService);
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
+var modules_ = __webpack_require__(236);
+;// CONCATENATED MODULE: external "@nestjs/core"
+
+// EXTERNAL MODULE: ./projects/nestjs-localization/src/entities/index.ts + 5 modules
+var src_entities = __webpack_require__(710);
+;// CONCATENATED MODULE: ./projects/nestjs-localization/src/services/localization-datasource.provider.ts
+function localization_datasource_provider_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 localization_datasource_provider_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function localization_datasource_provider_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+class LocalizationDataSourceProvider extends modules_.MultiTenantDataSourceService {
+    static tenantConnections = new Map();
+    static singleDataSource = null;
+    static tenantsRegistry = new Map();
+    static initialized = false;
+    static connectionLocks = new Map();
+    static singleConnectionLock = null;
+    constructor(configService, request){
+        super(LocalizationDataSourceProvider.buildParentOptions(configService.getOptions()), request);
+    }
+    static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
+        };
+    }
+    async createDataSourceFromConfig(config) {
+        const entities = (0,src_entities/* .getLocalizationEntities */.pw)();
+        return super.createDataSourceFromConfig(config, entities);
+    }
+}
+LocalizationDataSourceProvider = localization_datasource_provider_ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    localization_datasource_provider_ts_param(0, (0,common_.Inject)(LocalizationConfigService)),
+    localization_datasource_provider_ts_param(1, (0,common_.Optional)()),
+    localization_datasource_provider_ts_param(1, (0,common_.Inject)(__rspack_external__nestjs_core_d7b00a1a.REQUEST)),
+    localization_datasource_provider_ts_metadata("design:type", Function),
+    localization_datasource_provider_ts_metadata("design:paramtypes", [
+        typeof LocalizationConfigService === "undefined" ? Object : LocalizationConfigService,
+        typeof Request === "undefined" ? Object : Request
+    ])
+], LocalizationDataSourceProvider);
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/classes"
+var classes_ = __webpack_require__(937);
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+// EXTERNAL MODULE: ./projects/nestjs-localization/src/config/event-actions.ts
+var event_actions = __webpack_require__(102);
+// EXTERNAL MODULE: ./projects/nestjs-localization/src/config/message-keys.ts
+var message_keys = __webpack_require__(68);
+;// CONCATENATED MODULE: ./projects/nestjs-localization/src/services/language.service.ts
+function language_service_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 language_service_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function language_service_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+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) {
+        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,external_typeorm_.In)(ids),
+                deletedAt: (0,external_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: message_keys/* .LANGUAGE_MESSAGES.READONLY_UPDATE_FORBIDDEN */.ew.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,external_typeorm_.In)(ids),
+                deletedAt: (0,external_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: message_keys/* .LANGUAGE_MESSAGES.READONLY_DELETE_FORBIDDEN */.ew.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: message_keys/* .LANGUAGE_MESSAGES.DEFAULT_DELETE_FORBIDDEN */.ew.DEFAULT_DELETE_FORBIDDEN,
+                messageVariables: {
+                    names
+                }
+            });
+        }
+    }
+    async getDefaultLanguage() {
+        await this.ensureDataSourceRepository();
+        return this.repository.findOne({
+            where: {
+                isDefault: true,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            }
+        });
+    }
+    async getActiveLanguages() {
+        await this.ensureDataSourceRepository();
+        return this.repository.find({
+            where: {
+                isActive: true,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            },
+            order: {
+                serial: 'ASC',
+                name: 'ASC'
+            }
+        });
+    }
+    async setAsDefault(id) {
+        await this.ensureDataSourceRepository();
+        const previousDefaults = await this.repository.find({
+            where: {
+                isDefault: true
+            }
+        });
+        await this.repository.update({
+            isDefault: true
+        }, {
+            isDefault: false
+        });
+        await this.repository.update({
+            id
+        }, {
+            isDefault: true
+        });
+        const language = await this.repository.findOne({
+            where: {
+                id
+            }
+        });
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                ...previousDefaults,
+                {
+                    id
+                }
+            ])
+        ]);
+        return language;
+    }
+}
+LanguageService = language_service_ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    language_service_ts_param(0, (0,common_.Inject)('CACHE_INSTANCE')),
+    language_service_ts_param(1, (0,common_.Inject)(modules_.UtilsService)),
+    language_service_ts_param(2, (0,common_.Inject)(LocalizationDataSourceProvider)),
+    language_service_ts_metadata("design:type", Function),
+    language_service_ts_metadata("design:paramtypes", [
+        typeof classes_.HybridCache === "undefined" ? Object : classes_.HybridCache,
+        typeof modules_.UtilsService === "undefined" ? Object : modules_.UtilsService,
+        typeof LocalizationDataSourceProvider === "undefined" ? Object : LocalizationDataSourceProvider
+    ])
+], LanguageService);
+
+;// CONCATENATED MODULE: ./projects/nestjs-localization/src/services/translation-key.service.ts
+function translation_key_service_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 translation_key_service_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function translation_key_service_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+class TranslationKeyService extends classes_.ApiService {
+    cacheManager;
+    utilsService;
+    constructor(cacheManager, utilsService, dataSourceProvider){
+        super(event_actions/* .LOCALIZATION_EVENT_ENTITIES.TRANSLATION_KEY */.JX.TRANSLATION_KEY, cacheManager, utilsService, TranslationKeyService.name, true, event_actions/* .LOCALIZATION_EVENT_MODULE */.ec, dataSourceProvider, src_entities/* .TranslationKey */.Br), this.cacheManager = cacheManager, this.utilsService = utilsService;
+    }
+    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: (0,external_typeorm_.In)(ids),
+                deletedAt: (0,external_typeorm_.IsNull)()
+            }
+        });
+        // Check if any readonly keys are being updated with key/module changes
+        for (const d of dtos){
+            const existing = existingKeys.find((e)=>e.id === d.id);
+            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: message_keys/* .TRANSLATION_KEY_MESSAGES.READONLY_UPDATE_FORBIDDEN */.Bc.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: (0,external_typeorm_.In)(ids),
+                isReadonly: true,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            }
+        });
+        if (readonlyKeys.length > 0) {
+            const keys = readonlyKeys.map((k)=>k.key).join(', ');
+            throw new common_.ForbiddenException({
+                message: `Cannot delete readonly translation keys: ${keys}`,
+                messageKey: message_keys/* .TRANSLATION_KEY_MESSAGES.READONLY_DELETE_FORBIDDEN */.Bc.READONLY_DELETE_FORBIDDEN,
+                messageVariables: {
+                    keys
+                }
+            });
+        }
+    }
+    async findByModule(module) {
+        await this.ensureDataSourceRepository();
+        return this.repository.find({
+            where: {
+                module,
+                isActive: true,
+                deletedAt: (0,external_typeorm_.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 common_.BadRequestException({
+                    message: `Translation key "${key}" already exists in module "${module}"`,
+                    messageKey: message_keys/* .TRANSLATION_KEY_MESSAGES.DUPLICATE_KEY_IN_MODULE */.Bc.DUPLICATE_KEY_IN_MODULE,
+                    messageVariables: {
+                        key,
+                        module
+                    }
+                });
+            }
+        }
+    }
+}
+TranslationKeyService = translation_key_service_ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    translation_key_service_ts_param(0, (0,common_.Inject)('CACHE_INSTANCE')),
+    translation_key_service_ts_param(1, (0,common_.Inject)(modules_.UtilsService)),
+    translation_key_service_ts_param(2, (0,common_.Inject)(LocalizationDataSourceProvider)),
+    translation_key_service_ts_metadata("design:type", Function),
+    translation_key_service_ts_metadata("design:paramtypes", [
+        typeof classes_.HybridCache === "undefined" ? Object : classes_.HybridCache,
+        typeof modules_.UtilsService === "undefined" ? Object : modules_.UtilsService,
+        typeof LocalizationDataSourceProvider === "undefined" ? Object : LocalizationDataSourceProvider
+    ])
+], TranslationKeyService);
+
+;// CONCATENATED MODULE: ./projects/nestjs-localization/src/services/translation.service.ts
+function translation_service_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 translation_service_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function translation_service_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+class TranslationService extends classes_.ApiService {
+    cacheManager;
+    utilsService;
+    dataSourceProvider;
+    languageRepo = null;
+    translationKeyRepo = null;
+    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;
+    }
+    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(src_entities/* .Language */.TM);
+            this.translationKeyRepo = ds.getRepository(src_entities/* .TranslationKey */.Br);
+        }
+    }
+    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(src_entities/* .Translation */.wD, {
+                        id: update.id
+                    }, {
+                        value: update.value,
+                        isVerified: update.isVerified ?? false
+                    });
+                    resultIds.push(update.id);
+                } else {
+                    // Create new translation
+                    const newTranslation = queryRunner.manager.create(src_entities/* .Translation */.wD, {
+                        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: (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();
+        }
+    }
+    async getMissingTranslations(languageCode) {
+        await this.ensureAllReposInitialized();
+        const language = await this.findActiveLanguageByCode(languageCode);
+        if (!language) return [];
+        if (!this.translationKeyRepo) return [];
+        const allKeys = await this.translationKeyRepo.find({
+            where: {
+                isActive: true,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            }
+        });
+        const existingTranslations = await this.repository.find({
+            where: {
+                languageId: language.id,
+                isActive: true,
+                deletedAt: (0,external_typeorm_.IsNull)()
+            },
+            select: [
+                'translationKeyId'
+            ]
+        });
+        const existingKeyIds = new Set(existingTranslations.map((t)=>t.translationKeyId));
+        return allKeys.filter((k)=>!existingKeyIds.has(k.id));
+    }
+    async getTranslationCounts() {
+        await this.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: (0,external_typeorm_.IsNull)()
+            }
+        });
+    }
+    toTranslationsMap(translations) {
+        const result = {};
+        for (const t of translations){
+            if (t.translationKey) {
+                result[t.translationKey.key] = t.value;
+            }
+        }
+        return result;
+    }
+}
+TranslationService = translation_service_ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    translation_service_ts_param(0, (0,common_.Inject)('CACHE_INSTANCE')),
+    translation_service_ts_param(1, (0,common_.Inject)(modules_.UtilsService)),
+    translation_service_ts_param(2, (0,common_.Inject)(LocalizationDataSourceProvider)),
+    translation_service_ts_metadata("design:type", Function),
+    translation_service_ts_metadata("design:paramtypes", [
+        typeof classes_.HybridCache === "undefined" ? Object : classes_.HybridCache,
+        typeof modules_.UtilsService === "undefined" ? Object : modules_.UtilsService,
+        typeof LocalizationDataSourceProvider === "undefined" ? Object : LocalizationDataSourceProvider
+    ])
+], TranslationService);
+
+;// CONCATENATED MODULE: ./projects/nestjs-localization/src/services/index.ts
+
+
+
+
+
+
+
+},
+937(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_classes_6076a329;
+
+
+},
+236(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_modules_24702bee;
+
+
+},
+157(module) {
+
+module.exports = __rspack_external__nestjs_common_a04939da;
+
+
+},
+158(module) {
+
+module.exports = __rspack_external_typeorm;
+
+
+},
+
+};