@midwayjs/upload 3.16.0 → 3.17.0-beta.1

package/dist/configuration.d.ts

@@ -1,8 +1,9 @@
-import { MidwayApplicationManager } from '@midwayjs/core';
+import { ILogger, MidwayApplicationManager } from '@midwayjs/core';
 import { UploadOptions } from './interface';
 export declare class UploadConfiguration {
     applicationManager: MidwayApplicationManager;
     uploadConfig: UploadOptions;
+    logger: ILogger;
     onReady(): Promise<void>;
     onStop(): Promise<void>;
 }

package/dist/configuration.js

@@ -20,7 +20,9 @@ let UploadConfiguration = class UploadConfiguration {
         if (tmpdir) {
             await (0, utils_1.ensureDir)(tmpdir);
             if (cleanTimeout) {
-                (0, utils_1.autoRemoveUploadTmpFile)(tmpdir, cleanTimeout);
+                (0, utils_1.autoRemoveUploadTmpFile)(tmpdir, cleanTimeout).catch(err => {
+                    this.logger.error(err);
+                });
             }
         }
         this.applicationManager
@@ -41,6 +43,10 @@ __decorate([
     (0, core_1.Config)('upload'),
     __metadata("design:type", Object)
 ], UploadConfiguration.prototype, "uploadConfig", void 0);
+__decorate([
+    (0, core_1.Logger)('coreLogger'),
+    __metadata("design:type", Object)
+], UploadConfiguration.prototype, "logger", void 0);
 UploadConfiguration = __decorate([
     (0, core_1.Configuration)({
         namespace: 'upload',

package/dist/middleware.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { IMiddleware, ILogger, IgnoreMatcher } from '@midwayjs/core';
+import { IMiddleware, ILogger, IgnoreMatcher, IMidwayApplication } from '@midwayjs/core';
 import { UploadOptions } from '.';
 export declare class UploadMiddleware implements IMiddleware<any, any> {
     uploadConfig: UploadOptions;
@@ -17,16 +17,15 @@ export declare class UploadMiddleware implements IMiddleware<any, any> {
     match: IgnoreMatcher<any>[];
     ignore: IgnoreMatcher<any>[];
     init(): Promise<void>;
-    resolve(app: any): (req: any, res: any, next: any) => Promise<any>;
-    execUpload(ctx: any, req: any, res: any, next: any, isExpress: any): Promise<any>;
-    getUploadBoundary(request: any): false | string;
-    isReadableStream(req: any, isExpress: any): boolean;
+    resolve(app: IMidwayApplication): (ctxOrReq: any, resOrNext: any, next: any) => Promise<any>;
+    static getName(): string;
     checkAndGetExt(filename: any, whiteListMap?: Map<string, string>): string | boolean;
     checkFileType(ext: string, data: Buffer, uploadFileMimeTypeMap?: Map<string, string[]>): Promise<{
         passed: boolean;
         mime?: string;
         current?: string;
     }>;
-    static getName(): string;
+    isReadableStream(req: any, isExpress: any): boolean;
+    getUploadBoundary(request: any): false | string;
 }
 //# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.js

@@ -16,9 +16,9 @@ const fs_1 = require("fs");
 const stream_1 = require("stream");
 const _1 = require(".");
 const parse_1 = require("./parse");
-const getRawBody = require("raw-body");
 const file_type_1 = require("file-type");
 const utils_1 = require("./utils");
+const busboy = require("busboy");
 const { unlink, writeFile } = fs_1.promises;
 let UploadMiddleware = class UploadMiddleware {
     constructor() {
@@ -40,8 +40,6 @@ let UploadMiddleware = class UploadMiddleware {
         else {
             this.ignore = [].concat(this.uploadConfig.ignore || []);
         }
-    }
-    resolve(app) {
         if (this.uploadConfig.whitelist &&
             Array.isArray(this.uploadConfig.whitelist)) {
             for (const whiteExt of this.uploadConfig.whitelist) {
@@ -54,164 +52,205 @@ let UploadMiddleware = class UploadMiddleware {
                 this.uploadFileMimeTypeMap.set(ext, mime);
             }
         }
-        if (app.getFrameworkType() === core_1.MidwayFrameworkType.WEB_EXPRESS) {
-            return async (req, res, next) => {
-                return this.execUpload(req, req, res, next, true);
-            };
-        }
-        else {
-            return async (ctx, next) => {
-                var _a;
-                const req = ((_a = ctx.request) === null || _a === void 0 ? void 0 : _a.req) || ctx.request;
-                return this.execUpload(ctx, req, ctx, next, false);
-            };
-        }
     }
-    async execUpload(ctx, req, res, next, isExpress) {
-        var _a;
-        const { mode, tmpdir, fileSize } = this.uploadConfig;
-        const boundary = this.getUploadBoundary(req);
-        if (!boundary) {
-            return next();
-        }
-        ctx.fields = {};
-        ctx.files = [];
-        ctx.cleanupRequestFiles = async () => {
-            var _a;
-            if (!((_a = ctx.files) === null || _a === void 0 ? void 0 : _a.length)) {
-                return [];
+    resolve(app) {
+        const isExpress = app.getNamespace() === 'express';
+        return async (ctxOrReq, resOrNext, next) => {
+            var _a, _b;
+            const req = ((_a = ctxOrReq.request) === null || _a === void 0 ? void 0 : _a.req) || ctxOrReq.request || ctxOrReq;
+            const boundary = this.getUploadBoundary(req);
+            if (!boundary) {
+                return next();
             }
-            return Promise.all(ctx.files.map(async (fileInfo) => {
-                if (typeof fileInfo.data !== 'string') {
-                    return false;
-                }
-                try {
-                    await unlink(fileInfo.data);
-                    return true;
+            // let res = resOrNext;
+            if (!isExpress) {
+                next = resOrNext;
+                // res = ctxOrReq.res;
+            }
+            const { mode, tmpdir } = this.uploadConfig;
+            // create new map include custom white list
+            const currentContextWhiteListMap = new Map([
+                ...this.uploadWhiteListMap.entries(),
+            ]);
+            if (typeof this.uploadConfig.whitelist === 'function') {
+                const whiteListArray = this.uploadConfig.whitelist.call(this, ctxOrReq);
+                whiteListArray.forEach(ext => currentContextWhiteListMap.set(ext, ext));
+            }
+            // create new map include custom mime type white list
+            const currentContextMimeTypeWhiteListMap = new Map([
+                ...this.uploadFileMimeTypeMap.entries(),
+            ]);
+            if (typeof this.uploadConfig.mimeTypeWhiteList === 'function') {
+                const mimeTypeWhiteList = this.uploadConfig.mimeTypeWhiteList.call(this, ctxOrReq);
+                for (const ext in mimeTypeWhiteList) {
+                    const mime = [].concat(mimeTypeWhiteList[ext]);
+                    currentContextMimeTypeWhiteListMap.set(ext, mime);
                 }
-                catch (_a) {
-                    return false;
+            }
+            ctxOrReq.cleanupRequestFiles = async () => {
+                var _a;
+                if (!((_a = ctxOrReq.files) === null || _a === void 0 ? void 0 : _a.length)) {
+                    return [];
                 }
-            }));
-        };
-        // create new map include custom white list
-        const currentContextWhiteListMap = new Map([
-            ...this.uploadWhiteListMap.entries(),
-        ]);
-        if (typeof this.uploadConfig.whitelist === 'function') {
-            const whiteListArray = this.uploadConfig.whitelist.call(this, ctx);
-            whiteListArray.forEach(ext => currentContextWhiteListMap.set(ext, ext));
-        }
-        // create new map include custom mime type white list
-        const currentContextMimeTypeWhiteListMap = new Map([
-            ...this.uploadFileMimeTypeMap.entries(),
-        ]);
-        if (typeof this.uploadConfig.mimeTypeWhiteList === 'function') {
-            const mimeTypeWhiteList = this.uploadConfig.mimeTypeWhiteList.call(this, ctx);
-            for (const ext in mimeTypeWhiteList) {
-                const mime = [].concat(mimeTypeWhiteList[ext]);
-                currentContextMimeTypeWhiteListMap.set(ext, mime);
+                return Promise.all(ctxOrReq.files.map(async (fileInfo) => {
+                    if (typeof fileInfo.data !== 'string') {
+                        return false;
+                    }
+                    try {
+                        await unlink(fileInfo.data);
+                        return true;
+                    }
+                    catch (_a) {
+                        return false;
+                    }
+                }));
+            };
+            if (this.isReadableStream(req, isExpress)) {
+                let isStreamResolve = false;
+                const { files = [], fields = [] } = await new Promise((resolveP, reject) => {
+                    const bb = busboy({ headers: req.headers });
+                    const fields = [];
+                    const files = [];
+                    let fileModeCount = 0;
+                    bb.on('file', async (name, file, info) => {
+                        const { filename, encoding, mimeType } = info;
+                        const ext = this.checkAndGetExt(filename, currentContextWhiteListMap);
+                        if (!ext) {
+                            reject(new _1.MultipartInvalidFilenameError(filename));
+                        }
+                        if (mode === 'stream') {
+                            if (isStreamResolve) {
+                                // will be skip
+                                file.resume();
+                                return;
+                            }
+                            files.push(new Promise(resolve => {
+                                resolve({
+                                    filename,
+                                    mimeType,
+                                    encoding,
+                                    data: file,
+                                });
+                            }));
+                            isStreamResolve = true;
+                            return resolveP({
+                                fields: await Promise.all(fields),
+                                files: await Promise.all(files),
+                            });
+                        }
+                        else {
+                            fileModeCount++;
+                            // file mode
+                            const requireId = `upload_${Date.now()}.${Math.random()}`;
+                            // read stream pipe to temp file
+                            const tempFile = (0, path_1.resolve)(tmpdir, `${requireId}${ext}`);
+                            // get buffer from stream, and check file type
+                            file.once('data', async (chunk) => {
+                                const { passed, mime, current } = await this.checkFileType(ext, chunk, currentContextMimeTypeWhiteListMap);
+                                if (!passed) {
+                                    file.pause();
+                                    reject(new _1.MultipartInvalidFileTypeError(filename, current, mime));
+                                }
+                            });
+                            const writeStream = file.pipe((0, fs_1.createWriteStream)(tempFile));
+                            file.on('end', () => {
+                                fileModeCount--;
+                            });
+                            writeStream.on('error', reject);
+                            writeStream.on('finish', async () => {
+                                files.push(new Promise(resolve => {
+                                    resolve({
+                                        filename,
+                                        mimeType,
+                                        encoding,
+                                        data: tempFile,
+                                    });
+                                }));
+                                if (fileModeCount === 0) {
+                                    return resolveP({
+                                        fields: await Promise.all(fields),
+                                        files: await Promise.all(files),
+                                    });
+                                }
+                            });
+                        }
+                    });
+                    bb.on('field', (name, value, info) => {
+                        fields.push(new Promise(resolve => {
+                            resolve({
+                                name,
+                                value,
+                            });
+                        }));
+                    });
+                    req.pipe(bb);
+                });
+                ctxOrReq.files = files;
+                ctxOrReq.fields = fields.reduce((accumulator, current) => {
+                    accumulator[current.name] = current.value;
+                    return accumulator;
+                }, {});
+                Object.defineProperty(ctxOrReq, 'file', {
+                    get() {
+                        return ctxOrReq.files[0];
+                    },
+                    set(v) {
+                        ctxOrReq.files = [v];
+                    },
+                });
             }
-        }
-        let body;
-        if (this.isReadableStream(req, isExpress)) {
-            if (mode === 'stream') {
-                const { fields, fileInfo } = await (0, parse_1.parseFromReadableStream)(req, boundary);
-                const ext = this.checkAndGetExt(fileInfo.filename, currentContextWhiteListMap);
-                if (!ext) {
-                    throw new _1.MultipartInvalidFilenameError(fileInfo.filename);
+            else {
+                let body;
+                if (((_b = req === null || req === void 0 ? void 0 : req.originEvent) === null || _b === void 0 ? void 0 : _b.body) &&
+                    (typeof req.originEvent.body === 'string' ||
+                        Buffer.isBuffer(req.originEvent.body))) {
+                    body = req.originEvent.body;
                 }
                 else {
-                    fileInfo[_1.EXT_KEY] = ext;
-                    ctx.fields = fields;
-                    ctx.files = [fileInfo];
+                    body = req.body;
+                }
+                const data = await (0, parse_1.parseMultipart)(body, boundary, this.uploadConfig);
+                if (!data) {
                     return next();
                 }
+                ctxOrReq.fields = data.fields;
+                const requireId = `upload_${Date.now()}.${Math.random()}`;
+                const files = data.files;
+                for (const fileInfo of files) {
+                    const ext = this.checkAndGetExt(fileInfo.filename, currentContextWhiteListMap);
+                    if (!ext) {
+                        throw new _1.MultipartInvalidFilenameError(fileInfo.filename);
+                    }
+                    const { passed, mime, current } = await this.checkFileType(ext, fileInfo.data, currentContextMimeTypeWhiteListMap);
+                    if (!passed) {
+                        throw new _1.MultipartInvalidFileTypeError(fileInfo.filename, current, mime);
+                    }
+                    fileInfo[_1.EXT_KEY] = ext;
+                }
+                ctxOrReq.files = await Promise.all(files.map(async (file, index) => {
+                    const { data } = file;
+                    if (mode === 'file') {
+                        const ext = file[_1.EXT_KEY];
+                        const tmpFileName = (0, path_1.resolve)(tmpdir, `${requireId}.${index}${ext}`);
+                        await writeFile(tmpFileName, data, 'binary');
+                        file.data = tmpFileName;
+                    }
+                    else if (mode === 'stream') {
+                        file.data = new stream_1.Readable({
+                            read() {
+                                this.push(data);
+                                this.push(null);
+                            },
+                        });
+                    }
+                    return file;
+                }));
             }
-            body = await getRawBody(req, {
-                limit: fileSize,
-            });
-        }
-        else if (((_a = req === null || req === void 0 ? void 0 : req.originEvent) === null || _a === void 0 ? void 0 : _a.body) &&
-            (typeof req.originEvent.body === 'string' ||
-                Buffer.isBuffer(req.originEvent.body))) {
-            body = req.originEvent.body;
-        }
-        else {
-            body = req.body;
-        }
-        const data = await (0, parse_1.parseMultipart)(body, boundary, this.uploadConfig);
-        if (!data) {
-            return next();
-        }
-        ctx.fields = data.fields;
-        const requireId = `upload_${Date.now()}.${Math.random()}`;
-        const files = data.files;
-        for (const fileInfo of files) {
-            const ext = this.checkAndGetExt(fileInfo.filename, currentContextWhiteListMap);
-            if (!ext) {
-                throw new _1.MultipartInvalidFilenameError(fileInfo.filename);
-            }
-            const { passed, mime, current } = await this.checkFileType(ext, fileInfo.data, currentContextMimeTypeWhiteListMap);
-            if (!passed) {
-                throw new _1.MultipartInvalidFileTypeError(fileInfo.filename, current, mime);
-            }
-            fileInfo[_1.EXT_KEY] = ext;
-        }
-        ctx.files = await Promise.all(files.map(async (file, index) => {
-            const { data } = file;
-            if (mode === 'file') {
-                const ext = file[_1.EXT_KEY];
-                const tmpFileName = (0, path_1.resolve)(tmpdir, `${requireId}.${index}${ext}`);
-                await writeFile(tmpFileName, data, 'binary');
-                file.data = tmpFileName;
-            }
-            else if (mode === 'stream') {
-                file.data = new stream_1.Readable({
-                    read() {
-                        this.push(data);
-                        this.push(null);
-                    },
-                });
-            }
-            return file;
-        }));
-        return next();
-    }
-    getUploadBoundary(request) {
-        var _a;
-        const method = (request.method || request.httpMethod || '').toUpperCase();
-        if (method !== 'POST' &&
-            method !== 'PUT' &&
-            method !== 'DELETE' &&
-            method !== 'PATCH') {
-            return false;
-        }
-        if (!((_a = request.headers) === null || _a === void 0 ? void 0 : _a['content-type'])) {
-            return false;
-        }
-        const contentType = request.headers['content-type'];
-        if (!contentType.startsWith('multipart/form-data;')) {
-            return false;
-        }
-        const boundaryMatch = /boundary=(.*)(;|\s|$)/.exec(contentType);
-        if (!(boundaryMatch === null || boundaryMatch === void 0 ? void 0 : boundaryMatch[1])) {
-            return false;
-        }
-        return boundaryMatch[1];
+            await next();
+        };
     }
-    isReadableStream(req, isExpress) {
-        // ref: https://github.com/rvagg/isstream/blob/master/isstream.js#L10
-        if (req instanceof stream_1.Stream &&
-            typeof req._read === 'function' &&
-            typeof req._readableState === 'object' &&
-            (!req.body || isExpress)) {
-            return true;
-        }
-        if (req.pipe && req.on && !req.body) {
-            return true;
-        }
-        return false;
+    static getName() {
+        return 'upload';
     }
     // check extensions
     checkAndGetExt(filename, whiteListMap = this.uploadWhiteListMap) {
@@ -253,8 +292,40 @@ let UploadMiddleware = class UploadMiddleware {
             current: typeInfo.mime,
         };
     }
-    static getName() {
-        return 'upload';
+    isReadableStream(req, isExpress) {
+        // ref: https://github.com/rvagg/isstream/blob/master/isstream.js#L10
+        if (req instanceof stream_1.Stream &&
+            typeof req._read === 'function' &&
+            typeof req._readableState === 'object' &&
+            (!req.body || isExpress)) {
+            return true;
+        }
+        if (req.pipe && req.on && !req.body) {
+            return true;
+        }
+        return false;
+    }
+    getUploadBoundary(request) {
+        var _a;
+        const method = (request.method || request.httpMethod || '').toUpperCase();
+        if (method !== 'POST' &&
+            method !== 'PUT' &&
+            method !== 'DELETE' &&
+            method !== 'PATCH') {
+            return false;
+        }
+        if (!((_a = request.headers) === null || _a === void 0 ? void 0 : _a['content-type'])) {
+            return false;
+        }
+        const contentType = request.headers['content-type'];
+        if (!contentType.startsWith('multipart/form-data;')) {
+            return false;
+        }
+        const boundaryMatch = /boundary=(.*)(;|\s|$)/.exec(contentType);
+        if (!(boundaryMatch === null || boundaryMatch === void 0 ? void 0 : boundaryMatch[1])) {
+            return false;
+        }
+        return boundaryMatch[1];
     }
 };
 __decorate([

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@midwayjs/upload",
-  "version": "3.16.0",
+  "version": "3.17.0-beta.1",
   "description": "Midway Component for upload",
   "main": "dist/index.js",
   "typings": "index.d.ts",
   "scripts": {
     "build": "tsc",
-    "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
+    "test": "node --require=ts-node/register ../../node_modules/.bin/jest test/express.test.ts --runInBand",
     "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit",
     "ci": "npm run test"
   },
@@ -23,15 +23,15 @@
   "license": "MIT",
   "dependencies": {
     "file-type": "16.5.4",
-    "raw-body": "2.5.2"
+    "busboy": "1.6.0"
   },
   "devDependencies": {
     "@midwayjs/core": "^3.16.0",
     "@midwayjs/express": "^3.16.0",
     "@midwayjs/faas": "^3.16.0",
-    "@midwayjs/koa": "^3.16.0",
+    "@midwayjs/koa": "^3.16.1",
     "@midwayjs/mock": "^3.16.0",
-    "@midwayjs/web": "^3.16.0"
-  },
-  "gitHead": "7e75fe1bdc9a6df2956f9c22e704063aaa022d76"
+    "@midwayjs/web": "^3.16.0",
+    "@types/busboy": "1.5.4"
+  }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2013 - Now midwayjs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.