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

package/fesm/entities/folder.entity.js

@@ -1,54 +0,0 @@
-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 _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);
-}
-import { Identity } from '@flusys/nestjs-shared/entities';
-import { Column, Entity, OneToMany } from 'typeorm';
-export class Folder extends Identity {
-    constructor(...args){
-        super(...args), _define_property(this, "name", void 0), _define_property(this, "slug", void 0), _define_property(this, "fileManager", void 0);
-    }
-}
-_ts_decorate([
-    Column({
-        type: 'varchar',
-        length: 255,
-        nullable: false
-    }),
-    _ts_metadata("design:type", String)
-], Folder.prototype, "name", void 0);
-_ts_decorate([
-    Column({
-        type: 'varchar',
-        length: 255,
-        nullable: false
-    }),
-    _ts_metadata("design:type", String)
-], Folder.prototype, "slug", void 0);
-_ts_decorate([
-    OneToMany('FileManager', (fileManager)=>fileManager.folder),
-    _ts_metadata("design:type", Array)
-], Folder.prototype, "fileManager", void 0);
-Folder = _ts_decorate([
-    Entity({
-        name: 'folder'
-    })
-], Folder);

package/fesm/entities/index.spec.js

@@ -1,14 +0,0 @@
-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/entities/storage-config-with-company.entity.js

@@ -1,41 +0,0 @@
-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 _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);
-}
-import { Column, Entity } from 'typeorm';
-import { StorageConfig } from './storage-config.entity';
-export class StorageConfigWithCompany extends StorageConfig {
-    constructor(...args){
-        super(...args), _define_property(this, "companyId", void 0);
-    }
-}
-_ts_decorate([
-    Column({
-        type: 'uuid',
-        nullable: true
-    }),
-    _ts_metadata("design:type", Object)
-], StorageConfigWithCompany.prototype, "companyId", void 0);
-StorageConfigWithCompany = _ts_decorate([
-    Entity({
-        name: 'storage_config'
-    })
-], StorageConfigWithCompany);

package/fesm/entities/storage-config.entity.js

@@ -1,86 +0,0 @@
-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 _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);
-}
-import { getJsonColumnType } from '@flusys/nestjs-shared';
-import { Identity } from '@flusys/nestjs-shared/entities';
-import { Column, Entity, Index } from 'typeorm';
-export class StorageConfig extends Identity {
-    constructor(...args){
-        super(...args), _define_property(this, "name", void 0), _define_property(this, "storage", void 0), _define_property(this, "config", void 0), _define_property(this, "isActive", void 0), _define_property(this, "isDefault", void 0);
-    }
-}
-_ts_decorate([
-    Column({
-        type: 'varchar',
-        length: 255,
-        nullable: false
-    }),
-    _ts_metadata("design:type", String)
-], StorageConfig.prototype, "name", void 0);
-_ts_decorate([
-    Column({
-        type: 'varchar',
-        length: 50,
-        nullable: false
-    }),
-    _ts_metadata("design:type", String)
-], StorageConfig.prototype, "storage", void 0);
-_ts_decorate([
-    Column({
-        type: getJsonColumnType(),
-        nullable: false
-    }),
-    _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
-], StorageConfig.prototype, "config", void 0);
-_ts_decorate([
-    Column({
-        type: 'boolean',
-        default: true,
-        name: 'is_active'
-    }),
-    _ts_metadata("design:type", Boolean)
-], StorageConfig.prototype, "isActive", void 0);
-_ts_decorate([
-    Column({
-        type: 'boolean',
-        default: false,
-        name: 'is_default'
-    }),
-    _ts_metadata("design:type", Boolean)
-], StorageConfig.prototype, "isDefault", void 0);
-StorageConfig = _ts_decorate([
-    Entity({
-        name: 'storage_config'
-    }),
-    Index([
-        'name'
-    ]),
-    Index([
-        'storage'
-    ]),
-    Index([
-        'isActive'
-    ]),
-    Index([
-        'isDefault'
-    ])
-], StorageConfig);

