@flusys/nestjs-shared 7.1.0 → 8.0.0

package/fesm/470.js

@@ -0,0 +1,2713 @@
+import * as __rspack_external_crypto from "crypto";
+import * as __rspack_external__nestjs_passport_18907953 from "@nestjs/passport";
+import * as __rspack_external_rxjs from "rxjs";
+import * as __rspack_external_rxjs_operators_2eaa0997 from "rxjs/operators";
+export const __rspack_esm_id = 470;
+export const __rspack_esm_ids = [470];
+export const __webpack_modules__ = {
+504(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_core__rspack_import_0 = __webpack_require__(436);
+
+function getJsonColumnType() {
+    const driver = _flusys_nestjs_core__rspack_import_0.envConfig.getTypeOrmConfig().type;
+    if (driver === 'postgres') return 'jsonb';
+    if (driver === 'mysql') return 'json';
+    return 'simple-json';
+}
+function getCastIntType() {
+    const driver = _flusys_nestjs_core__rspack_import_0.envConfig.getTypeOrmConfig().type;
+    return driver === 'postgres' ? 'INTEGER' : 'UNSIGNED';
+}
+/**
+ * Converts MySQL-style `?` placeholders to PostgreSQL `$1, $2, ...` placeholders.
+ * No-op for MySQL/MariaDB.
+ */ function buildQuery(sql, dbType) {
+    if (dbType !== 'postgres') return sql;
+    let index = 0;
+    return sql.replace(/\?/g, ()=>`$${++index}`);
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  Tj: () => (getCastIntType),
+  Zq: () => (buildQuery),
+  pf: () => (getJsonColumnType)
+});
+
+
+},
+405(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  Y7: () => (/* reexport */ permissions/* .ACTION_PERMISSIONS */.Y7),
+  Bz: () => (/* reexport */ permissions/* .AI_ASSISTANT_PERMISSIONS */.Bz),
+  Gf: () => (/* reexport */ ApiService),
+  wA: () => (/* reexport */ permissions/* .BRANCH_PERMISSIONS */.wA),
+  aO: () => (/* reexport */ permissions/* .COMPANY_ACTION_PERMISSIONS */.aO),
+  t$: () => (/* reexport */ permissions/* .COMPANY_PERMISSIONS */.t$),
+  xC: () => (/* reexport */ (/* inlined export .DOMAIN_EVENT_VERSION */1)),
+  XI: () => (/* reexport */ disabled_event_bus_class/* .DisabledEventBus */.X),
+  V0: () => (/* reexport */ permissions/* .EMAIL_CONFIG_PERMISSIONS */.V0),
+  z$: () => (/* reexport */ permissions/* .EMAIL_TEMPLATE_PERMISSIONS */.z$),
+  Ub: () => (/* reexport */ permissions/* .EVENT_PERMISSIONS */.Ub),
+  qS: () => (/* reexport */ event_bus_registry/* .EventBusRegistry */.q),
+  Pm: () => (/* reexport */ event_transport_registry/* .EventTransportRegistry */.P),
+  S6: () => (/* reexport */ permissions/* .FILE_PERMISSIONS */.S6),
+  wM: () => (/* reexport */ permissions/* .FOLDER_PERMISSIONS */.wM),
+  Wc: () => (/* reexport */ permissions/* .FORM_PERMISSIONS */.Wc),
+  GT: () => (/* reexport */ permissions/* .FORM_RESULT_PERMISSIONS */.GT),
+  lx: () => (/* reexport */ hybrid_cache_class/* .HybridCache */.l),
+  Zk: () => (/* reexport */ hybrid_event_bus_class/* .HybridEventBus */.Z),
+  Q5: () => (/* reexport */ permissions/* .LANGUAGE_PERMISSIONS */.Q5),
+  PS: () => (/* reexport */ memory_transport/* .MemoryTransport */.P),
+  rH: () => (/* reexport */ permissions/* .NOTIFICATION_PERMISSIONS */.rH),
+  Jj: () => (/* reexport */ permissions/* .PERMISSIONS */.Jj),
+  P0: () => (/* reexport */ permissions/* .ROLE_ACTION_PERMISSIONS */.P0),
+  mV: () => (/* reexport */ permissions/* .ROLE_PERMISSIONS */.mV),
+  l3: () => (/* reexport */ permissions/* .SOCIAL_AUTH_CONFIG_PERMISSIONS */.l3),
+  Em: () => (/* reexport */ permissions/* .STORAGE_CONFIG_PERMISSIONS */.Em),
+  Y3: () => (/* reexport */ permissions/* .TASK_BOARD_PERMISSIONS */.Y3),
+  zd: () => (/* reexport */ permissions/* .TASK_COMMENT_PERMISSIONS */.zd),
+  UG: () => (/* reexport */ permissions/* .TASK_LABEL_PERMISSIONS */.UG),
+  ON: () => (/* reexport */ permissions/* .TASK_LIST_PERMISSIONS */.ON),
+  T: () => (/* reexport */ permissions/* .TASK_PERMISSIONS */.T),
+  N3: () => (/* reexport */ permissions/* .TRANSLATION_KEY_PERMISSIONS */.N3),
+  fS: () => (/* reexport */ permissions/* .TRANSLATION_PERMISSIONS */.fS),
+  UB: () => (/* reexport */ permissions/* .UPLOAD_CONFIG_PERMISSIONS */.UB),
+  _X: () => (/* reexport */ permissions/* .USER_ACTION_PERMISSIONS */._X),
+  BC: () => (/* reexport */ permissions/* .USER_PERMISSIONS */.BC),
+  w7: () => (/* reexport */ permissions/* .USER_ROLE_PERMISSIONS */.w7),
+  rv: () => (/* reexport */ buildDomainEvent),
+  Zq: () => (/* reexport */ handle_custome_db/* .buildQuery */.Zq),
+  RD: () => (/* reexport */ createApiController),
+  Xv: () => (/* reexport */ winston_logger_class/* .createModuleLogger */.X),
+  Tj: () => (/* reexport */ handle_custome_db/* .getCastIntType */.Tj),
+  pf: () => (/* reexport */ handle_custome_db/* .getJsonColumnType */.pf),
+  KJ: () => (/* reexport */ winston_logger_class/* .instance */.K),
+  wT: () => (/* reexport */ publishDomainEvent)
+});
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: external "@nestjs/swagger"
+var swagger_ = __webpack_require__(176);
+// EXTERNAL MODULE: external "class-transformer"
+var external_class_transformer_ = __webpack_require__(812);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/constants/message-keys.ts
+var message_keys = __webpack_require__(389);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/decorators/index.ts + 4 modules
+var src_decorators = __webpack_require__(523);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/decorators/api-response.decorator.ts
+var api_response_decorator = __webpack_require__(997);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/dtos/index.ts + 7 modules
+var src_dtos = __webpack_require__(980);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/exceptions/index.ts
+var exceptions = __webpack_require__(448);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/guards/index.ts + 4 modules
+var guards = __webpack_require__(510);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/interceptors/index.ts + 7 modules
+var interceptors = __webpack_require__(863);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/classes/api-controller.class.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);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+/**
+ * Helper to normalize security config
+ */ function normalizeSecurity(config) {
+    if (!config) return {
+        level: 'public'
+    };
+    if (typeof config === 'string') return {
+        level: config
+    };
+    return config;
+}
+/**
+ * Helper to check if endpoint is enabled
+ */ function isEndpointEnabled(endpoint, enabledEndpoints) {
+    if (!enabledEndpoints || enabledEndpoints === 'all') return true;
+    return enabledEndpoints.includes(endpoint);
+}
+/**
+ * Helper to conditionally exclude endpoint from Swagger if disabled
+ */ function createEndpointDecorators(security, endpoint, enabledEndpoints) {
+    const decorators = [];
+    // Add security decorators
+    decorators.push(createSecurityDecorators(security));
+    // Exclude from Swagger if endpoint is disabled
+    if (!isEndpointEnabled(endpoint, enabledEndpoints)) {
+        decorators.push((0,swagger_.ApiExcludeEndpoint)());
+    }
+    return (0,common_.applyDecorators)(...decorators);
+}
+/**
+ * Creates security decorators based on configuration
+ */ function createSecurityDecorators(security) {
+    const decorators = [];
+    switch(security.level){
+        case 'public':
+            decorators.push((0,src_decorators/* .Public */.w3)());
+            break;
+        case 'jwt':
+            // Apply JWT authentication guard
+            decorators.push((0,common_.UseGuards)(guards/* .JwtAuthGuard */.TD));
+            decorators.push((0,swagger_.ApiBearerAuth)());
+            break;
+        case 'permission':
+            // Apply JWT authentication guard (required for permission checks)
+            // Apply PermissionGuard to check permissions from cache
+            decorators.push((0,common_.UseGuards)(guards/* .JwtAuthGuard */.TD, guards/* .PermissionGuard */.LQ));
+            decorators.push((0,swagger_.ApiBearerAuth)());
+            // Check for complex logic first
+            if (security.logic) {
+                decorators.push((0,src_decorators/* .RequirePermissionLogic */.rY)(security.logic));
+            } else if (security.permissions && security.permissions.length > 0) {
+                if (security.operator === 'OR') {
+                    decorators.push((0,src_decorators/* .RequireAnyPermission */.Dz)(...security.permissions));
+                } else {
+                    // AND is default and most secure
+                    decorators.push((0,src_decorators/* .RequirePermission */.Tw)(...security.permissions));
+                }
+            }
+            break;
+    }
+    return (0,common_.applyDecorators)(...decorators);
+}
+/** Creates an API Controller with standardized CRUD endpoints (POST-only RPC pattern) */ function createApiController(createDtoClass, updateDtoClass, responseDtoClass, options = {}) {
+    const excludeExtraneousValues = options.excludeExtraneousValues ?? true;
+    function toDto(cls, input) {
+        return (0,external_class_transformer_.plainToInstance)(cls, input, {
+            excludeExtraneousValues
+        });
+    }
+    // Entity name for message keys (defaults to 'item')
+    const entityName = options.entityName ?? 'item';
+    // Determine if security is global (applies to all) or per-endpoint
+    const securityConfig = options.security;
+    const endpointKeys = [
+        'insert',
+        'insertMany',
+        'getById',
+        'getByIds',
+        'getAll',
+        'bulkUpsert',
+        'getByFilter',
+        'update',
+        'updateMany',
+        'delete'
+    ];
+    // Global security if:
+    // 1. It's a string (SecurityLevel)
+    // 2. It's an object with 'level' property but no endpoint keys
+    const isGlobalSecurity = typeof securityConfig === 'string' || securityConfig && typeof securityConfig === 'object' && 'level' in securityConfig && !endpointKeys.some((key)=>key in securityConfig);
+    // Normalize security config for each endpoint
+    // IMPORTANT: When per-endpoint security is specified, default to 'jwt' for unconfigured endpoints
+    // to prevent accidentally exposing endpoints without authentication
+    const defaultSecurity = isGlobalSecurity ? normalizeSecurity(securityConfig) : {
+        level: 'jwt'
+    };
+    const security = {
+        insert: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.insert),
+        insertMany: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.insertMany),
+        getById: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.getById),
+        getByIds: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.getByIds),
+        getAll: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.getAll),
+        getByFilter: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.getByFilter),
+        bulkUpsert: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.bulkUpsert),
+        update: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.update),
+        updateMany: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.updateMany),
+        delete: isGlobalSecurity ? defaultSecurity : normalizeSecurity(securityConfig?.delete)
+    };
+    let ApiController = class ApiController {
+        service;
+        enabledEndpoints = options.enabledEndpoints ?? 'all';
+        constructor(service){
+            this.service = service;
+        }
+        isEnabled(endpoint) {
+            if (this.enabledEndpoints === 'all') return true;
+            return Array.isArray(this.enabledEndpoints) && this.enabledEndpoints.includes(endpoint);
+        }
+        async insert(addDto, user) {
+            if (!this.isEnabled('insert')) {
+                throw new exceptions/* .BaseAppException */.m8({
+                    message: `Endpoint 'insert' is disabled`,
+                    messageKey: message_keys/* .ERROR_MESSAGES.ENDPOINT_DISABLED */.UU.ENDPOINT_DISABLED,
+                    messageVariables: {
+                        endpoint: 'insert'
+                    },
+                    status: common_.HttpStatus.FORBIDDEN
+                });
+            }
+            const entity = await this.service.insert(addDto, user);
+            const data = toDto(responseDtoClass, entity);
+            return {
+                success: true,
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} created successfully`,
+                messageKey: `${entityName}.create.success`,
+                data
+            };
+        }
+        async insertMany(addDto, user) {
+            if (!this.isEnabled('insertMany')) {
+                throw new exceptions/* .BaseAppException */.m8({
+                    message: `Endpoint 'insertMany' is disabled`,
+                    messageKey: message_keys/* .ERROR_MESSAGES.ENDPOINT_DISABLED */.UU.ENDPOINT_DISABLED,
+                    messageVariables: {
+                        endpoint: 'insertMany'
+                    },
+                    status: common_.HttpStatus.FORBIDDEN
+                });
+            }
+            const entities = await this.service.insertMany(addDto, user);
+            const data = entities.map((item)=>toDto(responseDtoClass, item));
+            return {
+                success: true,
+                message: `${data.length} ${entityName}s created successfully`,
+                messageKey: `${entityName}.create.many.success`,
+                messageVariables: {
+                    count: data.length
+                },
+                data,
+                meta: {
+                    count: data.length,
+                    total: addDto.length,
+                    failed: addDto.length - data.length
+                }
+            };
+        }
+        async getById(id, body, user) {
+            if (!this.isEnabled('getById')) {
+                throw new exceptions/* .BaseAppException */.m8({
+                    message: `Endpoint 'getById' is disabled`,
+                    messageKey: message_keys/* .ERROR_MESSAGES.ENDPOINT_DISABLED */.UU.ENDPOINT_DISABLED,
+                    messageVariables: {
+                        endpoint: 'getById'
+                    },
+                    status: common_.HttpStatus.FORBIDDEN
+                });
+            }
+            const entity = await this.service.findById(id, user, body?.select);
+            const data = toDto(responseDtoClass, entity);
+            return {
+                success: true,
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} retrieved successfully`,
+                messageKey: `${entityName}.get.success`,
+                data
+            };
+        }
+        async getByIds(body, user) {
+            if (!this.isEnabled('getByIds')) {
+                throw new exceptions/* .BaseAppException */.m8({
+                    message: `Endpoint 'getByIds' is disabled`,
+                    messageKey: message_keys/* .ERROR_MESSAGES.ENDPOINT_DISABLED */.UU.ENDPOINT_DISABLED,
+                    messageVariables: {
+                        endpoint: 'getByIds'
+                    },
+                    status: common_.HttpStatus.FORBIDDEN
+                });
+            }
+            const entities = await this.service.findByIds(body.ids, user, body?.select);
+            const data = entities.map((item)=>toDto(responseDtoClass, item));
+            return {
+                success: true,
+                message: `${data.length} ${entityName}${data.length !== 1 ? 's' : ''} retrieved successfully`,
+                messageKey: `${entityName}.get.by.ids.success`,
+                data,
+                meta: {
+                    total: data.length,
+                    page: 0,
+                    pageSize: data.length,
+                    count: data.length,
+                    totalPages: 1
+                }
+            };
+        }
+        async update(updateDto, user) {
+            if (!this.isEnabled('update')) {
+                throw new exceptions/* .BaseAppException */.m8({
+                    message: `Endpoint 'update' is disabled`,
+                    messageKey: message_keys/* .ERROR_MESSAGES.ENDPOINT_DISABLED */.UU.ENDPOINT_DISABLED,
+                    messageVariables: {
+                        endpoint: 'update'
+                    },
+                    status: common_.HttpStatus.FORBIDDEN
+                });
+            }
+            const entity = await this.service.update(updateDto, user);
+            const data = toDto(responseDtoClass, entity);
+            return {
+                success: true,
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} updated successfully`,
+                messageKey: `${entityName}.update.success`,
+                data
+            };
+        }
+        async updateMany(updateDtos, user) {
+            if (!this.isEnabled('updateMany')) {
+                throw new exceptions/* .BaseAppException */.m8({
+                    message: `Endpoint 'updateMany' is disabled`,
+                    messageKey: message_keys/* .ERROR_MESSAGES.ENDPOINT_DISABLED */.UU.ENDPOINT_DISABLED,
+                    messageVariables: {
+                        endpoint: 'updateMany'
+                    },
+                    status: common_.HttpStatus.FORBIDDEN
+                });
+            }
+            const entities = await this.service.updateMany(updateDtos, user);
+            const data = entities.map((item)=>toDto(responseDtoClass, item));
+            return {
+                success: true,
+                message: `${data.length} ${entityName}s updated successfully`,
+                messageKey: `${entityName}.update.many.success`,
+                messageVariables: {
+                    count: data.length
+                },
+                data,
+                meta: {
+                    count: data.length,
+                    total: updateDtos.length,
+                    failed: updateDtos.length - data.length
+                }
+            };
+        }
+        async bulkUpsert(dtos, user) {
+            if (!this.isEnabled('bulkUpsert')) {
+                throw new exceptions/* .BaseAppException */.m8({
+                    message: `Endpoint 'bulkUpsert' is disabled`,
+                    messageKey: message_keys/* .ERROR_MESSAGES.ENDPOINT_DISABLED */.UU.ENDPOINT_DISABLED,
+                    messageVariables: {
+                        endpoint: 'bulkUpsert'
+                    },
+                    status: common_.HttpStatus.FORBIDDEN
+                });
+            }
+            const toInsert = [];
+            const toUpdate = [];
+            for (const dto of dtos){
+                if ('id' in dto && dto.id) {
+                    toUpdate.push(dto);
+                } else {
+                    toInsert.push(dto);
+                }
+            }
+            const allEntities = await this.service.bulkUpsert(toInsert, toUpdate, user);
+            const data = allEntities.map((item)=>toDto(responseDtoClass, item));
+            return {
+                success: true,
+                message: `${data.length} ${entityName}s upserted successfully`,
+                messageKey: `${entityName}.upsert.many.success`,
+                messageVariables: {
+                    count: data.length
+                },
+                data,
+                meta: {
+                    count: data.length,
+                    total: dtos.length,
+                    failed: dtos.length - data.length
+                }
+            };
+        }
+        async getByFilter(filter, user) {
+            if (!this.isEnabled('getByFilter')) {
+                throw new exceptions/* .BaseAppException */.m8({
+                    message: `Endpoint 'getByFilter' is disabled`,
+                    messageKey: message_keys/* .ERROR_MESSAGES.ENDPOINT_DISABLED */.UU.ENDPOINT_DISABLED,
+                    messageVariables: {
+                        endpoint: 'getByFilter'
+                    },
+                    status: common_.HttpStatus.FORBIDDEN
+                });
+            }
+            const result = await this.service.getAll('', {
+                filter,
+                pagination: {
+                    currentPage: 0,
+                    pageSize: 1
+                }
+            }, user);
+            if (!result.data || result.data.length === 0) {
+                throw new exceptions/* .NotFoundException */.X6(entityName);
+            }
+            const entity = result.data[0];
+            const data = toDto(responseDtoClass, entity);
+            return {
+                success: true,
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)} retrieved successfully`,
+                messageKey: `${entityName}.get.by.filter.success`,
+                data
+            };
+        }
+        async getAll(filterAndPaginationDto, user, search) {
+            if (!this.isEnabled('getAll')) {
+                throw new exceptions/* .BaseAppException */.m8({
+                    message: `Endpoint 'getAll' is disabled`,
+                    messageKey: message_keys/* .ERROR_MESSAGES.ENDPOINT_DISABLED */.UU.ENDPOINT_DISABLED,
+                    messageVariables: {
+                        endpoint: 'getAll'
+                    },
+                    status: common_.HttpStatus.FORBIDDEN
+                });
+            }
+            const result = await this.service.getAll(search ?? '', filterAndPaginationDto, user);
+            const data = result.data.map((item)=>toDto(responseDtoClass, item));
+            const page = filterAndPaginationDto.pagination?.currentPage ?? 0;
+            const pageSize = filterAndPaginationDto.pagination?.pageSize ?? data.length;
+            const totalPages = pageSize > 0 ? Math.ceil(result.total / pageSize) : 1;
+            return {
+                success: true,
+                message: `${entityName.charAt(0).toUpperCase() + entityName.slice(1)}s retrieved successfully`,
+                messageKey: `${entityName}.get.all.success`,
+                data,
+                meta: {
+                    total: result.total,
+                    page,
+                    pageSize,
+                    count: data.length,
+                    hasMore: page < totalPages - 1,
+                    totalPages
+                }
+            };
+        }
+        async delete(deleteDto, user) {
+            if (!this.isEnabled('delete')) {
+                throw new exceptions/* .BaseAppException */.m8({
+                    message: `Endpoint 'delete' is disabled`,
+                    messageKey: message_keys/* .ERROR_MESSAGES.ENDPOINT_DISABLED */.UU.ENDPOINT_DISABLED,
+                    messageVariables: {
+                        endpoint: 'delete'
+                    },
+                    status: common_.HttpStatus.FORBIDDEN
+                });
+            }
+            await this.service.delete(deleteDto, user);
+            const count = Array.isArray(deleteDto.id) ? deleteDto.id.length : 1;
+            const action = deleteDto.type === 'restore' ? 'restore' : 'delete';
+            return {
+                success: true,
+                message: `${count} ${entityName}${count > 1 ? 's' : ''} ${action}d successfully`,
+                messageKey: `${entityName}.${action}.success`,
+                messageVariables: {
+                    count
+                }
+            };
+        }
+    };
+    _ts_decorate([
+        createEndpointDecorators(security.insert, 'insert', options.enabledEndpoints),
+        (0,common_.Version)(common_.VERSION_NEUTRAL),
+        (0,common_.Post)('insert'),
+        (0,common_.HttpCode)(common_.HttpStatus.CREATED),
+        (0,swagger_.ApiOperation)({
+            summary: 'Insert one item',
+            description: 'Creates a new item. Supports idempotency via X-Idempotency-Key header.'
+        }),
+        (0,swagger_.ApiHeader)({
+            name: 'X-Idempotency-Key',
+            required: false,
+            description: 'Unique key to prevent duplicate submissions (recommended for production)'
+        }),
+        (0,api_response_decorator/* .ApiResponseDto */.x)(responseDtoClass),
+        (0,swagger_.ApiBody)({
+            type: createDtoClass
+        }),
+        (0,common_.UseInterceptors)(interceptors/* .IdempotencyInterceptor */.Bw, interceptors/* .SetCreatedByOnBody */.VS, interceptors/* .Slug */.Mw),
+        _ts_param(0, (0,common_.Body)()),
+        _ts_param(1, (0,src_decorators/* .CurrentUser */.NO)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            typeof CreateDtoT === "undefined" ? Object : CreateDtoT,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "insert", null);
+    _ts_decorate([
+        createEndpointDecorators(security.insertMany, 'insertMany', options.enabledEndpoints),
+        (0,common_.Version)(common_.VERSION_NEUTRAL),
+        (0,common_.Post)('insert-many'),
+        (0,common_.HttpCode)(common_.HttpStatus.CREATED),
+        (0,swagger_.ApiOperation)({
+            summary: 'Insert multiple items',
+            description: 'Creates multiple items in a single request. Supports idempotency.'
+        }),
+        (0,swagger_.ApiHeader)({
+            name: 'X-Idempotency-Key',
+            required: false,
+            description: 'Unique key to prevent duplicate submissions'
+        }),
+        (0,api_response_decorator/* .ApiResponseDto */.x)(responseDtoClass, true, 'bulk'),
+        (0,swagger_.ApiBody)({
+            type: createDtoClass,
+            isArray: true
+        }),
+        (0,common_.UseInterceptors)(interceptors/* .IdempotencyInterceptor */.Bw, interceptors/* .SetCreatedByOnBody */.VS, interceptors/* .Slug */.Mw),
+        _ts_param(0, (0,common_.Body)()),
+        _ts_param(1, (0,src_decorators/* .CurrentUser */.NO)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            Array,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "insertMany", null);
+    _ts_decorate([
+        createEndpointDecorators(security.getById, 'getById', options.enabledEndpoints),
+        (0,common_.Version)(common_.VERSION_NEUTRAL),
+        (0,common_.Post)('get/:id'),
+        (0,common_.HttpCode)(common_.HttpStatus.OK),
+        (0,swagger_.ApiOperation)({
+            summary: 'Get item by ID',
+            description: 'Retrieves a single item by ID. Optionally specify fields to select and relations to include.'
+        }),
+        (0,swagger_.ApiParam)({
+            name: 'id',
+            type: String,
+            description: 'UUID of the item'
+        }),
+        (0,swagger_.ApiBody)({
+            type: src_dtos/* .GetByIdBodyDto */.a8,
+            required: false
+        }),
+        (0,api_response_decorator/* .ApiResponseDto */.x)(responseDtoClass),
+        _ts_param(0, (0,common_.Param)('id')),
+        _ts_param(1, (0,common_.Body)()),
+        _ts_param(2, (0,src_decorators/* .CurrentUser */.NO)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            String,
+            typeof src_dtos/* .GetByIdBodyDto */.a8 === "undefined" ? Object : src_dtos/* .GetByIdBodyDto */.a8,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "getById", null);
+    _ts_decorate([
+        createEndpointDecorators(security.getByIds, 'getByIds', options.enabledEndpoints),
+        (0,common_.Version)(common_.VERSION_NEUTRAL),
+        (0,common_.Post)('get-by-ids'),
+        (0,common_.HttpCode)(common_.HttpStatus.OK),
+        (0,swagger_.ApiOperation)({
+            summary: 'Get items by IDs',
+            description: 'Retrieves multiple items by their IDs. Optionally specify fields to select.'
+        }),
+        (0,swagger_.ApiBody)({
+            type: src_dtos/* .GetByIdsDto */.H$
+        }),
+        (0,api_response_decorator/* .ApiResponseDto */.x)(responseDtoClass, true, 'list'),
+        _ts_param(0, (0,common_.Body)()),
+        _ts_param(1, (0,src_decorators/* .CurrentUser */.NO)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            typeof src_dtos/* .GetByIdsDto */.H$ === "undefined" ? Object : src_dtos/* .GetByIdsDto */.H$,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "getByIds", null);
+    _ts_decorate([
+        createEndpointDecorators(security.update, 'update', options.enabledEndpoints),
+        (0,common_.Version)(common_.VERSION_NEUTRAL),
+        (0,common_.Post)('update'),
+        (0,common_.HttpCode)(common_.HttpStatus.OK),
+        (0,swagger_.ApiOperation)({
+            summary: 'Update one item',
+            description: 'Updates an existing item. ID must be included in the body.'
+        }),
+        (0,api_response_decorator/* .ApiResponseDto */.x)(responseDtoClass),
+        (0,swagger_.ApiBody)({
+            type: updateDtoClass
+        }),
+        (0,common_.UseInterceptors)(interceptors/* .SetUpdateByOnBody */._x, interceptors/* .Slug */.Mw),
+        _ts_param(0, (0,common_.Body)()),
+        _ts_param(1, (0,src_decorators/* .CurrentUser */.NO)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            typeof UpdateDtoT === "undefined" ? Object : UpdateDtoT,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "update", null);
+    _ts_decorate([
+        createEndpointDecorators(security.updateMany, 'updateMany', options.enabledEndpoints),
+        (0,common_.Version)(common_.VERSION_NEUTRAL),
+        (0,common_.Post)('update-many'),
+        (0,common_.HttpCode)(common_.HttpStatus.OK),
+        (0,swagger_.ApiOperation)({
+            summary: 'Update multiple items',
+            description: 'Updates multiple items in a single request. Each item must include an ID.'
+        }),
+        (0,api_response_decorator/* .ApiResponseDto */.x)(responseDtoClass, true, 'bulk'),
+        (0,swagger_.ApiBody)({
+            type: updateDtoClass,
+            isArray: true
+        }),
+        (0,common_.UseInterceptors)(interceptors/* .SetUpdateByOnBody */._x, interceptors/* .Slug */.Mw),
+        _ts_param(0, (0,common_.Body)()),
+        _ts_param(1, (0,src_decorators/* .CurrentUser */.NO)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            Array,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "updateMany", null);
+    _ts_decorate([
+        createEndpointDecorators(security.bulkUpsert, 'bulkUpsert', options.enabledEndpoints),
+        (0,common_.Version)(common_.VERSION_NEUTRAL),
+        (0,common_.Post)('bulk-upsert'),
+        (0,common_.HttpCode)(common_.HttpStatus.OK),
+        (0,swagger_.ApiOperation)({
+            summary: 'Create or update multiple items',
+            description: 'Bulk upsert: items without ID are created, items with ID are updated.'
+        }),
+        (0,api_response_decorator/* .ApiResponseDto */.x)(responseDtoClass, true, 'bulk'),
+        (0,swagger_.ApiBody)({
+            type: createDtoClass,
+            isArray: true
+        }),
+        (0,common_.UseInterceptors)(interceptors/* .SetCreatedByOnBody */.VS, interceptors/* .SetUpdateByOnBody */._x, interceptors/* .Slug */.Mw),
+        _ts_param(0, (0,common_.Body)()),
+        _ts_param(1, (0,src_decorators/* .CurrentUser */.NO)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            Array,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "bulkUpsert", null);
+    _ts_decorate([
+        createEndpointDecorators(security.getByFilter, 'getByFilter', options.enabledEndpoints),
+        (0,common_.Version)(common_.VERSION_NEUTRAL),
+        (0,common_.Post)('get-by-filter'),
+        (0,common_.HttpCode)(common_.HttpStatus.OK),
+        (0,swagger_.ApiOperation)({
+            summary: 'Get single item by filter',
+            description: 'Retrieves a single item matching the provided filter criteria. Returns first match if multiple exist.'
+        }),
+        (0,swagger_.ApiBody)({
+            schema: {
+                type: 'object',
+                description: 'Filter criteria'
+            }
+        }),
+        (0,api_response_decorator/* .ApiResponseDto */.x)(responseDtoClass),
+        _ts_param(0, (0,common_.Body)()),
+        _ts_param(1, (0,src_decorators/* .CurrentUser */.NO)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            typeof Record === "undefined" ? Object : Record,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "getByFilter", null);
+    _ts_decorate([
+        createEndpointDecorators(security.getAll, 'getAll', options.enabledEndpoints),
+        (0,common_.Version)(common_.VERSION_NEUTRAL),
+        (0,common_.Post)('get-all'),
+        (0,common_.HttpCode)(common_.HttpStatus.OK),
+        (0,swagger_.ApiOperation)({
+            summary: 'Get all items with filters and pagination',
+            description: 'Supports filter, pagination, sort, select, withDeleted, and q (search) params'
+        }),
+        (0,swagger_.ApiQuery)({
+            name: 'q',
+            required: false,
+            description: 'Global text search across searchable fields'
+        }),
+        (0,swagger_.ApiBody)({
+            type: src_dtos/* .FilterAndPaginationDto */.x
+        }),
+        (0,api_response_decorator/* .ApiResponseDto */.x)(responseDtoClass, true, 'list'),
+        _ts_param(0, (0,common_.Body)()),
+        _ts_param(1, (0,src_decorators/* .CurrentUser */.NO)()),
+        _ts_param(2, (0,common_.Query)('q')),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            typeof src_dtos/* .FilterAndPaginationDto */.x === "undefined" ? Object : src_dtos/* .FilterAndPaginationDto */.x,
+            Object,
+            String
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "getAll", null);
+    _ts_decorate([
+        createEndpointDecorators(security.delete, 'delete', options.enabledEndpoints),
+        (0,common_.Version)(common_.VERSION_NEUTRAL),
+        (0,common_.Post)('delete'),
+        (0,common_.HttpCode)(common_.HttpStatus.OK),
+        (0,swagger_.ApiOperation)({
+            summary: 'Delete, restore, or permanently remove items',
+            description: 'Types: delete (soft), restore, permanent. Supports batch IDs.'
+        }),
+        (0,swagger_.ApiResponse)({
+            status: 200,
+            description: 'Operation completed successfully',
+            schema: {
+                example: {
+                    success: true,
+                    message: '3 items deleted successfully'
+                }
+            }
+        }),
+        (0,swagger_.ApiBody)({
+            type: src_dtos/* .DeleteDto */.TG,
+            examples: {
+                softDelete: {
+                    summary: 'Soft delete',
+                    value: {
+                        id: [
+                            'uuid-1',
+                            'uuid-2'
+                        ],
+                        type: 'delete'
+                    }
+                },
+                restore: {
+                    summary: 'Restore deleted',
+                    value: {
+                        id: [
+                            'uuid-1'
+                        ],
+                        type: 'restore'
+                    }
+                },
+                permanent: {
+                    summary: 'Permanent delete',
+                    value: {
+                        id: [
+                            'uuid-1'
+                        ],
+                        type: 'permanent'
+                    }
+                }
+            }
+        }),
+        (0,common_.UseInterceptors)(interceptors/* .SetDeletedByOnBody */.Ul),
+        _ts_param(0, (0,common_.Body)()),
+        _ts_param(1, (0,src_decorators/* .CurrentUser */.NO)()),
+        _ts_metadata("design:type", Function),
+        _ts_metadata("design:paramtypes", [
+            typeof src_dtos/* .DeleteDto */.TG === "undefined" ? Object : src_dtos/* .DeleteDto */.TG,
+            Object
+        ]),
+        _ts_metadata("design:returntype", Promise)
+    ], ApiController.prototype, "delete", null);
+    return ApiController;
+}
+
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/decorators/log-action.decorator.ts
+var log_action_decorator = __webpack_require__(946);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/modules/utils/utils.service.ts
+var utils_service = __webpack_require__(169);
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(823);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/middlewares/logger.middleware.ts + 2 modules
+var logger_middleware = __webpack_require__(419);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/utils/event-pattern.util.ts
+var event_pattern_util = __webpack_require__(456);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/event-bus.registry.ts
+var event_bus_registry = __webpack_require__(228);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/classes/domain-event.publisher.ts
+
+
+
+
+const DOMAIN_EVENT_VERSION = 1;
+function buildDomainEvent(input) {
+    const rows = input.data === undefined ? [] : toArray(input.data);
+    const ids = input.ids ?? collectIds(rows);
+    return {
+        id: (0,external_crypto_.randomUUID)(),
+        name: `${input.module}.${input.entity}.${input.action}`,
+        module: input.module,
+        entity: input.entity,
+        action: input.action,
+        payload: {
+            ids,
+            ...rows.length && event_bus_registry/* .EventBusRegistry.shouldIncludePayload */.q.shouldIncludePayload(input.module) ? {
+                data: (0,event_pattern_util/* .sanitizeEventPayload */.IN)(rows)
+            } : {},
+            ...input.metadata ? {
+                metadata: (0,event_pattern_util/* .sanitizeEventPayload */.IN)(input.metadata)
+            } : {}
+        },
+        actor: {
+            userId: input.user?.id ?? null,
+            companyId: input.user?.companyId ?? (0,logger_middleware/* .getCompanyId */.xR)() ?? null,
+            tenantId: (0,logger_middleware/* .getTenantId */.EO)() ?? null,
+            requestId: (0,logger_middleware/* .getRequestId */.RE)() ?? null
+        },
+        occurredAt: new Date().toISOString(),
+        version: DOMAIN_EVENT_VERSION
+    };
+}
+/**
+ * Publishes a domain event for an operation that is not plain CRUD - a form
+ * submission, a login, a file upload. Honours the publishing module's own
+ * `events` config and never throws, so a broker outage cannot break the caller.
+ *
+ * Supplying `eventBus` chooses which bus to publish on; it never overrides the
+ * module's on/off switch, otherwise turning a module's events off would leave
+ * every service holding its own bus still publishing.
+ */ async function publishDomainEvent(input) {
+    const bus = input.eventBus ?? event_bus_registry/* .EventBusRegistry.getBus */.q.getBus();
+    if (!bus) return;
+    if (!event_bus_registry/* .EventBusRegistry.isEnabled */.q.isEnabled(input.module, input.entity, input.action)) return;
+    try {
+        await bus.publish(buildDomainEvent(input));
+    } catch  {
+    // Events must never break the operation that produced them
+    }
+}
+function toArray(value) {
+    return Array.isArray(value) ? value : [
+        value
+    ];
+}
+function collectIds(rows) {
+    return rows.reduce((ids, row)=>{
+        const id = row?.id;
+        if (id) ids.push(id);
+        return ids;
+    }, []);
+}
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/hybrid-cache.class.ts + 3 modules
+var hybrid_cache_class = __webpack_require__(375);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/classes/api-service.class.ts
+function api_service_class_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 api_service_class_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+
+
+
+
+
+const DELETE_EVENT_ACTIONS = {
+    delete: 'deleted',
+    restore: 'restored',
+    permanent: 'purged'
+};
+class ApiService {
+    entityName;
+    cacheManager;
+    utilsService;
+    _loggerName;
+    isCacheable;
+    moduleName;
+    repository;
+    repositoryInitialized = false;
+    _entity;
+    _dataSourceProvider;
+    /**
+   * `entity` is the table this service reads and writes. A service whose table
+   * depends on runtime config - the company feature, say - passes the ternary
+   * here, reading the injected config through the constructor parameter.
+   */ constructor(entityName, cacheManager, utilsService, _loggerName, isCacheable = false, moduleName, dataSourceProvider, entity){
+        this.entityName = entityName;
+        this.cacheManager = cacheManager;
+        this.utilsService = utilsService;
+        this._loggerName = _loggerName;
+        this.isCacheable = isCacheable;
+        this.moduleName = moduleName;
+        this._dataSourceProvider = dataSourceProvider;
+        this._entity = entity;
+    }
+    getDataSourceProvider() {
+        return this._dataSourceProvider;
+    }
+    async ensureDataSourceRepository() {
+        if (!this.repositoryInitialized) {
+            const provider = this.getDataSourceProvider();
+            this.repository = await provider.getRepository(this._entity);
+            this.repositoryInitialized = true;
+        }
+    }
+    async resolveRepositories(entities) {
+        const provider = this.getDataSourceProvider();
+        const repositories = [];
+        for (const entity of entities){
+            repositories.push(await provider.getRepository(entity));
+        }
+        return repositories;
+    }
+    async insert(dto, user) {
+        return this.executeInTransaction('created', async (qr)=>{
+            await this.beforeInsertOperation(dto, user, qr);
+            const entities = await this.convertRequestDtoToEntity(dto, user);
+            const saved = await qr.manager.save(this.repository.target, entities);
+            await this.afterInsertOperation(this.ensureArray(saved), dto, user, qr);
+            return {
+                saved,
+                returnFirst: true
+            };
+        }, user);
+    }
+    async insertMany(dtos, user) {
+        return this.executeInTransaction('created', async (qr)=>{
+            await this.beforeInsertOperation(dtos, user, qr);
+            const entities = await this.convertRequestDtoToEntity(dtos, user);
+            const saved = await qr.manager.save(this.repository.target, entities);
+            await this.afterInsertOperation(this.ensureArray(saved), dtos, user, qr);
+            return {
+                saved,
+                returnFirst: false
+            };
+        }, user);
+    }
+    async update(dto, user) {
+        return this.executeInTransaction('updated', async (qr)=>{
+            await this.beforeUpdateOperation(dto, user, qr);
+            const entities = await this.convertRequestDtoToEntity(dto, user);
+            const saved = await qr.manager.save(this.repository.target, entities);
+            await this.afterUpdateOperation(this.ensureArray(saved), dto, user, qr);
+            return {
+                saved,
+                returnFirst: true
+            };
+        }, user);
+    }
+    async updateMany(dtos, user) {
+        return this.executeInTransaction('updated', async (qr)=>{
+            await this.beforeUpdateOperation(dtos, user, qr);
+            const entities = await this.convertRequestDtoToEntity(dtos, user);
+            const saved = await qr.manager.save(this.repository.target, entities);
+            await this.afterUpdateOperation(this.ensureArray(saved), dtos, user, qr);
+            return {
+                saved,
+                returnFirst: false
+            };
+        }, user);
+    }
+    async bulkUpsert(toInsert, toUpdate, user) {
+        return this.executeInTransaction(undefined, async (qr)=>{
+            const allResults = [];
+            const eventGroups = [];
+            if (toInsert.length > 0) {
+                await this.beforeInsertOperation(toInsert, user, qr);
+                const insertedEntities = await this.convertRequestDtoToEntity(toInsert, user);
+                const insertedSaved = await qr.manager.save(this.repository.target, insertedEntities);
+                await this.afterInsertOperation(this.ensureArray(insertedSaved), toInsert, user, qr);
+                allResults.push(...this.ensureArray(insertedSaved));
+                eventGroups.push({
+                    action: 'created',
+                    entities: this.ensureArray(insertedSaved)
+                });
+            }
+            if (toUpdate.length > 0) {
+                await this.beforeUpdateOperation(toUpdate, user, qr);
+                const updatedEntities = await this.convertRequestDtoToEntity(toUpdate, user);
+                const updatedSaved = await qr.manager.save(this.repository.target, updatedEntities);
+                await this.afterUpdateOperation(this.ensureArray(updatedSaved), toUpdate, user, qr);
+                allResults.push(...this.ensureArray(updatedSaved));
+                eventGroups.push({
+                    action: 'updated',
+                    entities: this.ensureArray(updatedSaved)
+                });
+            }
+            return {
+                saved: allResults,
+                returnFirst: false,
+                eventGroups
+            };
+        }, user);
+    }
+    async findByIds(ids, user, select) {
+        await this.ensureDataSourceRepository();
+        try {
+            const query = this.repository.createQueryBuilder(this.entityName);
+            query.where({
+                id: (0,external_typeorm_.In)(ids)
+            });
+            const selectArray = typeof select === 'string' ? select.split(',').map((s)=>s.trim()) : select;
+            const { query: finalQuery, isRaw } = await this.getSelectQuery(query, user, selectArray);
+            let output;
+            if (isRaw) {
+                output = await finalQuery.getRawMany();
+            } else {
+                output = await finalQuery.getMany();
+            }
+            const result = this.convertEntityListToResponseListDto(output, isRaw);
+            if (!result || !result.length) throw new common_.NotFoundException({
+                message: 'No Data Found',
+                messageKey: message_keys/* .ERROR_MESSAGES.NOT_FOUND */.UU.NOT_FOUND
+            });
+            return result;
+        } catch (error) {
+            if (error instanceof common_.NotFoundException) {
+                throw error;
+            }
+            this.handleError(error);
+        }
+    }
+    async findById(id, user, select) {
+        await this.ensureDataSourceRepository();
+        try {
+            const query = this.repository.createQueryBuilder(this.entityName);
+            query.where({
+                id
+            });
+            const { query: finalQuery, isRaw } = await this.getSelectQuery(query, user, select);
+            let result;
+            let cacheKey = '';
+            if (this.isCacheable) {
+                cacheKey = this.utilsService.getCacheKey(this.entityName, finalQuery.getQueryAndParameters(), id);
+                result = await this.cacheManager.get(cacheKey);
+            }
+            if (!result) {
+                if (isRaw) {
+                    const rawOutput = await finalQuery.getRawMany();
+                    const convertResult = this.convertEntityListToResponseListDto(rawOutput, isRaw);
+                    if (convertResult.length) result = convertResult[0];
+                } else {
+                    const singleOutput = await finalQuery.getOne();
+                    if (!singleOutput) throw new common_.NotFoundException({
+                        message: 'No Data Found',
+                        messageKey: message_keys/* .ERROR_MESSAGES.NOT_FOUND */.UU.NOT_FOUND
+                    });
+                    result = this.convertEntityToResponseDto(singleOutput, false);
+                }
+                if (this.isCacheable) {
+                    await this.cacheManager.set(cacheKey, result);
+                    await this.utilsService.trackCacheKey(cacheKey, this.entityName, this.cacheManager, id);
+                }
+            }
+            return result;
+        } catch (error) {
+            if (error instanceof common_.NotFoundException) {
+                throw error;
+            }
+            this.handleError(error);
+        }
+    }
+    async getAll(search, filterAndPaginationDto, user) {
+        await this.ensureDataSourceRepository();
+        try {
+            let data;
+            let total;
+            let isRaw = false;
+            let query = this.repository.createQueryBuilder(this.entityName);
+            if (filterAndPaginationDto.filter) {
+                const { query: filterQuery, isRaw: filterIsRaw } = await this.getFilterQuery(query, filterAndPaginationDto.filter, user);
+                query = filterQuery;
+                isRaw = isRaw || filterIsRaw;
+            }
+            if (search) {
+                const { query: searchQuery, isRaw: searchIsRaw } = await this.getGlobalSearchQuery(query, search, user);
+                query = searchQuery;
+                isRaw = isRaw || searchIsRaw;
+            }
+            const { query: selectQuery, isRaw: selectIsRaw } = await this.getSelectQuery(query, user, filterAndPaginationDto.select);
+            query = selectQuery;
+            isRaw = isRaw || selectIsRaw;
+            if (filterAndPaginationDto.sort) {
+                const { query: sortQuery, isRaw: sortIsRaw } = await this.getSortQuery(query, filterAndPaginationDto.sort, user);
+                query = sortQuery;
+                isRaw = isRaw || sortIsRaw;
+            }
+            if (filterAndPaginationDto.withDeleted) query.withDeleted();
+            const { query: extraQuery, isRaw: extraIsRaw } = await this.getExtraManipulateQuery(query, filterAndPaginationDto, user);
+            query = extraQuery;
+            isRaw = isRaw || extraIsRaw;
+            if (filterAndPaginationDto.pagination) {
+                const offset = filterAndPaginationDto.pagination.currentPage * filterAndPaginationDto.pagination.pageSize;
+                const limit = filterAndPaginationDto.pagination.pageSize;
+                if (isRaw) {
+                    query.offset(offset).limit(limit);
+                } else {
+                    query.skip(offset).take(limit);
+                }
+            }
+            let cacheKey = '';
+            if (this.isCacheable) {
+                cacheKey = this.utilsService.getCacheKey(this.entityName, {
+                    raw: isRaw,
+                    pagination: filterAndPaginationDto.pagination,
+                    query: query.getQueryAndParameters()
+                });
+                const cached = await this.cacheManager.get(cacheKey);
+                if (cached) {
+                    return cached;
+                }
+            }
+            if (isRaw) {
+                const rawSubQuery = query.clone().offset(undefined).limit(undefined);
+                rawSubQuery.expressionMap.orderBys = {};
+                rawSubQuery.distinct(true);
+                const countSql = `
+            SELECT COUNT(*) as count
+            FROM (
+                SELECT COUNT(*) as count
+                FROM (${rawSubQuery.getQuery()}) AS subquery
+                GROUP BY subquery.${this.entityName}_id
+            ) AS final
+          `;
+                const parameters = rawSubQuery.getParameters();
+                const orderedValues = [];
+                const isPostgres = this.repository.manager.connection.options.type === 'postgres';
+                let paramIndex = 0;
+                const convertedQuery = countSql.replace(/:(\w+)/g, (_, key)=>{
+                    if (!(key in parameters)) {
+                        throw new common_.InternalServerErrorException({
+                            message: `Missing parameter value for: ${key}`,
+                            messageKey: message_keys/* .SYSTEM_MESSAGES.MISSING_PARAMETER */.hg.MISSING_PARAMETER,
+                            messageVariables: {
+                                key
+                            }
+                        });
+                    }
+                    orderedValues.push(parameters[key]);
+                    return isPostgres ? `$${++paramIndex}` : '?';
+                });
+                const result = await this.repository.query(convertedQuery, orderedValues);
+                total = Number(result[0]?.count || 0);
+                data = await query.getRawMany();
+            } else {
+                [data, total] = await query.getManyAndCount();
+            }
+            const convertedFinalData = this.convertEntityListToResponseListDto(data, isRaw);
+            const finalResponse = {
+                data: convertedFinalData,
+                total
+            };
+            if (this.isCacheable) {
+                await this.cacheManager.set(cacheKey, finalResponse);
+                await this.utilsService.trackCacheKey(cacheKey, this.entityName, this.cacheManager);
+            }
+            return finalResponse;
+        } catch (error) {
+            this.handleError(error);
+        }
+    }
+    async delete(option, user) {
+        await this.ensureDataSourceRepository();
+        const queryRunner = this.repository.manager.connection.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            await this.beforeDeleteOperation(option, user, queryRunner);
+            if (option.type === 'delete') {
+                await queryRunner.manager.softDelete(this.repository.target, option.id);
+                await queryRunner.manager.update(this.repository.target, option.id, {
+                    deletedById: option['deletedById']
+                });
+            } else if (option.type === 'restore') {
+                await queryRunner.manager.restore(this.repository.target, option.id);
+                await queryRunner.manager.update(this.repository.target, option.id, {
+                    deletedById: option['deletedById']
+                });
+            } else {
+                await queryRunner.manager.delete(this.repository.target, option.id);
+            }
+            const ids = (Array.isArray(option.id) ? option.id : [
+                option.id
+            ]).map((id)=>{
+                return {
+                    id
+                };
+            });
+            await this.afterDeleteOperation(ids, option, user, queryRunner);
+            await queryRunner.commitTransaction();
+            await Promise.all([
+                this.clearCacheForAll(),
+                this.clearCacheForId(ids)
+            ]);
+            await this.publishLifecycleEvents([
+                {
+                    action: DELETE_EVENT_ACTIONS[option.type],
+                    entities: ids,
+                    idsOnly: true
+                }
+            ], user);
+            return null;
+        } catch (error) {
+            await queryRunner.rollbackTransaction();
+            this.handleError(error);
+        } finally{
+            await queryRunner.release();
+        }
+    }
+    async publishLifecycleEvents(groups, user) {
+        for (const group of groups){
+            if (!group.entities.length) continue;
+            await publishDomainEvent({
+                module: this.moduleName,
+                entity: this.entityName,
+                action: group.action,
+                ids: group.entities.map((entity)=>entity.id),
+                ...group.idsOnly ? {} : {
+                    data: group.entities
+                },
+                user
+            });
+        }
+    }
+    /**
+   * Publishes a domain action for this service's entity - anything past plain
+   * CRUD, such as a submission or a state transition.
+   */ async publishDomainAction(action, input = {}) {
+        await publishDomainEvent({
+            ...input,
+            module: this.moduleName,
+            entity: this.entityName,
+            action
+        });
+    }
+    async clearCacheForAll() {
+        await this.utilsService.clearCache(this.entityName, this.cacheManager);
+    }
+    async clearCacheForId(entities) {
+        await Promise.all(entities.map((item)=>this.utilsService.clearCache(this.entityName, this.cacheManager, item.id)));
+    }
+    handleError(error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new common_.InternalServerErrorException({
+            message: typeof error === 'string' ? error : 'Unknown error',
+            messageKey: message_keys/* .ERROR_MESSAGES.INTERNAL */.UU.INTERNAL
+        });
+    }
+    ensureArray(value) {
+        return Array.isArray(value) ? value : [
+            value
+        ];
+    }
+    /**
+   * `action` is the lifecycle action to publish for the whole batch; an
+   * operation that saves more than one kind of row - a bulk upsert - passes
+   * `undefined` and returns its own `eventGroups` instead.
+   */ async executeInTransaction(action, fn, user) {
+        await this.ensureDataSourceRepository();
+        const qr = this.repository.manager.connection.createQueryRunner();
+        await qr.connect();
+        await qr.startTransaction();
+        try {
+            const { saved, returnFirst, eventGroups } = await fn(qr);
+            await qr.commitTransaction();
+            const savedArray = this.ensureArray(saved);
+            if (this.isCacheable) {
+                await Promise.all([
+                    this.clearCacheForAll(),
+                    this.clearCacheForId(savedArray)
+                ]);
+            }
+            await this.publishLifecycleEvents(eventGroups ?? (action ? [
+                {
+                    action,
+                    entities: savedArray
+                }
+            ] : []), user ?? null);
+            if (returnFirst) {
+                return this.convertEntityToResponseDto(savedArray[0], false);
+            }
+            return savedArray.map((e)=>this.convertEntityToResponseDto(e, false));
+        } catch (error) {
+            await qr.rollbackTransaction();
+            this.handleError(error);
+        } finally{
+            await qr.release();
+        }
+    }
+    async beforeInsertOperation(_dto, _user, _queryRunner) {}
+    async afterInsertOperation(_entity, _dto, _user, _queryRunner) {}
+    async beforeUpdateOperation(_dto, _user, _queryRunner) {}
+    async afterUpdateOperation(_entity, _dto, _user, _queryRunner) {}
+    async beforeDeleteOperation(_dto, _user, _queryRunner) {}
+    async afterDeleteOperation(_entity, _dto, _user, _queryRunner) {}
+    async getFilterQuery(query, filter, _user) {
+        Object.entries(filter).forEach(([key, value])=>{
+            query.andWhere(`${this.entityName}.${key} = :value`, {
+                value
+            });
+        });
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getSortQuery(query, sort, _user) {
+        Object.entries(sort).forEach(([key, direction])=>{
+            query.addOrderBy(`${this.entityName}.${key}`, direction);
+        });
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getSelectQuery(query, _user, select) {
+        if (select && select.length) query.select(select.map((field)=>`${this.entityName}.${field}`));
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getGlobalSearchQuery(query, search, _user) {
+        query.andWhere(`${this.entityName}.name LIKE :search`, {
+            search: `%${search}%`
+        });
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, _dto, _user) {
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async convertRequestDtoToEntity(dto, user) {
+        return Array.isArray(dto) ? await this.convertArrayDtoToEntities(dto, user) : [
+            await this.convertSingleDtoToEntity(dto, user)
+        ];
+    }
+    async convertSingleDtoToEntity(dto, _user) {
+        const d = dto;
+        if (d?.id && d.id !== '0' && d.id !== '') {
+            const existing = await this.repository.findOne({
+                where: {
+                    id: d.id
+                }
+            });
+            if (!existing) throw new common_.NotFoundException({
+                message: 'No such entity data found for update! Please, Try Again.',
+                messageKey: message_keys/* .ERROR_MESSAGES.NOT_FOUND */.UU.NOT_FOUND
+            });
+            return Object.assign(existing, d);
+        }
+        delete d.id;
+        return Object.assign(this.repository.create(), d);
+    }
+    async convertArrayDtoToEntities(dtos, user) {
+        return await Promise.all(dtos.map((dto)=>this.convertSingleDtoToEntity(dto, user)));
+    }
+    convertEntityToResponseDto(entity, _isRaw) {
+        return Object.assign({}, entity);
+    }
+    convertEntityListToResponseListDto(entities, _isRaw) {
+        return entities.map((entity)=>this.convertEntityToResponseDto(entity, _isRaw));
+    }
+}
+api_service_class_ts_decorate([
+    (0,log_action_decorator/* .LogAction */.J)({
+        action: 'create'
+    }),
+    api_service_class_ts_metadata("design:type", Function),
+    api_service_class_ts_metadata("design:paramtypes", [
+        typeof CreateDtoT === "undefined" ? Object : CreateDtoT,
+        Object
+    ]),
+    api_service_class_ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "insert", null);
+api_service_class_ts_decorate([
+    (0,log_action_decorator/* .LogAction */.J)({
+        action: 'createMany'
+    }),
+    api_service_class_ts_metadata("design:type", Function),
+    api_service_class_ts_metadata("design:paramtypes", [
+        typeof Array === "undefined" ? Object : Array,
+        Object
+    ]),
+    api_service_class_ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "insertMany", null);
+api_service_class_ts_decorate([
+    (0,log_action_decorator/* .LogAction */.J)({
+        action: 'update'
+    }),
+    api_service_class_ts_metadata("design:type", Function),
+    api_service_class_ts_metadata("design:paramtypes", [
+        typeof UpdateDtoT === "undefined" ? Object : UpdateDtoT,
+        Object
+    ]),
+    api_service_class_ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "update", null);
+api_service_class_ts_decorate([
+    (0,log_action_decorator/* .LogAction */.J)({
+        action: 'updateMany'
+    }),
+    api_service_class_ts_metadata("design:type", Function),
+    api_service_class_ts_metadata("design:paramtypes", [
+        Array,
+        Object
+    ]),
+    api_service_class_ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "updateMany", null);
+api_service_class_ts_decorate([
+    (0,log_action_decorator/* .LogAction */.J)({
+        action: 'bulkUpsert'
+    }),
+    api_service_class_ts_metadata("design:type", Function),
+    api_service_class_ts_metadata("design:paramtypes", [
+        Array,
+        Array,
+        Object
+    ]),
+    api_service_class_ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "bulkUpsert", null);
+api_service_class_ts_decorate([
+    (0,log_action_decorator/* .LogAction */.J)({
+        action: 'delete'
+    }),
+    api_service_class_ts_metadata("design:type", Function),
+    api_service_class_ts_metadata("design:paramtypes", [
+        typeof src_dtos/* .DeleteDto */.TG === "undefined" ? Object : src_dtos/* .DeleteDto */.TG,
+        Object
+    ]),
+    api_service_class_ts_metadata("design:returntype", Promise)
+], ApiService.prototype, "delete", null);
+ApiService = api_service_class_ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    api_service_class_ts_metadata("design:type", Function),
+    api_service_class_ts_metadata("design:paramtypes", [
+        String,
+        typeof hybrid_cache_class/* .HybridCache */.l === "undefined" ? Object : hybrid_cache_class/* .HybridCache */.l,
+        typeof utils_service/* .UtilsService */.T === "undefined" ? Object : utils_service/* .UtilsService */.T,
+        String,
+        Boolean,
+        String,
+        typeof IDataSourceProvider === "undefined" ? Object : IDataSourceProvider,
+        typeof EntityTarget === "undefined" ? Object : EntityTarget
+    ])
+], ApiService);
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/disabled-event-bus.class.ts
+var disabled_event_bus_class = __webpack_require__(864);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/event-transports/event-transport.registry.ts
+var event_transport_registry = __webpack_require__(149);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/event-transports/memory-transport.ts + 1 modules
+var memory_transport = __webpack_require__(346);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/classes/event-transports/index.ts
+
+// Built-in transport (no external dependencies)
+ // Note: Broker transports are loaded dynamically by HybridEventBus.
+ // Import them directly when registering manually:
+ // - import { RabbitMqTransport } from '@flusys/nestjs-shared/classes/event-transports/rabbitmq-transport.optional';
+ // - import { KafkaTransport } from '@flusys/nestjs-shared/classes/event-transports/kafka-transport.optional';
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/handle-custome-db.ts
+var handle_custome_db = __webpack_require__(504);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/hybrid-event-bus.class.ts
+var hybrid_event_bus_class = __webpack_require__(710);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/classes/winston.logger.class.ts + 5 modules
+var winston_logger_class = __webpack_require__(245);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/constants/permissions.ts
+var permissions = __webpack_require__(975);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/classes/index.ts
+
+
+
+
+
+
+
+
+
+
+// Re-export permission constants for convenience
+
+
+
+},
+997(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _dtos_index_js__rspack_import_0 = __webpack_require__(980);
+/* import */ var _nestjs_common__rspack_import_1 = __webpack_require__(157);
+/* import */ var _nestjs_swagger__rspack_import_2 = __webpack_require__(176);
+
+
+
+const ApiResponseDto = (dto, isArray = false, arrayType = 'list')=>{
+    let wrapperDto;
+    let metaDto = null;
+    if (!isArray || arrayType === 'single') {
+        wrapperDto = _dtos_index_js__rspack_import_0/* .SingleResponseDto */.f;
+    } else if (arrayType === 'bulk') {
+        wrapperDto = _dtos_index_js__rspack_import_0/* .BulkResponseDto */.jS;
+        metaDto = _dtos_index_js__rspack_import_0/* .BulkMetaDto */.L3;
+    } else {
+        wrapperDto = _dtos_index_js__rspack_import_0/* .ListResponseDto */.TW;
+        metaDto = _dtos_index_js__rspack_import_0/* .PaginationMetaDto */.DD;
+    }
+    return (0,_nestjs_common__rspack_import_1.applyDecorators)((0,_nestjs_swagger__rspack_import_2.ApiExtraModels)(_dtos_index_js__rspack_import_0/* .SingleResponseDto */.f, _dtos_index_js__rspack_import_0/* .ListResponseDto */.TW, _dtos_index_js__rspack_import_0/* .BulkResponseDto */.jS, _dtos_index_js__rspack_import_0/* .PaginationMetaDto */.DD, _dtos_index_js__rspack_import_0/* .BulkMetaDto */.L3, dto), (0,_nestjs_swagger__rspack_import_2.ApiOkResponse)({
+        schema: {
+            allOf: [
+                {
+                    $ref: (0,_nestjs_swagger__rspack_import_2.getSchemaPath)(wrapperDto)
+                },
+                {
+                    properties: {
+                        data: isArray ? {
+                            type: 'array',
+                            items: {
+                                $ref: (0,_nestjs_swagger__rspack_import_2.getSchemaPath)(dto)
+                            }
+                        } : {
+                            $ref: (0,_nestjs_swagger__rspack_import_2.getSchemaPath)(dto)
+                        },
+                        ...metaDto ? {
+                            meta: {
+                                $ref: (0,_nestjs_swagger__rspack_import_2.getSchemaPath)(metaDto)
+                            }
+                        } : {}
+                    }
+                }
+            ]
+        }
+    }));
+};
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  x: ApiResponseDto
+});
+
+
+},
+523(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  x_: () => (/* reexport */ api_response_decorator/* .ApiResponseDto */.x),
+  NO: () => (/* reexport */ CurrentUser),
+  Jz: () => (/* reexport */ log_action_decorator/* .LogAction */.J),
+  kd: () => (/* reexport */ OnDomainEvent),
+  w3: () => (/* reexport */ Public),
+  Dz: () => (/* reexport */ RequireAnyPermission),
+  Tw: () => (/* reexport */ RequirePermission),
+  rY: () => (/* reexport */ RequirePermissionLogic)
+});
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/decorators/api-response.decorator.ts
+var api_response_decorator = __webpack_require__(997);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/decorators/current-user.decorator.ts
+
+/**
+ * Parameter decorator that extracts the current user from the request.
+ * Works with any authentication guard that sets request.user
+ *
+ * @example
+ * // Get entire user object
+ * @Get('profile')
+ * getProfile(@CurrentUser() user: User) { }
+ *
+ * // Get specific property
+ * @Get('id')
+ * getId(@CurrentUser('id') userId: string) { }
+ */ const CurrentUser = (0,common_.createParamDecorator)((data, ctx)=>{
+    const request = ctx.switchToHttp().getRequest();
+    const user = request.user;
+    return data ? user?.[data] : user;
+});
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/decorators/log-action.decorator.ts
+var log_action_decorator = __webpack_require__(946);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/constants/index.ts
+var constants = __webpack_require__(43);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/decorators/on-domain-event.decorator.ts
+
+
+/**
+ * Marks a provider method as a domain event consumer.
+ *
+ * `*` matches one segment, `**` (or `#`) matches the rest:
+ *   `@OnDomainEvent('storage.folder.created')`
+ *   `@OnDomainEvent('auth.*.updated')`
+ *   `@OnDomainEvent('**')`
+ */ const OnDomainEvent = (...patterns)=>(0,common_.SetMetadata)(constants/* .DOMAIN_EVENT_HANDLER_KEY */.PT, patterns);
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/decorators/public.decorator.ts
+
+
+/**
+ * Decorator to mark routes as public (skip authentication)
+ *
+ * Use this on controller methods or entire controllers to bypass
+ * JWT authentication guards.
+ *
+ * @example
+ * // Skip auth for a single route
+ * @Public()
+ * @Post('login')
+ * login() { }
+ *
+ * @example
+ * // Skip auth for entire controller
+ * @Public()
+ * @Controller('public')
+ * export class PublicController { }
+ */ const Public = ()=>(0,common_.SetMetadata)(constants/* .IS_PUBLIC_KEY */.jA, true);
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/decorators/require-permission.decorator.ts
+
+
+/** Require ALL permissions (AND logic) - most secure pattern */ const RequirePermission = (...permissions)=>(0,common_.SetMetadata)(constants/* .PERMISSIONS_KEY */.N7, {
+        permissions,
+        operator: 'AND'
+    });
+/** Require ANY permission (OR logic) - use carefully */ const RequireAnyPermission = (...permissions)=>(0,common_.SetMetadata)(constants/* .PERMISSIONS_KEY */.N7, {
+        permissions,
+        operator: 'OR'
+    });
+/**
+ * Require complex permission logic using ILogicNode tree
+ * @example
+ * // Single permission
+ * @RequirePermissionLogic('users.read')
+ * @example
+ * // Complex: users.read AND (admin OR manager)
+ * @RequirePermissionLogic({
+ *   type: 'group', operator: 'AND', children: [
+ *     { type: 'action', actionId: 'users.read' },
+ *     { type: 'group', operator: 'OR', children: [
+ *       { type: 'action', actionId: 'admin' },
+ *       { type: 'action', actionId: 'manager' },
+ *     ]},
+ *   ],
+ * })
+ */ const RequirePermissionLogic = (logic)=>(0,common_.SetMetadata)(constants/* .PERMISSIONS_KEY */.N7, logic);
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/decorators/index.ts
+
+
+
+
+
+
+
+
+},
+946(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(157);
+/* import */ var _classes_winston_logger_class_js__rspack_import_1 = __webpack_require__(245);
+/* import */ var _middlewares_logger_middleware_js__rspack_import_2 = __webpack_require__(419);
+
+
+
+function createLoggerAdapter(className, moduleName) {
+    if (moduleName) {
+        const winstonLogger = (0,_classes_winston_logger_class_js__rspack_import_1/* .createModuleLogger */.X)(moduleName);
+        return {
+            log: (level, message, meta)=>{
+                winstonLogger.log(level, message, {
+                    context: className,
+                    ...meta
+                });
+            },
+            error: (message, stack, meta)=>{
+                winstonLogger.error(message, {
+                    context: className,
+                    stack,
+                    ...meta
+                });
+            }
+        };
+    }
+    const nestLogger = new _nestjs_common__rspack_import_0.Logger(className);
+    return {
+        log: (level, message, meta)=>{
+            nestLogger[level](message, meta);
+        },
+        error: (message, stack, meta)=>{
+            nestLogger.error(message, stack, meta);
+        }
+    };
+}
+function LogAction(options = {}) {
+    return function(target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const className = target.constructor.name;
+        const methodName = String(propertyKey);
+        descriptor.value = async function(...args) {
+            const startTime = Date.now();
+            // Resolve module: decorator option > instance property > undefined
+            const moduleName = options.module || this.moduleName;
+            const logger = createLoggerAdapter(className, moduleName);
+            const action = options.action || `${this.entityName || className}.${methodName}`;
+            const logLevel = options.logLevel || 'debug';
+            const context = {
+                requestId: (0,_middlewares_logger_middleware_js__rspack_import_2/* .getRequestId */.RE)(),
+                userId: (0,_middlewares_logger_middleware_js__rspack_import_2/* .getUserId */.F6)(),
+                tenantId: (0,_middlewares_logger_middleware_js__rspack_import_2/* .getTenantId */.EO)(),
+                companyId: (0,_middlewares_logger_middleware_js__rspack_import_2/* .getCompanyId */.xR)(),
+                method: methodName,
+                module: moduleName
+            };
+            const startMessage = `Executing action method "${action}"`;
+            const startContext = options.includeParams ? {
+                ...context,
+                params: sanitizeParams(args)
+            } : context;
+            logger.log(logLevel, startMessage, startContext);
+            try {
+                const result = await originalMethod.apply(this, args);
+                const duration = Date.now() - startTime;
+                const resultType = getResultType(result);
+                const successMessage = `Executed action method "${action}", returned result "${resultType}" in ${duration.toFixed(2)}ms.`;
+                const successContext = options.includeResult && result ? {
+                    ...context,
+                    duration: `${duration}ms`,
+                    resultType,
+                    resultPreview: getResultPreview(result)
+                } : {
+                    ...context,
+                    duration: `${duration}ms`,
+                    resultType
+                };
+                logger.log(logLevel, successMessage, successContext);
+                return result;
+            } catch (error) {
+                const duration = Date.now() - startTime;
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                logger.error(`Failed action method "${action}" after ${duration.toFixed(2)}ms: ${errorMessage}`, error instanceof Error ? error.stack : undefined, {
+                    ...context,
+                    duration: `${duration}ms`,
+                    error: errorMessage
+                });
+                throw error;
+            }
+        };
+        return descriptor;
+    };
+}
+function sanitizeParams(args) {
+    return args.map((arg)=>{
+        if (arg === null || arg === undefined) return arg;
+        if (typeof arg === 'object') {
+            const sanitized = {
+                ...arg
+            };
+            const sensitiveKeys = [
+                'password',
+                'secret',
+                'token',
+                'apiKey',
+                'authorization'
+            ];
+            for (const key of Object.keys(sanitized)){
+                if (sensitiveKeys.some((sk)=>key.toLowerCase().includes(sk))) {
+                    sanitized[key] = '[REDACTED]';
+                }
+            }
+            return sanitized;
+        }
+        return arg;
+    });
+}
+function getResultType(result) {
+    if (result === null) return 'null';
+    if (result === undefined) return 'undefined';
+    if (Array.isArray(result)) return `Array<${result.length} items>`;
+    if (typeof result === 'object') {
+        const name = result.constructor?.name;
+        return name && name !== 'Object' ? name : 'Object';
+    }
+    return typeof result;
+}
+function getResultPreview(result) {
+    if (Array.isArray(result)) {
+        return {
+            count: result.length,
+            sample: result.slice(0, 2)
+        };
+    }
+    if (typeof result === 'object' && result !== null) {
+        const keys = Object.keys(result).slice(0, 5);
+        return {
+            keys,
+            hasMore: Object.keys(result).length > 5
+        };
+    }
+    return result;
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  J: () => (LogAction)
+});
+
+
+},
+514(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(157);
+/* import */ var _constants_message_keys_js__rspack_import_1 = __webpack_require__(389);
+
+
+class BaseAppException extends _nestjs_common__rspack_import_0.HttpException {
+    messageKey;
+    messageVariables;
+    errors;
+    metadata;
+    constructor(options){
+        const status = options.status || _nestjs_common__rspack_import_0.HttpStatus.BAD_REQUEST;
+        super({
+            success: false,
+            message: options.message,
+            messageKey: options.messageKey || _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.GENERIC */.UU.GENERIC,
+            messageVariables: options.messageVariables,
+            errors: options.errors
+        }, status);
+        this.messageKey = options.messageKey || _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.GENERIC */.UU.GENERIC;
+        this.messageVariables = options.messageVariables;
+        this.errors = options.errors;
+        this.metadata = options.metadata;
+    }
+}
+class NotFoundException extends BaseAppException {
+    constructor(entity, id){
+        super({
+            message: id ? `${entity} with id "${id}" not found` : `${entity} not found`,
+            messageKey: _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.NOT_FOUND */.UU.NOT_FOUND,
+            status: _nestjs_common__rspack_import_0.HttpStatus.NOT_FOUND,
+            metadata: {
+                entity,
+                id
+            }
+        });
+    }
+}
+class ValidationException extends BaseAppException {
+    constructor(errors){
+        super({
+            message: 'Validation failed',
+            messageKey: _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.VALIDATION */.UU.VALIDATION,
+            status: _nestjs_common__rspack_import_0.HttpStatus.BAD_REQUEST,
+            errors
+        });
+    }
+}
+class UnauthorizedException extends BaseAppException {
+    constructor(message = 'Unauthorized access'){
+        super({
+            message,
+            messageKey: _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.UNAUTHORIZED */.UU.UNAUTHORIZED,
+            status: _nestjs_common__rspack_import_0.HttpStatus.UNAUTHORIZED
+        });
+    }
+}
+class ForbiddenException extends BaseAppException {
+    constructor(message = 'Access forbidden'){
+        super({
+            message,
+            messageKey: _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.FORBIDDEN */.UU.FORBIDDEN,
+            status: _nestjs_common__rspack_import_0.HttpStatus.FORBIDDEN
+        });
+    }
+}
+class ConflictException extends BaseAppException {
+    constructor(entity, field){
+        super({
+            message: field ? `${entity} with this ${field} already exists` : `${entity} already exists`,
+            messageKey: _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.CONFLICT */.UU.CONFLICT,
+            messageVariables: {
+                entity,
+                ...field !== undefined && {
+                    field
+                }
+            },
+            status: _nestjs_common__rspack_import_0.HttpStatus.CONFLICT,
+            metadata: {
+                entity,
+                field
+            }
+        });
+    }
+}
+class InternalServerException extends BaseAppException {
+    constructor(message = 'Internal server error'){
+        super({
+            message,
+            messageKey: _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.INTERNAL */.UU.INTERNAL,
+            status: _nestjs_common__rspack_import_0.HttpStatus.INTERNAL_SERVER_ERROR
+        });
+    }
+}
+class ServiceUnavailableException extends BaseAppException {
+    constructor(service){
+        super({
+            message: `${service} is temporarily unavailable`,
+            messageKey: _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.SERVICE_UNAVAILABLE */.UU.SERVICE_UNAVAILABLE,
+            messageVariables: {
+                service
+            },
+            status: _nestjs_common__rspack_import_0.HttpStatus.SERVICE_UNAVAILABLE,
+            metadata: {
+                service
+            }
+        });
+    }
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  GI: () => (InternalServerException),
+  X6: () => (NotFoundException),
+  ZT: () => (ForbiddenException),
+  _W: () => (UnauthorizedException),
+  cb: () => (ConflictException),
+  dr: () => (ValidationException),
+  ld: () => (ServiceUnavailableException),
+  m8: () => (BaseAppException)
+});
+
+
+},
+448(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _base_app_exception_js__rspack_import_0 = __webpack_require__(514);
+/* import */ var _permission_exception_js__rspack_import_1 = __webpack_require__(374);
+
+
+
+__webpack_require__.d(__webpack_exports__, {
+  GI: () => (/* reexport safe */ _base_app_exception_js__rspack_import_0.GI),
+  GS: () => (/* reexport safe */ _permission_exception_js__rspack_import_1.GS),
+  X6: () => (/* reexport safe */ _base_app_exception_js__rspack_import_0.X6),
+  ZT: () => (/* reexport safe */ _base_app_exception_js__rspack_import_0.ZT),
+  _W: () => (/* reexport safe */ _base_app_exception_js__rspack_import_0._W),
+  cb: () => (/* reexport safe */ _base_app_exception_js__rspack_import_0.cb),
+  d$: () => (/* reexport safe */ _permission_exception_js__rspack_import_1.d$),
+  dr: () => (/* reexport safe */ _base_app_exception_js__rspack_import_0.dr),
+  ld: () => (/* reexport safe */ _base_app_exception_js__rspack_import_0.ld),
+  m8: () => (/* reexport safe */ _base_app_exception_js__rspack_import_0.m8),
+  z8: () => (/* reexport safe */ _permission_exception_js__rspack_import_1.z8)
+});
+
+
+},
+374(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(157);
+/* import */ var _constants_message_keys_js__rspack_import_1 = __webpack_require__(389);
+
+
+class PermissionSystemUnavailableException extends _nestjs_common__rspack_import_0.InternalServerErrorException {
+    constructor(){
+        super({
+            success: false,
+            message: 'Permission system temporarily unavailable',
+            messageKey: _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.PERMISSION_SYSTEM_UNAVAILABLE */.UU.PERMISSION_SYSTEM_UNAVAILABLE
+        });
+    }
+}
+class InsufficientPermissionsException extends _nestjs_common__rspack_import_0.ForbiddenException {
+    constructor(missingPermissions, operator = 'AND'){
+        const messageKey = operator === 'OR' ? _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS_OR */.UU.INSUFFICIENT_PERMISSIONS_OR : _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS */.UU.INSUFFICIENT_PERMISSIONS;
+        super({
+            success: false,
+            message: 'Insufficient permissions',
+            messageKey,
+            messageVariables: {
+                permissions: missingPermissions.join(', ')
+            },
+            missingPermissions,
+            operator
+        });
+    }
+}
+class NoPermissionsFoundException extends _nestjs_common__rspack_import_0.ForbiddenException {
+    constructor(){
+        super({
+            success: false,
+            message: 'No permissions found',
+            messageKey: _constants_message_keys_js__rspack_import_1/* .ERROR_MESSAGES.NO_PERMISSIONS_FOUND */.UU.NO_PERMISSIONS_FOUND
+        });
+    }
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  GS: () => (PermissionSystemUnavailableException),
+  d$: () => (NoPermissionsFoundException),
+  z8: () => (InsufficientPermissionsException)
+});
+
+
+},
+510(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  TD: () => (/* reexport */ JwtAuthGuard),
+  Zb: () => (/* reexport */ OptionalJwtGuard),
+  LQ: () => (/* reexport */ PermissionGuard)
+});
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/constants/index.ts
+var constants = __webpack_require__(43);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/constants/message-keys.ts
+var message_keys = __webpack_require__(389);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: external "@nestjs/core"
+var core_ = __webpack_require__(75);
+;// CONCATENATED MODULE: external "@nestjs/passport"
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/guards/jwt-auth.guard.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 JwtAuthGuard extends (0,__rspack_external__nestjs_passport_18907953.AuthGuard)('jwt') {
+    reflector;
+    // NOTE: @Inject(Reflector) required for bundled code - external classes need explicit injection
+    constructor(reflector){
+        super(), this.reflector = reflector;
+    }
+    canActivate(context) {
+        // Check if route is marked as public
+        const isPublic = this.reflector.getAllAndOverride(constants/* .IS_PUBLIC_KEY */.jA, [
+            context.getHandler(),
+            context.getClass()
+        ]);
+        if (isPublic) {
+            return true;
+        }
+        return super.canActivate(context);
+    }
+    handleRequest(err, user) {
+        if (err || !user) {
+            throw err || new common_.UnauthorizedException({
+                message: 'Invalid or expired token',
+                messageKey: message_keys/* .AUTH_MESSAGES.TOKEN_INVALID */.mK.TOKEN_INVALID
+            });
+        }
+        return user;
+    }
+}
+JwtAuthGuard = _ts_decorate([
+    (0,common_.Injectable)(),
+    _ts_param(0, (0,common_.Inject)(core_.Reflector)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof core_.Reflector === "undefined" ? Object : core_.Reflector
+    ])
+], JwtAuthGuard);
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/guards/optional-jwt-auth.guard.ts
+function optional_jwt_auth_guard_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 optional_jwt_auth_guard_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function optional_jwt_auth_guard_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+class OptionalJwtGuard extends (0,__rspack_external__nestjs_passport_18907953.AuthGuard)('jwt') {
+    reflector;
+    constructor(reflector){
+        super(), this.reflector = reflector;
+    }
+    canActivate(context) {
+        const isPublic = this.reflector.getAllAndOverride(constants/* .IS_PUBLIC_KEY */.jA, [
+            context.getHandler(),
+            context.getClass()
+        ]);
+        if (isPublic) {
+            return true;
+        }
+        return super.canActivate(context);
+    }
+    handleRequest(_err, user) {
+        return user || undefined;
+    }
+}
+OptionalJwtGuard = optional_jwt_auth_guard_ts_decorate([
+    (0,common_.Injectable)(),
+    optional_jwt_auth_guard_ts_param(0, (0,common_.Inject)(core_.Reflector)),
+    optional_jwt_auth_guard_ts_metadata("design:type", Function),
+    optional_jwt_auth_guard_ts_metadata("design:paramtypes", [
+        typeof core_.Reflector === "undefined" ? Object : core_.Reflector
+    ])
+], OptionalJwtGuard);
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/exceptions/permission.exception.ts
+var permission_exception = __webpack_require__(374);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/modules/shared-permission-cache/shared-permission-cache.service.ts
+var shared_permission_cache_service = __webpack_require__(657);
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/guards/permission.guard.ts
+function permission_guard_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 permission_guard_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function permission_guard_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+class PermissionGuard {
+    reflector;
+    permissionCacheService;
+    constructor(reflector, permissionCacheService){
+        this.reflector = reflector;
+        this.permissionCacheService = permissionCacheService;
+    }
+    async canActivate(context) {
+        const isPublic = this.reflector.getAllAndOverride(constants/* .IS_PUBLIC_KEY */.jA, [
+            context.getHandler(),
+            context.getClass()
+        ]);
+        if (isPublic) return true;
+        const permissionConfig = this.reflector.getAllAndOverride(constants/* .PERMISSIONS_KEY */.N7, [
+            context.getHandler(),
+            context.getClass()
+        ]);
+        if (!permissionConfig) return true;
+        const request = context.switchToHttp().getRequest();
+        const user = request.user;
+        if (!user) throw new common_.UnauthorizedException({
+            message: 'Authentication required',
+            messageKey: message_keys/* .AUTH_MESSAGES.TOKEN_REQUIRED */.mK.TOKEN_REQUIRED
+        });
+        if (!this.permissionCacheService?.isCacheConfigured()) {
+            throw new permission_exception/* .PermissionSystemUnavailableException */.GS();
+        }
+        const permissionService = this.permissionCacheService;
+        const userPermissions = await permissionService.getPermissions({
+            userId: user.id,
+            companyId: user.companyId,
+            branchId: user.branchId
+        });
+        if (!userPermissions || userPermissions.length === 0) {
+            throw new permission_exception/* .NoPermissionsFoundException */.d$();
+        }
+        const logicNode = this.normalizeToLogicNode(permissionConfig);
+        if (!logicNode) return true;
+        const result = this.evaluateLogicNode(logicNode, userPermissions, permissionService);
+        if (!result.passed) {
+            throw new permission_exception/* .InsufficientPermissionsException */.z8(result.missingPermissions, result.operator);
+        }
+        return true;
+    }
+    normalizeToLogicNode(config) {
+        // string - single permission
+        if (typeof config === 'string') {
+            return config ? {
+                type: 'action',
+                actionId: config
+            } : null;
+        }
+        // string[] - treat as AND of multiple permissions
+        if (Array.isArray(config)) {
+            if (config.length === 0) return null;
+            if (config.length === 1) return {
+                type: 'action',
+                actionId: config[0]
+            };
+            return {
+                type: 'group',
+                operator: 'AND',
+                children: config.map((p)=>({
+                        type: 'action',
+                        actionId: p
+                    }))
+            };
+        }
+        // SimplePermissionConfig - { permissions: string[], operator: 'AND'|'OR' }
+        if ('permissions' in config && Array.isArray(config.permissions)) {
+            const simple = config;
+            if (simple.permissions.length === 0) return null;
+            if (simple.permissions.length === 1) return {
+                type: 'action',
+                actionId: simple.permissions[0]
+            };
+            return {
+                type: 'group',
+                operator: simple.operator || 'AND',
+                children: simple.permissions.map((p)=>({
+                        type: 'action',
+                        actionId: p
+                    }))
+            };
+        }
+        // ILogicNode
+        return config;
+    }
+    evaluateLogicNode(node, userPermissions, permissionService) {
+        if (node.type === 'action') {
+            const passed = permissionService.matchPermission(userPermissions, node.actionId);
+            return {
+                passed,
+                missingPermissions: passed ? [] : [
+                    node.actionId
+                ],
+                operator: 'AND'
+            };
+        }
+        // Group node
+        const { operator, children } = node;
+        // SECURITY: Fail-closed - deny access when no children configured
+        if (!children || children.length === 0) {
+            return {
+                passed: false,
+                missingPermissions: [],
+                operator
+            };
+        }
+        const results = [];
+        const missingPermissions = [];
+        for (const child of children){
+            const childResult = this.evaluateLogicNode(child, userPermissions, permissionService);
+            results.push(childResult.passed);
+            if (!childResult.passed) {
+                missingPermissions.push(...childResult.missingPermissions);
+            }
+        }
+        const passed = operator === 'OR' ? results.some((r)=>r) : results.every((r)=>r);
+        return {
+            passed,
+            missingPermissions: passed ? [] : missingPermissions,
+            operator
+        };
+    }
+}
+PermissionGuard = permission_guard_ts_decorate([
+    (0,common_.Injectable)(),
+    permission_guard_ts_param(0, (0,common_.Inject)(core_.Reflector)),
+    permission_guard_ts_param(1, (0,common_.Optional)()),
+    permission_guard_ts_param(1, (0,common_.Inject)(shared_permission_cache_service/* .SharedPermissionCacheService */.U)),
+    permission_guard_ts_metadata("design:type", Function),
+    permission_guard_ts_metadata("design:paramtypes", [
+        typeof core_.Reflector === "undefined" ? Object : core_.Reflector,
+        typeof shared_permission_cache_service/* .SharedPermissionCacheService */.U === "undefined" ? Object : shared_permission_cache_service/* .SharedPermissionCacheService */.U
+    ])
+], PermissionGuard);
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/guards/index.ts
+
+
+
+
+
+},
+863(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  nd: () => (/* reexport */ DeleteEmptyIdFromBodyInterceptor),
+  Bw: () => (/* reexport */ IdempotencyInterceptor),
+  c_: () => (/* reexport */ ResponseMetaInterceptor),
+  VS: () => (/* reexport */ SetCreatedByOnBody),
+  Ul: () => (/* reexport */ SetDeletedByOnBody),
+  _x: () => (/* reexport */ SetUpdateByOnBody),
+  Mw: () => (/* reexport */ Slug),
+  BR: () => (/* reexport */ createSetUserFieldInterceptor)
+});
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+;// 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;
+    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;
+}
+
+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;
+            }
+            request.body = item;
+        }
+        return next.handle();
+    }
+}
+DeleteEmptyIdFromBodyInterceptor = _ts_decorate([
+    (0,common_.Injectable)()
+], DeleteEmptyIdFromBodyInterceptor);
+
+;// CONCATENATED MODULE: external "rxjs"
+
+;// 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);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/constants/index.ts
+var constants = __webpack_require__(43);
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/constants/message-keys.ts
+var message_keys = __webpack_require__(389);
+;// 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;
+    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 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 request = context.switchToHttp().getRequest();
+        const idempotencyKey = request.headers[constants/* .IDEMPOTENCY_KEY_HEADER */.iH];
+        // Skip if no idempotency key provided
+        if (!idempotencyKey) {
+            return next.handle();
+        }
+        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: message_keys/* .SYSTEM_MESSAGES.DUPLICATE_REQUEST */.hg.DUPLICATE_REQUEST
+                });
+            }
+            // Return cached response
+            return (0,__rspack_external_rxjs.of)(cached);
+        }
+        // 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);
+        }));
+    }
+}
+IdempotencyInterceptor = idempotency_interceptor_ts_decorate([
+    (0,common_.Injectable)(),
+    _ts_param(0, (0,common_.Optional)()),
+    _ts_param(0, (0,common_.Inject)(constants/* .CACHE_INSTANCE */.zl)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof hybrid_cache_class/* .HybridCache */.l === "undefined" ? Object : hybrid_cache_class/* .HybridCache */.l
+    ])
+], IdempotencyInterceptor);
+
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(823);
+;// 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;
+    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;
+}
+
+
+
+
+class ResponseMetaInterceptor {
+    intercept(context, next) {
+        const request = context.switchToHttp().getRequest();
+        const startTime = Date.now();
+        // Generate or use existing request ID
+        const requestId = request.headers[constants/* .REQUEST_ID_HEADER */.kC] || `req_${(0,external_crypto_.randomUUID)().slice(0, 12)}`;
+        // Store request ID for logging
+        request.requestId = requestId;
+        return next.handle().pipe((0,__rspack_external_rxjs_operators_2eaa0997.map)((response)=>{
+            // Only add metadata if response is an object with success field
+            if (response && typeof response === 'object' && 'success' in response) {
+                return {
+                    ...response,
+                    _meta: {
+                        requestId,
+                        timestamp: new Date().toISOString(),
+                        responseTime: Date.now() - startTime
+                    }
+                };
+            }
+            return response;
+        }));
+    }
+}
+ResponseMetaInterceptor = response_meta_interceptor_ts_decorate([
+    (0,common_.Injectable)()
+], ResponseMetaInterceptor);
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/interceptors/set-user-field-on-body.interceptor.ts
+function set_user_field_on_body_interceptor_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;
+}
+
+/**
+ * Factory function to create interceptors that set user ID fields on request body
+ * @param fieldName - The field name to set (e.g., 'createdById', 'updatedById', 'deletedById')
+ */ function createSetUserFieldInterceptor(fieldName) {
+    let SetUserFieldOnBody = class SetUserFieldOnBody {
+        intercept(context, next) {
+            const request = context.switchToHttp().getRequest();
+            const user = request?.user;
+            if (user) {
+                if (Array.isArray(request.body)) {
+                    request.body = request.body.map((item)=>({
+                            ...item,
+                            [fieldName]: user.id
+                        }));
+                } else if (typeof request.body === 'object' && request.body !== null) {
+                    request.body = {
+                        ...request.body,
+                        [fieldName]: user.id
+                    };
+                }
+            }
+            return next.handle();
+        }
+    };
+    SetUserFieldOnBody = set_user_field_on_body_interceptor_ts_decorate([
+        (0,common_.Injectable)()
+    ], SetUserFieldOnBody);
+    return SetUserFieldOnBody;
+}
+/** Sets createdById field on request body from authenticated user */ const SetCreatedByOnBody = createSetUserFieldInterceptor('createdById');
+/** Sets updatedById field on request body from authenticated user */ const SetUpdateByOnBody = createSetUserFieldInterceptor('updatedById');
+/** Sets deletedById field on request body from authenticated user */ const SetDeletedByOnBody = createSetUserFieldInterceptor('deletedById');
+
+// EXTERNAL MODULE: ./projects/nestjs-shared/src/modules/utils/utils.service.ts
+var utils_service = __webpack_require__(169);
+;// 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;
+    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 slug_interceptor_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function slug_interceptor_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+class Slug {
+    utilsService;
+    constructor(utilsService){
+        this.utilsService = utilsService;
+    }
+    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)
+            };
+        }
+        return next.handle();
+    }
+}
+Slug = slug_interceptor_ts_decorate([
+    (0,common_.Injectable)(),
+    slug_interceptor_ts_param(0, (0,common_.Inject)(utils_service/* .UtilsService */.T)),
+    slug_interceptor_ts_metadata("design:type", Function),
+    slug_interceptor_ts_metadata("design:paramtypes", [
+        typeof utils_service/* .UtilsService */.T === "undefined" ? Object : utils_service/* .UtilsService */.T
+    ])
+], Slug);
+
+;// CONCATENATED MODULE: ./projects/nestjs-shared/src/interceptors/index.ts
+
+
+
+
+
+
+
+},
+823(module) {
+
+module.exports = __rspack_external_crypto;
+
+
+},
+
+};