@flusys/nestjs-storage 7.1.0 → 8.0.0

package/cjs/middlewares/file-serve.middleware.js

@@ -1,241 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "FileServeMiddleware", {
-    enumerable: true,
-    get: function() {
-        return FileServeMiddleware;
-    }
-});
-const _common = require("@nestjs/common");
-const _fs = require("fs");
-const _path = require("path");
-const _mimetypes = /*#__PURE__*/ _interop_require_wildcard(require("mime-types"));
-const _config = require("../config");
-const _uploadservice = require("../services/upload.service");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-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(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-/** MIME type prefixes that can be displayed inline in browser */ const VIEWABLE_TYPE_PREFIXES = [
-    'image/',
-    'video/',
-    'audio/',
-    'text/',
-    'application/pdf',
-    'application/json',
-    'application/xml'
-];
-let FileServeMiddleware = class FileServeMiddleware {
-    async use(req, res, next) {
-        try {
-            const normalizedPath = this.extractFilePath(req);
-            const fullPath = await this.resolveFilePath(normalizedPath);
-            const stats = (0, _fs.statSync)(fullPath);
-            if (!stats.isFile()) {
-                throw new _common.NotFoundException({
-                    message: `Not a file: ${normalizedPath}`,
-                    messageKey: _config.FILE_MESSAGES.NOT_FOUND,
-                    messageVariables: {
-                        path: normalizedPath
-                    }
-                });
-            }
-            const mimeType = this.getMimeType(fullPath);
-            this.setResponseHeaders(res, stats.size, mimeType, normalizedPath);
-            this.streamFile(res, fullPath, normalizedPath);
-        } catch (error) {
-            this.sendErrorResponse(res, error);
-        }
-    }
-    /** Extract and validate file path from request URL */ extractFilePath(req) {
-        const urlPath = req.path || req.url;
-        const match = urlPath.match(/\/storage\/upload\/file\/(.+)/);
-        const normalizedPath = match ? match[1] : '';
-        if (!normalizedPath) {
-            throw new _common.BadRequestException({
-                message: 'File path is required',
-                messageKey: _config.UPLOAD_MESSAGES.NO_FILE_PATH
-            });
-        }
-        return normalizedPath;
-    }
-    /** Resolve file path using multiple fallback strategies */ async resolveFilePath(normalizedPath) {
-        // Strategy 1: Path relative to CWD (new format: key includes basePath)
-        let fullPath = (0, _path.join)(this.uploadDir, normalizedPath);
-        const resolvedPath = (0, _path.resolve)(fullPath);
-        // Prevent path traversal attacks
-        if (!resolvedPath.startsWith(this.uploadDir)) {
-            throw new _common.BadRequestException({
-                message: 'Invalid file path',
-                messageKey: _config.UPLOAD_MESSAGES.INVALID_FILE_PATH
-            });
-        }
-        if ((0, _fs.existsSync)(fullPath)) {
-            return fullPath;
-        }
-        // Try fallback strategies with basePath
-        const basePath = await this.uploadService.getLocalStorageBasePath();
-        if (basePath) {
-            const fallbackPath = this.tryFallbackPaths(normalizedPath, basePath);
-            if (fallbackPath) {
-                return fallbackPath;
-            }
-        }
-        throw new _common.NotFoundException({
-            message: `File not found: ${normalizedPath}`,
-            messageKey: _config.FILE_MESSAGES.NOT_FOUND,
-            messageVariables: {
-                path: normalizedPath
-            }
-        });
-    }
-    /** Try basePath-based fallback strategies */ tryFallbackPaths(normalizedPath, basePath) {
-        const normalizedBasePath = basePath.replace(/^\.\//, '').replace(/\/$/, '');
-        const pathStartsWithBase = normalizedPath.startsWith(normalizedBasePath + '/') || normalizedPath.startsWith(normalizedBasePath);
-        if (pathStartsWithBase) {
-            // Strategy 2: basePath + remaining path
-            const remainingPath = normalizedPath.substring(normalizedBasePath.length).replace(/^\//, '');
-            const fallbackPath = (0, _path.join)(basePath, remainingPath);
-            if ((0, _fs.existsSync)(fallbackPath)) return fallbackPath;
-        } else {
-            // Strategy 3: Old format - prepend basePath
-            const fallbackPath = (0, _path.join)(basePath, normalizedPath);
-            if ((0, _fs.existsSync)(fallbackPath)) return fallbackPath;
-        }
-        return null;
-    }
-    /** Get MIME type with SVG special handling */ getMimeType(fullPath) {
-        if (fullPath.toLowerCase().endsWith('.svg')) {
-            return 'image/svg+xml';
-        }
-        return _mimetypes.lookup(fullPath) || 'application/octet-stream';
-    }
-    /** Set response headers for file serving */ setResponseHeaders(res, size, mimeType, normalizedPath) {
-        const isViewable = VIEWABLE_TYPE_PREFIXES.some((type)=>mimeType.startsWith(type));
-        const filename = normalizedPath.split('/').pop() || 'download';
-        const contentDisposition = isViewable ? 'inline' : `attachment; filename="${encodeURIComponent(filename)}"`;
-        res.set({
-            'Content-Type': mimeType,
-            'Content-Length': size,
-            'Content-Disposition': contentDisposition,
-            'Cache-Control': 'public, max-age=3600',
-            'Accept-Ranges': 'bytes',
-            'Cross-Origin-Resource-Policy': 'cross-origin',
-            'Access-Control-Allow-Origin': '*',
-            'X-Content-Type-Options': 'nosniff'
-        });
-    }
-    /** Stream file to response with error handling */ streamFile(res, fullPath, normalizedPath) {
-        const stream = (0, _fs.createReadStream)(fullPath);
-        stream.pipe(res);
-        stream.on('error', ()=>{
-            if (!res.headersSent) {
-                this.sendErrorResponse(res, new _common.NotFoundException({
-                    message: `Failed to serve file: ${normalizedPath}`,
-                    messageKey: _config.FILE_MESSAGES.NOT_FOUND,
-                    messageVariables: {
-                        path: normalizedPath
-                    }
-                }));
-            }
-        });
-        res.on('close', ()=>stream.destroy());
-    }
-    /** Send consistent error response */ sendErrorResponse(res, error) {
-        if (!res.headersSent) {
-            const isNotFound = error instanceof _common.NotFoundException;
-            const response = isNotFound ? error.getResponse() : null;
-            const message = response?.message ?? 'File not found';
-            const messageKey = response?.messageKey ?? _config.FILE_MESSAGES.NOT_FOUND;
-            const messageVariables = response?.messageVariables;
-            res.status(404).json({
-                success: false,
-                message,
-                messageKey,
-                messageVariables,
-                error: 'Not Found',
-                statusCode: 404
-            });
-        }
-    }
-    constructor(uploadService){
-        _define_property(this, "uploadService", void 0);
-        _define_property(this, "uploadDir", void 0);
-        this.uploadService = uploadService;
-        this.uploadDir = process.cwd();
-    }
-};
-FileServeMiddleware = _ts_decorate([
-    (0, _common.Injectable)(),
-    _ts_param(0, (0, _common.Inject)(_uploadservice.UploadService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _uploadservice.UploadService === "undefined" ? Object : _uploadservice.UploadService
-    ])
-], FileServeMiddleware);

package/cjs/middlewares/file-serve.middleware.spec.js

@@ -1,211 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _events = require("events");
-const _path = require("path");
-const _fileservemiddleware = require("./file-serve.middleware");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-const mockCreateReadStream = jest.fn();
-const mockExistsSync = jest.fn();
-const mockStatSync = jest.fn();
-jest.mock('fs', ()=>({
-        ...jest.requireActual('fs'),
-        createReadStream: (...args)=>mockCreateReadStream(...args),
-        existsSync: (...args)=>mockExistsSync(...args),
-        statSync: (...args)=>mockStatSync(...args)
-    }));
-const mockMimeLookup = jest.fn();
-jest.mock('mime-types', ()=>({
-        lookup: (...args)=>mockMimeLookup(...args)
-    }));
-let FakeStream = class FakeStream extends _events.EventEmitter {
-    constructor(...args){
-        super(...args), _define_property(this, "pipe", jest.fn()), _define_property(this, "destroy", jest.fn());
-    }
-};
-function buildRes() {
-    const listeners = {};
-    return {
-        headersSent: false,
-        set: jest.fn(),
-        status: jest.fn().mockReturnThis(),
-        json: jest.fn(),
-        on: jest.fn((event, cb)=>{
-            listeners[event] = listeners[event] || [];
-            listeners[event].push(cb);
-        }),
-        emitClose: ()=>(listeners['close'] || []).forEach((cb)=>cb())
-    };
-}
-function buildReq(urlPath) {
-    return {
-        path: urlPath,
-        url: urlPath
-    };
-}
-describe('FileServeMiddleware', ()=>{
-    let middleware;
-    let mockUploadService;
-    let next;
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        mockUploadService = {
-            getLocalStorageBasePath: jest.fn().mockResolvedValue(null)
-        };
-        middleware = new _fileservemiddleware.FileServeMiddleware(mockUploadService);
-        next = jest.fn();
-    });
-    it('responds 404 when the file path segment is missing from the URL', async ()=>{
-        const res = buildRes();
-        await middleware.use(buildReq('/storage/upload/file/'), res, next);
-        expect(res.status).toHaveBeenCalledWith(404);
-        expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-            success: false,
-            statusCode: 404
-        }));
-        expect(mockExistsSync).not.toHaveBeenCalled();
-    });
-    it('blocks path traversal attempts that resolve outside the upload directory', async ()=>{
-        const res = buildRes();
-        mockExistsSync.mockReturnValue(false);
-        await middleware.use(buildReq('/storage/upload/file/../../etc/passwd'), res, next);
-        expect(res.status).toHaveBeenCalledWith(404);
-        expect(mockStatSync).not.toHaveBeenCalled();
-    });
-    it('serves a file that exists directly under the upload directory with inline disposition for viewable types', async ()=>{
-        const res = buildRes();
-        mockExistsSync.mockReturnValue(true);
-        mockStatSync.mockReturnValue({
-            isFile: ()=>true,
-            size: 1234
-        });
-        mockMimeLookup.mockReturnValue('application/pdf');
-        const stream = new FakeStream();
-        mockCreateReadStream.mockReturnValue(stream);
-        await middleware.use(buildReq('/storage/upload/file/report.pdf'), res, next);
-        expect(res.set).toHaveBeenCalledWith(expect.objectContaining({
-            'Content-Type': 'application/pdf',
-            'Content-Length': 1234,
-            'Content-Disposition': 'inline'
-        }));
-        expect(stream.pipe).toHaveBeenCalledWith(res);
-    });
-    it('sets an attachment content-disposition with the filename for non-viewable mime types', async ()=>{
-        const res = buildRes();
-        mockExistsSync.mockReturnValue(true);
-        mockStatSync.mockReturnValue({
-            isFile: ()=>true,
-            size: 500
-        });
-        mockMimeLookup.mockReturnValue('application/zip');
-        mockCreateReadStream.mockReturnValue(new FakeStream());
-        await middleware.use(buildReq('/storage/upload/file/archive.zip'), res, next);
-        expect(res.set).toHaveBeenCalledWith(expect.objectContaining({
-            'Content-Disposition': expect.stringContaining('attachment; filename="archive.zip"')
-        }));
-    });
-    it('always serves .svg files as image/svg+xml regardless of mime-types lookup', async ()=>{
-        const res = buildRes();
-        mockExistsSync.mockReturnValue(true);
-        mockStatSync.mockReturnValue({
-            isFile: ()=>true,
-            size: 200
-        });
-        mockCreateReadStream.mockReturnValue(new FakeStream());
-        await middleware.use(buildReq('/storage/upload/file/logo.svg'), res, next);
-        expect(mockMimeLookup).not.toHaveBeenCalled();
-        expect(res.set).toHaveBeenCalledWith(expect.objectContaining({
-            'Content-Type': 'image/svg+xml'
-        }));
-    });
-    it('returns 404 when the resolved path exists but is not a regular file', async ()=>{
-        const res = buildRes();
-        mockExistsSync.mockReturnValue(true);
-        mockStatSync.mockReturnValue({
-            isFile: ()=>false
-        });
-        await middleware.use(buildReq('/storage/upload/file/some-dir'), res, next);
-        expect(res.status).toHaveBeenCalledWith(404);
-        expect(mockCreateReadStream).not.toHaveBeenCalled();
-    });
-    it('falls back to the configured local storage base path (strategy 2: path already prefixed with base)', async ()=>{
-        const res = buildRes();
-        const fallbackPath = (0, _path.join)('uploads', 'report.pdf');
-        mockUploadService.getLocalStorageBasePath.mockResolvedValue('./uploads');
-        mockExistsSync.mockImplementation((p)=>p === fallbackPath);
-        mockStatSync.mockReturnValue({
-            isFile: ()=>true,
-            size: 10
-        });
-        mockMimeLookup.mockReturnValue('application/pdf');
-        mockCreateReadStream.mockReturnValue(new FakeStream());
-        await middleware.use(buildReq('/storage/upload/file/uploads/report.pdf'), res, next);
-        expect(mockCreateReadStream).toHaveBeenCalledWith(fallbackPath);
-    });
-    it('falls back to the configured local storage base path (strategy 3: legacy path without base prefix)', async ()=>{
-        const res = buildRes();
-        const fallbackPath = (0, _path.join)('uploads', 'report.pdf');
-        mockUploadService.getLocalStorageBasePath.mockResolvedValue('uploads');
-        mockExistsSync.mockImplementation((p)=>p === fallbackPath);
-        mockStatSync.mockReturnValue({
-            isFile: ()=>true,
-            size: 10
-        });
-        mockMimeLookup.mockReturnValue('application/pdf');
-        mockCreateReadStream.mockReturnValue(new FakeStream());
-        await middleware.use(buildReq('/storage/upload/file/report.pdf'), res, next);
-        expect(mockCreateReadStream).toHaveBeenCalledWith(fallbackPath);
-    });
-    it('returns the underlying not-found message when no direct or fallback path resolves', async ()=>{
-        const res = buildRes();
-        mockExistsSync.mockReturnValue(false);
-        mockUploadService.getLocalStorageBasePath.mockResolvedValue(null);
-        await middleware.use(buildReq('/storage/upload/file/missing.pdf'), res, next);
-        expect(res.status).toHaveBeenCalledWith(404);
-        expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-            message: expect.stringContaining('File not found'),
-            statusCode: 404
-        }));
-    });
-    it('sends a 404 if the file stream errors before headers are sent', async ()=>{
-        const res = buildRes();
-        mockExistsSync.mockReturnValue(true);
-        mockStatSync.mockReturnValue({
-            isFile: ()=>true,
-            size: 10
-        });
-        mockMimeLookup.mockReturnValue('application/pdf');
-        const stream = new FakeStream();
-        mockCreateReadStream.mockReturnValue(stream);
-        await middleware.use(buildReq('/storage/upload/file/report.pdf'), res, next);
-        stream.emit('error', new Error('boom'));
-        expect(res.status).toHaveBeenCalledWith(404);
-    });
-    it('destroys the stream when the response is closed early', async ()=>{
-        const res = buildRes();
-        mockExistsSync.mockReturnValue(true);
-        mockStatSync.mockReturnValue({
-            isFile: ()=>true,
-            size: 10
-        });
-        mockMimeLookup.mockReturnValue('application/pdf');
-        const stream = new FakeStream();
-        mockCreateReadStream.mockReturnValue(stream);
-        await middleware.use(buildReq('/storage/upload/file/report.pdf'), res, next);
-        res.emitClose();
-        expect(stream.destroy).toHaveBeenCalled();
-    });
-});

