@flusys/nestjs-shared 9.1.1 → 9.2.0

package/fesm/interceptors/index.js

@@ -1,5 +1,3 @@
-import * as __rspack_external__flusys_nestjs_core_config_197fa0a9 from "@flusys/nestjs-core/config";
-import * as __rspack_external__nestjs_common_a04939da from "@nestjs/common";
 import * as __rspack_external_crypto from "crypto";
 import * as __rspack_external__keyv_redis_139d03ca from "@keyv/redis";
 import * as __rspack_external_cacheable from "cacheable";
@@ -9,7 +7,7 @@ import * as __rspack_external_rxjs_operators_2eaa0997 from "rxjs/operators";
 export const __rspack_esm_id = 971;
 export const __rspack_esm_ids = [971];
 export const __webpack_modules__ = {
-375(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+5375(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -17,25 +15,41 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 // EXTERNAL MODULE: external "@flusys/nestjs-core/config"
-var config_ = __webpack_require__(307);
+var config_ = __webpack_require__(8307);
 ;// CONCATENATED MODULE: external "@keyv/redis"
 
 ;// CONCATENATED MODULE: external "cacheable"
 
 ;// CONCATENATED MODULE: external "keyv"
 
+// EXTERNAL MODULE: external "node:crypto"
+var external_node_crypto_ = __webpack_require__(2561);
 ;// CONCATENATED MODULE: ./projects/nestjs-shared/src/classes/hybrid-cache.class.ts
 
 
 
 
-class HybridCache {
+
+const RAW_KEY_PREFIX = 'flusys';
+const STAMP_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+/**
+ * L1 in-process memory + L2 Redis, chosen by `USE_CACHE_LABEL` (memory | redis | hybrid).
+ *
+ * Plain `get`/`set` may be served by L1, which other instances cannot invalidate, so a value
+ * read that way must be immutable for its key - which is what version stamps give: data keys
+ * embed the current stamp, and invalidation moves the stamp instead of deleting entries.
+ * Stamps and claims live outside Keyv so they can be set atomically (Redis `SET NX`).
+ */ class HybridCache {
+    mode;
+    defaultTtl;
     memory;
     redis;
+    redisStore;
+    localAtomic;
     constructor(memoryTtl = 60 * 1000, memorySize = 5000){
-        // Default to 'memory' if not specified
-        const useCacheLabel = config_.envConfig.tryGetValue('USE_CACHE_LABEL', false) || 'memory';
-        if (useCacheLabel === 'memory' || useCacheLabel === 'hybrid') {
+        this.mode = config_.envConfig.tryGetValue('USE_CACHE_LABEL', false) || 'memory';
+        this.defaultTtl = memoryTtl;
+        if (this.mode === 'memory' || this.mode === 'hybrid') {
             this.memory = new __rspack_external_keyv["default"]({
                 store: new __rspack_external_cacheable.CacheableMemory({
                     ttl: memoryTtl,
@@ -43,35 +57,51 @@ class HybridCache {
                 })
             });
         }
-        if (useCacheLabel === 'redis' || useCacheLabel === 'hybrid') {
+        if (this.mode === 'redis' || this.mode === 'hybrid') {
+            this.redisStore = new __rspack_external__keyv_redis_139d03ca["default"](config_.envConfig.getRedisUrl());
             this.redis = new __rspack_external_keyv["default"]({
-                store: new __rspack_external__keyv_redis_139d03ca["default"](config_.envConfig.getRedisUrl())
+                store: this.redisStore
+            });
+        } else {
+            // Stamps and claims must never be LRU-evicted while still referenced
+            this.localAtomic = new __rspack_external_cacheable.CacheableMemory({
+                ttl: STAMP_TTL_MS,
+                lruSize: 0,
+                checkInterval: 60_000
             });
         }
     }
-    async get(key) {
-        // Prefer memory first if available
-        if (this.memory) {
+    getMode() {
+        return this.mode;
+    }
+    async get(key, options = {}) {
+        const useMemory = this.memory && !(options.skipMemory && this.redis);
+        if (useMemory) {
             const value = await this.memory.get(key);
             if (value !== undefined) return value;
         }
-        // Fallback to redis
         if (this.redis) {
-            const value = await this.redis.get(key);
-            if (value !== undefined && this.memory) {
-                // backfill L1 memory cache
-                await this.memory.set(key, value);
+            const raw = await this.redis.get(key, {
+                raw: true
+            });
+            if (raw === undefined) return undefined;
+            if (useMemory) {
+                // Never let the L1 copy outlive the Redis entry (time-bound values such as permissions)
+                const remaining = raw.expires ? raw.expires - Date.now() : this.defaultTtl;
+                if (remaining > 0) await this.memory.set(key, raw.value, Math.min(remaining, this.defaultTtl));
             }
-            return value;
+            return raw.value;
         }
         return undefined;
     }
-    async set(key, value, ttl) {
-        if (this.memory) {
-            await this.memory.set(key, value, ttl);
+    async set(key, value, ttl, options = {}) {
+        const effectiveTtl = ttl ?? this.defaultTtl;
+        const useMemory = this.memory && !(options.skipMemory && this.redis);
+        if (useMemory) {
+            await this.memory.set(key, value, effectiveTtl);
         }
         if (this.redis) {
-            await this.redis.set(key, value, ttl);
+            await this.redis.set(key, value, effectiveTtl);
         }
     }
     async del(key) {
@@ -82,460 +112,86 @@ class HybridCache {
             await this.redis.delete(key);
         }
     }
-    async reset() {
-        if (this.memory) {
-            await this.memory.clear();
+    /**
+   * The current version stamp for `name`, creating one when absent. A missing stamp is always
+   * replaced by a fresh random one - never a fixed default - so entries cached under a stamp that
+   * expired or was lost can never become current again.
+   */ async getStamp(name) {
+        const key = this.rawKey('stamp', name);
+        if (this.localAtomic) {
+            let stamp = this.localAtomic.get(key);
+            if (!stamp) {
+                stamp = (0,external_node_crypto_.randomUUID)();
+                this.localAtomic.set(key, stamp);
+            }
+            return stamp;
         }
+        const client = await this.redisStore.getClient();
+        const existing = await client.get(key);
+        if (existing) return String(existing);
+        const candidate = (0,external_node_crypto_.randomUUID)();
+        await client.set(key, candidate, {
+            NX: true,
+            PX: STAMP_TTL_MS
+        });
+        // A key evicted between SET NX and GET must not turn into the fixed stamp "null"
+        return String(await client.get(key) ?? candidate);
     }
-    async resetL2() {
-        if (this.redis) {
-            await this.redis.clear();
+    /** Moves the stamp for `name`, orphaning every entry cached under the previous one on all instances */ async bumpStamp(name) {
+        const key = this.rawKey('stamp', name);
+        if (this.localAtomic) {
+            this.localAtomic.set(key, (0,external_node_crypto_.randomUUID)());
+            return;
+        }
+        const client = await this.redisStore.getClient();
+        await client.set(key, (0,external_node_crypto_.randomUUID)(), {
+            PX: STAMP_TTL_MS
+        });
+    }
+    /** Atomically claims `name` for `ttl` ms; true only for the first caller while the claim lives */ async claim(name, ttl) {
+        const key = this.rawKey('claim', name);
+        if (this.localAtomic) {
+            if (this.localAtomic.has(key)) return false;
+            this.localAtomic.set(key, true, ttl);
+            return true;
+        }
+        const client = await this.redisStore.getClient();
+        return await client.set(key, '1', {
+            NX: true,
+            PX: ttl
+        }) !== null;
+    }
+    async releaseClaim(name) {
+        const key = this.rawKey('claim', name);
+        if (this.localAtomic) {
+            this.localAtomic.delete(key);
+            return;
         }
+        const client = await this.redisStore.getClient();
+        await client.del(key);
+    }
+    /**
+   * Reads and removes a one-time value; only one caller across all instances ever receives it.
+   * The claim is per value, so a fresh value later stored under the same key (a resent code)
+   * can be taken again while the claim on the consumed one is still alive.
+   */ async take(key, ttl) {
+        const value = await this.get(key, {
+            skipMemory: true
+        });
+        if (value === undefined) return undefined;
+        const digest = (0,external_node_crypto_.createHash)('sha256').update(JSON.stringify(value) ?? '').digest('hex');
+        if (!await this.claim(`take:${key}:${digest}`, ttl)) return undefined;
+        await this.del(key);
+        return value;
+    }
+    rawKey(kind, name) {
+        return `${RAW_KEY_PREFIX}:${kind}:${name}`;
     }
 }
 
 
 },
-43(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _permissions_js__rspack_import_0 = __webpack_require__(975);
-/* import */ var _message_keys_js__rspack_import_1 = __webpack_require__(389);
-// Metadata keys
-const IS_PUBLIC_KEY = 'isPublic';
-const PERMISSIONS_KEY = 'permissions';
-const DOMAIN_EVENT_HANDLER_KEY = 'domainEventHandler';
-// Injection tokens
-const CACHE_INSTANCE = 'CACHE_INSTANCE';
-const PERMISSION_GUARD_CONFIG = 'PERMISSION_GUARD_CONFIG';
-const EVENT_BUS_INSTANCE = 'EVENT_BUS_INSTANCE';
-const EVENT_BUS_MODULE_OPTIONS = 'EVENT_BUS_MODULE_OPTIONS';
-// Header names
-const IDEMPOTENCY_KEY_HEADER = 'x-idempotency-key';
-const REQUEST_ID_HEADER = 'x-request-id';
-const CLIENT_TYPE_HEADER = 'x-client-type';
-// Cache key prefixes
-const PERMISSIONS_CACHE_PREFIX = 'my-permissions';
-const IDEMPOTENCY_CACHE_PREFIX = 'idempotency';
-// Event bus defaults
-const DEFAULT_EVENT_EXCHANGE = 'flusys.events';
-const DEFAULT_EVENT_TOPIC = 'flusys.domain-events';
-const DEFAULT_EVENT_SERVICE_NAME = 'flusys';
-// Permission codes
-
-// Message keys for localization
-
-
-__webpack_require__.d(__webpack_exports__, {
-  BC: () => (/* reexport safe */ _permissions_js__rspack_import_0.BC),
-  Bz: () => (/* reexport safe */ _permissions_js__rspack_import_0.Bz),
-  DP: () => (/* reexport safe */ _permissions_js__rspack_import_0.DP),
-  Em: () => (/* reexport safe */ _permissions_js__rspack_import_0.Em),
-  G0: () => (/* reexport safe */ _permissions_js__rspack_import_0.G0),
-  GH: () => (/* reexport safe */ _permissions_js__rspack_import_0.GH),
-  GT: () => (/* reexport safe */ _permissions_js__rspack_import_0.GT),
-  Jj: () => (/* reexport safe */ _permissions_js__rspack_import_0.Jj),
-  N3: () => (/* reexport safe */ _permissions_js__rspack_import_0.N3),
-  ON: () => (/* reexport safe */ _permissions_js__rspack_import_0.ON),
-  P0: () => (/* reexport safe */ _permissions_js__rspack_import_0.P0),
-  Q5: () => (/* reexport safe */ _permissions_js__rspack_import_0.Q5),
-  S6: () => (/* reexport safe */ _permissions_js__rspack_import_0.S6),
-  T: () => (/* reexport safe */ _permissions_js__rspack_import_0.T),
-  UB: () => (/* reexport safe */ _permissions_js__rspack_import_0.UB),
-  UG: () => (/* reexport safe */ _permissions_js__rspack_import_0.UG),
-  UU: () => (/* reexport safe */ _message_keys_js__rspack_import_1.UU),
-  Ub: () => (/* reexport safe */ _permissions_js__rspack_import_0.Ub),
-  V0: () => (/* reexport safe */ _permissions_js__rspack_import_0.V0),
-  Wc: () => (/* reexport safe */ _permissions_js__rspack_import_0.Wc),
-  Y3: () => (/* reexport safe */ _permissions_js__rspack_import_0.Y3),
-  Y7: () => (/* reexport safe */ _permissions_js__rspack_import_0.Y7),
-  _X: () => (/* reexport safe */ _permissions_js__rspack_import_0._X),
-  aO: () => (/* reexport safe */ _permissions_js__rspack_import_0.aO),
-  aT: () => (/* reexport safe */ _permissions_js__rspack_import_0.aT),
-  fS: () => (/* reexport safe */ _permissions_js__rspack_import_0.fS),
-  hg: () => (/* reexport safe */ _message_keys_js__rspack_import_1.hg),
-  kA: () => (/* reexport safe */ _permissions_js__rspack_import_0.kA),
-  kd: () => (/* reexport safe */ _permissions_js__rspack_import_0.kd),
-  l3: () => (/* reexport safe */ _permissions_js__rspack_import_0.l3),
-  mK: () => (/* reexport safe */ _message_keys_js__rspack_import_1.mK),
-  mV: () => (/* reexport safe */ _permissions_js__rspack_import_0.mV),
-  rH: () => (/* reexport safe */ _permissions_js__rspack_import_0.rH),
-  t$: () => (/* reexport safe */ _permissions_js__rspack_import_0.t$),
-  w7: () => (/* reexport safe */ _permissions_js__rspack_import_0.w7),
-  wA: () => (/* reexport safe */ _permissions_js__rspack_import_0.wA),
-  wM: () => (/* reexport safe */ _permissions_js__rspack_import_0.wM),
-  z$: () => (/* reexport safe */ _permissions_js__rspack_import_0.z$),
-  zd: () => (/* reexport safe */ _permissions_js__rspack_import_0.zd)
-}, {
-  Hq: DEFAULT_EVENT_EXCHANGE,
-  Lw: PERMISSION_GUARD_CONFIG,
-  N7: PERMISSIONS_KEY,
-  PT: DOMAIN_EVENT_HANDLER_KEY,
-  Qj: EVENT_BUS_INSTANCE,
-  SL: EVENT_BUS_MODULE_OPTIONS,
-  fG: PERMISSIONS_CACHE_PREFIX,
-  iH: IDEMPOTENCY_KEY_HEADER,
-  jA: IS_PUBLIC_KEY,
-  kC: REQUEST_ID_HEADER,
-  mg: IDEMPOTENCY_CACHE_PREFIX,
-  nx: DEFAULT_EVENT_TOPIC,
-  xw: CLIENT_TYPE_HEADER,
-  zl: CACHE_INSTANCE
-});
-
-
-},
-389(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-// ==================== AUTH (Shared across guards/interceptors) ====================
-// These are duplicated in nestjs-auth but needed here to avoid circular dependencies
-const AUTH_MESSAGES = {
-    TOKEN_REQUIRED: 'auth.token.required',
-    TOKEN_INVALID: 'auth.token.invalid',
-    ENTITY_BELOG_ANOTHER_COMPANY: 'entity.belongs.another.company',
-    COMPANY_NO_ACCESS: 'auth.company.no.access'
-};
-// ==================== ERROR (HTTP Exceptions) ====================
-const ERROR_MESSAGES = {
-    NOT_FOUND: 'error.not.found',
-    VALIDATION: 'error.validation',
-    UNAUTHORIZED: 'error.unauthorized',
-    FORBIDDEN: 'error.forbidden',
-    CONFLICT: 'error.conflict',
-    DB_FOREIGN_KEY: 'error.db.foreign.key',
-    DB_NOT_NULL: 'error.db.not.null',
-    DB_INVALID_INPUT: 'error.db.invalid.input',
-    DB_VALUE_TOO_LONG: 'error.db.value.too.long',
-    DB_CHECK_CONSTRAINT: 'error.db.check.constraint',
-    DB_DEADLOCK: 'error.db.deadlock',
-    INTERNAL: 'error.internal',
-    SERVICE_UNAVAILABLE: 'error.service.unavailable',
-    UNKNOWN: 'error.unknown',
-    HTTP: 'error.http',
-    GENERIC: 'error.generic',
-    PERMISSION_SYSTEM_UNAVAILABLE: 'error.permission.system.unavailable',
-    INSUFFICIENT_PERMISSIONS: 'error.insufficient.permissions',
-    INSUFFICIENT_PERMISSIONS_OR: 'error.insufficient.permissions.or',
-    NO_PERMISSIONS_FOUND: 'error.no.permissions.found',
-    ENDPOINT_DISABLED: 'error.endpoint.disabled'
-};
-// ==================== SYSTEM (Infrastructure) ====================
-const SYSTEM_MESSAGES = {
-    REPOSITORY_NOT_AVAILABLE: 'system.repository.not.available',
-    DATASOURCE_NOT_AVAILABLE: 'system.datasource.not.available',
-    DATABASE_CONFIG_NOT_AVAILABLE: 'system.database.config.not.available',
-    SERVICE_NOT_AVAILABLE: 'system.service.not.available',
-    CONFIG_REQUIRED: 'system.config.required',
-    INTERNAL_ERROR: 'system.internal.error',
-    DUPLICATE_REQUEST: 'system.duplicate.request',
-    INVALID_TENANT_ID: 'system.invalid.tenant.id',
-    TENANT_NOT_FOUND: 'system.tenant.not.found',
-    TENANT_HEADER_REQUIRED: 'system.tenant.header.required',
-    MISSING_PARAMETER: 'system.missing.parameter',
-    SDK_NOT_INSTALLED: 'system.sdk.not.installed',
-    PATH_TRAVERSAL_DETECTED: 'system.path.traversal.detected',
-    INVALID_FILE_KEY: 'system.invalid.file.key'
-};
-
-__webpack_require__.d(__webpack_exports__, {
-}, {
-  UU: ERROR_MESSAGES,
-  hg: SYSTEM_MESSAGES,
-  mK: AUTH_MESSAGES
-});
-
-
-},
-975(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-// ==================== AUTH MODULE ====================
-const USER_PERMISSIONS = {
-    CREATE: 'user.create',
-    READ: 'user.read',
-    UPDATE: 'user.update',
-    DELETE: 'user.delete',
-    LOOKUP: 'user.lookup'
-};
-const COMPANY_PERMISSIONS = {
-    CREATE: 'company.create',
-    READ: 'company.read',
-    UPDATE: 'company.update',
-    DELETE: 'company.delete'
-};
-const BRANCH_PERMISSIONS = {
-    CREATE: 'branch.create',
-    READ: 'branch.read',
-    UPDATE: 'branch.update',
-    DELETE: 'branch.delete'
-};
-const SOCIAL_AUTH_CONFIG_PERMISSIONS = {
-    CREATE: 'social-config.create',
-    READ: 'social-config.read',
-    UPDATE: 'social-config.update',
-    DELETE: 'social-config.delete'
-};
-// ==================== IAM MODULE ====================
-const ACTION_PERMISSIONS = {
-    CREATE: 'action.create',
-    READ: 'action.read',
-    UPDATE: 'action.update',
-    DELETE: 'action.delete'
-};
-const ROLE_PERMISSIONS = {
-    CREATE: 'role.create',
-    READ: 'role.read',
-    UPDATE: 'role.update',
-    DELETE: 'role.delete'
-};
-const ROLE_ACTION_PERMISSIONS = {
-    READ: 'role-action.read',
-    ASSIGN: 'role-action.assign'
-};
-const USER_ROLE_PERMISSIONS = {
-    READ: 'user-role.read',
-    ASSIGN: 'user-role.assign'
-};
-const USER_ACTION_PERMISSIONS = {
-    READ: 'user-action.read',
-    ASSIGN: 'user-action.assign'
-};
-const COMPANY_ACTION_PERMISSIONS = {
-    READ: 'company-action.read',
-    ASSIGN: 'company-action.assign'
-};
-// ==================== STORAGE MODULE ====================
-const FILE_PERMISSIONS = {
-    CREATE: 'file.create',
-    READ: 'file.read',
-    UPDATE: 'file.update',
-    DELETE: 'file.delete',
-    VIEW_PRIVATE_ACTION: 'file.view.private'
-};
-const FOLDER_PERMISSIONS = {
-    CREATE: 'folder.create',
-    READ: 'folder.read',
-    UPDATE: 'folder.update',
-    DELETE: 'folder.delete'
-};
-const STORAGE_CONFIG_PERMISSIONS = {
-    CREATE: 'storage-config.create',
-    READ: 'storage-config.read',
-    UPDATE: 'storage-config.update',
-    DELETE: 'storage-config.delete'
-};
-const UPLOAD_CONFIG_PERMISSIONS = {
-    DELETE: 'upload-config.delete'
-};
-// ==================== EMAIL MODULE ====================
-const EMAIL_CONFIG_PERMISSIONS = {
-    CREATE: 'email-config.create',
-    READ: 'email-config.read',
-    UPDATE: 'email-config.update',
-    DELETE: 'email-config.delete'
-};
-const EMAIL_TEMPLATE_PERMISSIONS = {
-    CREATE: 'email-template.create',
-    READ: 'email-template.read',
-    UPDATE: 'email-template.update',
-    DELETE: 'email-template.delete'
-};
-// ==================== FORM BUILDER MODULE ====================
-const FORM_PERMISSIONS = {
-    CREATE: 'form.create',
-    READ: 'form.read',
-    UPDATE: 'form.update',
-    DELETE: 'form.delete'
-};
-const FORM_RESULT_PERMISSIONS = {
-    CREATE: 'form-result.create',
-    READ: 'form-result.read',
-    UPDATE: 'form-result.update',
-    DELETE: 'form-result.delete'
-};
-// ==================== ENTITY BUILDER MODULE ====================
-// Static metadata permissions only. Per-dynamic-entity record permissions
-// (`entity_builder.entity.<entityCode>.<action>`) are checked by flows running as the caller;
-// ENTITY_BUILDER_ALL_DYNAMIC is the wildcard that grants all of them (and nothing else).
-const ENTITY_DEFINITION_PERMISSIONS = {
-    CREATE: 'entity_builder.entity_definition.create',
-    READ: 'entity_builder.entity_definition.read',
-    UPDATE: 'entity_builder.entity_definition.update',
-    DELETE: 'entity_builder.entity_definition.delete'
-};
-const FIELD_DEFINITION_PERMISSIONS = {
-    READ: 'entity_builder.field_definition.read',
-    UPDATE: 'entity_builder.field_definition.update'
-};
-const FLOW_DEFINITION_PERMISSIONS = {
-    CREATE: 'entity_builder.flow_definition.create',
-    READ: 'entity_builder.flow_definition.read',
-    UPDATE: 'entity_builder.flow_definition.update',
-    DELETE: 'entity_builder.flow_definition.delete',
-    TEST: 'entity_builder.flow_definition.test',
-    /** Needed to save a flow containing a code node (sandboxed JavaScript). */ CODE: 'entity_builder.flow_definition.code'
-};
-const ENTITY_BUILDER_DYNAMIC_PREFIX = 'entity_builder.entity';
-const ENTITY_BUILDER_ALL_DYNAMIC = {
-    ALL: `${ENTITY_BUILDER_DYNAMIC_PREFIX}.*`
-};
-const dynamicEntityPermissionParent = (entityCode)=>`${ENTITY_BUILDER_DYNAMIC_PREFIX}.${entityCode}`;
-const dynamicEntityPermission = (entityCode, action)=>`${dynamicEntityPermissionParent(entityCode)}.${action}`;
-// ==================== EVENT MANAGER MODULE ====================
-const EVENT_PERMISSIONS = {
-    CREATE: 'event.create',
-    READ: 'event.read',
-    UPDATE: 'event.update',
-    DELETE: 'event.delete'
-};
-// ==================== NOTIFICATION MODULE ====================
-const NOTIFICATION_PERMISSIONS = {
-    CREATE: 'notification.create',
-    READ: 'notification.read',
-    UPDATE: 'notification.update',
-    DELETE: 'notification.delete'
-};
-// ==================== LOCALIZATION MODULE ====================
-const LANGUAGE_PERMISSIONS = {
-    CREATE: 'language.create',
-    READ: 'language.read',
-    UPDATE: 'language.update',
-    DELETE: 'language.delete'
-};
-const TRANSLATION_KEY_PERMISSIONS = {
-    CREATE: 'translation-key.create',
-    READ: 'translation-key.read',
-    UPDATE: 'translation-key.update',
-    DELETE: 'translation-key.delete'
-};
-const TRANSLATION_PERMISSIONS = {
-    CREATE: 'translation.create',
-    READ: 'translation.read',
-    UPDATE: 'translation.update',
-    DELETE: 'translation.delete'
-};
-// ==================== TASK MANAGER MODULE ====================
-const TASK_BOARD_PERMISSIONS = {
-    CREATE: 'task-board.create',
-    READ: 'task-board.read',
-    UPDATE: 'task-board.update',
-    DELETE: 'task-board.delete',
-    MANAGE_MEMBERS: 'task-board.manage-members'
-};
-const TASK_LIST_PERMISSIONS = {
-    CREATE: 'task-list.create',
-    READ: 'task-list.read',
-    UPDATE: 'task-list.update',
-    DELETE: 'task-list.delete'
-};
-const TASK_PERMISSIONS = {
-    CREATE: 'task.create',
-    READ: 'task.read',
-    UPDATE: 'task.update',
-    DELETE: 'task.delete',
-    MOVE: 'task.move',
-    ASSIGN: 'task.assign'
-};
-const TASK_LABEL_PERMISSIONS = {
-    CREATE: 'task-label.create',
-    READ: 'task-label.read',
-    UPDATE: 'task-label.update',
-    DELETE: 'task-label.delete'
-};
-const TASK_COMMENT_PERMISSIONS = {
-    CREATE: 'task-comment.create',
-    READ: 'task-comment.read',
-    DELETE: 'task-comment.delete'
-};
-// ==================== AI ASSISTANT MODULE ====================
-const AI_ASSISTANT_PERMISSIONS = {
-    VIEW_ALL_HISTORY: 'ai-assistant.view-all-history'
-};
-// ==================== AGGREGATED EXPORTS ====================
-const PERMISSIONS = {
-    // Auth
-    USER: USER_PERMISSIONS,
-    COMPANY: COMPANY_PERMISSIONS,
-    BRANCH: BRANCH_PERMISSIONS,
-    SOCIAL_AUTH_CONFIG: SOCIAL_AUTH_CONFIG_PERMISSIONS,
-    // IAM
-    ACTION: ACTION_PERMISSIONS,
-    ROLE: ROLE_PERMISSIONS,
-    ROLE_ACTION: ROLE_ACTION_PERMISSIONS,
-    USER_ROLE: USER_ROLE_PERMISSIONS,
-    USER_ACTION: USER_ACTION_PERMISSIONS,
-    COMPANY_ACTION: COMPANY_ACTION_PERMISSIONS,
-    // Storage
-    FILE: FILE_PERMISSIONS,
-    FOLDER: FOLDER_PERMISSIONS,
-    STORAGE_CONFIG: STORAGE_CONFIG_PERMISSIONS,
-    // Email
-    EMAIL_CONFIG: EMAIL_CONFIG_PERMISSIONS,
-    EMAIL_TEMPLATE: EMAIL_TEMPLATE_PERMISSIONS,
-    // Form Builder
-    FORM: FORM_PERMISSIONS,
-    FORM_RESULT: FORM_RESULT_PERMISSIONS,
-    // Entity Builder
-    ENTITY_DEFINITION: ENTITY_DEFINITION_PERMISSIONS,
-    FIELD_DEFINITION: FIELD_DEFINITION_PERMISSIONS,
-    FLOW_DEFINITION: FLOW_DEFINITION_PERMISSIONS,
-    ENTITY_BUILDER_ALL_DYNAMIC: ENTITY_BUILDER_ALL_DYNAMIC,
-    // Event Manager
-    EVENT: EVENT_PERMISSIONS,
-    // Notification
-    NOTIFICATION: NOTIFICATION_PERMISSIONS,
-    // Localization
-    LANGUAGE: LANGUAGE_PERMISSIONS,
-    TRANSLATION_KEY: TRANSLATION_KEY_PERMISSIONS,
-    TRANSLATION: TRANSLATION_PERMISSIONS,
-    // Task Manager
-    TASK_BOARD: TASK_BOARD_PERMISSIONS,
-    TASK_LIST: TASK_LIST_PERMISSIONS,
-    TASK: TASK_PERMISSIONS,
-    TASK_LABEL: TASK_LABEL_PERMISSIONS,
-    TASK_COMMENT: TASK_COMMENT_PERMISSIONS,
-    // AI Assistant
-    AI_ASSISTANT: AI_ASSISTANT_PERMISSIONS
-};
-
-__webpack_require__.d(__webpack_exports__, {
-}, {
-  BC: USER_PERMISSIONS,
-  Bz: AI_ASSISTANT_PERMISSIONS,
-  DP: ENTITY_DEFINITION_PERMISSIONS,
-  Em: STORAGE_CONFIG_PERMISSIONS,
-  G0: ENTITY_BUILDER_ALL_DYNAMIC,
-  GH: dynamicEntityPermissionParent,
-  GT: FORM_RESULT_PERMISSIONS,
-  Jj: PERMISSIONS,
-  N3: TRANSLATION_KEY_PERMISSIONS,
-  ON: TASK_LIST_PERMISSIONS,
-  P0: ROLE_ACTION_PERMISSIONS,
-  Q5: LANGUAGE_PERMISSIONS,
-  S6: FILE_PERMISSIONS,
-  T: TASK_PERMISSIONS,
-  UB: UPLOAD_CONFIG_PERMISSIONS,
-  UG: TASK_LABEL_PERMISSIONS,
-  Ub: EVENT_PERMISSIONS,
-  V0: EMAIL_CONFIG_PERMISSIONS,
-  Wc: FORM_PERMISSIONS,
-  Y3: TASK_BOARD_PERMISSIONS,
-  Y7: ACTION_PERMISSIONS,
-  _X: USER_ACTION_PERMISSIONS,
-  aO: COMPANY_ACTION_PERMISSIONS,
-  aT: dynamicEntityPermission,
-  fS: TRANSLATION_PERMISSIONS,
-  kA: FIELD_DEFINITION_PERMISSIONS,
-  kd: FLOW_DEFINITION_PERMISSIONS,
-  l3: SOCIAL_AUTH_CONFIG_PERMISSIONS,
-  mV: ROLE_PERMISSIONS,
-  rH: NOTIFICATION_PERMISSIONS,
-  t$: COMPANY_PERMISSIONS,
-  w7: USER_ROLE_PERMISSIONS,
-  wA: BRANCH_PERMISSIONS,
-  wM: FOLDER_PERMISSIONS,
-  z$: EMAIL_TEMPLATE_PERMISSIONS,
-  zd: TASK_COMMENT_PERMISSIONS
-});
-
-
-},
-863(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+6863(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -546,11 +202,12 @@ __webpack_require__.d(__webpack_exports__, {
   Ul: () => (/* reexport */ SetDeletedByOnBody),
   _x: () => (/* reexport */ SetUpdateByOnBody),
   Mw: () => (/* reexport */ Slug),
+  NM: () => (/* reexport */ buildIdempotencyCacheKey),
   BR: () => (/* reexport */ createSetUserFieldInterceptor)
 });
 
 // EXTERNAL MODULE: external "@nestjs/common"
-var common_ = __webpack_require__(157);
+var common_ = __webpack_require__(6157);
 ;// CONCATENATED MODULE: ./projects/nestjs-shared/src/interceptors/delete-empty-id-from-body.interceptor.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;
@@ -569,19 +226,13 @@ function _ts_decorate(decorators, target, key, desc) {
 class DeleteEmptyIdFromBodyInterceptor {
     intercept(context, next) {
         const request = context.switchToHttp().getRequest();
-        if (Array.isArray(request.body)) {
-            request.body = request.body.map((item)=>{
-                if (!item?.id || item?.id === '' || item?.id === null) {
-                    delete item.id;
-                }
-                return item;
-            });
-        } else if (typeof request.body === 'object' && request.body !== null) {
-            const item = request.body;
-            if (!item?.id || item?.id === '' || item?.id === null) {
-                delete item.id;
+        const items = Array.isArray(request.body) ? request.body : [
+            request.body
+        ];
+        for (const item of items){
+            if (typeof item === 'object' && item !== null && !item['id']) {
+                delete item['id'];
             }
-            request.body = item;
         }
         return next.handle();
     }
@@ -595,9 +246,11 @@ DeleteEmptyIdFromBodyInterceptor = _ts_decorate([
 ;// CONCATENATED MODULE: external "rxjs/operators"
 
 // EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/hybrid-cache.class.ts + 3 modules
-var hybrid_cache_class = __webpack_require__(375);
+var hybrid_cache_class = __webpack_require__(5375);
 // EXTERNAL MODULE: ./projects/nestjs-shared/src/constants/index.ts
-var constants = __webpack_require__(43);
+var constants = __webpack_require__(6043);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/middlewares/logger.middleware.ts + 1 modules
+var logger_middleware = __webpack_require__(8244);
 ;// CONCATENATED MODULE: ./projects/nestjs-shared/src/interceptors/idempotency.interceptor.ts
 function idempotency_interceptor_ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -627,47 +280,54 @@ function _ts_param(paramIndex, decorator) {
 
 
 
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+/** Bounds how long a crashed instance can hold a key; no request runs this long */ const PROCESSING_TTL_MS = 10 * 60 * 1000;
+/**
+ * Replays the stored response for a repeated `X-Idempotency-Key`. A key only ever replays for the
+ * same tenant, user and endpoint, and a failed request releases it so the client can retry.
+ */ function buildIdempotencyCacheKey(request, idempotencyKey) {
+    const tenant = (0,logger_middleware/* .getTenantId */.EO)() ?? '-';
+    const user = request.user?.id ?? 'anonymous';
+    const endpoint = `${request.method ?? ''} ${request.route?.path ?? request.originalUrl ?? request.url ?? ''}`;
+    return `${constants/* .IDEMPOTENCY_CACHE_PREFIX */.mg}:${tenant}:${user}:${endpoint}:${idempotencyKey}`;
+}
 class IdempotencyInterceptor {
     cache;
-    CACHE_TTL = 24 * 60 * 60 * 1000;
-    PROCESSING_MARKER = '__PROCESSING__';
     constructor(cache){
         this.cache = cache;
     }
     async intercept(context, next) {
-        // Skip if no cache available
-        if (!this.cache) {
-            return next.handle();
-        }
+        const cache = this.cache;
+        if (!cache) return next.handle();
         const request = context.switchToHttp().getRequest();
         const idempotencyKey = request.headers[constants/* .IDEMPOTENCY_KEY_HEADER */.iH];
-        // Skip if no idempotency key provided
-        if (!idempotencyKey) {
-            return next.handle();
+        if (!idempotencyKey || typeof idempotencyKey !== 'string') return next.handle();
+        const cacheKey = buildIdempotencyCacheKey(request, idempotencyKey);
+        const stored = await cache.get(cacheKey, {
+            skipMemory: true
+        });
+        if (stored !== undefined) return (0,__rspack_external_rxjs.of)(stored);
+        // Atomic across instances: of two concurrent requests with one key, exactly one runs
+        if (!await cache.claim(cacheKey, PROCESSING_TTL_MS)) {
+            throw new common_.ConflictException({
+                success: false,
+                message: 'Request is already being processed',
+                messageKey: constants/* .SYSTEM_MESSAGES.DUPLICATE_REQUEST */.hg.DUPLICATE_REQUEST
+            });
         }
-        const cacheKey = `${constants/* .IDEMPOTENCY_CACHE_PREFIX */.mg}:${idempotencyKey}`;
-        // Check if request already exists
-        const cached = await this.cache.get(cacheKey);
-        if (cached) {
-            // If still processing, throw conflict
-            if (cached === this.PROCESSING_MARKER) {
-                throw new common_.ConflictException({
-                    success: false,
-                    message: 'Request is already being processed',
-                    messageKey: constants/* .SYSTEM_MESSAGES.DUPLICATE_REQUEST */.hg.DUPLICATE_REQUEST
-                });
-            }
-            // Return cached response
-            return (0,__rspack_external_rxjs.of)(cached);
+        const release = ()=>cache.releaseClaim(cacheKey).catch(()=>undefined);
+        // The first request may have stored its response and released the claim between our read and claim
+        const storedMeanwhile = await cache.get(cacheKey, {
+            skipMemory: true
+        }).catch(()=>undefined);
+        if (storedMeanwhile !== undefined) {
+            await release();
+            return (0,__rspack_external_rxjs.of)(storedMeanwhile);
         }
-        // Mark as processing
-        const cache = this.cache;
-        await cache.set(cacheKey, this.PROCESSING_MARKER, this.CACHE_TTL);
-        // Process request and cache response
-        return next.handle().pipe((0,__rspack_external_rxjs_operators_2eaa0997.tap)(async (response)=>{
-            // Cache the successful response
-            await cache.set(cacheKey, response, this.CACHE_TTL);
-        }));
+        return next.handle().pipe((0,__rspack_external_rxjs_operators_2eaa0997.concatMap)((response)=>(0,__rspack_external_rxjs.from)(cache.set(cacheKey, response, CACHE_TTL_MS, {
+                skipMemory: true
+            }).catch(()=>undefined).then(release).then(()=>response))), (0,__rspack_external_rxjs_operators_2eaa0997.catchError)((error)=>(0,__rspack_external_rxjs.from)(release()).pipe((0,__rspack_external_rxjs_operators_2eaa0997.concatMap)(()=>(0,__rspack_external_rxjs.throwError)(()=>error)))));
     }
 }
 IdempotencyInterceptor = idempotency_interceptor_ts_decorate([
@@ -681,7 +341,7 @@ IdempotencyInterceptor = idempotency_interceptor_ts_decorate([
 ], IdempotencyInterceptor);
 
 // EXTERNAL MODULE: external "crypto"
-var external_crypto_ = __webpack_require__(823);
+var external_crypto_ = __webpack_require__(7823);
 ;// CONCATENATED MODULE: ./projects/nestjs-shared/src/interceptors/response-meta.interceptor.ts
 function response_meta_interceptor_ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -772,7 +432,7 @@ const SetUpdateByOnBody = createSetUserFieldInterceptor('updatedById');
 const SetDeletedByOnBody = createSetUserFieldInterceptor('deletedById');
 
 // EXTERNAL MODULE: ./projects/nestjs-shared/src/modules/utils/utils.service.ts
-var utils_service = __webpack_require__(169);
+var utils_service = __webpack_require__(1169);
 ;// CONCATENATED MODULE: ./projects/nestjs-shared/src/interceptors/slug.interceptor.ts
 function slug_interceptor_ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -806,26 +466,18 @@ class Slug {
     }
     intercept(context, next) {
         const request = context.switchToHttp().getRequest();
-        if (Array.isArray(request.body)) {
-            request.body = request.body.map((item)=>{
-                // Only generate slug if not provided and name exists
-                if (!item.slug && item?.name) {
-                    return {
-                        ...item,
-                        slug: this.utilsService.transformToSlug(item.name)
-                    };
-                }
-                return item;
-            });
-        } else if (!request.body?.slug && request.body?.name) {
-            // Only generate slug if not provided and name exists
-            request.body = {
-                ...request.body,
-                slug: this.utilsService.transformToSlug(request.body.name)
-            };
-        }
+        request.body = Array.isArray(request.body) ? request.body.map((item)=>this.withSlug(item)) : this.withSlug(request.body);
         return next.handle();
     }
+    withSlug(item) {
+        if (typeof item !== 'object' || item === null || Array.isArray(item)) return item;
+        const body = item;
+        if (body['slug'] || typeof body['name'] !== 'string' || !body['name']) return item;
+        return {
+            ...body,
+            slug: this.utilsService.transformToSlug(body['name'])
+        };
+    }
 }
 Slug = slug_interceptor_ts_decorate([
     (0,common_.Injectable)(),
@@ -845,8 +497,10 @@ Slug = slug_interceptor_ts_decorate([
 
 
 },
-169(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(157);
+1169(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(6157);
+/* import */ var node_crypto__rspack_import_1 = __webpack_require__(2561);
+/* import */ var _utils_string_util_js__rspack_import_2 = __webpack_require__(3366);
 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") {
@@ -861,61 +515,42 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 
+
+
 class UtilsService {
+    logger = new _nestjs_common__rspack_import_0.Logger(UtilsService.name);
     // ---------------- CACHE HELPERS ----------------
     /**
-   * Generate cache key with optional tenant prefix for multi-tenant isolation
-   */ getCacheKey(entityName, params, entityId, tenantId) {
-        const prefix = this.buildTenantPrefix(tenantId);
-        if (entityId) {
-            return `${prefix}entity_${entityName}_id_${entityId}${params ? '_select_' + JSON.stringify(params) : ''}`;
-        }
-        return `${prefix}entity_${entityName}_all_${JSON.stringify(params)}`;
+   * The combined version stamp of every entity a cached read depends on. Read it BEFORE querying
+   * the database: a write that commits mid-read moves the stamp, so the stale result is stored
+   * under a key no later read asks for.
+   */ async getCacheStamp(cacheManager, entityNames, tenantId) {
+        const stamps = await Promise.all(entityNames.map((name)=>cacheManager.getStamp(this.getStampName(name, tenantId))));
+        return stamps.join('.');
     }
-    /**
-   * Track cache key for later invalidation with optional tenant prefix
-   */ async trackCacheKey(cacheKey, entityName, cacheManager, entityId, tenantId) {
-        try {
-            const trackingKey = this.buildTrackingKey(entityName, entityId, tenantId);
-            const keys = await cacheManager.get(trackingKey) || [];
-            if (!keys.includes(cacheKey)) keys.push(cacheKey);
-            await cacheManager.set(trackingKey, keys);
-        } catch  {
-        // Silent failure - cache tracking is non-critical
-        }
+    getCacheKey(entityName, params, entityId, tenantId, stamp) {
+        const scope = entityId ? `id_${entityId}` : 'all';
+        const digest = (0,node_crypto__rspack_import_1.createHash)('sha256').update(JSON.stringify(params ?? null)).digest('hex');
+        return `${this.buildTenantPrefix(tenantId)}entity_${entityName}_${scope}_${stamp}_${digest}`;
     }
-    /**
-   * Clear cache for entity with optional tenant prefix
-   */ async clearCache(entityName, cacheManager, entityId, tenantId) {
+    /** Invalidates every cached list and row of `entityName` in the tenant, on every instance */ async clearCache(entityName, cacheManager, tenantId) {
         try {
-            const trackingKey = this.buildTrackingKey(entityName, entityId, tenantId);
-            const keys = await cacheManager.get(trackingKey) || [];
-            await Promise.allSettled(keys.map((key)=>cacheManager.del(key)));
-            await cacheManager.del(trackingKey);
-        } catch  {
-        // Silent failure - cache invalidation is non-critical
+            await cacheManager.bumpStamp(this.getStampName(entityName, tenantId));
+        } catch (error) {
+            this.logger.error(`Cache invalidation failed for '${entityName}': ${error.message}`);
         }
     }
-    // ---------------- STRING HELPERS ----------------
-    /**
-   * Transform string to URL-friendly slug
-   */ transformToSlug(value, salt) {
-        const slug = value?.trim().replace(/[^A-Z0-9]+/gi, '-').toLowerCase();
-        return salt ? `${slug}-${this.getRandomInt(1, 100)}` : slug;
+    /** The stamp `clearCache` bumps; for callers that must see the bump fail instead of having it logged */ getStampName(entityName, tenantId) {
+        return `${this.buildTenantPrefix(tenantId)}entity_${entityName}`;
     }
-    /**
-   * Generate random integer between min and max (inclusive)
-   */ getRandomInt(min, max) {
-        return Math.floor(Math.random() * (max - min + 1)) + min;
+    // ---------------- STRING HELPERS ----------------
+    transformToSlug(value) {
+        return (0,_utils_string_util_js__rspack_import_2/* .generateSlug */.z)(value);
     }
     // ---------------- PRIVATE HELPERS ----------------
     buildTenantPrefix(tenantId) {
         return tenantId ? `tenant_${tenantId}_` : '';
     }
-    buildTrackingKey(entityName, entityId, tenantId) {
-        const prefix = this.buildTenantPrefix(tenantId);
-        return entityId ? `${prefix}entity_${entityName}_id_${entityId}_keys` : `${prefix}entity_${entityName}_keys`;
-    }
 }
 UtilsService = _ts_decorate([
     (0,_nestjs_common__rspack_import_0.Injectable)()
@@ -927,19 +562,81 @@ __webpack_require__.d(__webpack_exports__, {
 
 
 },
-307(module) {
-
-module.exports = __rspack_external__flusys_nestjs_core_config_197fa0a9;
-
-
-},
-157(module) {
+3366(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * URL-friendly slug: lower case, words joined by single hyphens. Latin accents are folded
+ * (`Café` -> `cafe`) and letters of other scripts are kept, so a non-Latin name never
+ * collapses to an empty slug. Never starts or ends with a hyphen, also after truncation.
+ *
+ * @example
+ * generateSlug('My Company Name') // 'my-company-name'
+ * generateSlug('Hello World!') // 'hello-world'
+ */ function generateSlug(text, maxLength = 100) {
+    const slug = text.normalize('NFKD').toLowerCase().replace(/([a-z0-9])\p{M}+/gu, '$1').replace(/[^\p{L}\p{N}\p{M}\s-]/gu, '').trim().replace(/[\s-]+/g, '-').replace(/^-+|-+$/g, '').normalize('NFC');
+    return Array.from(slug).slice(0, Math.max(maxLength, 0)).join('').replace(/-+$/, '');
+}
+/**
+ * Generate unique slug using single database query (optimized for large datasets)
+ * Appends numeric suffix if collision exists (e.g., 'my-company-1', 'my-company-2')
+ *
+ * Performance: O(1) database query regardless of collision count
+ * - Works efficiently with millions of records
+ * - Requires index on slug column for best performance
+ *
+ * @param text - The text to convert to slug
+ * @param findMatchingSlugs - Async function that returns all slugs matching base pattern
+ *                            Should query: WHERE slug = baseSlug OR slug LIKE 'baseSlug-%'
+ * @param maxLength - Maximum length of the base slug (default: 100)
+ * @returns Unique URL-friendly slug
+ *
+ * @example
+ * const slug = await generateUniqueSlug('My Company', async (baseSlug) => {
+ *   return repo
+ *     .createQueryBuilder('c')
+ *     .select('c.slug')
+ *     .where('c.slug = :base OR c.slug LIKE :pattern', {
+ *       base: baseSlug,
+ *       pattern: `${baseSlug}-%`,
+ *     })
+ *     .getMany()
+ *     .then(rows => rows.map(r => r.slug));
+ * });
+ */ async function generateUniqueSlug(text, findMatchingSlugs, maxLength = 100) {
+    const baseSlug = generateSlug(text, maxLength);
+    // Single query to get all matching slugs
+    const existingSlugs = await findMatchingSlugs(baseSlug);
+    // No collisions - base slug is available
+    if (existingSlugs.length === 0) {
+        return baseSlug;
+    }
+    // Build set for O(1) lookup
+    const existingSet = new Set(existingSlugs);
+    // Base slug not taken (only suffixed versions exist)
+    if (!existingSet.has(baseSlug)) {
+        return baseSlug;
+    }
+    // Find next available suffix in memory (fast)
+    let counter = 1;
+    while(counter < 10000){
+        const slugWithSuffix = `${baseSlug}-${counter}`;
+        if (!existingSet.has(slugWithSuffix)) {
+            return slugWithSuffix;
+        }
+        counter++;
+    }
+    // Fallback: append random string (extremely rare edge case)
+    const randomSuffix = Math.random().toString(36).substring(2, 8);
+    return `${baseSlug}-${randomSuffix}`;
+}
 
-module.exports = __rspack_external__nestjs_common_a04939da;
+__webpack_require__.d(__webpack_exports__, {
+  o: () => (generateUniqueSlug),
+  z: () => (generateSlug)
+});
 
 
 },
-823(module) {
+7823(module) {
 
 module.exports = __rspack_external_crypto;
 
@@ -949,14 +646,17 @@ module.exports = __rspack_external_crypto;
 };
 import { __webpack_require__ } from '../runtime.js';
 var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); }
-import * as __rspack_chunk_1 from './index.js';
+import * as __rspack_chunk_1 from '../997.js';
 __webpack_require__.C(__rspack_chunk_1);
-var __webpack_exports__ = __webpack_exec__(863);var __webpack_exports__DeleteEmptyIdFromBodyInterceptor = __webpack_exports__.nd;
+import * as __rspack_chunk_2 from './index.js';
+__webpack_require__.C(__rspack_chunk_2);
+var __webpack_exports__ = __webpack_exec__(6863);var __webpack_exports__DeleteEmptyIdFromBodyInterceptor = __webpack_exports__.nd;
 var __webpack_exports__IdempotencyInterceptor = __webpack_exports__.Bw;
 var __webpack_exports__ResponseMetaInterceptor = __webpack_exports__.c_;
 var __webpack_exports__SetCreatedByOnBody = __webpack_exports__.VS;
 var __webpack_exports__SetDeletedByOnBody = __webpack_exports__.Ul;
 var __webpack_exports__SetUpdateByOnBody = __webpack_exports__._x;
 var __webpack_exports__Slug = __webpack_exports__.Mw;
+var __webpack_exports__buildIdempotencyCacheKey = __webpack_exports__.NM;
 var __webpack_exports__createSetUserFieldInterceptor = __webpack_exports__.BR;
-export { __webpack_exports__DeleteEmptyIdFromBodyInterceptor as DeleteEmptyIdFromBodyInterceptor, __webpack_exports__IdempotencyInterceptor as IdempotencyInterceptor, __webpack_exports__ResponseMetaInterceptor as ResponseMetaInterceptor, __webpack_exports__SetCreatedByOnBody as SetCreatedByOnBody, __webpack_exports__SetDeletedByOnBody as SetDeletedByOnBody, __webpack_exports__SetUpdateByOnBody as SetUpdateByOnBody, __webpack_exports__Slug as Slug, __webpack_exports__createSetUserFieldInterceptor as createSetUserFieldInterceptor };
+export { __webpack_exports__DeleteEmptyIdFromBodyInterceptor as DeleteEmptyIdFromBodyInterceptor, __webpack_exports__IdempotencyInterceptor as IdempotencyInterceptor, __webpack_exports__ResponseMetaInterceptor as ResponseMetaInterceptor, __webpack_exports__SetCreatedByOnBody as SetCreatedByOnBody, __webpack_exports__SetDeletedByOnBody as SetDeletedByOnBody, __webpack_exports__SetUpdateByOnBody as SetUpdateByOnBody, __webpack_exports__Slug as Slug, __webpack_exports__buildIdempotencyCacheKey as buildIdempotencyCacheKey, __webpack_exports__createSetUserFieldInterceptor as createSetUserFieldInterceptor };