@flusys/nestjs-storage 0.1.0-beta.2 → 0.1.0-beta.3

package/README.md

@@ -161,6 +161,8 @@ import { StorageModule } from '@flusys/nestjs-storage';
         // File validation
         maxFileSize: 10 * 1024 * 1024, // 10MB
         allowedFileTypes: ['image/*', 'application/pdf', 'text/*'],
+        // URL generation (optional - falls back to APP_URL env or PORT)
+        appUrl: process.env.APP_URL || `http://localhost:${process.env.PORT || 3000}`,
       },
     }),
   ],

package/cjs/config/storage-config.service.js

@@ -116,6 +116,37 @@ let StorageConfigService = class StorageConfigService {
    */ getOptions() {
         return this.options;
     }
+    /**
+   * Get default local storage base path
+   * Used for serving local files without database lookup
+   * Falls back to './uploads' if not configured
+   */ getDefaultLocalStoragePath() {
+        // Check if localStoragePath is configured in module options
+        const configuredPath = this.options.config?.localStoragePath;
+        if (configuredPath) {
+            return configuredPath;
+        }
+        // Default to ./uploads in the project root
+        return './uploads';
+    }
+    /**
+   * Get application base URL for generating file URLs
+   * - First tries module config
+   * - Falls back to APP_URL env var
+   * - Finally constructs from PORT env var
+   */ getAppUrl() {
+        // Try from module config first
+        if (this.options.config?.appUrl) {
+            return this.options.config.appUrl;
+        }
+        // Fallback: read directly from environment
+        if (process.env.APP_URL) {
+            return process.env.APP_URL;
+        }
+        // Last resort: construct from PORT
+        const port = process.env.PORT || '3000';
+        return `http://localhost:${port}`;
+    }
     constructor(options){
         _define_property(this, "options", void 0);
         this.options = options;

package/cjs/controllers/file-manager.controller.js

@@ -51,7 +51,7 @@ let FileManagerController = class FileManagerController extends (0, _classes.cre
             throw new _common.BadRequestException('No files provided');
         }
         // Fetch files from service
-        const files = await this.fileService.getFiles(dto, req.protocol, req.host, user);
+        const files = await this.fileService.getFiles(dto, req.protocol, req.get('host') || req.hostname, user);
         return {
             success: true,
             message: 'Files retrieved successfully',

package/cjs/controllers/upload.controller.js

@@ -15,11 +15,9 @@ const _dtos = require("../dtos");
 const _common = require("@nestjs/common");
 const _platformexpress = require("@nestjs/platform-express");
 const _swagger = require("@nestjs/swagger");
-const _express = require("express");
-const _fs = require("fs");
-const _mimetypes = /*#__PURE__*/ _interop_require_wildcard(require("mime-types"));
-const _path = require("path");
 const _uploadservice = require("../services/upload.service");
+const _config = require("../config");
+const _storagefactoryservice = require("../providers/storage-factory.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -33,47 +31,6 @@ function _define_property(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);
@@ -90,15 +47,17 @@ function _ts_param(paramIndex, decorator) {
 }
 let UploadController = class UploadController {
     async uploadSingleFile(file, options, user) {
-        const url = await this.uploadService.uploadSingleFile(file, options, user);
+        const result = await this.uploadService.uploadSingleFile(file, options, user);
         return {
             success: true,
             message: 'File uploaded successfully',
             data: {
-                size: this.uploadService.bytesToKb(url.size),
-                name: url.name,
-                key: url.key,
-                contentType: url.contentType
+                size: this.uploadService.bytesToKb(result.size),
+                name: result.name,
+                key: result.key,
+                contentType: result.contentType,
+                location: result.location || 'local',
+                storageConfigId: result.storageConfigId || ''
             }
         };
     }
@@ -108,7 +67,9 @@ let UploadController = class UploadController {
                 size: this.uploadService.bytesToKb(file.size),
                 name: file.name,
                 key: file.key,
-                contentType: file.contentType
+                contentType: file.contentType,
+                location: file.location || 'local',
+                storageConfigId: file.storageConfigId || ''
             }));
         return {
             success: true,
@@ -132,82 +93,13 @@ let UploadController = class UploadController {
             data
         };
     }
-    async seeUploadedFile(filePath, res) {
-        try {
-            const uploadDir = (0, _path.join)(process.cwd(), 'uploads');
-            const normalizedPath = Array.isArray(filePath) ? filePath.join('/') : filePath;
-            const fullPath = (0, _path.join)(uploadDir, normalizedPath);
-            this.logger.debug(`Attempting to serve file from: ${fullPath}`);
-            // Validate path is inside uploads directory
-            if (!fullPath.startsWith(uploadDir)) {
-                throw new _common.NotFoundException('Invalid file path');
-            }
-            // Check if file exists
-            if (!(0, _fs.existsSync)(fullPath)) {
-                throw new _common.NotFoundException(`File not found: ${normalizedPath}`);
-            }
-            const stats = (0, _fs.statSync)(fullPath);
-            if (!stats.isFile()) {
-                throw new _common.NotFoundException(`Not a file: ${normalizedPath}`);
-            }
-            // Enhanced MIME type detection
-            let mimeType = _mimetypes.lookup(fullPath) || 'application/octet-stream';
-            // Special handling for SVG files
-            if (fullPath.toLowerCase().endsWith('.svg')) {
-                mimeType = 'image/svg+xml';
-            }
-            // Determine if file should be displayed inline or downloaded
-            // Inline: PDFs, images, videos, audio, text files
-            // Download: Office docs, archives, executables, etc.
-            const viewableTypes = [
-                'image/',
-                'video/',
-                'audio/',
-                'text/',
-                'application/pdf',
-                'application/json',
-                'application/xml'
-            ];
-            const isViewable = viewableTypes.some((type)=>mimeType.startsWith(type));
-            const contentDisposition = isViewable ? 'inline' : `attachment; filename="${encodeURIComponent(normalizedPath.split('/').pop() || 'download')}"`;
-            // Set headers optimized for different file types
-            res.set({
-                'Content-Type': mimeType,
-                'Content-Length': stats.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 the file
-            const stream = (0, _fs.createReadStream)(fullPath);
-            stream.pipe(res);
-            return new Promise((resolve, reject)=>{
-                stream.on('end', ()=>{
-                    res.end();
-                    resolve();
-                });
-                stream.on('error', (err)=>{
-                    this.logger.error('File stream error', err);
-                    reject(new _common.NotFoundException(`Failed to serve file: ${normalizedPath}`));
-                });
-                // Handle client disconnection
-                res.on('close', ()=>{
-                    stream.destroy();
-                });
-            });
-        } catch (error) {
-            this.logger.error('File retrieval error:', error);
-            throw new _common.NotFoundException(`File not found: ${filePath}`);
-        }
-    }
-    constructor(uploadService){
+    constructor(uploadService, storageConfigService, storageFactoryService){
         _define_property(this, "uploadService", void 0);
-        _define_property(this, "logger", void 0);
+        _define_property(this, "storageConfigService", void 0);
+        _define_property(this, "storageFactoryService", void 0);
         this.uploadService = uploadService;
-        this.logger = new _common.Logger(UploadController.name);
+        this.storageConfigService = storageConfigService;
+        this.storageFactoryService = storageFactoryService;
     }
 };
 _ts_decorate([
@@ -329,57 +221,18 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", Promise)
 ], UploadController.prototype, "deleteMultipleFile", null);
-_ts_decorate([
-    (0, _decorators.Public)(),
-    (0, _common.Get)('file/*filePath'),
-    (0, _swagger.ApiOperation)({
-        summary: 'Serve uploaded file by relative path (Public endpoint)',
-        description: `
-This endpoint returns a stored file from the server.
-
-- The \`filePath\` is a **wildcard path parameter** that supports nested folders.
-- Example:
-  \`GET /uploads/file/profile/user123/avatar.png\`
-  → Will serve the file from \`./profile/user123/avatar.png\`
-
-**Use case:**
-Access uploaded files publicly through a structured path.
-
-**Note:** This endpoint is public and does not require authentication.
-    `
-    }),
-    (0, _swagger.ApiParam)({
-        name: 'filePath',
-        required: true,
-        description: 'Relative path to the uploaded file (supports nested directories, e.g. "profile/user123/avatar.png")',
-        example: 'profile/user123/avatar.png'
-    }),
-    (0, _swagger.ApiProduces)('image/jpeg'),
-    (0, _swagger.ApiResponse)({
-        status: 200,
-        description: 'Uploaded file successfully returned',
-        schema: {
-            type: 'string',
-            format: 'binary'
-        }
-    }),
-    _ts_param(0, (0, _common.Param)('filePath')),
-    _ts_param(1, (0, _common.Res)()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object,
-        typeof _express.Response === "undefined" ? Object : _express.Response
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UploadController.prototype, "seeUploadedFile", null);
 UploadController = _ts_decorate([
     (0, _swagger.ApiTags)('Upload'),
     (0, _swagger.ApiBearerAuth)(),
     (0, _common.Controller)('storage/upload'),
     (0, _common.UseGuards)(_guards.JwtAuthGuard),
     _ts_param(0, (0, _common.Inject)(_uploadservice.UploadService)),
+    _ts_param(1, (0, _common.Inject)(_config.StorageConfigService)),
+    _ts_param(2, (0, _common.Inject)(_storagefactoryservice.StorageFactoryService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof _uploadservice.UploadService === "undefined" ? Object : _uploadservice.UploadService
+        typeof _uploadservice.UploadService === "undefined" ? Object : _uploadservice.UploadService,
+        typeof _config.StorageConfigService === "undefined" ? Object : _config.StorageConfigService,
+        typeof _storagefactoryservice.StorageFactoryService === "undefined" ? Object : _storagefactoryservice.StorageFactoryService
     ])
 ], UploadController);

package/cjs/dtos/file-manager.dto.js

@@ -149,7 +149,17 @@ _ts_decorate([
     _ts_metadata("design:type", String)
 ], UpdateFileManagerDto.prototype, "id", void 0);
 let FileManagerResponseDto = class FileManagerResponseDto extends UpdateFileManagerDto {
+    constructor(...args){
+        super(...args), _define_property(this, "providerName", void 0);
+    }
 };
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: 'My S3 Storage',
+        description: 'Name of the storage configuration/provider'
+    }),
+    _ts_metadata("design:type", String)
+], FileManagerResponseDto.prototype, "providerName", void 0);
 let GetFilesRequestDto = class GetFilesRequestDto {
     constructor(){
         _define_property(this, "id", void 0);
@@ -167,6 +177,9 @@ let FilesResponseDto = class FilesResponseDto {
         _define_property(this, "name", void 0);
         _define_property(this, "contentType", void 0);
         _define_property(this, "url", void 0);
+        _define_property(this, "location", void 0);
+        _define_property(this, "storageConfigId", void 0);
+        _define_property(this, "providerName", void 0);
     }
 };
 _ts_decorate([
@@ -183,13 +196,34 @@ _ts_decorate([
 ], FilesResponseDto.prototype, "name", void 0);
 _ts_decorate([
     (0, _swagger.ApiProperty)({
-        example: 'file123.jpg'
+        example: 'image/jpeg'
     }),
     _ts_metadata("design:type", String)
 ], FilesResponseDto.prototype, "contentType", void 0);
 _ts_decorate([
     (0, _swagger.ApiProperty)({
-        example: 'file123.jpg'
+        example: 'https://example.com/file123.jpg'
     }),
     _ts_metadata("design:type", String)
 ], FilesResponseDto.prototype, "url", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: 'local',
+        description: 'Storage provider type (local, aws, azure, sftp)'
+    }),
+    _ts_metadata("design:type", String)
+], FilesResponseDto.prototype, "location", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: '123e4567-e89b-12d3-a456-426614174000',
+        description: 'Storage configuration ID'
+    }),
+    _ts_metadata("design:type", String)
+], FilesResponseDto.prototype, "storageConfigId", void 0);
+_ts_decorate([
+    (0, _swagger.ApiPropertyOptional)({
+        example: 'My S3 Storage',
+        description: 'Name of the storage configuration/provider'
+    }),
+    _ts_metadata("design:type", String)
+], FilesResponseDto.prototype, "providerName", void 0);