package/cjs/middlewares/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./file-serve.middleware"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/modules/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./storage.module"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/modules/storage.module.js

@@ -1,165 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "StorageModule", {
-    enumerable: true,
-    get: function() {
-        return StorageModule;
-    }
-});
-const _modules = require("@flusys/nestjs-shared/modules");
-const _common = require("@nestjs/common");
-const _middlewares = require("../middlewares");
-const _services = require("../services");
-const _storageconstants = require("../config/storage.constants");
-const _controllers = require("../controllers");
-const _filelocationenum = require("../enums/file-location.enum");
-const _providers = require("../providers");
-const _localprovider = require("../providers/local-provider");
-const _storageproviderconfigservice = require("../services/storage-provider-config.service");
-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;
-}
-const logger = new _common.Logger('StorageModule');
-const CONTROLLERS = [
-    _controllers.FileManagerController,
-    _controllers.FolderController,
-    _controllers.StorageConfigController,
-    _controllers.UploadController
-];
-const EXPORTED_SERVICES = [
-    _services.StorageConfigService,
-    _services.StorageDataSourceProvider,
-    _services.FileManagerService,
-    _services.FolderService,
-    _storageproviderconfigservice.StorageProviderConfigService,
-    _services.UploadService,
-    _providers.StorageFactoryService
-];
-// Register built-in provider
-_providers.StorageProviderRegistry.register(_filelocationenum.FileLocationEnum.LOCAL, _localprovider.LocalProvider);
-logger.log('Registered LocalProvider');
-// Register optional providers (skip if dependencies not installed)
-const OPTIONAL_PROVIDERS = [
-    {
-        location: _filelocationenum.FileLocationEnum.AWS,
-        path: '../providers/s3-provider.optional',
-        name: 'S3Provider',
-        dep: '@aws-sdk/client-s3'
-    },
-    {
-        location: _filelocationenum.FileLocationEnum.AZURE,
-        path: '../providers/azure-provider.optional',
-        name: 'AzureProvider',
-        dep: '@azure/storage-blob'
-    },
-    {
-        location: _filelocationenum.FileLocationEnum.SFTP,
-        path: '../providers/sftp-provider.optional',
-        name: 'SftpProvider',
-        dep: 'ssh2-sftp-client'
-    }
-];
-for (const { location, path, name, dep } of OPTIONAL_PROVIDERS){
-    try {
-        _providers.StorageProviderRegistry.register(location, require(path)[name]);
-        logger.log(`Registered ${name}`);
-    } catch  {
-        logger.debug(`${name} not available (install ${dep} to enable)`);
-    }
-}
-let StorageModule = class StorageModule {
-    configure(consumer) {
-        consumer.apply(_middlewares.FileServeMiddleware).forRoutes({
-            path: 'storage/upload/file/*',
-            method: _common.RequestMethod.GET
-        });
-    }
-    static forRoot(options) {
-        return {
-            module: StorageModule,
-            global: options.global ?? false,
-            imports: [
-                _modules.CacheModule,
-                _modules.UtilsModule
-            ],
-            controllers: options.includeController !== false ? CONTROLLERS : [],
-            providers: this.buildProviders(options),
-            exports: EXPORTED_SERVICES
-        };
-    }
-    static forRootAsync(options) {
-        return {
-            module: StorageModule,
-            global: options.global ?? false,
-            imports: [
-                ...options.imports || [],
-                _modules.CacheModule,
-                _modules.UtilsModule
-            ],
-            controllers: options.includeController !== false ? CONTROLLERS : [],
-            providers: [
-                ...this.createAsyncProviders(options),
-                ...this.buildProviders()
-            ],
-            exports: EXPORTED_SERVICES
-        };
-    }
-    // ─── Private Helpers ──────────────────────────────────────────────────────────
-    static buildProviders(options) {
-        const providers = [
-            ...EXPORTED_SERVICES,
-            _middlewares.FileServeMiddleware
-        ];
-        if (options) {
-            providers.unshift({
-                provide: _storageconstants.STORAGE_MODULE_OPTIONS,
-                useValue: options
-            });
-        }
-        providers.push((0, _modules.createModuleEventsProvider)('storage', _storageconstants.STORAGE_MODULE_OPTIONS));
-        return providers;
-    }
-    static createAsyncProviders(options) {
-        if (options.useFactory) {
-            return [
-                {
-                    provide: _storageconstants.STORAGE_MODULE_OPTIONS,
-                    useFactory: async (...args)=>({
-                            ...options,
-                            config: await options.useFactory(...args)
-                        }),
-                    inject: options.inject || []
-                }
-            ];
-        }
-        const factoryClass = options.useClass || options.useExisting;
-        if (!factoryClass) return [];
-        const providers = [
-            {
-                provide: _storageconstants.STORAGE_MODULE_OPTIONS,
-                useFactory: async (factory)=>({
-                        ...options,
-                        config: await factory.createStorageOptions()
-                    }),
-                inject: [
-                    factoryClass
-                ]
-            }
-        ];
-        if (options.useClass) {
-            providers.push({
-                provide: options.useClass,
-                useClass: options.useClass
-            });
-        }
-        return providers;
-    }
-};
-StorageModule = _ts_decorate([
-    (0, _common.Module)({})
-], StorageModule);