@midwayjs/busboy 3.17.1 → 3.18.0

package/dist/error.js

@@ -4,13 +4,13 @@ exports.MultipartFieldsLimitError = exports.MultipartPartsLimitError = exports.M
 const core_1 = require("@midwayjs/core");
 class MultipartInvalidFilenameError extends core_1.httpError.BadRequestError {
     constructor(filename) {
-        super(`Invalid upload file name "${filename}", please check it`);
+        super(`Invalid file name or suffix "${filename}".`);
     }
 }
 exports.MultipartInvalidFilenameError = MultipartInvalidFilenameError;
 class MultipartInvalidFileTypeError extends core_1.httpError.BadRequestError {
     constructor(filename, currentType, type) {
-        super(`Invalid upload file type, "${filename}" type(${currentType || 'unknown'}) is not ${type} , please check it`);
+        super(`Invalid file type, "${filename}" type(${currentType || 'unknown'}) is not ${type}.`);
     }
 }
 exports.MultipartInvalidFileTypeError = MultipartInvalidFileTypeError;

package/dist/interface.d.ts

@@ -2,7 +2,7 @@
 import { Readable } from 'stream';
 import { IgnoreMatcher, IMidwayContext } from '@midwayjs/core';
 import { BusboyConfig } from 'busboy';
-export type UploadMode = 'stream' | 'file';
+export type UploadMode = 'stream' | 'file' | 'asyncIterator';
 export interface UploadOptions extends BusboyConfig {
     /**
      * Upload mode, default is `file`
@@ -50,6 +50,10 @@ export interface UploadFileInfo {
      * file data, a string of path
      */
     data: string;
+    /**
+     * field name
+     */
+    fieldName: string;
 }
 export interface UploadStreamFileInfo {
     /**
@@ -64,5 +68,19 @@ export interface UploadStreamFileInfo {
      * file data, Readable stream
      */
     data: Readable;
+    /**
+     * field name
+     */
+    fieldName: string;
+}
+export interface UploadStreamFieldInfo {
+    /**
+     * field name
+     */
+    name: string;
+    /**
+     * field value
+     */
+    value: any;
 }
 //# sourceMappingURL=interface.d.ts.map

