@midwayjs/busboy 3.16.0

package/README.md

@@ -0,0 +1,12 @@
+# midway busboy module
+
+[![Package Quality](http://npm.packagequality.com/shield/@midwayjs/validate.svg)](http://packagequality.com/#?package=@midwayjs/busboy)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/midwayjs/midway/pulls)
+
+this is a sub package for midway.
+
+Document: [https://midwayjs.org](https://midwayjs.org)
+
+## License
+
+[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/configuration.d.ts

@@ -0,0 +1,9 @@
+import { ILogger } from '@midwayjs/core';
+import { UploadOptions } from './interface';
+export declare class BusboyConfiguration {
+    uploadConfig: UploadOptions;
+    logger: ILogger;
+    onReady(): Promise<void>;
+    onStop(): Promise<void>;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,61 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BusboyConfiguration = void 0;
+const core_1 = require("@midwayjs/core");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+const path_1 = require("path");
+const os_1 = require("os");
+let BusboyConfiguration = class BusboyConfiguration {
+    async onReady() {
+        const { tmpdir, cleanTimeout, mode } = this.uploadConfig;
+        if (mode === 'file' && tmpdir) {
+            await (0, utils_1.ensureDir)(tmpdir);
+            if (cleanTimeout) {
+                (0, utils_1.autoRemoveUploadTmpFile)(tmpdir, cleanTimeout).catch(err => {
+                    this.logger.error(err);
+                });
+            }
+        }
+    }
+    async onStop() {
+        await (0, utils_1.stopAutoRemoveUploadTmpFile)();
+    }
+};
+__decorate([
+    (0, core_1.Config)('busboy'),
+    __metadata("design:type", Object)
+], BusboyConfiguration.prototype, "uploadConfig", void 0);
+__decorate([
+    (0, core_1.Logger)('coreLogger'),
+    __metadata("design:type", Object)
+], BusboyConfiguration.prototype, "logger", void 0);
+BusboyConfiguration = __decorate([
+    (0, core_1.Configuration)({
+        namespace: 'busboy',
+        importConfigs: [
+            {
+                default: {
+                    busboy: {
+                        mode: 'file',
+                        whitelist: constants_1.uploadWhiteList,
+                        tmpdir: (0, path_1.join)((0, os_1.tmpdir)(), 'midway-busboy-files'),
+                        cleanTimeout: 5 * 60 * 1000,
+                        base64: false,
+                    },
+                },
+            },
+        ],
+    })
+], BusboyConfiguration);
+exports.BusboyConfiguration = BusboyConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/constants.d.ts

@@ -0,0 +1,24 @@
+export declare const uploadWhiteList: string[];
+export declare const DefaultUploadFileMimeType: {
+    '.jpg': string;
+    '.jpeg': string;
+    '.png': string;
+    '.gif': string;
+    '.bmp': string;
+    '.wbmp': string;
+    '.webp': string;
+    '.tif': string;
+    '.tiff': string;
+    '.psd': string;
+    '.svg': string;
+    '.xml': string;
+    '.pdf': string;
+    '.zip': string;
+    '.gz': string;
+    '.gzip': string;
+    '.mp3': string;
+    '.mp4': string;
+    '.avi': string;
+};
+export declare const EXT_KEY: unique symbol;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXT_KEY = exports.DefaultUploadFileMimeType = exports.uploadWhiteList = void 0;
+exports.uploadWhiteList = [
+    // images
+    '.jpg',
+    '.jpeg',
+    '.png',
+    '.gif',
+    '.bmp',
+    '.wbmp',
+    '.webp',
+    '.tif',
+    '.tiff',
+    '.psd',
+    // text
+    '.svg',
+    '.js',
+    '.jsx',
+    '.json',
+    '.css',
+    '.less',
+    '.html',
+    '.htm',
+    '.xml',
+    '.pdf',
+    // tar
+    '.zip',
+    '.gz',
+    '.tgz',
+    '.gzip',
+    // video
+    '.mp3',
+    '.mp4',
+    '.avi',
+];
+// https://mimetype.io/
+exports.DefaultUploadFileMimeType = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.bmp': 'image/bmp',
+    '.wbmp': 'image/vnd.wap.wbmp',
+    '.webp': 'image/webp',
+    '.tif': 'image/tiff',
+    '.tiff': 'image/tiff',
+    '.psd': 'image/vnd.adobe.photoshop',
+    '.svg': 'image/svg+xml',
+    '.xml': 'application/xml',
+    '.pdf': 'application/pdf',
+    '.zip': 'application/zip',
+    '.gz': 'application/gzip',
+    '.gzip': 'application/gzip',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.avi': 'video/x-msvideo',
+};
+exports.EXT_KEY = Symbol('_ext');
+//# sourceMappingURL=constants.js.map

package/dist/error.d.ts

@@ -0,0 +1,23 @@
+import { httpError } from '@midwayjs/core';
+export declare class MultipartInvalidFilenameError extends httpError.BadRequestError {
+    constructor(filename: string);
+}
+export declare class MultipartInvalidFileTypeError extends httpError.BadRequestError {
+    constructor(filename: string, currentType: string, type: string);
+}
+export declare class MultipartFileSizeLimitError extends httpError.BadRequestError {
+    constructor(filename: string);
+}
+export declare class MultipartError extends httpError.BadRequestError {
+    constructor(err: Error);
+}
+export declare class MultipartFileLimitError extends httpError.BadRequestError {
+    constructor();
+}
+export declare class MultipartPartsLimitError extends httpError.BadRequestError {
+    constructor();
+}
+export declare class MultipartFieldsLimitError extends httpError.BadRequestError {
+    constructor();
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/error.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultipartFieldsLimitError = exports.MultipartPartsLimitError = exports.MultipartFileLimitError = exports.MultipartError = exports.MultipartFileSizeLimitError = exports.MultipartInvalidFileTypeError = exports.MultipartInvalidFilenameError = void 0;
+const core_1 = require("@midwayjs/core");
+class MultipartInvalidFilenameError extends core_1.httpError.BadRequestError {
+    constructor(filename) {
+        super(`Invalid upload file name "${filename}", please check it`);
+    }
+}
+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`);
+    }
+}
+exports.MultipartInvalidFileTypeError = MultipartInvalidFileTypeError;
+class MultipartFileSizeLimitError extends core_1.httpError.BadRequestError {
+    constructor(filename) {
+        super(`Upload file "${filename}" size exceeds the limit`);
+    }
+}
+exports.MultipartFileSizeLimitError = MultipartFileSizeLimitError;
+class MultipartError extends core_1.httpError.BadRequestError {
+    constructor(err) {
+        super(err.message);
+    }
+}
+exports.MultipartError = MultipartError;
+class MultipartFileLimitError extends core_1.httpError.BadRequestError {
+    constructor() {
+        super('Upload file count exceeds the limit');
+    }
+}
+exports.MultipartFileLimitError = MultipartFileLimitError;
+// partsLimit
+class MultipartPartsLimitError extends core_1.httpError.BadRequestError {
+    constructor() {
+        super('Upload parts count exceeds the limit');
+    }
+}
+exports.MultipartPartsLimitError = MultipartPartsLimitError;
+// fieldsLimit
+class MultipartFieldsLimitError extends core_1.httpError.BadRequestError {
+    constructor() {
+        super('Upload fields count exceeds the limit');
+    }
+}
+exports.MultipartFieldsLimitError = MultipartFieldsLimitError;
+//# sourceMappingURL=error.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { BusboyConfiguration as Configuration } from './configuration';
+export * from './interface';
+export * from './middleware';
+export * from './error';
+export * from './constants';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = void 0;
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.BusboyConfiguration; } });
+__exportStar(require("./interface"), exports);
+__exportStar(require("./middleware"), exports);
+__exportStar(require("./error"), exports);
+__exportStar(require("./constants"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { IgnoreMatcher, IMidwayContext } from '@midwayjs/core';
+import { BusboyConfig } from 'busboy';
+export type UploadMode = 'stream' | 'file';
+export interface UploadOptions extends BusboyConfig {
+    /**
+     * Upload mode, default is `file`
+     */
+    mode?: UploadMode;
+    /**
+     * The white ext file names
+     */
+    whitelist?: string[] | null | ((ctx: IMidwayContext<any>) => string[]);
+    /**
+     * Temporary file directory
+     */
+    tmpdir?: string;
+    /**
+     * Temporary file automatic cleanup time, default is 5 minutes
+     */
+    cleanTimeout?: number;
+    /**
+     * Whether the uploaded body is base64, for example, apigw of Tencent Cloud
+     */
+    base64?: boolean;
+    /**
+     * Which paths to ignore
+     */
+    ignore?: IgnoreMatcher<any> | IgnoreMatcher<any>[];
+    /**
+     * Match those paths with higher priority than ignore
+     */
+    match?: IgnoreMatcher<any> | IgnoreMatcher<any>[];
+    /**
+     * Mime type white list
+     */
+    mimeTypeWhiteList?: Record<string, string | string[]> | ((ctx: IMidwayContext<any>) => string | string[]);
+}
+export interface UploadFileInfo {
+    /**
+     * File name
+     */
+    filename: string;
+    /**
+     * file mime type
+     */
+    mimeType: string;
+    /**
+     * file data, a string of path
+     */
+    data: string;
+}
+export interface UploadStreamFileInfo {
+    /**
+     * File name
+     */
+    filename: string;
+    /**
+     * file mime type
+     */
+    mimeType: string;
+    /**
+     * file data, Readable stream
+     */
+    data: Readable;
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/middleware.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import { IMiddleware, ILogger, IgnoreMatcher, IMidwayApplication } from '@midwayjs/core';
+import { UploadOptions } from '.';
+import { BusboyConfig } from 'busboy';
+export declare class UploadMiddleware implements IMiddleware<any, any> {
+    uploadConfig: UploadOptions;
+    logger: ILogger;
+    /**
+     * cache global upload white list when uploadConfig.whitelist is set
+     * @private
+     */
+    private uploadWhiteListMap;
+    /**
+     * cache global upload mime type white list when uploadConfig.mimeTypeWhiteList is set
+     * @private
+     */
+    private uploadFileMimeTypeMap;
+    match: IgnoreMatcher<any>[];
+    ignore: IgnoreMatcher<any>[];
+    init(): Promise<void>;
+    resolve(app: IMidwayApplication, options?: {
+        mode?: 'file' | 'stream';
+    } & BusboyConfig): (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;
+    }>;
+    isReadableStream(req: any, isExpress: any): boolean;
+    getUploadBoundary(request: any): false | string;
+}
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.js

@@ -0,0 +1,366 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadMiddleware = void 0;
+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 parse_1 = require("./parse");
+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() {
+        /**
+         * cache global upload white list when uploadConfig.whitelist is set
+         * @private
+         */
+        this.uploadWhiteListMap = new Map();
+        /**
+         * cache global upload mime type white list when uploadConfig.mimeTypeWhiteList is set
+         * @private
+         */
+        this.uploadFileMimeTypeMap = new Map();
+    }
+    async init() {
+        if (this.uploadConfig.match) {
+            this.match = [].concat(this.uploadConfig.match || []);
+        }
+        else {
+            this.ignore = [].concat(this.uploadConfig.ignore || []);
+        }
+        if (this.uploadConfig.whitelist &&
+            Array.isArray(this.uploadConfig.whitelist)) {
+            for (const whiteExt of this.uploadConfig.whitelist) {
+                this.uploadWhiteListMap.set(whiteExt, whiteExt);
+            }
+        }
+        if (this.uploadConfig.mimeTypeWhiteList) {
+            for (const ext in this.uploadConfig.mimeTypeWhiteList) {
+                const mime = [].concat(this.uploadConfig.mimeTypeWhiteList[ext]);
+                this.uploadFileMimeTypeMap.set(ext, mime);
+            }
+        }
+    }
+    resolve(app, options) {
+        const isExpress = app.getNamespace() === 'express';
+        const uploadConfig = options
+            ? (0, core_1.extend)({}, this.uploadConfig, options || {})
+            : this.uploadConfig;
+        return async (ctxOrReq, resOrNext, next) => {
+            var _a, _b;
+            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;
+            // create new map include custom white list
+            const currentContextWhiteListMap = new Map([
+                ...this.uploadWhiteListMap.entries(),
+            ]);
+            if (typeof uploadConfig.whitelist === 'function') {
+                const whiteListArray = 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 uploadConfig.mimeTypeWhiteList === 'function') {
+                const mimeTypeWhiteList = uploadConfig.mimeTypeWhiteList.call(this, ctxOrReq);
+                for (const ext in mimeTypeWhiteList) {
+                    const mime = [].concat(mimeTypeWhiteList[ext]);
+                    currentContextMimeTypeWhiteListMap.set(ext, mime);
+                }
+            }
+            ctxOrReq.cleanupRequestFiles = async () => {
+                var _a;
+                if (!((_a = ctxOrReq.files) === null || _a === void 0 ? void 0 : _a.length)) {
+                    return [];
+                }
+                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,
+                        ...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 (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,
+                            });
+                        }));
+                    });
+                    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);
+                });
+                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];
+                    },
+                });
+            }
+            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);
+                    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;
+                }));
+            }
+            await next();
+        };
+    }
+    static getName() {
+        return 'upload';
+    }
+    // check extensions
+    checkAndGetExt(filename, whiteListMap = this.uploadWhiteListMap) {
+        const lowerCaseFileNameList = filename.toLowerCase().split('.');
+        while (lowerCaseFileNameList.length) {
+            lowerCaseFileNameList.shift();
+            const curExt = `.${lowerCaseFileNameList.join('.')}`;
+            if (this.uploadConfig.whitelist === null) {
+                return (0, utils_1.formatExt)(curExt);
+            }
+            if (whiteListMap.has(curExt)) {
+                // Avoid the presence of hidden characters and return extensions in the white list.
+                return whiteListMap.get(curExt);
+            }
+        }
+        return false;
+    }
+    // check file-type
+    async checkFileType(ext, data, uploadFileMimeTypeMap = this.uploadFileMimeTypeMap) {
+        // fileType == null, pass check
+        if (!this.uploadConfig.mimeTypeWhiteList) {
+            return { passed: true };
+        }
+        const mime = uploadFileMimeTypeMap.get(ext);
+        if (!mime) {
+            return { passed: false, mime: ext };
+        }
+        if (!mime.length) {
+            return { passed: true };
+        }
+        const typeInfo = await (0, file_type_1.fromBuffer)(data);
+        if (!typeInfo) {
+            return { passed: false, mime: mime.join('、') };
+        }
+        const findMime = mime.find(mimeItem => mimeItem === typeInfo.mime);
+        return {
+            passed: !!findMime,
+            mime: mime.join('、'),
+            current: typeInfo.mime,
+        };
+    }
+    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([
+    (0, core_1.Config)('busboy'),
+    __metadata("design:type", Object)
+], UploadMiddleware.prototype, "uploadConfig", void 0);
+__decorate([
+    (0, core_1.Logger)(),
+    __metadata("design:type", Object)
+], UploadMiddleware.prototype, "logger", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], UploadMiddleware.prototype, "init", null);
+UploadMiddleware = __decorate([
+    (0, core_1.Middleware)()
+], UploadMiddleware);
+exports.UploadMiddleware = UploadMiddleware;
+//# sourceMappingURL=middleware.js.map

package/dist/parse.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { UploadOptions } from './interface';
+export declare const parseMultipart: (body: any, boundary: string, uploadConfig: UploadOptions) => Promise<{
+    files: any[];
+    fields: {};
+}>;
+export declare const bufferIndexOf: (buffer: Buffer, search: Buffer, offset?: number) => number;
+export declare const bufferSplit: (buffer: Buffer, separator: Buffer, limit?: number) => Buffer[];
+export declare const parseHead: (headBuf: Buffer) => {};
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHead = exports.bufferSplit = exports.bufferIndexOf = exports.parseMultipart = void 0;
+const headSeparator = Buffer.from('\r\n\r\n');
+const parseMultipart = async (body, boundary, uploadConfig) => {
+    if (typeof body === 'string') {
+        if (uploadConfig.base64) {
+            body = Buffer.from(body, 'base64');
+        }
+        else {
+            body = Buffer.from(body);
+        }
+    }
+    const bufferSeparator = Buffer.from('\r\n--' + boundary);
+    const fields = {};
+    const files = [];
+    (0, exports.bufferSplit)(body, bufferSeparator).forEach(buf => {
+        const [headerBuf, data] = (0, exports.bufferSplit)(buf, headSeparator, 2);
+        const head = (0, exports.parseHead)(headerBuf);
+        if (!head['content-disposition']) {
+            return;
+        }
+        if (!head['content-disposition'].filename) {
+            if (head['content-disposition'].name) {
+                fields[head['content-disposition'].name] = data.toString();
+            }
+            return;
+        }
+        files.push({
+            filename: head['content-disposition'].filename,
+            data,
+            fieldName: head['content-disposition'].name,
+            mimeType: head['content-type'],
+        });
+    });
+    return {
+        files,
+        fields,
+    };
+};
+exports.parseMultipart = parseMultipart;
+// search buffer index
+const bufferIndexOf = (buffer, search, offset) => {
+    return buffer.indexOf(search, offset);
+};
+exports.bufferIndexOf = bufferIndexOf;
+// split buffer to buffer list
+const bufferSplit = (buffer, separator, limit) => {
+    let index = 0;
+    const result = [];
+    let find = (0, exports.bufferIndexOf)(buffer, separator, index);
+    while (find !== -1) {
+        result.push(buffer.slice(index, find));
+        index = find + separator.length;
+        if (limit && result.length + 1 === limit) {
+            break;
+        }
+        find = (0, exports.bufferIndexOf)(buffer, separator, index);
+    }
+    result.push(buffer.slice(index));
+    return result;
+};
+exports.bufferSplit = bufferSplit;
+const headReg = /^([^:]+):[ \t]?(.+)?$/;
+const parseHead = (headBuf) => {
+    const head = {};
+    const headStrList = headBuf.toString().split('\r\n');
+    for (const headStr of headStrList) {
+        const matched = headReg.exec(headStr);
+        if (!matched) {
+            continue;
+        }
+        const name = matched[1].toLowerCase();
+        const value = matched[2]
+            ? matched[2].replace(/&#(\d+);/g, (origin, code) => {
+                try {
+                    return String.fromCharCode(parseInt(code));
+                }
+                catch (_a) {
+                    return origin;
+                }
+            })
+            : '';
+        if (name === 'content-disposition') {
+            const headCol = {};
+            value.split(/;\s+/).forEach((kv) => {
+                const [k, v] = kv.split('=');
+                headCol[k] = v ? v.replace(/^"/, '').replace(/"$/, '') : v !== null && v !== void 0 ? v : true;
+            });
+            head[name] = headCol;
+        }
+        else {
+            head[name] = value;
+        }
+    }
+    return head;
+};
+exports.parseHead = parseHead;
+//# sourceMappingURL=parse.js.map

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+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;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+let autoRemoveUploadTmpFileTimeoutHandler;
+let autoRemoveUploadTmpFilePromise;
+const autoRemoveUploadTmpFile = async (tmpDir, cleanTimeout) => {
+    clearTimeout(autoRemoveUploadTmpFileTimeoutHandler);
+    let waitTime = cleanTimeout / 3;
+    if (waitTime < 1000) {
+        waitTime = 1000;
+    }
+    if (autoRemoveUploadTmpFilePromise) {
+        const exists = await (0, exports.checkExists)(tmpDir);
+        if (exists) {
+            const paths = await readdir(tmpDir);
+            const now = Date.now();
+            await Promise.all(paths.map(async (path) => {
+                const filePath = (0, path_1.join)(tmpDir, path);
+                try {
+                    const statInfo = await stat(filePath);
+                    if (statInfo.isFile() && now - statInfo.ctimeMs > cleanTimeout) {
+                        await unlink(filePath);
+                    }
+                }
+                catch (_a) {
+                    return false;
+                }
+            }));
+        }
+    }
+    autoRemoveUploadTmpFileTimeoutHandler = setTimeout(() => {
+        autoRemoveUploadTmpFilePromise = (0, exports.autoRemoveUploadTmpFile)(tmpDir, cleanTimeout);
+    }, waitTime);
+};
+exports.autoRemoveUploadTmpFile = autoRemoveUploadTmpFile;
+const stopAutoRemoveUploadTmpFile = async () => {
+    if (autoRemoveUploadTmpFilePromise) {
+        await autoRemoveUploadTmpFilePromise;
+        autoRemoveUploadTmpFilePromise = null;
+    }
+    clearTimeout(autoRemoveUploadTmpFileTimeoutHandler);
+};
+exports.stopAutoRemoveUploadTmpFile = stopAutoRemoveUploadTmpFile;
+const checkExists = async (path) => {
+    try {
+        await access(path, fs_1.constants.W_OK | fs_1.constants.R_OK);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.checkExists = checkExists;
+const ensureDir = async (dirPath) => {
+    const isExists = await (0, exports.checkExists)(dirPath);
+    if (isExists) {
+        return true;
+    }
+    try {
+        await mkdir(dirPath, { recursive: true });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.ensureDir = ensureDir;
+const formatExt = (ext) => {
+    return Buffer.from(ext.toLowerCase())
+        .filter(ext => {
+        // .
+        if (ext === 0x2e) {
+            return true;
+        }
+        // 0-9
+        if (ext >= 0x30 && ext <= 0x39) {
+            return true;
+        }
+        // a-z
+        if (ext >= 0x61 && ext <= 0x7a) {
+            return true;
+        }
+        return false;
+    })
+        .toString();
+};
+exports.formatExt = formatExt;
+//# sourceMappingURL=utils.js.map

package/index.d.ts

@@ -0,0 +1,39 @@
+import { UploadFileInfo, UploadOptions } from './dist/index';
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    busboy?: Partial<UploadOptions>;
+  }
+}
+declare module '@midwayjs/koa/dist/interface' {
+  interface Context {
+    files?: UploadFileInfo<any>[];
+    fields?: { [fieldName: string]: any };
+    cleanupRequestFiles?: () => Promise<Array<boolean>>;
+  }
+}
+
+declare module '@midwayjs/web/dist/interface' {
+  interface Context {
+    files?: UploadFileInfo<any>[];
+    fields?: { [fieldName: string]: any };
+    cleanupRequestFiles?: () => Promise<Array<boolean>>;
+  }
+}
+
+declare module '@midwayjs/faas/dist/interface' {
+  interface Context {
+    files?: UploadFileInfo<any>[];
+    fields?: { [fieldName: string]: any };
+    cleanupRequestFiles?: () => Promise<Array<boolean>>;
+  }
+}
+
+declare module '@midwayjs/express/dist/interface' {
+  interface Context {
+    files?: UploadFileInfo<any>[];
+    fields?: { [fieldName: string]: any };
+    cleanupRequestFiles?: () => Promise<Array<boolean>>;
+  }
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@midwayjs/busboy",
+  "version": "3.16.0",
+  "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",
+    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit",
+    "ci": "npm run test"
+  },
+  "keywords": [],
+  "author": "",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "file-type": "16.5.4",
+    "busboy": "1.6.0",
+    "@types/busboy": "1.5.4"
+  },
+  "devDependencies": {
+    "@midwayjs/core": "^3.16.2",
+    "@midwayjs/express": "^3.16.2",
+    "@midwayjs/faas": "^3.16.2",
+    "@midwayjs/koa": "^3.16.2",
+    "@midwayjs/mock": "^3.16.2",
+    "@midwayjs/web": "^3.16.2"
+  }
+}