@flusys/nestjs-storage 6.0.2 → 6.1.0

package/fesm/controllers/storage-config.controller.spec.js

@@ -0,0 +1,81 @@
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { StorageConfigController } from './storage-config.controller';
+function buildStorageConfig(overrides = {}) {
+    return {
+        id: 'storage-config-1',
+        provider: 'local',
+        isActive: true,
+        isDefault: true,
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('StorageConfigController', ()=>{
+    let controller;
+    let mockStorageConfigService;
+    beforeEach(()=>{
+        mockStorageConfigService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn()
+        };
+        controller = new StorageConfigController(mockStorageConfigService);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.storageConfigService).toBe(mockStorageConfigService);
+        expect(controller.service).toBe(mockStorageConfigService);
+    });
+    describe('insert', ()=>{
+        it('creates a storage config and returns the mapped response', async ()=>{
+            const user = buildMockUser();
+            mockStorageConfigService.insert.mockResolvedValue(buildStorageConfig());
+            const result = await controller.insert({
+                provider: 'local'
+            }, user);
+            expect(mockStorageConfigService.insert).toHaveBeenCalledWith({
+                provider: 'local'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'storage-config-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates storage configs and maps the response list', async ()=>{
+            mockStorageConfigService.getAll.mockResolvedValue({
+                data: [
+                    buildStorageConfig()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, buildMockUser(), '');
+            expect(mockStorageConfigService.getAll).toHaveBeenCalledWith('', {}, buildMockUser());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('delete', ()=>{
+        it('delegates soft-delete to the service', async ()=>{
+            mockStorageConfigService.delete.mockResolvedValue({
+                count: 1
+            });
+            const result = await controller.delete({
+                id: [
+                    'storage-config-1'
+                ],
+                type: 'delete'
+            }, buildMockUser());
+            expect(mockStorageConfigService.delete).toHaveBeenCalledWith({
+                id: [
+                    'storage-config-1'
+                ],
+                type: 'delete'
+            }, buildMockUser());
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/fesm/controllers/upload.controller.spec.js

@@ -0,0 +1,128 @@
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { UploadController } from './upload.controller';
+describe('UploadController', ()=>{
+    let controller;
+    let mockUploadService;
+    beforeEach(()=>{
+        mockUploadService = {
+            bytesToKb: jest.fn((bytes)=>bytes / 1024),
+            uploadSingleFile: jest.fn(),
+            uploadMultipleFiles: jest.fn(),
+            deleteSingleFile: jest.fn(),
+            deleteMultipleFile: jest.fn()
+        };
+        controller = new UploadController(mockUploadService);
+    });
+    describe('uploadSingleFile', ()=>{
+        it('uploads a file and maps the response payload', async ()=>{
+            const user = buildMockUser();
+            const file = {
+                originalname: 'photo.png'
+            };
+            mockUploadService.uploadSingleFile.mockResolvedValue({
+                size: 2048,
+                name: 'photo.png',
+                key: 'files/photo.png',
+                contentType: 'image/png',
+                location: 's3',
+                storageConfigId: 'storage-1'
+            });
+            const result = await controller.uploadSingleFile(file, {
+                folderPath: 'photos'
+            }, user);
+            expect(mockUploadService.uploadSingleFile).toHaveBeenCalledWith(file, {
+                folderPath: 'photos'
+            }, user);
+            expect(mockUploadService.bytesToKb).toHaveBeenCalledWith(2048);
+            expect(result).toEqual({
+                success: true,
+                message: 'File uploaded successfully',
+                messageKey: expect.any(String),
+                data: {
+                    size: 2,
+                    name: 'photo.png',
+                    key: 'files/photo.png',
+                    contentType: 'image/png',
+                    location: 's3',
+                    storageConfigId: 'storage-1'
+                }
+            });
+        });
+        it('defaults location to "local" and storageConfigId to an empty string when absent', async ()=>{
+            const user = buildMockUser();
+            mockUploadService.uploadSingleFile.mockResolvedValue({
+                size: 100,
+                name: 'file.txt',
+                key: 'files/file.txt',
+                contentType: 'text/plain'
+            });
+            const result = await controller.uploadSingleFile({}, {}, user);
+            expect(result.data.location).toBe('local');
+            expect(result.data.storageConfigId).toBe('');
+        });
+    });
+    describe('uploadMultipleFiles', ()=>{
+        it('uploads multiple files and maps each response payload', async ()=>{
+            const user = buildMockUser();
+            const files = [
+                {
+                    originalname: 'a.png'
+                },
+                {
+                    originalname: 'b.png'
+                }
+            ];
+            mockUploadService.uploadMultipleFiles.mockResolvedValue([
+                {
+                    size: 100,
+                    name: 'a.png',
+                    key: 'files/a.png',
+                    contentType: 'image/png'
+                },
+                {
+                    size: 200,
+                    name: 'b.png',
+                    key: 'files/b.png',
+                    contentType: 'image/png'
+                }
+            ]);
+            const result = await controller.uploadMultipleFiles(files, {}, user);
+            expect(mockUploadService.uploadMultipleFiles).toHaveBeenCalledWith(files, {}, user);
+            expect(result.data).toHaveLength(2);
+            expect(result.data[0]).toEqual(expect.objectContaining({
+                name: 'a.png',
+                key: 'files/a.png'
+            }));
+        });
+    });
+    describe('deleteSingleFile', ()=>{
+        it('deletes a file by key and storage config', async ()=>{
+            const user = buildMockUser();
+            mockUploadService.deleteSingleFile.mockResolvedValue(true);
+            const result = await controller.deleteSingleFile({
+                key: 'files/a.png',
+                storageConfigId: 'storage-1'
+            }, user);
+            expect(mockUploadService.deleteSingleFile).toHaveBeenCalledWith('files/a.png', 'storage-1', user);
+            expect(result.data).toBe(true);
+        });
+    });
+    describe('deleteMultipleFile', ()=>{
+        it('deletes multiple files by keys and storage config', async ()=>{
+            const user = buildMockUser();
+            mockUploadService.deleteMultipleFile.mockResolvedValue(true);
+            const result = await controller.deleteMultipleFile({
+                keys: [
+                    'files/a.png',
+                    'files/b.png'
+                ],
+                storageConfigId: 'storage-1'
+            }, user);
+            expect(mockUploadService.deleteMultipleFile).toHaveBeenCalledWith([
+                'files/a.png',
+                'files/b.png'
+            ], 'storage-1', user);
+            expect(result.data).toBe(true);
+        });
+    });
+});

package/fesm/docs/storage-swagger.config.spec.js

@@ -0,0 +1,68 @@
+import { storageSwaggerConfig } from './storage-swagger.config';
+describe('storageSwaggerConfig', ()=>{
+    it('should default to company feature enabled and single-database mode when no config is given', ()=>{
+        const config = storageSwaggerConfig();
+        expect(config.title).toBe('Storage API');
+        expect(config.path).toBe('api/docs/storage');
+        expect(config.bearerAuth).toBe(true);
+        expect(config.excludeTags).toEqual([]);
+        expect(config.excludeSchemaProperties).toBeUndefined();
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+        expect(config.description).toContain('with multi-tenant support');
+    });
+    it('should exclude companyId schema properties when the company feature is disabled', ()=>{
+        const config = storageSwaggerConfig({
+            enableCompanyFeature: false
+        });
+        expect(config.excludeSchemaProperties).toEqual([
+            {
+                schemaName: 'FileManagerResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'FolderResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'StorageConfigResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            }
+        ]);
+    });
+    it('should not exclude any schema properties when the company feature is enabled', ()=>{
+        const config = storageSwaggerConfig({
+            enableCompanyFeature: true
+        });
+        expect(config.excludeSchemaProperties).toBeUndefined();
+    });
+    it('should describe company isolation and multi-tenant sections only when the company feature is enabled', ()=>{
+        const withCompany = storageSwaggerConfig({
+            enableCompanyFeature: true
+        });
+        const withoutCompany = storageSwaggerConfig({
+            enableCompanyFeature: false
+        });
+        expect(withCompany.description).toContain('Company isolation');
+        expect(withCompany.description).toContain('## Multi-Tenant Support');
+        expect(withCompany.description).toContain('## Examples');
+        expect(withoutCompany.description).not.toContain('Company isolation');
+        expect(withoutCompany.description).not.toContain('## Multi-Tenant Support');
+        expect(withoutCompany.description).not.toContain('## Examples');
+    });
+    it('should mention multi-tenant mode in the description only for multi-tenant database mode', ()=>{
+        const multiTenant = storageSwaggerConfig({
+            databaseMode: 'multi-tenant'
+        });
+        const single = storageSwaggerConfig({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+});

package/fesm/entities/index.spec.js

@@ -0,0 +1,14 @@
+import { getStorageEntitiesByConfig, StorageCoreEntities, StorageCompanyEntities } from './index';
+describe('getStorageEntitiesByConfig', ()=>{
+    it('returns the core entities when the company feature is disabled', ()=>{
+        expect(getStorageEntitiesByConfig(false)).toBe(StorageCoreEntities);
+    });
+    it('returns the company-scoped entities when the company feature is enabled', ()=>{
+        expect(getStorageEntitiesByConfig(true)).toBe(StorageCompanyEntities);
+    });
+    it('core and company entity sets are disjoint (never mixed)', ()=>{
+        const core = getStorageEntitiesByConfig(false);
+        const company = getStorageEntitiesByConfig(true);
+        expect(core.some((e)=>company.includes(e))).toBe(false);
+    });
+});

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

@@ -0,0 +1,207 @@
+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;
+}
+import { EventEmitter } from 'events';
+import { join } from 'path';
+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)
+    }));
+import { FileServeMiddleware } from './file-serve.middleware';
+let FakeStream = class FakeStream extends 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(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 = 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 = 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/fesm/modules/storage.module.spec.js

@@ -0,0 +1,180 @@
+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;
+}
+import { StorageModule } from './storage.module';
+import { STORAGE_MODULE_OPTIONS } from '../config/storage.constants';
+import { FileManagerController, FolderController, StorageConfigController, UploadController } from '../controllers';
+import { FileServeMiddleware } from '../middlewares';
+function providerTokens(providers) {
+    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
+}
+describe('StorageModule', ()=>{
+    describe('forRoot', ()=>{
+        it('should default to a non-global module with all controllers registered', ()=>{
+            const dynamicModule = StorageModule.forRoot({});
+            expect(dynamicModule.module).toBe(StorageModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                FileManagerController,
+                FolderController,
+                StorageConfigController,
+                UploadController
+            ]);
+        });
+        it('should respect global: true', ()=>{
+            expect(StorageModule.forRoot({
+                global: true
+            }).global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            expect(StorageModule.forRoot({
+                includeController: false
+            }).controllers).toEqual([]);
+        });
+        it('should register controllers when includeController is anything other than exactly false', ()=>{
+            expect(StorageModule.forRoot({
+                includeController: true
+            }).controllers).toHaveLength(4);
+            expect(StorageModule.forRoot({}).controllers).toHaveLength(4);
+        });
+        it('should register a STORAGE_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            };
+            const dynamicModule = StorageModule.forRoot(options);
+            const provider = dynamicModule.providers.find((p)=>p.provide === STORAGE_MODULE_OPTIONS);
+            expect(provider.useValue).toBe(options);
+        });
+        it('should always export the same fixed set of services', ()=>{
+            const dynamicModule = StorageModule.forRoot({});
+            expect(dynamicModule.exports).toHaveLength(7);
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                imports: [
+                    FakeImportedModule
+                ]
+            });
+            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
+                FakeImportedModule
+            ]));
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            const dynamicModule = StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                includeController: false
+            });
+            expect(dynamicModule.controllers).toEqual([]);
+        });
+        it('useFactory: builds a STORAGE_MODULE_OPTIONS provider that merges resolved config into the static options', async ()=>{
+            const useFactory = jest.fn().mockResolvedValue({
+                maxFileSize: 1024
+            });
+            const dynamicModule = StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const provider = dynamicModule.providers.find((p)=>p.provide === STORAGE_MODULE_OPTIONS);
+            expect(provider.inject).toEqual([
+                'SOME_TOKEN'
+            ]);
+            const resolved = await provider.useFactory('injected');
+            expect(useFactory).toHaveBeenCalledWith('injected');
+            expect(resolved.config).toEqual({
+                maxFileSize: 1024
+            });
+        });
+        it('useClass: registers both the class provider and an options provider calling createStorageOptions()', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createStorageOptions", jest.fn().mockResolvedValue({
+                        maxFileSize: 2048
+                    }));
+                }
+            };
+            const dynamicModule = StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useClass: MyOptionsFactory
+            });
+            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
+            expect(classProvider.useClass).toBe(MyOptionsFactory);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === STORAGE_MODULE_OPTIONS);
+            const instance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(instance);
+            expect(instance.createStorageOptions).toHaveBeenCalled();
+            expect(resolved.config).toEqual({
+                maxFileSize: 2048
+            });
+        });
+        it('useExisting: registers a single options provider without a duplicate class registration', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createStorageOptions", jest.fn().mockResolvedValue({
+                        maxFileSize: 4096
+                    }));
+                }
+            };
+            const dynamicModule = StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useExisting: MyOptionsFactory
+            });
+            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === STORAGE_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+        });
+        it('should register no STORAGE_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
+            const dynamicModule = StorageModule.forRootAsync({
+                bootstrapAppConfig: {}
+            });
+            expect(providerTokens(dynamicModule.providers)).not.toContain(STORAGE_MODULE_OPTIONS);
+        });
+        it('should still register the fixed exported services as providers alongside async options', ()=>{
+            const dynamicModule = StorageModule.forRootAsync({
+                bootstrapAppConfig: {},
+                useFactory: jest.fn()
+            });
+            expect(dynamicModule.providers).toEqual(expect.arrayContaining([
+                ...dynamicModule.exports
+            ]));
+        });
+    });
+    describe('configure (NestModule)', ()=>{
+        it('should wire FileServeMiddleware to the file GET route', ()=>{
+            const forRoutes = jest.fn();
+            const apply = jest.fn().mockReturnValue({
+                forRoutes
+            });
+            const consumer = {
+                apply
+            };
+            new StorageModule().configure(consumer);
+            expect(apply).toHaveBeenCalledWith(FileServeMiddleware);
+            expect(forRoutes).toHaveBeenCalledWith({
+                path: 'storage/upload/file/*',
+                method: expect.anything()
+            });
+        });
+    });
+});