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

package/fesm/providers/index.js

@@ -1,9 +1,370 @@
+import * as __rspack_external_sharp from "sharp";
+import * as __rspack_external_path from "path";
+import * as __rspack_external_uuid from "uuid";
+import * as __rspack_external_fs_promises_e1851c9c from "fs/promises";
+export const __rspack_esm_id = 467;
+export const __rspack_esm_ids = [467];
+export const __webpack_modules__ = {
+922(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _storage_factory_service_js__rspack_import_0 = __webpack_require__(192);
+/* import */ var _storage_provider_registry_js__rspack_import_1 = __webpack_require__(264);
+/* import */ var _local_provider_js__rspack_import_2 = __webpack_require__(632);
 // Core exports
-export * from './storage-factory.service';
-export * from './storage-provider.registry';
+
+
 // Built-in provider (no external dependencies)
-export * from './local-provider'; // Note: Optional storage providers are loaded dynamically
+ // Note: Optional storage providers are loaded dynamically
  // Import them directly from their files when needed:
  // - import { S3Provider } from '@flusys/nestjs-storage/providers/s3-provider.optional';
  // - import { AzureProvider } from '@flusys/nestjs-storage/providers/azure-provider.optional';
  // - import { SftpProvider } from '@flusys/nestjs-storage/providers/sftp-provider.optional';
+
+__webpack_require__.d(__webpack_exports__, {
+  CG: () => (/* reexport safe */ _storage_provider_registry_js__rspack_import_1.C),
+  Lk: () => (/* reexport safe */ _storage_factory_service_js__rspack_import_0.L),
+  TZ: () => (/* reexport safe */ _local_provider_js__rspack_import_2.T)
+});
+
+
+},
+632(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  T: () => (/* binding */ LocalProvider)
+});
+
+// EXTERNAL MODULE: external "@nestjs/common"
+var common_ = __webpack_require__(157);
+// EXTERNAL MODULE: external "@flusys/nestjs-shared/constants"
+var constants_ = __webpack_require__(140);
+// EXTERNAL MODULE: ./projects/nestjs-storage/src/utils/image-compressor.util.ts + 1 modules
+var image_compressor_util = __webpack_require__(872);
+;// CONCATENATED MODULE: external "fs/promises"
+
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(521);
+// EXTERNAL MODULE: external "uuid"
+var external_uuid_ = __webpack_require__(37);
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/providers/local-provider.ts
+/**
+ * LOCAL File System Provider
+ *
+ * This provider uses Node.js built-in 'fs' module - NO external dependencies required!
+ * Perfect for same-server storage scenarios.
+ *
+ * Usage:
+ * import { LocalProvider } from '@flusys/nestjs-storage/providers/local-provider';
+ * import { StorageProviderRegistry, FileLocationEnum } from '@flusys/nestjs-storage';
+ *
+ * StorageProviderRegistry.register(FileLocationEnum.LOCAL, LocalProvider);
+ */ 
+
+
+
+
+
+/**
+ * Local File System Storage Provider
+ * Uses Node.js built-in fs module - no external dependencies
+ */ class LocalProvider {
+    basePath = '';
+    baseUrl = '';
+    relativeBasePath = '';
+    /**
+   * SECURITY: Validates that a target path does not escape the base directory
+   * Prevents path traversal attacks using ../ sequences
+   * @throws Error if path traversal is detected
+   */ validatePathWithinBase(targetPath) {
+        const normalizedBasePath = external_path_.resolve(this.basePath);
+        const normalizedTargetPath = external_path_.resolve(targetPath);
+        if (!normalizedTargetPath.startsWith(normalizedBasePath + external_path_.sep) && normalizedTargetPath !== normalizedBasePath) {
+            throw new common_.BadRequestException({
+                message: 'Invalid path: Path traversal attempt detected',
+                messageKey: constants_.SYSTEM_MESSAGES.PATH_TRAVERSAL_DETECTED
+            });
+        }
+    }
+    /**
+   * SECURITY: Validates file key format to prevent malicious input
+   * @throws Error if key contains suspicious patterns
+   */ validateKeyFormat(key) {
+        if (!key || typeof key !== 'string' || key.trim().length === 0) {
+            throw new common_.BadRequestException({
+                message: 'Invalid file key: empty or invalid',
+                messageKey: constants_.SYSTEM_MESSAGES.INVALID_FILE_KEY
+            });
+        }
+        if (key.includes('\0')) {
+            throw new common_.BadRequestException({
+                message: 'Invalid file key: contains null bytes',
+                messageKey: constants_.SYSTEM_MESSAGES.INVALID_FILE_KEY
+            });
+        }
+    }
+    /**
+   * Initialize Local File System provider with configuration
+   * @param config.basePath - Base path for file storage (default: './uploads')
+   * @param config.baseUrl - Optional base URL for generating file URLs
+   */ async initialize(config) {
+        // Store original relative path for key generation
+        this.relativeBasePath = config?.basePath || './uploads';
+        // Resolve to absolute path for file operations
+        this.basePath = external_path_.resolve(this.relativeBasePath);
+        this.baseUrl = config?.baseUrl || '';
+        // Ensure base directory exists
+        await __rspack_external_fs_promises_e1851c9c.mkdir(this.basePath, {
+            recursive: true
+        });
+    }
+    async uploadFile(file, options) {
+        let processedBuffer = file.buffer;
+        let contentType = file.mimetype;
+        const fileName = `${(0,external_uuid_.v4)()}-${file.originalname}`;
+        // Compress image if needed
+        if (options.compress && file.mimetype.startsWith('image/')) {
+            const result = await image_compressor_util/* .ImageCompressor.compress */.J.compress(file.buffer, file.mimetype, {
+                maxWidth: options.maxWidth,
+                maxHeight: options.maxHeight,
+                quality: options.quality,
+                format: options.format
+            });
+            processedBuffer = result.buffer;
+            contentType = result.format;
+        }
+        // Build file path
+        const folderPath = options.folderPath ? external_path_.join(this.basePath, options.folderPath) : this.basePath;
+        // SECURITY: Validate path does not escape base directory
+        this.validatePathWithinBase(folderPath);
+        const filePath = external_path_.join(folderPath, fileName);
+        // SECURITY: Double-check final file path
+        this.validatePathWithinBase(filePath);
+        // Ensure directory exists
+        await __rspack_external_fs_promises_e1851c9c.mkdir(folderPath, {
+            recursive: true
+        });
+        // Write file to disk
+        await __rspack_external_fs_promises_e1851c9c.writeFile(filePath, processedBuffer);
+        // Generate key that includes the base path (relative to cwd)
+        // This makes the key self-contained for serving files
+        const relativeKey = external_path_.join(this.relativeBasePath, options.folderPath || '', fileName).replace(/\\/g, '/'); // Normalize path separators
+        return {
+            name: fileName,
+            key: relativeKey,
+            size: processedBuffer.length,
+            contentType
+        };
+    }
+    async uploadMultipleFiles(files, options) {
+        return Promise.all(files.map((file)=>this.uploadFile(file, options)));
+    }
+    async deleteFile(key) {
+        try {
+            // SECURITY: Validate key format first
+            this.validateKeyFormat(key);
+            // Key now includes the basePath, resolve from cwd
+            let filePath = external_path_.resolve(key);
+            // SECURITY: Validate resolved path is within base directory
+            this.validatePathWithinBase(filePath);
+            // Check if file exists at the resolved path
+            try {
+                await __rspack_external_fs_promises_e1851c9c.access(filePath);
+            } catch  {
+                // Fallback: try with basePath prefix (for old keys without basePath)
+                const fallbackPath = external_path_.join(this.basePath, key);
+                // SECURITY: Validate fallback path as well
+                this.validatePathWithinBase(fallbackPath);
+                try {
+                    await __rspack_external_fs_promises_e1851c9c.access(fallbackPath);
+                    filePath = fallbackPath;
+                } catch  {
+                    // File doesn't exist at either location - silent return
+                    return;
+                }
+            }
+            await __rspack_external_fs_promises_e1851c9c.unlink(filePath);
+        } catch (error) {
+            // Re-throw security errors
+            if (error instanceof Error && error.message.includes('Invalid')) {
+                throw error;
+            }
+        // Silent failure for other errors
+        }
+    }
+    async deleteMultipleFiles(keys) {
+        await Promise.all(keys.map((key)=>this.deleteFile(key)));
+    }
+    async generatePresignedUrl(key, _expiresInSeconds) {
+        // Return public URL or relative path
+        // Note: Local storage doesn't support true presigned URLs
+        // If baseUrl is provided, return full URL with file serving endpoint, otherwise return relative path
+        if (this.baseUrl) {
+            // Construct URL with the file serving endpoint
+            const baseUrlWithoutTrailingSlash = this.baseUrl.replace(/\/$/, '');
+            return `${baseUrlWithoutTrailingSlash}/storage/upload/file/${key}`;
+        }
+        return `/storage/upload/file/${key}`;
+    }
+    async healthCheck() {
+        try {
+            await __rspack_external_fs_promises_e1851c9c.access(this.basePath);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+}
+
+
+},
+872(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  J: () => (/* binding */ ImageCompressor)
+});
+
+;// CONCATENATED MODULE: external "sharp"
+
+;// CONCATENATED MODULE: ./projects/nestjs-storage/src/utils/image-compressor.util.ts
+
+// Handle ESM/CJS interop - sharp exports differently in each module system
+const sharp = __rspack_external_sharp["default"] || __rspack_external_sharp;
+/**
+ * Image Compression Utility
+ * Handles image compression and format conversion using sharp
+ */ class ImageCompressor {
+    /**
+   * Dynamically compresses an image based on its format and provided options.
+   * - Preserves original format if not overridden
+   * - Adjusts compression settings for each codec
+   */ static async compress(buffer, mimetype, options = {}) {
+        const { maxWidth = 1280, maxHeight = 1280, quality = 85, format = 'original' } = options;
+        // Skip processing for SVG
+        if (mimetype === 'image/svg+xml') {
+            return {
+                buffer,
+                format: mimetype
+            };
+        }
+        // Initialize sharp with improved error handling
+        const image = sharp(buffer, {
+            failOnError: false,
+            density: 300
+        });
+        // Apply initial resize
+        image.resize({
+            width: maxWidth,
+            height: maxHeight,
+            fit: 'inside',
+            withoutEnlargement: true
+        });
+        // Determine target format
+        let targetFormat = format !== 'original' ? format : mimetype.split('/')[1];
+        // Format-specific optimizations
+        switch(targetFormat.toLowerCase()){
+            case 'jpeg':
+            case 'jpg':
+                image.jpeg({
+                    quality,
+                    mozjpeg: true,
+                    chromaSubsampling: '4:4:4'
+                });
+                break;
+            case 'png':
+                image.png({
+                    compressionLevel: 9,
+                    adaptiveFiltering: true,
+                    palette: true,
+                    quality,
+                    colors: 256,
+                    dither: 1.0
+                });
+                break;
+            case 'webp':
+                image.webp({
+                    quality,
+                    smartSubsample: true,
+                    effort: 6,
+                    lossless: quality === 100
+                });
+                break;
+            case 'avif':
+                image.avif({
+                    quality,
+                    effort: 6,
+                    chromaSubsampling: '4:4:4'
+                });
+                break;
+            case 'tiff':
+                image.tiff({
+                    quality,
+                    compression: 'lzw',
+                    predictor: 'horizontal',
+                    pyramid: true
+                });
+                break;
+            case 'gif':
+                image.gif({
+                    colours: 256,
+                    effort: 10,
+                    dither: 1
+                });
+                break;
+            case 'jp2':
+                image.jp2({
+                    quality,
+                    lossless: quality === 100
+                });
+                break;
+            default:
+                // Fallback to WebP for best compression/quality ratio
+                targetFormat = 'webp';
+                image.webp({
+                    quality,
+                    smartSubsample: true,
+                    effort: 6
+                });
+                break;
+        }
+        try {
+            const compressedBuffer = await image.toBuffer();
+            return {
+                buffer: compressedBuffer,
+                format: `image/${targetFormat}`
+            };
+        } catch  {
+            return {
+                buffer,
+                format: mimetype
+            };
+        }
+    }
+}
+
+
+},
+521(module) {
+
+module.exports = __rspack_external_path;
+
+
+},
+37(module) {
+
+module.exports = __rspack_external_uuid;
+
+
+},
+
+};
+import { __webpack_require__ } from '../runtime.js';
+var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); }
+import * as __rspack_chunk_1 from '../493.js';
+__webpack_require__.C(__rspack_chunk_1);
+import * as __rspack_chunk_2 from './index.js';
+__webpack_require__.C(__rspack_chunk_2);
+var __webpack_exports__ = __webpack_exec__(922);var __webpack_exports__LocalProvider = __webpack_exports__.TZ;
+var __webpack_exports__StorageFactoryService = __webpack_exports__.Lk;
+var __webpack_exports__StorageProviderRegistry = __webpack_exports__.CG;
+export { __webpack_exports__LocalProvider as LocalProvider, __webpack_exports__StorageFactoryService as StorageFactoryService, __webpack_exports__StorageProviderRegistry as StorageProviderRegistry };

