@flusys/nestjs-storage 7.1.0 → 8.0.0

package/fesm/493.js

@@ -0,0 +1,2768 @@
+import { Identity } from "@flusys/nestjs-shared/entities";
+import * as __rspack_external__flusys_nestjs_shared_393d2cae from "@flusys/nestjs-shared";
+import * as __rspack_external__flusys_nestjs_shared_classes_6076a329 from "@flusys/nestjs-shared/classes";
+import * as __rspack_external__flusys_nestjs_shared_constants_81f33d5b from "@flusys/nestjs-shared/constants";
+import * as __rspack_external__flusys_nestjs_shared_modules_24702bee from "@flusys/nestjs-shared/modules";
+import * as __rspack_external__flusys_nestjs_shared_utils_9125c1f1 from "@flusys/nestjs-shared/utils";
+import * as __rspack_external__nestjs_common_a04939da from "@nestjs/common";
+import * as __rspack_external__nestjs_swagger_7cd450b5 from "@nestjs/swagger";
+import * as __rspack_external_class_transformer_c5a479fb from "class-transformer";
+import * as __rspack_external_class_validator_7b99ef4d from "class-validator";
+import * as __rspack_external_typeorm from "typeorm";
+import * as __rspack_external__nestjs_core_d7b00a1a from "@nestjs/core";
+import * as __rspack_external_crypto from "crypto";
+export const __rspack_esm_id = 493;
+export const __rspack_esm_ids = [493];
+export const __webpack_modules__ = {
+884(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Domain event actions published by the storage module, alongside the CRUD
+ * lifecycle actions every ApiService emits.
+ */ const STORAGE_EVENT_ACTIONS = {
+    UPLOADED: 'uploaded',
+    REMOVED: 'removed'
+};
+/** Every entity the storage module publishes under, ApiService backed or not */ const STORAGE_EVENT_ENTITIES = {
+    FILE: 'file_manager',
+    FOLDER: 'folder',
+    STORAGE_CONFIG: 'storageConfig'
+};
+const STORAGE_EVENT_MODULE = 'storage';
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  fR: STORAGE_EVENT_ENTITIES,
+  hw: STORAGE_EVENT_ACTIONS,
+  qh: STORAGE_EVENT_MODULE
+});
+
+
+},
+450(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+// ==================== STORAGE MODULE MESSAGE KEYS ====================
+const FILE_MESSAGES = {
+    GET_ALL_SUCCESS: 'file.get.all.success',
+    DELETE_SUCCESS: 'file.delete.success',
+    NOT_FOUND: 'file.not.found'
+};
+const STORAGE_CONFIG_MESSAGES = {
+    DEFAULT_DELETE_FORBIDDEN: 'storage.config.default.delete.forbidden'
+};
+const FOLDER_MESSAGES = {
+    NOT_FOUND: 'folder.not.found'
+};
+const UPLOAD_MESSAGES = {
+    SUCCESS: 'upload.success',
+    MANY_SUCCESS: 'upload.many.success',
+    FILE_TOO_LARGE: 'upload.file.too.large',
+    INVALID_TYPE: 'upload.invalid.type',
+    NO_FILES_PROVIDED: 'upload.no.files.provided',
+    NO_FILE_PATH: 'upload.no.file.path',
+    INVALID_FILE_PATH: 'upload.invalid.file.path',
+    CONFIG_NOT_FOUND: 'upload.config.not.found'
+};
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  Ee: FOLDER_MESSAGES,
+  Y8: STORAGE_CONFIG_MESSAGES,
+  dS: UPLOAD_MESSAGES,
+  uA: FILE_MESSAGES
+});
+
+
+},
+188(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Storage Module Constants
+ */ const STORAGE_MODULE_OPTIONS = 'STORAGE_MODULE_OPTIONS';
+const DEFAULT_MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
+const DEFAULT_ALLOWED_FILE_TYPES = [
+    '*/*'
+]; // All file types
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  A_: DEFAULT_ALLOWED_FILE_TYPES,
+  Sj: DEFAULT_MAX_FILE_SIZE,
+  k0: STORAGE_MODULE_OPTIONS
+});
+
+
+},
+322(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _nestjs_swagger__rspack_import_0 = __webpack_require__(176);
+/* import */ var class_transformer__rspack_import_1 = __webpack_require__(812);
+/* import */ var class_validator__rspack_import_2 = __webpack_require__(421);
+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);
+    }
+}
+
+
+
+var ImageFormat = /*#__PURE__*/ function(ImageFormat) {
+    ImageFormat["ORIGINAL"] = "original";
+    ImageFormat["JPEG"] = "jpeg";
+    ImageFormat["PNG"] = "png";
+    ImageFormat["WEBP"] = "webp";
+    return ImageFormat;
+}({});
+class DeleteSingleFileDto {
+    key;
+    storageConfigId;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        description: 'Key of the file to delete',
+        example: '/uploads/some-path'
+    }),
+    (0,class_validator__rspack_import_2.IsNotEmpty)(),
+    (0,class_validator__rspack_import_2.IsString)(),
+    _ts_metadata("design:type", String)
+], DeleteSingleFileDto.prototype, "key", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Storage configuration ID',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_validator__rspack_import_2.IsUUID)(),
+    _ts_metadata("design:type", String)
+], DeleteSingleFileDto.prototype, "storageConfigId", void 0);
+class DeleteMultipleFileDto {
+    keys;
+    storageConfigId;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        description: 'Array of file keys to delete',
+        example: [
+            '/uploads/file1',
+            '/uploads/file2'
+        ],
+        type: [
+            String
+        ]
+    }),
+    (0,class_validator__rspack_import_2.IsNotEmpty)(),
+    (0,class_validator__rspack_import_2.IsArray)(),
+    (0,class_validator__rspack_import_2.IsString)({
+        each: true
+    }),
+    _ts_metadata("design:type", Array)
+], DeleteMultipleFileDto.prototype, "keys", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Storage configuration ID',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_validator__rspack_import_2.IsUUID)(),
+    _ts_metadata("design:type", String)
+], DeleteMultipleFileDto.prototype, "storageConfigId", void 0);
+class UploadOptionsDto {
+    storageConfigId;
+    folderPath;
+    maxWidth = 1280;
+    maxHeight = 1280;
+    quality = 85;
+    format = "original";
+    compress = true;
+}
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Storage configuration ID',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_validator__rspack_import_2.IsUUID)(),
+    _ts_metadata("design:type", String)
+], UploadOptionsDto.prototype, "storageConfigId", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Folder path for upload',
+        example: 'uploads/images'
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_validator__rspack_import_2.Matches)(/^[a-zA-Z0-9-_/]*$/, {
+        message: 'folderPath can only contain letters, numbers, hyphens, underscores, and slashes.'
+    }),
+    _ts_metadata("design:type", String)
+], UploadOptionsDto.prototype, "folderPath", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Maximum width in pixels',
+        example: 1280,
+        minimum: 100,
+        maximum: 10000,
+        default: 1280
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_transformer__rspack_import_1.Type)(()=>Number),
+    (0,class_validator__rspack_import_2.IsInt)(),
+    (0,class_validator__rspack_import_2.Min)(100),
+    (0,class_validator__rspack_import_2.Max)(10000),
+    _ts_metadata("design:type", Number)
+], UploadOptionsDto.prototype, "maxWidth", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Maximum height in pixels',
+        example: 1280,
+        minimum: 100,
+        maximum: 10000,
+        default: 1280
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_transformer__rspack_import_1.Type)(()=>Number),
+    (0,class_validator__rspack_import_2.IsInt)(),
+    (0,class_validator__rspack_import_2.Min)(100),
+    (0,class_validator__rspack_import_2.Max)(10000),
+    _ts_metadata("design:type", Number)
+], UploadOptionsDto.prototype, "maxHeight", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Compression quality (1-100)',
+        example: 85,
+        minimum: 1,
+        maximum: 100,
+        default: 85
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_transformer__rspack_import_1.Type)(()=>Number),
+    (0,class_validator__rspack_import_2.IsInt)(),
+    (0,class_validator__rspack_import_2.Min)(1),
+    (0,class_validator__rspack_import_2.Max)(100),
+    _ts_metadata("design:type", Number)
+], UploadOptionsDto.prototype, "quality", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Output image format',
+        enum: ImageFormat,
+        default: "original"
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_validator__rspack_import_2.IsEnum)(ImageFormat),
+    _ts_metadata("design:type", String)
+], UploadOptionsDto.prototype, "format", void 0);
+_ts_decorate([
+    (0,_nestjs_swagger__rspack_import_0.ApiPropertyOptional)({
+        description: 'Whether to compress the image',
+        example: true,
+        default: true
+    }),
+    (0,class_validator__rspack_import_2.IsOptional)(),
+    (0,class_transformer__rspack_import_1.Type)(()=>Boolean),
+    (0,class_validator__rspack_import_2.IsBoolean)(),
+    _ts_metadata("design:type", Boolean)
+], UploadOptionsDto.prototype, "compress", void 0);
+class FileUploadResponsePayloadDto {
+    name;
+    contentType;
+    size;
+    key;
+    location;
+    storageConfigId;
+}
+_ts_decorate([
+    (0,class_transformer__rspack_import_1.Expose)(),
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        description: 'Original filename of the uploaded file',
+        example: 'profile-photo.jpg'
+    }),
+    _ts_metadata("design:type", String)
+], FileUploadResponsePayloadDto.prototype, "name", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_1.Expose)(),
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        description: 'MIME type of the uploaded file',
+        example: 'image/jpeg'
+    }),
+    _ts_metadata("design:type", String)
+], FileUploadResponsePayloadDto.prototype, "contentType", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_1.Expose)(),
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        description: 'File size in bytes',
+        example: 204800,
+        minimum: 0
+    }),
+    _ts_metadata("design:type", Number)
+], FileUploadResponsePayloadDto.prototype, "size", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_1.Expose)(),
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        description: 'Storage key / path used to retrieve the file from the provider',
+        example: 'uploads/users/abc123/profile-photo.jpg'
+    }),
+    _ts_metadata("design:type", String)
+], FileUploadResponsePayloadDto.prototype, "key", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_1.Expose)(),
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        description: 'Storage provider type (e.g. s3, gcs, local)',
+        example: 's3'
+    }),
+    _ts_metadata("design:type", String)
+], FileUploadResponsePayloadDto.prototype, "location", void 0);
+_ts_decorate([
+    (0,class_transformer__rspack_import_1.Expose)(),
+    (0,_nestjs_swagger__rspack_import_0.ApiProperty)({
+        description: 'ID of the storage configuration used to store this file',
+        example: '123e4567-e89b-12d3-a456-426614174000'
+    }),
+    _ts_metadata("design:type", String)
+], FileUploadResponsePayloadDto.prototype, "storageConfigId", void 0);
+
+__webpack_require__.d(__webpack_exports__, {
+  $V: () => (DeleteMultipleFileDto),
+  My: () => (FileUploadResponsePayloadDto),
+  Pd: () => (DeleteSingleFileDto),
+  f5: () => (ImageFormat),
+  hL: () => (UploadOptionsDto)
+});
+
+
+},
+975(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  FileManager: () => (/* reexport */ FileManager),
+  NP: () => (/* reexport */ FileManager),
+  FileManagerWithCompany: () => (/* reexport */ FileManagerWithCompany),
+  Folder: () => (/* reexport */ Folder),
+  KQ: () => (/* reexport */ Folder),
+  FolderWithCompany: () => (/* reexport */ FolderWithCompany),
+  eZ: () => (/* binding */ StorageCompanyEntities),
+  StorageConfig: () => (/* reexport */ StorageConfig),
+  Zk: () => (/* reexport */ StorageConfig),
+  StorageConfigWithCompany: () => (/* reexport */ StorageConfigWithCompany),
+  oM: () => (/* binding */ StorageCoreEntities),
+  eu: () => (/* binding */ getStorageEntitiesByConfig)
+});
+
+;// CONCATENATED MODULE: external "@flusys/nestjs-shared/entities"
+
+// EXTERNAL MODULE: external "typeorm"
+var external_typeorm_ = __webpack_require__(158);
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/entities/file-manager.entity.ts
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+class FileManager extends Identity {
+    name;
+    contentType;
+    size;
+    key;
+    url;
+    location;
+    storageConfigId;
+    expiresAt = null;
+    isPrivate;
+    folder;
+}
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], FileManager.prototype, "name", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], FileManager.prototype, "contentType", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], FileManager.prototype, "size", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'text',
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], FileManager.prototype, "key", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'text',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], FileManager.prototype, "url", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 50,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], FileManager.prototype, "location", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], FileManager.prototype, "storageConfigId", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'bigint',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], FileManager.prototype, "expiresAt", void 0);
+_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        nullable: false,
+        default: false
+    }),
+    _ts_metadata("design:type", Boolean)
+], FileManager.prototype, "isPrivate", void 0);
+_ts_decorate([
+    (0,external_typeorm_.ManyToOne)('Folder', (folder)=>folder.fileManager, {
+        nullable: true,
+        onDelete: 'SET NULL'
+    }),
+    (0,external_typeorm_.JoinColumn)({
+        name: 'folder_id'
+    }),
+    _ts_metadata("design:type", Object)
+], FileManager.prototype, "folder", void 0);
+FileManager = _ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'file_manager'
+    })
+], FileManager);
+
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/entities/folder.entity.ts
+function folder_entity_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function folder_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+class Folder extends Identity {
+    name;
+    slug;
+    fileManager;
+}
+folder_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    folder_entity_ts_metadata("design:type", String)
+], Folder.prototype, "name", void 0);
+folder_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    folder_entity_ts_metadata("design:type", String)
+], Folder.prototype, "slug", void 0);
+folder_entity_ts_decorate([
+    (0,external_typeorm_.OneToMany)('FileManager', (fileManager)=>fileManager.folder),
+    folder_entity_ts_metadata("design:type", Array)
+], Folder.prototype, "fileManager", void 0);
+Folder = folder_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'folder'
+    })
+], Folder);
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared"
+var nestjs_shared_ = __webpack_require__(422);
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/entities/storage-config.entity.ts
+function storage_config_entity_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function storage_config_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+
+class StorageConfig extends Identity {
+    name;
+    storage;
+    config;
+    isActive;
+    isDefault;
+}
+storage_config_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: false
+    }),
+    storage_config_entity_ts_metadata("design:type", String)
+], StorageConfig.prototype, "name", void 0);
+storage_config_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'varchar',
+        length: 50,
+        nullable: false
+    }),
+    storage_config_entity_ts_metadata("design:type", String)
+], StorageConfig.prototype, "storage", void 0);
+storage_config_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: (0,nestjs_shared_.getJsonColumnType)(),
+        nullable: false
+    }),
+    storage_config_entity_ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], StorageConfig.prototype, "config", void 0);
+storage_config_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: true,
+        name: 'is_active'
+    }),
+    storage_config_entity_ts_metadata("design:type", Boolean)
+], StorageConfig.prototype, "isActive", void 0);
+storage_config_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'boolean',
+        default: false,
+        name: 'is_default'
+    }),
+    storage_config_entity_ts_metadata("design:type", Boolean)
+], StorageConfig.prototype, "isDefault", void 0);
+StorageConfig = storage_config_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'storage_config'
+    }),
+    (0,external_typeorm_.Index)([
+        'name'
+    ]),
+    (0,external_typeorm_.Index)([
+        'storage'
+    ]),
+    (0,external_typeorm_.Index)([
+        'isActive'
+    ]),
+    (0,external_typeorm_.Index)([
+        'isDefault'
+    ])
+], StorageConfig);
+
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/entities/file-manager-with-company.entity.ts
+function file_manager_with_company_entity_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function file_manager_with_company_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+class FileManagerWithCompany extends FileManager {
+    companyId;
+}
+file_manager_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        nullable: true
+    }),
+    file_manager_with_company_entity_ts_metadata("design:type", Object)
+], FileManagerWithCompany.prototype, "companyId", void 0);
+file_manager_with_company_entity_ts_decorate([
+    (0,external_typeorm_.ManyToOne)('FolderWithCompany', (folder)=>folder.fileManager, {
+        nullable: true,
+        onDelete: 'SET NULL'
+    }),
+    (0,external_typeorm_.JoinColumn)({
+        name: 'folder_id'
+    }),
+    file_manager_with_company_entity_ts_metadata("design:type", Object)
+], FileManagerWithCompany.prototype, "folder", void 0);
+FileManagerWithCompany = file_manager_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'file_manager'
+    })
+], FileManagerWithCompany);
+
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/entities/folder-with-company.entity.ts
+function folder_with_company_entity_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function folder_with_company_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+class FolderWithCompany extends Folder {
+    companyId;
+}
+folder_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        nullable: true
+    }),
+    folder_with_company_entity_ts_metadata("design:type", Object)
+], FolderWithCompany.prototype, "companyId", void 0);
+folder_with_company_entity_ts_decorate([
+    (0,external_typeorm_.OneToMany)('FileManagerWithCompany', (fileManager)=>fileManager.folder),
+    folder_with_company_entity_ts_metadata("design:type", Array)
+], FolderWithCompany.prototype, "fileManager", void 0);
+FolderWithCompany = folder_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'folder'
+    })
+], FolderWithCompany);
+
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/entities/storage-config-with-company.entity.ts
+function storage_config_with_company_entity_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function storage_config_with_company_entity_ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+
+
+class StorageConfigWithCompany extends StorageConfig {
+    companyId;
+}
+storage_config_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Column)({
+        type: 'uuid',
+        nullable: true
+    }),
+    storage_config_with_company_entity_ts_metadata("design:type", Object)
+], StorageConfigWithCompany.prototype, "companyId", void 0);
+StorageConfigWithCompany = storage_config_with_company_entity_ts_decorate([
+    (0,external_typeorm_.Entity)({
+        name: 'storage_config'
+    })
+], StorageConfigWithCompany);
+
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/entities/index.ts
+// Entities without company feature
+
+
+
+// Entities with company feature
+
+
+
+
+
+
+
+
+
+// Core entities (no company feature)
+const StorageCoreEntities = [
+    FileManager,
+    Folder,
+    StorageConfig
+];
+// Company-specific entities
+const StorageCompanyEntities = [
+    FileManagerWithCompany,
+    FolderWithCompany,
+    StorageConfigWithCompany
+];
+function getStorageEntitiesByConfig(enableCompanyFeature) {
+    return enableCompanyFeature ? StorageCompanyEntities : StorageCoreEntities;
+}
+// Base type aliases for backwards compatibility with services
+
+
+
+
+
+},
+733(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+var FileLocationEnum = /*#__PURE__*/ function(FileLocationEnum) {
+    FileLocationEnum["AWS"] = "aws";
+    FileLocationEnum["AZURE"] = "azure";
+    FileLocationEnum["SFTP"] = "sftp";
+    FileLocationEnum["LOCAL"] = "local";
+    return FileLocationEnum;
+}({});
+
+__webpack_require__.d(__webpack_exports__, {
+  N: () => (FileLocationEnum)
+});
+
+
+},
+192(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  L: () => (/* binding */ StorageFactoryService)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/constants"
+var constants_ = __webpack_require__(140);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+;// CONCATENATED MODULE: external "crypto"
+
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/services/index.ts
+var services = __webpack_require__(148);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/providers/storage-provider.registry.ts
+var storage_provider_registry = __webpack_require__(264);
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/providers/storage-factory.service.ts
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+class StorageFactoryService {
+    configService;
+    cache = new Map();
+    constructor(configService){
+        this.configService = configService;
+    }
+    async createProvider(config) {
+        const cacheKey = this.generateCacheKey(config);
+        const cached = this.cache.get(cacheKey);
+        if (cached) return cached;
+        const ProviderClass = storage_provider_registry/* .StorageProviderRegistry.get */.C.get(config.provider);
+        if (!ProviderClass) {
+            throw new common_.NotFoundException({
+                message: `Storage provider '${config.provider}' not available. Available: ${storage_provider_registry/* .StorageProviderRegistry.getAll */.C.getAll().join(', ')}`,
+                messageKey: constants_.SYSTEM_MESSAGES.SERVICE_NOT_AVAILABLE,
+                messageVariables: {
+                    provider: config.provider,
+                    available: storage_provider_registry/* .StorageProviderRegistry.getAll */.C.getAll().join(', ')
+                }
+            });
+        }
+        try {
+            const instance = new ProviderClass();
+            await this.initializeProvider(instance, config);
+            this.cache.set(cacheKey, instance);
+            return instance;
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new common_.InternalServerErrorException({
+                message: `Failed to initialize '${config.provider}': ${errorMessage}`,
+                messageKey: constants_.SYSTEM_MESSAGES.INTERNAL_ERROR,
+                messageVariables: {
+                    provider: config.provider,
+                    error: errorMessage
+                }
+            });
+        }
+    }
+    async getProvider(providerName) {
+        const cachedKey = Array.from(this.cache.keys()).find((k)=>k.startsWith(providerName));
+        if (cachedKey) return this.cache.get(cachedKey);
+        return this.createProvider({
+            provider: providerName,
+            config: {}
+        });
+    }
+    getLocalProviderBasePath() {
+        const localKey = Array.from(this.cache.keys()).find((k)=>k.startsWith('local'));
+        const provider = localKey ? this.cache.get(localKey) : null;
+        return provider && 'basePath' in provider ? provider.basePath : null;
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+    async onModuleDestroy() {
+        const closePromises = Array.from(this.cache.entries()).filter(([, p])=>'close' in p && typeof p.close === 'function').map(([, p])=>p.close().catch(()=>{}));
+        await Promise.allSettled(closePromises);
+        this.cache.clear();
+    }
+    // ─── Private Helpers ──────────────────────────────────────────────────────────
+    generateCacheKey(config) {
+        const sortedKeys = Object.keys(config.config || {}).sort();
+        const hash = __rspack_external_crypto.createHash('sha256').update(JSON.stringify(config.config, sortedKeys)).digest('hex').substring(0, 16);
+        return `${config.provider}-${hash}`;
+    }
+    async initializeProvider(instance, config) {
+        if (!('initialize' in instance) || typeof instance.initialize !== 'function') {
+            return;
+        }
+        let initConfig = config.config;
+        // Inject appUrl as baseUrl fallback for local provider
+        if (config.provider === 'local' && !config.config?.baseUrl) {
+            const appUrl = this.configService.getAppUrl();
+            if (appUrl) {
+                initConfig = {
+                    ...config.config,
+                    baseUrl: appUrl
+                };
+            }
+        }
+        await instance.initialize(initConfig);
+    }
+}
+StorageFactoryService = _ts_decorate([
+    (0,common_.Injectable)(),
+    _ts_param(0, (0,common_.Inject)(services/* .StorageConfigService */.tP)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof services/* .StorageConfigService */.tP === "undefined" ? Object : services/* .StorageConfigService */.tP
+    ])
+], StorageFactoryService);
+
+
+},
+264(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/**
+ * Static registry for storage provider classes
+ * Allows dynamic registration at runtime
+ */ class StorageProviderRegistry {
+    static providers = new Map();
+    static register(name, providerClass) {
+        this.providers.set(name.toLowerCase(), providerClass);
+    }
+    static get(name) {
+        return this.providers.get(name.toLowerCase());
+    }
+    static has(name) {
+        return this.providers.has(name.toLowerCase());
+    }
+    static getAll() {
+        return Array.from(this.providers.keys());
+    }
+    static clear() {
+        this.providers.clear();
+    }
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  C: () => (StorageProviderRegistry)
+});
+
+
+},
+955(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  D: () => (FileManagerService)
+});
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(937);
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_1 = __webpack_require__(236);
+/* import */ var _flusys_nestjs_shared_utils__rspack_import_2 = __webpack_require__(216);
+/* import */ var _nestjs_common__rspack_import_3 = __webpack_require__(157);
+/* import */ var typeorm__rspack_import_4 = __webpack_require__(158);
+/* import */ var _config_index_js__rspack_import_9 = __webpack_require__(884);
+/* import */ var _config_index_js__rspack_import_10 = __webpack_require__(450);
+/* import */ var _entities_index_js__rspack_import_5 = __webpack_require__(975);
+/* import */ var _enums_file_location_enum_js__rspack_import_11 = __webpack_require__(733);
+/* import */ var _storage_config_service_js__rspack_import_6 = __webpack_require__(397);
+/* import */ var _storage_datasource_provider_js__rspack_import_7 = __webpack_require__(616);
+/* import */ var _upload_service_js__rspack_import_8 = __webpack_require__(18);
+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);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+const URL_EXPIRY_SECONDS = 3600;
+const DEFAULT_SELECT_FIELDS = [
+    'id',
+    'name',
+    'contentType',
+    'size',
+    'key',
+    'url',
+    'location',
+    'storageConfigId',
+    'isPrivate',
+    'createdAt',
+    'deletedAt'
+];
+class FileManagerService extends _flusys_nestjs_shared_classes__rspack_import_0.ApiService {
+    cacheManager;
+    utilsService;
+    uploadService;
+    storageConfig;
+    dataSourceProvider;
+    permissionCacheService;
+    constructor(cacheManager, utilsService, uploadService, storageConfig, dataSourceProvider, permissionCacheService){
+        super(_config_index_js__rspack_import_9/* .STORAGE_EVENT_ENTITIES.FILE */.fR.FILE, cacheManager, utilsService, FileManagerService.name, true, _config_index_js__rspack_import_9/* .STORAGE_EVENT_MODULE */.qh, dataSourceProvider, storageConfig.isCompanyFeatureEnabled() ? _entities_index_js__rspack_import_5.FileManagerWithCompany : _entities_index_js__rspack_import_5.FileManager), this.cacheManager = cacheManager, this.utilsService = utilsService, this.uploadService = uploadService, this.storageConfig = storageConfig, this.dataSourceProvider = dataSourceProvider, this.permissionCacheService = permissionCacheService;
+    }
+    // ─── Override Methods ───────────────────────────────────────────────────────
+    async convertSingleDtoToEntity(dto, user) {
+        let entity = {};
+        if ('id' in dto && dto.id && typeof dto.id === 'string') {
+            const existing = await this.repository.findOne({
+                where: {
+                    id: dto.id
+                }
+            });
+            if (!existing) throw new _nestjs_common__rspack_import_3.NotFoundException({
+                message: 'Entity not found for update',
+                messageKey: _config_index_js__rspack_import_10/* .FILE_MESSAGES.NOT_FOUND */.uA.NOT_FOUND
+            });
+            entity = existing;
+        }
+        const validatedFolder = dto.folderId ? await this.validateFolder(dto.folderId, user) : null;
+        const storageLocation = await this.resolveStorageLocation(dto, user);
+        const merged = {
+            ...entity,
+            ...dto,
+            location: storageLocation,
+            folder: validatedFolder
+        };
+        if (this.storageConfig.isCompanyFeatureEnabled()) {
+            merged.companyId = user?.companyId ?? null;
+        }
+        return merged;
+    }
+    async getSelectQuery(query, _user, select) {
+        const fields = (select?.length ? select : DEFAULT_SELECT_FIELDS).map((f)=>`${this.entityName}.${f}`);
+        if (this.storageConfig.isCompanyFeatureEnabled()) {
+            fields.push('file_manager.companyId');
+        }
+        fields.push('folder.id', 'folder.name');
+        query.leftJoinAndSelect('file_manager.folder', 'folder').select(fields);
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getFilterQuery(query, filter, _user) {
+        for (const [key, value] of Object.entries(filter)){
+            if (key === 'contentType' && typeof value === 'string') {
+                this.applyContentTypeFilter(query, value);
+            } else {
+                query.andWhere(`${this.entityName}.${key} = :value`, {
+                    value
+                });
+            }
+        }
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        (0,_flusys_nestjs_shared_utils__rspack_import_2.applyCompanyFilter)(query, {
+            isCompanyFeatureEnabled: this.storageConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'file_manager'
+        }, user);
+        await this.applyPrivateFileFilter(query, user);
+        return result;
+    }
+    async beforeDeleteOperation(dto, user, _qr) {
+        if (dto.type !== 'permanent') return;
+        const ids = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        const files = await this.repository.findBy({
+            id: (0,typeorm__rspack_import_4.In)(ids)
+        });
+        const grouped = this.groupFilesByConfig(files);
+        for (const [configId, { keys, location }] of grouped){
+            let deleteKeys = keys;
+            if (location === _enums_file_location_enum_js__rspack_import_11/* .FileLocationEnum.LOCAL */.N.LOCAL && configId !== 'default') {
+                const basePath = await this.getStorageConfigBasePath(configId);
+                if (basePath) {
+                    deleteKeys = keys.map((k)=>k.includes('/') ? k : `${basePath}/${k}`);
+                }
+            }
+            await this.uploadService.deleteMultipleFile(deleteKeys, configId === 'default' ? undefined : configId, user ?? undefined, location);
+        }
+    }
+    // ─── Public Methods ─────────────────────────────────────────────────────────
+    async getFiles(dtos, protocol, host, user) {
+        await this.ensureDataSourceRepository();
+        const ids = dtos.map((d)=>d.id).filter(Boolean);
+        if (!ids.length) throw new _nestjs_common__rspack_import_3.BadRequestException({
+            message: 'No valid file IDs provided',
+            messageKey: _config_index_js__rspack_import_10/* .UPLOAD_MESSAGES.NO_FILES_PROVIDED */.dS.NO_FILES_PROVIDED
+        });
+        const fetched = await this.repository.findBy({
+            id: (0,typeorm__rspack_import_4.In)(ids)
+        });
+        const files = await this.scopeFilesToRequester(fetched, user);
+        const now = Date.now();
+        const updatedFiles = [];
+        const responses = await Promise.all(files.map(async (file)=>{
+            const updated = await this.refreshFileUrl(file, protocol, host, now, user);
+            if (updated) updatedFiles.push(file);
+            return this.toFileResponse(file);
+        }));
+        if (updatedFiles.length) {
+            try {
+                await this.repository.save(updatedFiles);
+                await Promise.all([
+                    this.clearCacheForAll(),
+                    this.clearCacheForId(updatedFiles)
+                ]);
+            } catch  {
+            // Silent failure - URL update is non-critical
+            }
+        }
+        return responses;
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    buildWhereWithCompany(id, user) {
+        const where = {
+            id
+        };
+        if (this.storageConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            where.companyId = user.companyId;
+        }
+        return where;
+    }
+    async getStorageConfigRepository() {
+        const entity = this.storageConfig.isCompanyFeatureEnabled() ? (await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, 975))).StorageConfigWithCompany : (await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, 975))).StorageConfig;
+        return this.dataSourceProvider.getRepository(entity);
+    }
+    async getStorageConfigBasePath(configId) {
+        try {
+            const repo = await this.getStorageConfigRepository();
+            const config = await repo.findOne({
+                where: {
+                    id: configId
+                },
+                select: [
+                    'id',
+                    'config'
+                ]
+            });
+            return config?.config?.basePath?.replace(/^\.\//, '') ?? null;
+        } catch  {
+            return null;
+        }
+    }
+    async validateFolder(folderId, user) {
+        const entity = this.storageConfig.isCompanyFeatureEnabled() ? _entities_index_js__rspack_import_5.FolderWithCompany : _entities_index_js__rspack_import_5.Folder;
+        const repo = await this.dataSourceProvider.getRepository(entity);
+        const folder = await repo.findOne({
+            where: this.buildWhereWithCompany(folderId, user)
+        });
+        if (!folder) {
+            throw new _nestjs_common__rspack_import_3.BadRequestException({
+                message: `Folder "${folderId}" not found or access denied`,
+                messageKey: _config_index_js__rspack_import_10/* .FOLDER_MESSAGES.NOT_FOUND */.Ee.NOT_FOUND,
+                messageVariables: {
+                    folderId
+                }
+            });
+        }
+        return folder;
+    }
+    async resolveStorageLocation(dto, user) {
+        const configId = dto.storageConfigId;
+        if (!configId) return dto.location || _enums_file_location_enum_js__rspack_import_11/* .FileLocationEnum.LOCAL */.N.LOCAL;
+        try {
+            const repo = await this.getStorageConfigRepository();
+            const config = await repo.findOne({
+                where: this.buildWhereWithCompany(configId, user)
+            });
+            return config?.storage || dto.location || _enums_file_location_enum_js__rspack_import_11/* .FileLocationEnum.LOCAL */.N.LOCAL;
+        } catch  {
+            return dto.location || _enums_file_location_enum_js__rspack_import_11/* .FileLocationEnum.LOCAL */.N.LOCAL;
+        }
+    }
+    applyContentTypeFilter(query, value) {
+        const patterns = value.split(',').map((t)=>t.trim().replace('*', '%'));
+        query.where(new typeorm__rspack_import_4.Brackets((qb)=>{
+            patterns.forEach((p, i)=>{
+                const method = i === 0 ? 'where' : 'orWhere';
+                qb[method](`${this.entityName}.contentType LIKE :p${i}`, {
+                    [`p${i}`]: p
+                });
+            });
+        }));
+    }
+    /**
+   * Restricts a bulk-fetched file set to what the requester is allowed to see -
+   * same company scoping / private-file gating that getAll/getById apply via
+   * getExtraManipulateQuery. Without this, getFiles() would return a working URL
+   * for any file ID, including other companies' or other users' private files.
+   */ async scopeFilesToRequester(files, user) {
+        let scoped = files;
+        if (this.storageConfig.isCompanyFeatureEnabled() && user?.companyId) {
+            scoped = scoped.filter((file)=>file.companyId === user.companyId);
+        }
+        const canViewPrivate = user ? await this.permissionCacheService.hasPermission({
+            userId: user.id,
+            companyId: user.companyId,
+            branchId: user.branchId
+        }, _flusys_nestjs_shared_classes__rspack_import_0.FILE_PERMISSIONS.VIEW_PRIVATE_ACTION) : false;
+        if (!canViewPrivate) {
+            scoped = scoped.filter((file)=>!file.isPrivate);
+        }
+        return scoped;
+    }
+    async applyPrivateFileFilter(query, user) {
+        if (!user) {
+            query.andWhere('file_manager.isPrivate = :isPrivate', {
+                isPrivate: false
+            });
+            return;
+        }
+        const canViewPrivate = await this.permissionCacheService.hasPermission({
+            userId: user.id,
+            companyId: user.companyId,
+            branchId: user.branchId
+        }, _flusys_nestjs_shared_classes__rspack_import_0.FILE_PERMISSIONS.VIEW_PRIVATE_ACTION);
+        if (!canViewPrivate) {
+            query.andWhere('file_manager.isPrivate = :isPrivate', {
+                isPrivate: false
+            });
+        }
+    }
+    groupFilesByConfig(files) {
+        const grouped = new Map();
+        for (const file of files){
+            const configId = file.storageConfigId || 'default';
+            if (!grouped.has(configId)) {
+                grouped.set(configId, {
+                    keys: [],
+                    location: file.location
+                });
+            }
+            grouped.get(configId).keys.push(file.key);
+        }
+        return grouped;
+    }
+    getFileBaseUrl(protocol, host) {
+        const appUrl = this.storageConfig.getAppUrl()?.replace(/\/$/, '');
+        return appUrl || `${protocol}://${host}`;
+    }
+    async refreshFileUrl(file, protocol, host, now, user) {
+        const isCloudProvider = file.location === _enums_file_location_enum_js__rspack_import_11/* .FileLocationEnum.AWS */.N.AWS || file.location === _enums_file_location_enum_js__rspack_import_11/* .FileLocationEnum.AZURE */.N.AZURE;
+        const needsNewUrl = !file.url || isCloudProvider && (typeof file.expiresAt !== 'number' || now >= file.expiresAt);
+        if (needsNewUrl && file.storageConfigId) {
+            try {
+                file.url = await this.uploadService.makeFileUrl(file.key, file.storageConfigId, URL_EXPIRY_SECONDS, user);
+                file.expiresAt = now + URL_EXPIRY_SECONDS * 1000;
+                return true;
+            } catch  {
+                file.url = `${this.getFileBaseUrl(protocol, host)}/storage/upload/file/${file.key}`;
+            }
+        }
+        if (file.location === _enums_file_location_enum_js__rspack_import_11/* .FileLocationEnum.SFTP */.N.SFTP || file.location === _enums_file_location_enum_js__rspack_import_11/* .FileLocationEnum.LOCAL */.N.LOCAL) {
+            let fileKey = file.key;
+            if (!fileKey.includes('/') && file.storageConfigId) {
+                const basePath = await this.getStorageConfigBasePath(file.storageConfigId);
+                if (basePath) fileKey = `${basePath}/${file.key}`;
+            }
+            const expectedUrl = `${this.getFileBaseUrl(protocol, host)}/storage/upload/file/${fileKey}`;
+            if (file.url !== expectedUrl) {
+                file.url = expectedUrl;
+                return true;
+            }
+        }
+        return false;
+    }
+    toFileResponse(file) {
+        return {
+            id: file.id,
+            name: file.name,
+            contentType: file.contentType,
+            url: file.url || '',
+            location: file.location,
+            storageConfigId: file.storageConfigId || undefined
+        };
+    }
+}
+FileManagerService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_3.Injectable)({
+        scope: _nestjs_common__rspack_import_3.Scope.REQUEST
+    }),
+    _ts_param(0, (0,_nestjs_common__rspack_import_3.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0,_nestjs_common__rspack_import_3.Inject)(_flusys_nestjs_shared_modules__rspack_import_1.UtilsService)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_3.Inject)(_upload_service_js__rspack_import_8/* .UploadService */.B)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_3.Inject)(_storage_config_service_js__rspack_import_6/* .StorageConfigService */.t)),
+    _ts_param(4, (0,_nestjs_common__rspack_import_3.Inject)(_storage_datasource_provider_js__rspack_import_7/* .StorageDataSourceProvider */.M)),
+    _ts_param(5, (0,_nestjs_common__rspack_import_3.Inject)(_flusys_nestjs_shared_modules__rspack_import_1.SharedPermissionCacheService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _flusys_nestjs_shared_classes__rspack_import_0.HybridCache === "undefined" ? Object : _flusys_nestjs_shared_classes__rspack_import_0.HybridCache,
+        typeof _flusys_nestjs_shared_modules__rspack_import_1.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_1.UtilsService,
+        typeof _upload_service_js__rspack_import_8/* .UploadService */.B === "undefined" ? Object : _upload_service_js__rspack_import_8/* .UploadService */.B,
+        typeof _storage_config_service_js__rspack_import_6/* .StorageConfigService */.t === "undefined" ? Object : _storage_config_service_js__rspack_import_6/* .StorageConfigService */.t,
+        typeof _storage_datasource_provider_js__rspack_import_7/* .StorageDataSourceProvider */.M === "undefined" ? Object : _storage_datasource_provider_js__rspack_import_7/* .StorageDataSourceProvider */.M,
+        typeof _flusys_nestjs_shared_modules__rspack_import_1.SharedPermissionCacheService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_1.SharedPermissionCacheService
+    ])
+], FileManagerService);
+
+
+},
+195(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(937);
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_1 = __webpack_require__(236);
+/* import */ var _flusys_nestjs_shared_utils__rspack_import_2 = __webpack_require__(216);
+/* import */ var _nestjs_common__rspack_import_3 = __webpack_require__(157);
+/* import */ var _config_index_js__rspack_import_7 = __webpack_require__(884);
+/* import */ var _entities_index_js__rspack_import_4 = __webpack_require__(975);
+/* import */ var _storage_config_service_js__rspack_import_5 = __webpack_require__(397);
+/* import */ var _storage_datasource_provider_js__rspack_import_6 = __webpack_require__(616);
+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 FolderService extends _flusys_nestjs_shared_classes__rspack_import_0.ApiService {
+    cacheManager;
+    utilsService;
+    storageConfig;
+    constructor(cacheManager, utilsService, storageConfig, dataSourceProvider){
+        super(_config_index_js__rspack_import_7/* .STORAGE_EVENT_ENTITIES.FOLDER */.fR.FOLDER, cacheManager, utilsService, FolderService.name, true, _config_index_js__rspack_import_7/* .STORAGE_EVENT_MODULE */.qh, dataSourceProvider, storageConfig.isCompanyFeatureEnabled() ? _entities_index_js__rspack_import_4.FolderWithCompany : _entities_index_js__rspack_import_4.Folder), this.cacheManager = cacheManager, this.utilsService = utilsService, this.storageConfig = storageConfig;
+    }
+    // ─── Override Methods ───────────────────────────────────────────────────────
+    async convertSingleDtoToEntity(dto, user) {
+        const entity = await super.convertSingleDtoToEntity(dto, user);
+        if (this.storageConfig.isCompanyFeatureEnabled()) {
+            entity.companyId = user?.companyId ?? null;
+        }
+        return entity;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select?.length) {
+            select = [
+                'id',
+                'name',
+                'slug',
+                'createdAt',
+                'deletedAt'
+            ];
+            if (this.storageConfig.isCompanyFeatureEnabled()) {
+                select.push('companyId');
+            }
+        }
+        query.select(select.map((f)=>`${this.entityName}.${f}`));
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        (0,_flusys_nestjs_shared_utils__rspack_import_2.applyCompanyFilter)(query, {
+            isCompanyFeatureEnabled: this.storageConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'folder'
+        }, user);
+        return result;
+    }
+}
+FolderService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_3.Injectable)({
+        scope: _nestjs_common__rspack_import_3.Scope.REQUEST
+    }),
+    _ts_param(0, (0,_nestjs_common__rspack_import_3.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0,_nestjs_common__rspack_import_3.Inject)(_flusys_nestjs_shared_modules__rspack_import_1.UtilsService)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_3.Inject)(_storage_config_service_js__rspack_import_5/* .StorageConfigService */.t)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_3.Inject)(_storage_datasource_provider_js__rspack_import_6/* .StorageDataSourceProvider */.M)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _flusys_nestjs_shared_classes__rspack_import_0.HybridCache === "undefined" ? Object : _flusys_nestjs_shared_classes__rspack_import_0.HybridCache,
+        typeof _flusys_nestjs_shared_modules__rspack_import_1.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_1.UtilsService,
+        typeof _storage_config_service_js__rspack_import_5/* .StorageConfigService */.t === "undefined" ? Object : _storage_config_service_js__rspack_import_5/* .StorageConfigService */.t,
+        typeof _storage_datasource_provider_js__rspack_import_6/* .StorageDataSourceProvider */.M === "undefined" ? Object : _storage_datasource_provider_js__rspack_import_6/* .StorageDataSourceProvider */.M
+    ])
+], FolderService);
+
+__webpack_require__.d(__webpack_exports__, {
+  k: () => (FolderService)
+});
+
+
+},
+148(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  BB: () => (/* reexport safe */ _upload_service_js__rspack_import_5.B),
+  DL: () => (/* reexport safe */ _file_manager_service_js__rspack_import_0.D),
+  M0: () => (/* reexport safe */ _storage_datasource_provider_js__rspack_import_4.M),
+  kh: () => (/* reexport safe */ _folder_service_js__rspack_import_1.k),
+  ol: () => (/* reexport safe */ _storage_provider_config_service_js__rspack_import_3.o),
+  tP: () => (/* reexport safe */ _storage_config_service_js__rspack_import_2.t)
+});
+/* import */ var _file_manager_service_js__rspack_import_0 = __webpack_require__(955);
+/* import */ var _folder_service_js__rspack_import_1 = __webpack_require__(195);
+/* import */ var _storage_config_service_js__rspack_import_2 = __webpack_require__(397);
+/* import */ var _storage_provider_config_service_js__rspack_import_3 = __webpack_require__(623);
+/* import */ var _storage_datasource_provider_js__rspack_import_4 = __webpack_require__(616);
+/* import */ var _upload_service_js__rspack_import_5 = __webpack_require__(18);
+
+
+
+
+
+
+
+
+},
+397(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _nestjs_common__rspack_import_0 = __webpack_require__(157);
+/* import */ var _config_index_js__rspack_import_2 = __webpack_require__(450);
+/* import */ var _config_storage_constants_js__rspack_import_1 = __webpack_require__(188);
+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);
+    };
+}
+
+
+
+const BYTES_PER_MB = 1024 * 1024;
+const DEFAULT_LOCAL_PATH = './uploads';
+const DEFAULT_PORT = '3000';
+class StorageConfigService {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    // ─── IModuleConfigService Implementation ────────────────────────────────────
+    isCompanyFeatureEnabled() {
+        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    }
+    getDatabaseMode() {
+        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
+    }
+    isMultiTenant() {
+        return this.getDatabaseMode() === 'multi-tenant';
+    }
+    // ─── Config Getters ─────────────────────────────────────────────────────────
+    getMaxFileSize() {
+        return this.options.config?.maxFileSize ?? _config_storage_constants_js__rspack_import_1/* .DEFAULT_MAX_FILE_SIZE */.Sj;
+    }
+    getAllowedFileTypes() {
+        return this.options.config?.allowedFileTypes ?? _config_storage_constants_js__rspack_import_1/* .DEFAULT_ALLOWED_FILE_TYPES */.A_;
+    }
+    getOptions() {
+        return this.options;
+    }
+    getDefaultLocalStoragePath() {
+        return this.options.config?.localStoragePath ?? DEFAULT_LOCAL_PATH;
+    }
+    getAppUrl() {
+        return this.options.config?.appUrl ?? process.env.APP_URL ?? `http://localhost:${process.env.PORT ?? DEFAULT_PORT}`;
+    }
+    // ─── Validation Methods ─────────────────────────────────────────────────────
+    isFileTypeAllowed(mimeType) {
+        const allowedTypes = this.getAllowedFileTypes();
+        if (allowedTypes.includes('*/*')) {
+            return true;
+        }
+        return allowedTypes.some((type)=>type.endsWith('/*') ? mimeType.startsWith(type.slice(0, -2)) : type === mimeType);
+    }
+    validateFileSize(fileSize) {
+        const maxSize = this.getMaxFileSize();
+        if (fileSize > maxSize) {
+            return {
+                valid: false,
+                message: `File size (${this.toMB(fileSize)}MB) exceeds maximum ${this.toMB(maxSize)}MB`,
+                messageKey: _config_index_js__rspack_import_2/* .UPLOAD_MESSAGES.FILE_TOO_LARGE */.dS.FILE_TOO_LARGE,
+                messageVariables: {
+                    fileSize: this.toMB(fileSize),
+                    maxSize: this.toMB(maxSize)
+                }
+            };
+        }
+        return {
+            valid: true
+        };
+    }
+    validateFileType(mimeType) {
+        if (!this.isFileTypeAllowed(mimeType)) {
+            return {
+                valid: false,
+                message: `File type "${mimeType}" not allowed. Allowed: ${this.getAllowedFileTypes().join(', ')}`,
+                messageKey: _config_index_js__rspack_import_2/* .UPLOAD_MESSAGES.INVALID_TYPE */.dS.INVALID_TYPE,
+                messageVariables: {
+                    mimeType,
+                    allowedTypes: this.getAllowedFileTypes().join(', ')
+                }
+            };
+        }
+        return {
+            valid: true
+        };
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────────
+    toMB(bytes) {
+        return (bytes / BYTES_PER_MB).toFixed(2);
+    }
+}
+StorageConfigService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_0.Injectable)(),
+    _ts_param(0, (0,_nestjs_common__rspack_import_0.Inject)(_config_storage_constants_js__rspack_import_1/* .STORAGE_MODULE_OPTIONS */.k0)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof StorageModuleOptions === "undefined" ? Object : StorageModuleOptions
+    ])
+], StorageConfigService);
+
+__webpack_require__.d(__webpack_exports__, {
+  t: () => (StorageConfigService)
+});
+
+
+},
+616(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  M: () => (/* binding */ StorageDataSourceProvider)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/modules"
+var modules_ = __webpack_require__(236);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+;// CONCATENATED MODULE: external "@nestjs/core"
+
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/services/storage-config.service.ts
+var storage_config_service = __webpack_require__(397);
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/services/storage-datasource.provider.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 StorageDataSourceProvider extends modules_.MultiTenantDataSourceService {
+    configService;
+    static tenantConnections = new Map();
+    static singleDataSource = null;
+    static tenantsRegistry = new Map();
+    static initialized = false;
+    static connectionLocks = new Map();
+    static singleConnectionLock = null;
+    constructor(configService, request){
+        super(StorageDataSourceProvider.buildParentOptions(configService.getOptions()), request), this.configService = configService;
+    }
+    static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
+        };
+    }
+    getEnableCompanyFeatureForTenant(tenant) {
+        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
+    }
+    async getStorageEntities(enableCompanyFeature) {
+        const enable = enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
+        const entities = await Promise.resolve(/* import() */).then(__webpack_require__.bind(__webpack_require__, 975));
+        return enable ? [
+            entities.FileManagerWithCompany,
+            entities.FolderWithCompany,
+            entities.StorageConfigWithCompany
+        ] : [
+            entities.FileManager,
+            entities.Folder,
+            entities.StorageConfig
+        ];
+    }
+    async createDataSourceFromConfig(config) {
+        const currentTenant = this.getCurrentTenant();
+        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
+        const entities = await this.getStorageEntities(enableCompanyFeature);
+        return super.createDataSourceFromConfig(config, entities);
+    }
+}
+StorageDataSourceProvider = _ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    _ts_param(0, (0,common_.Inject)(storage_config_service/* .StorageConfigService */.t)),
+    _ts_param(1, (0,common_.Optional)()),
+    _ts_param(1, (0,common_.Inject)(__rspack_external__nestjs_core_d7b00a1a.REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof storage_config_service/* .StorageConfigService */.t === "undefined" ? Object : storage_config_service/* .StorageConfigService */.t,
+        typeof Request === "undefined" ? Object : Request
+    ])
+], StorageDataSourceProvider);
+
+
+},
+623(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _flusys_nestjs_shared_classes__rspack_import_0 = __webpack_require__(937);
+/* import */ var _flusys_nestjs_shared_modules__rspack_import_1 = __webpack_require__(236);
+/* import */ var _flusys_nestjs_shared_utils__rspack_import_2 = __webpack_require__(216);
+/* import */ var _nestjs_common__rspack_import_3 = __webpack_require__(157);
+/* import */ var typeorm__rspack_import_4 = __webpack_require__(158);
+/* import */ var _config_index_js__rspack_import_8 = __webpack_require__(884);
+/* import */ var _config_index_js__rspack_import_9 = __webpack_require__(450);
+/* import */ var _entities_index_js__rspack_import_5 = __webpack_require__(975);
+/* import */ var _storage_config_service_js__rspack_import_6 = __webpack_require__(397);
+/* import */ var _storage_datasource_provider_js__rspack_import_7 = __webpack_require__(616);
+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 StorageProviderConfigService extends _flusys_nestjs_shared_classes__rspack_import_0.ApiService {
+    cacheManager;
+    utilsService;
+    storageConfig;
+    constructor(cacheManager, utilsService, storageConfig, dataSourceProvider){
+        super(_config_index_js__rspack_import_8/* .STORAGE_EVENT_ENTITIES.STORAGE_CONFIG */.fR.STORAGE_CONFIG, cacheManager, utilsService, StorageProviderConfigService.name, true, _config_index_js__rspack_import_8/* .STORAGE_EVENT_MODULE */.qh, dataSourceProvider, storageConfig.isCompanyFeatureEnabled() ? _entities_index_js__rspack_import_5.StorageConfigWithCompany : _entities_index_js__rspack_import_5.StorageConfig), this.cacheManager = cacheManager, this.utilsService = utilsService, this.storageConfig = storageConfig;
+    }
+    async beforeDeleteOperation(dto, _user, _queryRunner) {
+        const ids = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        await this.ensureDataSourceRepository();
+        const defaultConfigs = await this.repository.find({
+            where: {
+                id: (0,typeorm__rspack_import_4.In)(ids),
+                isDefault: true,
+                deletedAt: (0,typeorm__rspack_import_4.IsNull)()
+            }
+        });
+        if (defaultConfigs.length > 0) {
+            const names = defaultConfigs.map((c)=>c.name).join(', ');
+            throw new _nestjs_common__rspack_import_3.ForbiddenException({
+                message: `Cannot delete the default storage config(s): ${names}. Set another config as default first.`,
+                messageKey: _config_index_js__rspack_import_9/* .STORAGE_CONFIG_MESSAGES.DEFAULT_DELETE_FORBIDDEN */.Y8.DEFAULT_DELETE_FORBIDDEN,
+                messageVariables: {
+                    names
+                }
+            });
+        }
+    }
+    // ─── Override Methods ───────────────────────────────────────────────────────
+    async convertSingleDtoToEntity(dto, user) {
+        const entity = await super.convertSingleDtoToEntity(dto, user);
+        if (this.storageConfig.isCompanyFeatureEnabled()) {
+            entity.companyId = user?.companyId ?? null;
+        }
+        return entity;
+    }
+    async getSelectQuery(query, _user, select) {
+        if (!select?.length) {
+            select = [
+                'id',
+                'name',
+                'storage',
+                'config',
+                'isActive',
+                'isDefault',
+                'createdAt',
+                'updatedAt'
+            ];
+            if (this.storageConfig.isCompanyFeatureEnabled()) {
+                select.push('companyId');
+            }
+        }
+        query.select(select.map((f)=>`${this.entityName}.${f}`));
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        (0,_flusys_nestjs_shared_utils__rspack_import_2.applyCompanyFilter)(query, {
+            isCompanyFeatureEnabled: this.storageConfig.isCompanyFeatureEnabled(),
+            entityAlias: 'storageConfig'
+        }, user);
+        query.orderBy(`${this.entityName}.createdAt`, 'DESC');
+        return result;
+    }
+    async findByIdDirect(id) {
+        await this.ensureDataSourceRepository();
+        return await this.repository.findOne({
+            where: {
+                id
+            }
+        });
+    }
+    async getDefaultConfig(user) {
+        await this.ensureDataSourceRepository();
+        const baseWhere = (0,_flusys_nestjs_shared_utils__rspack_import_2.buildCompanyWhereCondition)({
+            isActive: true
+        }, this.storageConfig.isCompanyFeatureEnabled(), user);
+        const defaultConfig = await this.repository.findOne({
+            where: {
+                ...baseWhere,
+                isDefault: true
+            },
+            order: {
+                createdAt: 'ASC'
+            }
+        });
+        if (defaultConfig) {
+            return defaultConfig;
+        }
+        return await this.repository.findOne({
+            where: baseWhere,
+            order: {
+                createdAt: 'ASC'
+            }
+        });
+    }
+    async getConfigByType(storage, user) {
+        await this.ensureDataSourceRepository();
+        const where = (0,_flusys_nestjs_shared_utils__rspack_import_2.buildCompanyWhereCondition)({
+            storage,
+            isActive: true
+        }, this.storageConfig.isCompanyFeatureEnabled(), user);
+        return await this.repository.find({
+            where
+        });
+    }
+}
+StorageProviderConfigService = _ts_decorate([
+    (0,_nestjs_common__rspack_import_3.Injectable)({
+        scope: _nestjs_common__rspack_import_3.Scope.REQUEST
+    }),
+    _ts_param(0, (0,_nestjs_common__rspack_import_3.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0,_nestjs_common__rspack_import_3.Inject)(_flusys_nestjs_shared_modules__rspack_import_1.UtilsService)),
+    _ts_param(2, (0,_nestjs_common__rspack_import_3.Inject)(_storage_config_service_js__rspack_import_6/* .StorageConfigService */.t)),
+    _ts_param(3, (0,_nestjs_common__rspack_import_3.Inject)(_storage_datasource_provider_js__rspack_import_7/* .StorageDataSourceProvider */.M)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _flusys_nestjs_shared_classes__rspack_import_0.HybridCache === "undefined" ? Object : _flusys_nestjs_shared_classes__rspack_import_0.HybridCache,
+        typeof _flusys_nestjs_shared_modules__rspack_import_1.UtilsService === "undefined" ? Object : _flusys_nestjs_shared_modules__rspack_import_1.UtilsService,
+        typeof _storage_config_service_js__rspack_import_6/* .StorageConfigService */.t === "undefined" ? Object : _storage_config_service_js__rspack_import_6/* .StorageConfigService */.t,
+        typeof _storage_datasource_provider_js__rspack_import_7/* .StorageDataSourceProvider */.M === "undefined" ? Object : _storage_datasource_provider_js__rspack_import_7/* .StorageDataSourceProvider */.M
+    ])
+], StorageProviderConfigService);
+
+__webpack_require__.d(__webpack_exports__, {
+  o: () => (StorageProviderConfigService)
+});
+
+
+},
+18(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  B: () => (/* binding */ UploadService)
+});
+
+// EXTERNAL MODULE: external "@flusys/nestjs-shared"
+var nestjs_shared_ = __webpack_require__(422);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/classes"
+var classes_ = __webpack_require__(937);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/utils"
+var utils_ = __webpack_require__(216);
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/config/message-keys.ts
+var message_keys = __webpack_require__(450);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/config/event-actions.ts
+var event_actions = __webpack_require__(884);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/dtos/upload.dto.ts
+var upload_dto = __webpack_require__(322);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/enums/file-location.enum.ts
+var file_location_enum = __webpack_require__(733);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/providers/storage-factory.service.ts + 1 modules
+var storage_factory_service = __webpack_require__(192);
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/utils/file-validator.util.ts
+/**
+ * Result of file content validation.
+ */ /**
+ * Magic byte signatures for common file types.
+ * Each entry maps a hex signature pattern to its MIME type.
+ */ const MAGIC_BYTES = [
+    // Images
+    {
+        signature: [
+            0xff,
+            0xd8,
+            0xff
+        ],
+        offset: 0,
+        mimeType: 'image/jpeg'
+    },
+    {
+        signature: [
+            0x89,
+            0x50,
+            0x4e,
+            0x47,
+            0x0d,
+            0x0a,
+            0x1a,
+            0x0a
+        ],
+        offset: 0,
+        mimeType: 'image/png'
+    },
+    {
+        signature: [
+            0x47,
+            0x49,
+            0x46,
+            0x38,
+            0x37,
+            0x61
+        ],
+        offset: 0,
+        mimeType: 'image/gif'
+    },
+    {
+        signature: [
+            0x47,
+            0x49,
+            0x46,
+            0x38,
+            0x39,
+            0x61
+        ],
+        offset: 0,
+        mimeType: 'image/gif'
+    },
+    {
+        signature: [
+            0x42,
+            0x4d
+        ],
+        offset: 0,
+        mimeType: 'image/bmp'
+    },
+    {
+        signature: [
+            0x52,
+            0x49,
+            0x46,
+            0x46
+        ],
+        offset: 0,
+        mimeType: 'image/webp'
+    },
+    {
+        signature: [
+            0x00,
+            0x00,
+            0x01,
+            0x00
+        ],
+        offset: 0,
+        mimeType: 'image/x-icon'
+    },
+    {
+        signature: [
+            0x00,
+            0x00,
+            0x02,
+            0x00
+        ],
+        offset: 0,
+        mimeType: 'image/x-icon'
+    },
+    // Documents
+    {
+        signature: [
+            0x25,
+            0x50,
+            0x44,
+            0x46
+        ],
+        offset: 0,
+        mimeType: 'application/pdf'
+    },
+    {
+        signature: [
+            0x50,
+            0x4b,
+            0x03,
+            0x04
+        ],
+        offset: 0,
+        mimeType: 'application/zip'
+    },
+    // Audio
+    {
+        signature: [
+            0x49,
+            0x44,
+            0x33
+        ],
+        offset: 0,
+        mimeType: 'audio/mpeg'
+    },
+    {
+        signature: [
+            0xff,
+            0xfb
+        ],
+        offset: 0,
+        mimeType: 'audio/mpeg'
+    },
+    {
+        signature: [
+            0xff,
+            0xfa
+        ],
+        offset: 0,
+        mimeType: 'audio/mpeg'
+    },
+    {
+        signature: [
+            0x4f,
+            0x67,
+            0x67,
+            0x53
+        ],
+        offset: 0,
+        mimeType: 'audio/ogg'
+    },
+    {
+        signature: [
+            0x66,
+            0x4c,
+            0x61,
+            0x43
+        ],
+        offset: 0,
+        mimeType: 'audio/flac'
+    },
+    // Video
+    {
+        signature: [
+            0x00,
+            0x00,
+            0x00,
+            0x1c,
+            0x66,
+            0x74,
+            0x79,
+            0x70
+        ],
+        offset: 0,
+        mimeType: 'video/mp4'
+    },
+    {
+        signature: [
+            0x00,
+            0x00,
+            0x00,
+            0x20,
+            0x66,
+            0x74,
+            0x79,
+            0x70
+        ],
+        offset: 0,
+        mimeType: 'video/mp4'
+    },
+    {
+        signature: [
+            0x1a,
+            0x45,
+            0xdf,
+            0xa3
+        ],
+        offset: 0,
+        mimeType: 'video/webm'
+    },
+    {
+        signature: [
+            0x52,
+            0x49,
+            0x46,
+            0x46
+        ],
+        offset: 0,
+        mimeType: 'video/avi'
+    },
+    // Archives
+    {
+        signature: [
+            0x1f,
+            0x8b
+        ],
+        offset: 0,
+        mimeType: 'application/gzip'
+    },
+    {
+        signature: [
+            0x37,
+            0x7a,
+            0xbc,
+            0xaf,
+            0x27,
+            0x1c
+        ],
+        offset: 0,
+        mimeType: 'application/x-7z-compressed'
+    },
+    {
+        signature: [
+            0x52,
+            0x61,
+            0x72,
+            0x21,
+            0x1a,
+            0x07
+        ],
+        offset: 0,
+        mimeType: 'application/x-rar-compressed'
+    }
+];
+/**
+ * MIME type aliases - types that are equivalent.
+ */ const MIME_ALIASES = {
+    'image/jpeg': [
+        'image/jpg'
+    ],
+    'image/jpg': [
+        'image/jpeg'
+    ],
+    'video/mp4': [
+        'video/quicktime'
+    ],
+    'application/zip': [
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+    ]
+};
+/**
+ * File types that are text-based and don't have magic bytes.
+ * SECURITY NOTE: Dangerous types (HTML, JS, SVG) are excluded as they can contain scripts.
+ * These types require explicit allowlisting and additional content scanning.
+ */ const TEXT_BASED_TYPES = [
+    'text/plain',
+    'text/csv',
+    'text/markdown',
+    'application/json',
+    'application/xml',
+    'application/typescript',
+    'text/css'
+];
+/**
+ * Dangerous text-based types that can execute scripts.
+ * These bypass magic-bytes validation but require explicit allowlisting.
+ */ const DANGEROUS_TEXT_TYPES = [
+    'text/html',
+    'application/javascript',
+    'text/javascript',
+    'image/svg+xml',
+    'application/xhtml+xml'
+];
+/**
+ * ZIP-based format prefixes that are valid when detected as application/zip.
+ */ const ZIP_VARIANT_PREFIXES = [
+    'application/vnd.openxmlformats-officedocument',
+    'application/x-zip',
+    'application/x-compressed'
+];
+/**
+ * Utility class for validating file content using magic bytes.
+ * Prevents file type spoofing by checking actual file content.
+ */ class FileValidator {
+    // Result Helpers
+    static failureResult(message, detectedType, declaredType) {
+        return {
+            valid: false,
+            detectedType,
+            declaredType,
+            message
+        };
+    }
+    static successResult(detectedType, declaredType) {
+        return {
+            valid: true,
+            detectedType,
+            declaredType
+        };
+    }
+    /**
+   * Detect file type from buffer using magic bytes.
+   * @param buffer - File buffer to analyze
+   * @returns Detected MIME type or null if unknown
+   */ static detectFileType(buffer) {
+        for (const { signature, offset, mimeType } of MAGIC_BYTES){
+            if (buffer.length < offset + signature.length) continue;
+            let matches = true;
+            for(let i = 0; i < signature.length; i++){
+                if (buffer[offset + i] !== signature[i]) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) {
+                return mimeType;
+            }
+        }
+        return null;
+    }
+    /**
+   * Check if a MIME type is text-based (doesn't have magic bytes).
+   */ static isTextBasedType(mimeType) {
+        return TEXT_BASED_TYPES.some((t)=>mimeType.startsWith(t) || mimeType === t);
+    }
+    /**
+   * Check if a MIME type is a dangerous text type that can execute scripts.
+   */ static isDangerousTextType(mimeType) {
+        return DANGEROUS_TEXT_TYPES.some((t)=>mimeType === t);
+    }
+    /**
+   * Check if two MIME types are compatible (exact match or aliases).
+   */ static mimeTypesMatch(detected, declared) {
+        // Exact match
+        if (detected === declared) return true;
+        // Check aliases
+        const aliases = MIME_ALIASES[detected];
+        if (aliases?.includes(declared)) return true;
+        // Check reverse aliases
+        const reverseAliases = MIME_ALIASES[declared];
+        if (reverseAliases?.includes(detected)) return true;
+        // Check if both are in same category (e.g., both images)
+        const detectedCategory = detected.split('/')[0];
+        const declaredCategory = declared.split('/')[0];
+        // For ZIP-based formats, allow any ZIP-detected file if declared is a ZIP variant
+        if (detected === 'application/zip' && ZIP_VARIANT_PREFIXES.some((v)=>declared.startsWith(v))) {
+            return true;
+        }
+        return detectedCategory === declaredCategory;
+    }
+    /**
+   * Check if a MIME type is in the allowed list.
+   */ static isTypeAllowed(mimeType, allowedTypes) {
+        // Wildcard allows all
+        if (allowedTypes.includes('*/*')) return true;
+        return allowedTypes.some((allowed)=>{
+            // Category wildcard (e.g., "image/*")
+            if (allowed.endsWith('/*')) {
+                const category = allowed.slice(0, -2);
+                return mimeType.startsWith(category);
+            }
+            return allowed === mimeType;
+        });
+    }
+    /**
+   * Validate file content matches declared MIME type using magic bytes.
+   * @param buffer - File buffer
+   * @param declaredMimeType - MIME type declared by client
+   * @param allowedTypes - List of allowed MIME types/patterns
+   * @returns Validation result
+   */ static validateFileContent(buffer, declaredMimeType, allowedTypes = [
+        '*/*'
+    ]) {
+        try {
+            const detectedType = this.detectFileType(buffer);
+            // No magic bytes detected - handle text-based types
+            if (!detectedType) {
+                return this.validateUndetectedType(declaredMimeType, allowedTypes);
+            }
+            // Verify detected type matches declared type
+            if (!this.mimeTypesMatch(detectedType, declaredMimeType)) {
+                return this.failureResult(`File content does not match declared type. Detected: ${detectedType}, Declared: ${declaredMimeType}`, detectedType, declaredMimeType);
+            }
+            // Verify type is in allowed list
+            if (!this.isTypeAllowed(detectedType, allowedTypes)) {
+                return this.failureResult(`File type "${detectedType}" is not allowed`, detectedType, declaredMimeType);
+            }
+            return this.successResult(detectedType, declaredMimeType);
+        } catch  {
+            return this.failureResult('File validation failed');
+        }
+    }
+    /**
+   * Handle validation for files without detectable magic bytes.
+   */ static validateUndetectedType(declaredMimeType, allowedTypes) {
+        // Check for dangerous text types first (HTML, JS, SVG)
+        if (this.isDangerousTextType(declaredMimeType)) {
+            const explicitlyAllowed = allowedTypes.some((t)=>t === declaredMimeType && t !== '*/*' && !t.endsWith('/*'));
+            if (!explicitlyAllowed) {
+                return this.failureResult(`File type "${declaredMimeType}" is potentially dangerous and not explicitly allowed`, declaredMimeType, declaredMimeType);
+            }
+        }
+        // Safe text-based files don't have magic bytes, trust declared type
+        if (this.isTextBasedType(declaredMimeType)) {
+            const isAllowed = this.isTypeAllowed(declaredMimeType, allowedTypes);
+            return isAllowed ? this.successResult(declaredMimeType, declaredMimeType) : this.failureResult(`File type "${declaredMimeType}" is not allowed`, declaredMimeType, declaredMimeType);
+        }
+        // Binary files without recognized signatures - be cautious
+        return this.failureResult('Unable to verify file type. File may be corrupted or unsupported.', undefined, declaredMimeType);
+    }
+    /**
+   * Sanitize filename to prevent path traversal and special character issues.
+   * @param filename - Original filename
+   * @returns Sanitized filename
+   */ static sanitizeFilename(filename) {
+        return filename// Remove path components (prevent traversal)
+        .replace(/^.*[\\/]/, '')// Remove null bytes
+        .replace(/\0/g, '')// Replace multiple dots with single
+        .replace(/\.{2,}/g, '.')// Remove special characters except allowed ones
+        .replace(/[^a-zA-Z0-9._-]/g, '_')// Limit length
+        .substring(0, 255);
+    }
+}
+
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/services/storage-config.service.ts
+var storage_config_service = __webpack_require__(397);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/services/storage-provider-config.service.ts
+var storage_provider_config_service = __webpack_require__(623);
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/services/upload.service.ts
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+        r = Reflect.decorate(decorators, target, key, desc);
+    } else {
+        for(var i = decorators.length - 1; i >= 0; i--){
+            if (d = decorators[i]) {
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+            }
+        }
+    }
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+        return Reflect.metadata(metadataKey, metadataValue);
+    }
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+
+
+
+
+
+
+
+
+
+
+
+class UploadService {
+    storageFactory;
+    storageConfigService;
+    storageProviderConfigService;
+    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
+    constructor(storageFactory, storageConfigService, storageProviderConfigService){
+        this.storageFactory = storageFactory;
+        this.storageConfigService = storageConfigService;
+        this.storageProviderConfigService = storageProviderConfigService;
+    }
+    /**
+   * Validate file before upload - includes size, type, and content validation.
+   * Uses magic bytes to verify file content matches declared MIME type.
+   */ validateFile(file) {
+        // Validate file size
+        const sizeValidation = this.storageConfigService.validateFileSize(file.size);
+        if (!sizeValidation.valid) {
+            throw new common_.BadRequestException({
+                message: sizeValidation.message,
+                messageKey: sizeValidation.messageKey,
+                messageVariables: sizeValidation.messageVariables
+            });
+        }
+        // Validate declared file type (MIME)
+        const typeValidation = this.storageConfigService.validateFileType(file.mimetype);
+        if (!typeValidation.valid) {
+            throw new common_.BadRequestException({
+                message: typeValidation.message,
+                messageKey: typeValidation.messageKey,
+                messageVariables: typeValidation.messageVariables
+            });
+        }
+        // Validate file content matches declared type (magic bytes check)
+        // This prevents MIME type spoofing attacks
+        const allowedTypes = this.storageConfigService.getAllowedFileTypes();
+        const contentValidation = FileValidator.validateFileContent(file.buffer, file.mimetype, allowedTypes);
+        if (!contentValidation.valid) {
+            throw new common_.BadRequestException({
+                message: contentValidation.message || 'File content validation failed',
+                messageKey: message_keys/* .UPLOAD_MESSAGES.INVALID_TYPE */.dS.INVALID_TYPE,
+                messageVariables: {
+                    mimeType: file.mimetype,
+                    allowedTypes: allowedTypes.join(', ')
+                }
+            });
+        }
+        // Sanitize filename to prevent path traversal attacks
+        file.originalname = FileValidator.sanitizeFilename(file.originalname);
+    }
+    /**
+   * Create provider from storage config entity
+   */ async createProviderFromConfig(config) {
+        return this.storageFactory.createProvider({
+            provider: config.storage,
+            config: config.config
+        });
+    }
+    /**
+   * Create fallback local provider
+   */ async createFallbackLocalProvider() {
+        return this.storageFactory.createProvider({
+            provider: file_location_enum/* .FileLocationEnum.LOCAL */.N.LOCAL,
+            config: {
+                basePath: this.storageConfigService.getDefaultLocalStoragePath()
+            }
+        });
+    }
+    /**
+   * Get storage provider and config info based on storage config ID
+   * Validates company ownership when company feature is enabled
+   */ async getStorageProviderWithConfig(storageConfigId, user) {
+        let storageConfig;
+        // Get storage config from database
+        if (storageConfigId) {
+            // Use direct lookup (bypasses company filtering, returns null instead of throwing)
+            const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
+            if (!config) {
+                throw new common_.NotFoundException({
+                    message: 'Storage configuration not found',
+                    messageKey: message_keys/* .UPLOAD_MESSAGES.CONFIG_NOT_FOUND */.dS.CONFIG_NOT_FOUND
+                });
+            }
+            // Validate company ownership using shared utility
+            (0,utils_.validateCompanyOwnership)(config, user, this.storageConfigService.isCompanyFeatureEnabled(), 'Storage configuration');
+            storageConfig = config;
+        } else {
+            // Use default config (scoped to user's company/branch)
+            const defaultConfig = await this.storageProviderConfigService.getDefaultConfig(user);
+            if (!defaultConfig) {
+                throw new common_.NotFoundException({
+                    message: 'No default storage configuration found for your company/branch. Please create one.',
+                    messageKey: message_keys/* .UPLOAD_MESSAGES.CONFIG_NOT_FOUND */.dS.CONFIG_NOT_FOUND
+                });
+            }
+            storageConfig = defaultConfig;
+        }
+        const provider = await this.createProviderFromConfig(storageConfig);
+        return {
+            provider,
+            location: storageConfig.storage,
+            configId: storageConfig.id
+        };
+    }
+    /**
+   * Get storage provider for delete operations with fallback
+   * If the original storage config doesn't exist, falls back based on locationHint
+   */ async getStorageProviderForDelete(storageConfigId, user, locationHint) {
+        // Try to find by storageConfigId
+        if (storageConfigId) {
+            const config = await this.storageProviderConfigService.findByIdDirect(storageConfigId);
+            if (config) {
+                return this.createProviderFromConfig(config);
+            }
+        }
+        // Fallback: Use locationHint to find a matching config
+        if (locationHint) {
+            const matchingConfigs = await this.storageProviderConfigService.getConfigByType(locationHint, user);
+            if (matchingConfigs.length > 0) {
+                return this.createProviderFromConfig(matchingConfigs[0]);
+            }
+            if (locationHint === file_location_enum/* .FileLocationEnum.LOCAL */.N.LOCAL) {
+                return this.createFallbackLocalProvider();
+            }
+        }
+        // Last resort: Try default config
+        const defaultConfig = await this.storageProviderConfigService.getDefaultConfig(user);
+        if (defaultConfig) {
+            return this.createProviderFromConfig(defaultConfig);
+        }
+        return this.createFallbackLocalProvider();
+    }
+    async uploadSingleFile(file, options, user) {
+        this.validateFile(file);
+        const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
+        const result = await provider.uploadFile(file, options);
+        await this.publishFileEvent(event_actions/* .STORAGE_EVENT_ACTIONS.UPLOADED */.hw.UPLOADED, [
+            result.key
+        ], user, {
+            location,
+            storageConfigId: configId,
+            totalSize: result.size,
+            count: 1
+        });
+        return {
+            ...result,
+            location,
+            storageConfigId: configId
+        };
+    }
+    async uploadMultipleFiles(files, options, user) {
+        for (const file of files){
+            this.validateFile(file);
+        }
+        const { provider, location, configId } = await this.getStorageProviderWithConfig(options.storageConfigId, user);
+        const results = await provider.uploadMultipleFiles(files, options);
+        await this.publishFileEvent(event_actions/* .STORAGE_EVENT_ACTIONS.UPLOADED */.hw.UPLOADED, results.map((result)=>result.key), user, {
+            location,
+            storageConfigId: configId,
+            totalSize: results.reduce((sum, result)=>sum + (result.size ?? 0), 0),
+            count: results.length
+        });
+        return results.map((result)=>({
+                ...result,
+                location,
+                storageConfigId: configId
+            }));
+    }
+    async deleteSingleFile(key, storageConfigId, user, locationHint) {
+        if (!key) throw new common_.BadRequestException({
+            message: 'No file path provided',
+            messageKey: message_keys/* .UPLOAD_MESSAGES.NO_FILE_PATH */.dS.NO_FILE_PATH
+        });
+        const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
+        await provider.deleteFile(key);
+        await this.publishFileEvent(event_actions/* .STORAGE_EVENT_ACTIONS.REMOVED */.hw.REMOVED, [
+            key
+        ], user, {
+            storageConfigId,
+            count: 1
+        });
+        return true;
+    }
+    async deleteMultipleFile(keys, storageConfigId, user, locationHint) {
+        if (!keys || !keys.length) throw new common_.BadRequestException({
+            message: 'No file paths provided',
+            messageKey: message_keys/* .UPLOAD_MESSAGES.NO_FILE_PATH */.dS.NO_FILE_PATH
+        });
+        const provider = await this.getStorageProviderForDelete(storageConfigId, user, locationHint);
+        await provider.deleteMultipleFiles(keys);
+        await this.publishFileEvent(event_actions/* .STORAGE_EVENT_ACTIONS.REMOVED */.hw.REMOVED, keys, user, {
+            storageConfigId,
+            count: keys.length
+        });
+        return true;
+    }
+    async publishFileEvent(action, keys, user, metadata) {
+        await (0,classes_.publishDomainEvent)({
+            module: event_actions/* .STORAGE_EVENT_MODULE */.qh,
+            entity: event_actions/* .STORAGE_EVENT_ENTITIES.FILE */.fR.FILE,
+            action,
+            ids: keys,
+            metadata,
+            user: user ?? null
+        });
+    }
+    bytesToKb(bytes) {
+        return Number((bytes * 0.001).toFixed(2));
+    }
+    /**
+   * Get local storage basePath from DB config
+   * Initializes local provider if not cached, ensuring basePath is from DB
+   */ async getLocalStorageBasePath() {
+        try {
+            // First check if already cached
+            const cachedPath = this.storageFactory.getLocalProviderBasePath();
+            if (cachedPath) {
+                return cachedPath;
+            }
+            // Get local config from DB (without user context for public access)
+            const localConfigs = await this.storageProviderConfigService.getConfigByType(file_location_enum/* .FileLocationEnum.LOCAL */.N.LOCAL);
+            if (localConfigs.length > 0) {
+                const localConfig = localConfigs[0];
+                // Initialize provider to cache it
+                await this.storageFactory.createProvider({
+                    provider: file_location_enum/* .FileLocationEnum.LOCAL */.N.LOCAL,
+                    config: localConfig.config
+                });
+                // Now get the cached basePath
+                return this.storageFactory.getLocalProviderBasePath();
+            }
+            return null;
+        } catch  {
+            return null;
+        }
+    }
+    async makeFileUrl(key, storageConfigId, expiresIn = 3600, user) {
+        const { provider } = await this.getStorageProviderWithConfig(storageConfigId, user);
+        // Check if provider supports presigned URLs
+        if (provider.generatePresignedUrl) {
+            return await provider.generatePresignedUrl(key, expiresIn);
+        }
+        // For SFTP or other providers without presigned URLs
+        return key;
+    }
+}
+_ts_decorate([
+    (0,nestjs_shared_.LogAction)({
+        action: 'storage.uploadSingle',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Express === "undefined" || typeof Express.Multer === "undefined" || typeof Express.Multer.File === "undefined" ? Object : Express.Multer.File,
+        typeof upload_dto/* .UploadOptionsDto */.hL === "undefined" ? Object : upload_dto/* .UploadOptionsDto */.hL,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "uploadSingleFile", null);
+_ts_decorate([
+    (0,nestjs_shared_.LogAction)({
+        action: 'storage.uploadMultiple',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        typeof upload_dto/* .UploadOptionsDto */.hL === "undefined" ? Object : upload_dto/* .UploadOptionsDto */.hL,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "uploadMultipleFiles", null);
+_ts_decorate([
+    (0,nestjs_shared_.LogAction)({
+        action: 'storage.deleteSingle',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "deleteSingleFile", null);
+_ts_decorate([
+    (0,nestjs_shared_.LogAction)({
+        action: 'storage.deleteMultiple',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        Array,
+        String,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "deleteMultipleFile", null);
+_ts_decorate([
+    (0,nestjs_shared_.LogAction)({
+        action: 'storage.makeFileUrl',
+        module: 'storage'
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        Number,
+        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], UploadService.prototype, "makeFileUrl", null);
+UploadService = _ts_decorate([
+    (0,common_.Injectable)({
+        scope: common_.Scope.REQUEST
+    }),
+    _ts_param(0, (0,common_.Inject)(storage_factory_service/* .StorageFactoryService */.L)),
+    _ts_param(1, (0,common_.Inject)(storage_config_service/* .StorageConfigService */.t)),
+    _ts_param(2, (0,common_.Inject)(storage_provider_config_service/* .StorageProviderConfigService */.o)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof storage_factory_service/* .StorageFactoryService */.L === "undefined" ? Object : storage_factory_service/* .StorageFactoryService */.L,
+        typeof storage_config_service/* .StorageConfigService */.t === "undefined" ? Object : storage_config_service/* .StorageConfigService */.t,
+        typeof storage_provider_config_service/* .StorageProviderConfigService */.o === "undefined" ? Object : storage_provider_config_service/* .StorageProviderConfigService */.o
+    ])
+], UploadService);
+
+
+},
+422(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_393d2cae;
+
+
+},
+937(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_classes_6076a329;
+
+
+},
+140(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_constants_81f33d5b;
+
+
+},
+236(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_modules_24702bee;
+
+
+},
+216(module) {
+
+module.exports = __rspack_external__flusys_nestjs_shared_utils_9125c1f1;
+
+
+},
+157(module) {
+
+module.exports = __rspack_external__nestjs_common_a04939da;
+
+
+},
+176(module) {
+
+module.exports = __rspack_external__nestjs_swagger_7cd450b5;
+
+
+},
+812(module) {
+
+module.exports = __rspack_external_class_transformer_c5a479fb;
+
+
+},
+421(module) {
+
+module.exports = __rspack_external_class_validator_7b99ef4d;
+
+
+},
+158(module) {
+
+module.exports = __rspack_external_typeorm;
+
+
+},
+
+};