package/cjs/dtos/upload.dto.js

@@ -210,6 +210,8 @@ let FileUploadResponsePayloadDto = class FileUploadResponsePayloadDto {
         _define_property(this, "contentType", void 0);
         _define_property(this, "size", void 0);
         _define_property(this, "key", void 0);
+        _define_property(this, "location", void 0);
+        _define_property(this, "storageConfigId", void 0);
     }
 };
 _ts_decorate([
@@ -236,3 +238,17 @@ _ts_decorate([
     }),
     _ts_metadata("design:type", String)
 ], FileUploadResponsePayloadDto.prototype, "key", void 0);
+_ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: 'local',
+        description: 'Storage provider type (local, aws, azure, sftp)'
+    }),
+    _ts_metadata("design:type", String)
+], FileUploadResponsePayloadDto.prototype, "location", void 0);
+_ts_decorate([
+    (0, _swagger.ApiProperty)({
+        example: '123e4567-e89b-12d3-a456-426614174000',
+        description: 'Storage configuration ID used for this upload'
+    }),
+    _ts_metadata("design:type", String)
+], FileUploadResponsePayloadDto.prototype, "storageConfigId", void 0);

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

@@ -0,0 +1,204 @@
+"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 _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);
+}
+let FileServeMiddleware = class FileServeMiddleware {
+    async use(req, res, next) {
+        try {
+            const uploadDir = process.cwd();
+            // Extract path after /storage/upload/file/
+            const urlPath = req.path || req.url;
+            const match = urlPath.match(/\/storage\/upload\/file\/(.+)/);
+            const normalizedPath = match ? match[1] : '';
+            if (!normalizedPath) {
+                throw new _common.NotFoundException('File path is required');
+            }
+            this.logger.debug(`Attempting to serve file, normalizedPath: ${normalizedPath}`);
+            // Get the local storage basePath for fallback lookups
+            const basePath = await this.uploadService.getLocalStorageBasePath();
+            const normalizedBasePath = basePath ? basePath.replace(/^\.\//, '').replace(/\/$/, '') : null;
+            // Strategy 1: Try path relative to CWD (new format: key includes basePath)
+            let fullPath = (0, _path.join)(uploadDir, normalizedPath);
+            let resolvedPath = (0, _path.resolve)(fullPath);
+            this.logger.debug(`Strategy 1 - CWD relative: ${fullPath}`);
+            // Validate path is inside the project directory (prevent path traversal)
+            if (!resolvedPath.startsWith(uploadDir)) {
+                throw new _common.NotFoundException('Invalid file path');
+            }
+            // Check if file exists
+            if (!(0, _fs.existsSync)(fullPath)) {
+                // Strategy 2: If key already starts with basePath, try using basePath directly
+                if (basePath && normalizedBasePath) {
+                    const pathStartsWithBase = normalizedPath.startsWith(normalizedBasePath + '/') || normalizedPath.startsWith(normalizedBasePath);
+                    if (pathStartsWithBase) {
+                        const remainingPath = normalizedPath.substring(normalizedBasePath.length).replace(/^\//, '');
+                        const fallbackPath = (0, _path.join)(basePath, remainingPath);
+                        this.logger.debug(`Strategy 2 - basePath + remaining: ${fallbackPath}`);
+                        if ((0, _fs.existsSync)(fallbackPath)) {
+                            fullPath = fallbackPath;
+                            resolvedPath = (0, _path.resolve)(fullPath);
+                        }
+                    } else {
+                        // Old format: key doesn't include basePath, prepend it
+                        const fallbackPath = (0, _path.join)(basePath, normalizedPath);
+                        this.logger.debug(`Strategy 3 - basePath + full key (old format): ${fallbackPath}`);
+                        if ((0, _fs.existsSync)(fallbackPath)) {
+                            fullPath = fallbackPath;
+                            resolvedPath = (0, _path.resolve)(fullPath);
+                        }
+                    }
+                }
+                // Final check if file was found
+                if (!(0, _fs.existsSync)(fullPath)) {
+                    throw new _common.NotFoundException(`File not found: ${normalizedPath}`);
+                }
+            }
+            const stats = (0, _fs.statSync)(fullPath);
+            if (!stats.isFile()) {
+                throw new _common.NotFoundException(`Not a file: ${normalizedPath}`);
+            }
+            // Enhanced MIME type detection
+            let mimeType = _mimetypes.lookup(fullPath) || 'application/octet-stream';
+            // Special handling for SVG files
+            if (fullPath.toLowerCase().endsWith('.svg')) {
+                mimeType = 'image/svg+xml';
+            }
+            // Determine if file should be displayed inline or downloaded
+            const viewableTypes = [
+                'image/',
+                'video/',
+                'audio/',
+                'text/',
+                'application/pdf',
+                'application/json',
+                'application/xml'
+            ];
+            const isViewable = viewableTypes.some((type)=>mimeType.startsWith(type));
+            const contentDisposition = isViewable ? 'inline' : `attachment; filename="${encodeURIComponent(normalizedPath.split('/').pop() || 'download')}"`;
+            // Set headers
+            res.set({
+                'Content-Type': mimeType,
+                'Content-Length': stats.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 the file
+            const stream = (0, _fs.createReadStream)(fullPath);
+            stream.pipe(res);
+            stream.on('error', (err)=>{
+                this.logger.error('File stream error', err);
+                if (!res.headersSent) {
+                    res.status(404).json({
+                        message: `Failed to serve file: ${normalizedPath}`,
+                        error: 'Not Found',
+                        statusCode: 404
+                    });
+                }
+            });
+            // Handle client disconnection
+            res.on('close', ()=>{
+                stream.destroy();
+            });
+        } catch (error) {
+            this.logger.error('File retrieval error:', error);
+            if (!res.headersSent) {
+                res.status(404).json({
+                    message: error instanceof _common.NotFoundException ? error.message : `File not found`,
+                    error: 'Not Found',
+                    statusCode: 404
+                });
+            }
+        }
+    }
+    constructor(uploadService){
+        _define_property(this, "uploadService", void 0);
+        _define_property(this, "logger", void 0);
+        this.uploadService = uploadService;
+        this.logger = new _common.Logger(FileServeMiddleware.name);
+    }
+};
+FileServeMiddleware = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _uploadservice.UploadService === "undefined" ? Object : _uploadservice.UploadService
+    ])
+], FileServeMiddleware);

package/cjs/middlewares/index.js

@@ -0,0 +1,18 @@
+"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;
+}