package/fesm/runtime.js

@@ -0,0 +1,252 @@
+var __webpack_modules__ = ({});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// expose the modules object (__webpack_modules__)
+__webpack_require__.m = __webpack_modules__;
+
+// expose the module cache
+__webpack_require__.c = __webpack_module_cache__;
+
+// webpack/runtime/async_module
+(() => {
+var hasSymbol = typeof Symbol === "function";
+var rspackQueues = hasSymbol ? Symbol("rspack queues") : "__rspack_queues";
+var rspackExports = __webpack_require__.aE = hasSymbol ? Symbol("rspack exports") : "__webpack_exports__";
+var rspackError = hasSymbol ? Symbol("rspack error") : "__rspack_error";
+var rspackDone = hasSymbol ? Symbol("rspack done") : "__rspack_done";
+var rspackDefer = __webpack_require__.zS = hasSymbol ? Symbol("rspack defer") : "__rspack_defer";
+__webpack_require__.zT = (asyncDeps) => {
+	var hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {
+		var cache = __webpack_module_cache__[id];
+		return !cache || cache[rspackDone] === false;
+	});
+	if (hasUnresolvedAsyncSubgraph) {
+		return ({ then(onFulfilled, onRejected) { return Promise.all(asyncDeps.map(__webpack_require__)).then(onFulfilled, onRejected) } });
+	}
+}
+var resolveQueue = (queue) => {
+	if (queue && queue.d < 1) {
+		queue.d = 1;
+    	queue.forEach((fn) => (fn.r--));
+		queue.forEach((fn) => (fn.r-- ? fn.r++ : fn()));
+	}
+}
+var wrapDeps = (deps) => {
+	return deps.map((dep) => {
+		if (dep !== null && typeof dep === "object") {
+			if(!dep[rspackQueues] && dep[rspackDefer]) {
+				var asyncDeps = __webpack_require__.zT(dep[rspackDefer]);
+				if (asyncDeps) {
+					var d = dep;
+					dep = {
+						then(onFulfilled, onRejected) {
+							asyncDeps.then(() => (onFulfilled(d)), onRejected);
+						}
+					};
+				} else return dep;
+			}
+			if (dep[rspackQueues]) return dep;
+			if (dep.then) {
+				var queue = [];
+				queue.d = 0;
+				dep.then((r) => {
+					obj[rspackExports] = r;
+					resolveQueue(queue);
+				},(e) => {
+					obj[rspackError] = e;
+					resolveQueue(queue);
+				});
+				var obj = {};
+				obj[rspackDefer] = false;
+				obj[rspackQueues] = (fn) => (fn(queue));
+				return obj;
+			}
+		}
+		var ret = {};
+		ret[rspackQueues] = () => {};
+		ret[rspackExports] = dep;
+		return ret;
+	});
+};
+__webpack_require__.a = (module, body, hasAwait, useModuleExports) => {
+	var queue;
+	hasAwait && ((queue = []).d = -1);
+	var depQueues = new Set();
+	var exports = module.exports;
+	var currentDeps;
+	var outerResolve;
+	var reject;
+	var promise = new Promise((resolve, rej) => {
+		reject = rej;
+		outerResolve = resolve;
+	});
+	promise[rspackExports] = exports;
+	promise[rspackQueues] = (fn) => { queue && fn(queue), depQueues.forEach(fn), promise["catch"](() => {}); };
+	module.exports = promise;
+	var asyncModule = module;
+	if (useModuleExports) {
+		asyncModule = Object.create(module);
+		asyncModule.exports = exports;
+	}
+	var handle = (deps) => {
+		currentDeps = wrapDeps(deps);
+		var fn;
+		var getResult = () => {
+			return currentDeps.map((d) => {
+				if(d[rspackDefer]) return d;
+				if (d[rspackError]) throw d[rspackError];
+				return d[rspackExports];
+			});
+		}
+		var promise = new Promise((resolve) => {
+			fn = () => (resolve(getResult));
+			fn.r = 0;
+			var fnQueue = (q) => (q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn))));
+			currentDeps.map((dep) => (dep[rspackDefer] || dep[rspackQueues](fnQueue)));
+		});
+		return fn.r ? promise : getResult();
+	};
+	var done = (err) => ((err ? reject(promise[rspackError] = err) : (useModuleExports && (exports = promise[rspackExports] = asyncModule.exports), outerResolve(exports))), resolveQueue(queue), promise[rspackDone] = true);
+	body(handle, done, asyncModule);
+	queue && queue.d < 0 && (queue.d = 0);
+};
+
+})();
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/ensure_chunk
+(() => {
+__webpack_require__.f = {};
+// This file contains only the entry chunk.
+// The chunk loading function for additional chunks
+__webpack_require__.e = (chunkId) => {
+	return Promise.all(
+		Object.keys(__webpack_require__.f).reduce((promises, key) => {
+			__webpack_require__.f[key](chunkId, promises);
+			return promises;
+		}, [])
+	);
+};
+})();
+// webpack/runtime/export_webpack_require
+var __webpack_require__temp = __webpack_require__;
+export { __webpack_require__temp as __webpack_require__ };
+// webpack/runtime/get javascript chunk filename
+(() => {
+// This function allow to reference chunks
+__webpack_require__.u = (chunkId) => {
+  // return url for filenames not based on template
+  
+  // return url for filenames based on template
+  return "chunks/" + chunkId + ".js"
+}
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+// webpack/runtime/module_chunk_loading
+(() => {
+// no BaseURI
+      // object to store loaded and loading chunks
+      // undefined = chunk not loaded, null = chunk preloaded/prefetched
+      // [resolve, Promise] = chunk loading, 0 = chunk loaded
+      var moduleInstalledChunks = {146: 0,};
+      var moduleInstallChunk = (data) => {
+    var __rspack_esm_ids = data.__rspack_esm_ids;
+    var moreModules = data.__webpack_modules__;
+    var __rspack_esm_runtime = data.__rspack_esm_runtime;
+    // add "modules" to the modules object,
+    // then flag all "ids" as loaded and fire callback
+    var moduleId, chunkId, i = 0;
+    for (moduleId in moreModules) {
+        if (__webpack_require__.o(moreModules, moduleId)) {
+            __webpack_require__.m[moduleId] = moreModules[moduleId];
+        }
+    }
+    if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
+    for (; i < __rspack_esm_ids.length; i++) {
+        chunkId = __rspack_esm_ids[i];
+        if (__webpack_require__.o(moduleInstalledChunks, chunkId) && moduleInstalledChunks[chunkId]) {
+            moduleInstalledChunks[chunkId][0]();
+        }
+        moduleInstalledChunks[__rspack_esm_ids[i]] = 0;
+    }
+    
+};
+
+        __webpack_require__.f.j = function (chunkId, promises) {
+          // import() chunk loading for javascript
+var installedChunkData = __webpack_require__.o(moduleInstalledChunks, chunkId) ? moduleInstalledChunks[chunkId] : undefined;
+if (installedChunkData !== 0) { // 0 means "already installed".'
+    // a Promise means "currently loading".
+    if (installedChunkData) {
+        promises.push(installedChunkData[1]);
+    } else {
+        if (146 != chunkId) {
+            // setup Promise in chunk cache
+            var promise = import("./" + __webpack_require__.u(chunkId)).then(moduleInstallChunk, (e) => {
+                if (moduleInstalledChunks[chunkId] !== 0) moduleInstalledChunks[chunkId] = undefined;
+                throw e;
+            });
+            var promise = Promise.race([promise, new Promise((resolve) => {
+                installedChunkData = moduleInstalledChunks[chunkId] = [resolve];
+            })]);
+            promises.push(installedChunkData[1] = promise);
+        }
+        else moduleInstalledChunks[chunkId] = 0;
+
+    }
+}
+
+        }
+        
+        __webpack_require__.C = moduleInstallChunk;
+        // no on chunks loaded
+// no HMR
+// no HMR manifest
+
+})();

package/fesm/services/index.js

@@ -1,6 +1,16 @@
-export * from './file-manager.service';
-export * from './folder.service';
-export * from './storage-config.service';
-export * from './storage-provider-config.service';
-export * from './storage-datasource.provider';
-export * from './upload.service';
+export const __rspack_esm_id = 995;
+export const __rspack_esm_ids = [995];
+export const __webpack_modules__ = {};
+import { __webpack_require__ } from '../runtime.js';
+var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); }
+import * as __rspack_chunk_1 from '../493.js';
+__webpack_require__.C(__rspack_chunk_1);
+import * as __rspack_chunk_2 from './index.js';
+__webpack_require__.C(__rspack_chunk_2);
+var __webpack_exports__ = __webpack_exec__(148);var __webpack_exports__FileManagerService = __webpack_exports__.DL;
+var __webpack_exports__FolderService = __webpack_exports__.kh;
+var __webpack_exports__StorageConfigService = __webpack_exports__.tP;
+var __webpack_exports__StorageDataSourceProvider = __webpack_exports__.M0;
+var __webpack_exports__StorageProviderConfigService = __webpack_exports__.ol;
+var __webpack_exports__UploadService = __webpack_exports__.BB;
+export { __webpack_exports__FileManagerService as FileManagerService, __webpack_exports__FolderService as FolderService, __webpack_exports__StorageConfigService as StorageConfigService, __webpack_exports__StorageDataSourceProvider as StorageDataSourceProvider, __webpack_exports__StorageProviderConfigService as StorageProviderConfigService, __webpack_exports__UploadService as UploadService };