package/fesm/enums/file-location.enum.js

@@ -1,7 +0,0 @@
-export var FileLocationEnum = /*#__PURE__*/ function(FileLocationEnum) {
-    FileLocationEnum["AWS"] = "aws";
-    FileLocationEnum["AZURE"] = "azure";
-    FileLocationEnum["SFTP"] = "sftp";
-    FileLocationEnum["LOCAL"] = "local";
-    return FileLocationEnum;
-}({});

package/fesm/interfaces/file-manager.interface.js

@@ -1 +0,0 @@
-export { };

package/fesm/interfaces/folder.interface.js

@@ -1 +0,0 @@
-export { };

package/fesm/interfaces/storage-config.interface.js

@@ -1 +0,0 @@
-export { };

package/fesm/interfaces/storage-module-options.interface.js

@@ -1,3 +0,0 @@
-/**
- * Async options for StorageModule registration
- */ export { };

package/fesm/interfaces/storage-provider.interface.js

@@ -1,4 +0,0 @@
-/**
- * Storage Provider Interface
- * All storage providers must implement this interface
- */ export { };

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

@@ -1,190 +0,0 @@
-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 _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);
-    };
-}
-import { Injectable, NotFoundException, BadRequestException, Inject } from '@nestjs/common';
-import { createReadStream, existsSync, statSync } from 'fs';
-import { join, resolve } from 'path';
-import * as mime from 'mime-types';
-import { FILE_MESSAGES, UPLOAD_MESSAGES } from '../config';
-import { UploadService } from '../services/upload.service';
-/** MIME type prefixes that can be displayed inline in browser */ const VIEWABLE_TYPE_PREFIXES = [
-    'image/',
-    'video/',
-    'audio/',
-    'text/',
-    'application/pdf',
-    'application/json',
-    'application/xml'
-];
-export class FileServeMiddleware {
-    async use(req, res, next) {
-        try {
-            const normalizedPath = this.extractFilePath(req);
-            const fullPath = await this.resolveFilePath(normalizedPath);
-            const stats = statSync(fullPath);
-            if (!stats.isFile()) {
-                throw new NotFoundException({
-                    message: `Not a file: ${normalizedPath}`,
-                    messageKey: 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 BadRequestException({
-                message: 'File path is required',
-                messageKey: 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 = join(this.uploadDir, normalizedPath);
-        const resolvedPath = resolve(fullPath);
-        // Prevent path traversal attacks
-        if (!resolvedPath.startsWith(this.uploadDir)) {
-            throw new BadRequestException({
-                message: 'Invalid file path',
-                messageKey: UPLOAD_MESSAGES.INVALID_FILE_PATH
-            });
-        }
-        if (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 NotFoundException({
-            message: `File not found: ${normalizedPath}`,
-            messageKey: 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 = join(basePath, remainingPath);
-            if (existsSync(fallbackPath)) return fallbackPath;
-        } else {
-            // Strategy 3: Old format - prepend basePath
-            const fallbackPath = join(basePath, normalizedPath);
-            if (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 mime.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 = createReadStream(fullPath);
-        stream.pipe(res);
-        stream.on('error', ()=>{
-            if (!res.headersSent) {
-                this.sendErrorResponse(res, new NotFoundException({
-                    message: `Failed to serve file: ${normalizedPath}`,
-                    messageKey: 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 NotFoundException;
-            const response = isNotFound ? error.getResponse() : null;
-            const message = response?.message ?? 'File not found';
-            const messageKey = response?.messageKey ?? 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([
-    Injectable(),
-    _ts_param(0, Inject(UploadService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof UploadService === "undefined" ? Object : UploadService
-    ])
-], FileServeMiddleware);

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

@@ -1,207 +0,0 @@
-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/middlewares/index.js

@@ -1 +0,0 @@
-export * from './file-serve.middleware';