package/dist/middleware.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IMiddleware, ILogger, IgnoreMatcher, IMidwayApplication } from '@midwayjs/core';
-import { UploadOptions } from '.';
+import { UploadOptions, UploadMode } from './interface';
 import { BusboyConfig } from 'busboy';
 export declare class UploadMiddleware implements IMiddleware<any, any> {
     uploadConfig: UploadOptions;
@@ -17,10 +17,13 @@ export declare class UploadMiddleware implements IMiddleware<any, any> {
     private uploadFileMimeTypeMap;
     match: IgnoreMatcher<any>[];
     ignore: IgnoreMatcher<any>[];
-    init(): Promise<void>;
+    protected init(): Promise<void>;
     resolve(app: IMidwayApplication, options?: {
-        mode?: 'file' | 'stream';
+        mode?: UploadMode;
     } & BusboyConfig): (ctxOrReq: any, resOrNext: any, next: any) => Promise<any>;
+    private processFileOrStream;
+    private processAsyncIterator;
+    private processServerlessUpload;
     static getName(): string;
     checkAndGetExt(filename: any, whiteListMap?: Map<string, string>): string | boolean;
     checkFileType(ext: string, data: Buffer, uploadFileMimeTypeMap?: Map<string, string[]>): Promise<{

package/dist/middleware.js

@@ -14,11 +14,12 @@ const core_1 = require("@midwayjs/core");
 const path_1 = require("path");
 const fs_1 = require("fs");
 const stream_1 = require("stream");
-const _1 = require(".");
+const error_1 = require("./error");
 const parse_1 = require("./parse");
 const file_type_1 = require("file-type");
 const utils_1 = require("./utils");
 const busboy = require("busboy");
+const constants_1 = require("./constants");
 const { unlink, writeFile } = fs_1.promises;
 let UploadMiddleware = class UploadMiddleware {
     constructor() {
@@ -59,14 +60,14 @@ let UploadMiddleware = class UploadMiddleware {
             ? (0, core_1.extend)({}, this.uploadConfig, options || {})
             : this.uploadConfig;
         return async (ctxOrReq, resOrNext, next) => {
-            var _a, _b;
+            var _a;
             const req = ((_a = ctxOrReq.request) === null || _a === void 0 ? void 0 : _a.req) || ctxOrReq.request || ctxOrReq;
             next = isExpress ? next : resOrNext;
             const boundary = this.getUploadBoundary(req);
             if (!boundary) {
                 return next();
             }
-            const { mode, tmpdir } = uploadConfig;
+            const useAsyncIterator = uploadConfig.mode === 'asyncIterator';
             // create new map include custom white list
             const currentContextWhiteListMap = new Map([
                 ...this.uploadWhiteListMap.entries(),
@@ -105,166 +106,250 @@ let UploadMiddleware = class UploadMiddleware {
                 }));
             };
             if (this.isReadableStream(req, isExpress)) {
-                let isStreamResolve = false;
-                const { files = [], fields = [] } = await new Promise((resolveP, reject) => {
-                    const bb = busboy({
-                        headers: req.headers,
-                        ...uploadConfig,
-                    });
-                    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));
-                        }
-                        file.on('limit', () => {
-                            reject(new _1.MultipartFileSizeLimitError(filename));
+                if (useAsyncIterator) {
+                    await this.processAsyncIterator(req, uploadConfig, currentContextWhiteListMap, currentContextMimeTypeWhiteListMap, ctxOrReq);
+                }
+                else {
+                    await this.processFileOrStream(req, uploadConfig, currentContextWhiteListMap, currentContextMimeTypeWhiteListMap, ctxOrReq);
+                }
+            }
+            else {
+                await this.processServerlessUpload(req, boundary, uploadConfig, next, currentContextWhiteListMap, currentContextMimeTypeWhiteListMap, ctxOrReq);
+            }
+            await next();
+        };
+    }
+    async processFileOrStream(req, uploadConfig, currentContextWhiteListMap, currentContextMimeTypeWhiteListMap, ctxOrReq) {
+        let isStreamResolve = false;
+        const { mode, tmpdir } = uploadConfig;
+        const { files = [], fields = [] } = await new Promise((resolveP, reject) => {
+            const bb = busboy({
+                headers: req.headers,
+                ...uploadConfig,
+            });
+            const fields = [];
+            const files = [];
+            bb.on('file', async (name, file, info) => {
+                this.logger.debug('[busboy]: busboy file event');
+                const { filename, encoding, mimeType } = info;
+                const ext = this.checkAndGetExt(filename, currentContextWhiteListMap);
+                if (!ext) {
+                    reject(new error_1.MultipartInvalidFilenameError(filename));
+                }
+                file.once('limit', () => {
+                    reject(new error_1.MultipartFileSizeLimitError(filename));
+                });
+                if (mode === 'stream') {
+                    if (isStreamResolve) {
+                        // will be skip
+                        file.resume();
+                        return;
+                    }
+                    files.push(new Promise(resolve => {
+                        resolve({
+                            fieldName: name,
+                            filename,
+                            encoding,
+                            mimeType,
+                            data: file,
                         });
-                        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),
-                                    });
-                                }
-                            });
+                    }));
+                    isStreamResolve = true;
+                    // busboy 这里无法触发 close 事件，所以这里直接 resolve
+                    return resolveP({
+                        fields,
+                        files: await Promise.all(files),
+                    });
+                }
+                else {
+                    this.logger.debug('[busboy]: file mode, file data event');
+                    // 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 error_1.MultipartInvalidFileTypeError(filename, current, mime));
                         }
                     });
-                    bb.on('field', (name, value, info) => {
-                        fields.push(new Promise(resolve => {
+                    const fp = new Promise(resolve => {
+                        const writeStream = file.pipe((0, fs_1.createWriteStream)(tempFile));
+                        writeStream.on('error', reject);
+                        writeStream.on('finish', () => {
                             resolve({
-                                name,
-                                value,
+                                filename,
+                                mimeType,
+                                encoding,
+                                fieldName: name,
+                                data: tempFile,
                             });
-                        }));
-                    });
-                    bb.on('error', (err) => {
-                        reject(new _1.MultipartError(err));
-                    });
-                    bb.on('partsLimit', () => {
-                        reject(new _1.MultipartPartsLimitError());
-                    });
-                    bb.on('filesLimit', () => {
-                        reject(new _1.MultipartFileLimitError());
-                    });
-                    bb.on('fieldsLimit', () => {
-                        reject(new _1.MultipartFieldsLimitError());
+                        });
                     });
-                    req.pipe(bb);
+                    files.push(fp);
+                }
+            });
+            bb.on('close', async () => {
+                this.logger.debug('[busboy]: busboy close');
+                // close 事件会在 busboy 解析完所有数据后触发，但是这个时候有可能没有写完文件，所以使用 Promise.all 等待所有文件写入完成
+                resolveP({
+                    fields,
+                    files: await Promise.all(files),
                 });
-                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];
-                    },
+            });
+            bb.on('field', (name, value, info) => {
+                fields.push({
+                    name,
+                    value,
+                    info,
                 });
-            }
-            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 {
-                    body = req.body;
-                }
-                const data = await (0, parse_1.parseMultipart)(body, boundary, 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);
+            });
+            bb.on('error', (err) => {
+                reject(new error_1.MultipartError(err));
+            });
+            bb.on('partsLimit', () => {
+                reject(new error_1.MultipartPartsLimitError());
+            });
+            bb.on('filesLimit', () => {
+                reject(new error_1.MultipartFileLimitError());
+            });
+            bb.on('fieldsLimit', () => {
+                reject(new error_1.MultipartFieldsLimitError());
+            });
+            req.pipe(bb);
+        });
+        ctxOrReq.files = files;
+        ctxOrReq.fields = fields.reduce((accumulator, current) => {
+            accumulator[current.name] = current.value;
+            return accumulator;
+        }, {});
+    }
+    async processAsyncIterator(req, uploadConfig, currentContextWhiteListMap, currentContextMimeTypeWhiteListMap, ctxOrReq) {
+        const bb = busboy({
+            headers: req.headers,
+            ...uploadConfig,
+        });
+        const fileReadable = new stream_1.Readable({
+            objectMode: true,
+            read() { },
+            autoDestroy: true,
+        });
+        const fieldReadable = new stream_1.Readable({
+            objectMode: true,
+            read() { },
+            autoDestroy: true,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        async function* streamToAsyncIteratorWithError(stream) {
+            for await (const chunk of stream) {
+                chunk.data.once('data', async (chunk) => {
+                    const { passed, mime, current } = await self.checkFileType(chunk.ext, chunk, currentContextMimeTypeWhiteListMap);
                     if (!passed) {
-                        throw new _1.MultipartInvalidFileTypeError(fileInfo.filename, current, mime);
+                        throw new error_1.MultipartInvalidFileTypeError(chunk.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;
-                }));
+                });
+                yield chunk;
             }
-            await next();
-        };
+        }
+        const files = streamToAsyncIteratorWithError(fileReadable);
+        const fields = (0, utils_1.streamToAsyncIterator)(fieldReadable);
+        bb.on('file', (name, file, info) => {
+            const { filename, encoding, mimeType } = info;
+            const ext = this.checkAndGetExt(filename, currentContextWhiteListMap);
+            if (!ext) {
+                fileReadable.destroy(new error_1.MultipartInvalidFilenameError(filename));
+                return;
+            }
+            file.once('limit', () => {
+                fileReadable.destroy(new error_1.MultipartFileSizeLimitError(filename));
+            });
+            fileReadable.push({
+                fieldName: name,
+                filename,
+                mimeType,
+                encoding,
+                data: file,
+                ext,
+            });
+        });
+        bb.on('field', (name, value, info) => {
+            fieldReadable.push({
+                name,
+                value,
+                info,
+            });
+        });
+        bb.on('close', () => {
+            fileReadable.push(null);
+            fieldReadable.push(null);
+        });
+        bb.on('error', (err) => {
+            fileReadable.destroy(new error_1.MultipartError(err));
+        });
+        bb.on('partsLimit', () => {
+            fileReadable.destroy(new error_1.MultipartPartsLimitError());
+        });
+        bb.on('filesLimit', () => {
+            fileReadable.destroy(new error_1.MultipartFileLimitError());
+        });
+        bb.on('fieldsLimit', () => {
+            fieldReadable.destroy(new error_1.MultipartFieldsLimitError());
+        });
+        req.pipe(bb);
+        ctxOrReq.fields = fields;
+        ctxOrReq.files = files;
+    }
+    async processServerlessUpload(req, boundary, uploadConfig, next, currentContextWhiteListMap, currentContextMimeTypeWhiteListMap, ctxOrReq) {
+        var _a;
+        let body;
+        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 { mode, tmpdir } = uploadConfig;
+        const data = await (0, parse_1.parseMultipart)(body, boundary, uploadConfig);
+        if (!data) {
+            return next();
+        }
+        const requireId = `upload_${Date.now()}.${Math.random()}`;
+        for (const fileInfo of data.files) {
+            const ext = this.checkAndGetExt(fileInfo.filename, currentContextWhiteListMap);
+            if (!ext) {
+                throw new error_1.MultipartInvalidFilenameError(fileInfo.filename);
+            }
+            const { passed, mime, current } = await this.checkFileType(ext, fileInfo.data, currentContextMimeTypeWhiteListMap);
+            if (!passed) {
+                throw new error_1.MultipartInvalidFileTypeError(fileInfo.filename, current, mime);
+            }
+            fileInfo[constants_1.EXT_KEY] = ext;
+        }
+        const files = await Promise.all(data.files.map(async (file, index) => {
+            const { data } = file;
+            if (mode === 'file') {
+                const ext = file[constants_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;
+        }));
+        ctxOrReq.fields = data.fields;
+        ctxOrReq.files = files;
     }
     static getName() {
         return 'upload';

package/dist/utils.d.ts

@@ -1,6 +1,9 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
 export declare const autoRemoveUploadTmpFile: (tmpDir: string, cleanTimeout: number) => Promise<void>;
 export declare const stopAutoRemoveUploadTmpFile: () => Promise<void>;
 export declare const checkExists: (path: string) => Promise<boolean>;
 export declare const ensureDir: (dirPath: string) => Promise<boolean>;
 export declare const formatExt: (ext: string) => string;
+export declare function streamToAsyncIterator(stream: Readable): AsyncGenerator<any>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatExt = exports.ensureDir = exports.checkExists = exports.stopAutoRemoveUploadTmpFile = exports.autoRemoveUploadTmpFile = void 0;
+exports.streamToAsyncIterator = exports.formatExt = exports.ensureDir = exports.checkExists = exports.stopAutoRemoveUploadTmpFile = exports.autoRemoveUploadTmpFile = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const { readdir, access, stat, unlink, mkdir } = fs_1.promises;
@@ -88,4 +88,10 @@ const formatExt = (ext) => {
         .toString();
 };
 exports.formatExt = formatExt;
+async function* streamToAsyncIterator(stream) {
+    for await (const chunk of stream) {
+        yield chunk;
+    }
+}
+exports.streamToAsyncIterator = streamToAsyncIterator;
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/busboy",
-  "version": "3.17.1",
+  "version": "3.18.0",
   "description": "Midway Component for upload",
   "main": "dist/index.js",
   "typings": "index.d.ts",
@@ -27,12 +27,12 @@
     "file-type": "16.5.4"
   },
   "devDependencies": {
-    "@midwayjs/core": "^3.17.1",
-    "@midwayjs/express": "^3.17.1",
-    "@midwayjs/faas": "^3.17.1",
-    "@midwayjs/koa": "^3.17.1",
-    "@midwayjs/mock": "^3.17.1",
-    "@midwayjs/web": "^3.17.1"
+    "@midwayjs/core": "^3.18.0",
+    "@midwayjs/express": "^3.18.0",
+    "@midwayjs/faas": "^3.18.0",
+    "@midwayjs/koa": "^3.18.0",
+    "@midwayjs/mock": "^3.18.0",
+    "@midwayjs/web": "^3.18.0"
   },
-  "gitHead": "824d8474a425b342fcd4480649c83677f846afb9"
+  "gitHead": "5e6180ba0fabe1acc6df112c68855129a534e941"
 }