payload 3.89.0 → 3.90.1

package/dist/uploads/fetchAPI-multipart/index.js

@@ -2,14 +2,22 @@ import { APIError } from '../../errors/APIError.js';
 import { isEligibleRequest } from './isEligibleRequest.js';
 import { processMultipart } from './processMultipart.js';
 import { debugLog } from './utilities.js';
+const DEFAULT_REQUEST_SIZE_LIMIT = 50 * 1024 * 1024;
 const DEFAULT_UPLOAD_OPTIONS = {
-    abortOnLimit: false,
+    abortOnLimit: true,
     createParentPath: false,
     debug: false,
     defParamCharset: 'utf8',
     limitHandler: false,
+    limits: {
+        fields: 20,
+        fieldSize: 1024 * 1024,
+        files: 3,
+        fileSize: 20 * 1024 * 1024
+    },
     parseNested: false,
     preserveExtension: false,
+    requestSizeLimit: DEFAULT_REQUEST_SIZE_LIMIT,
     responseOnLimit: 'File size limit has been reached',
     safeFileNames: false,
     tempFileDir: 'tmp',
@@ -18,10 +26,24 @@ const DEFAULT_UPLOAD_OPTIONS = {
     useTempFiles: false
 };
 export const processMultipartFormdata = async ({ options: incomingOptions, request })=>{
+    const requestSizeLimit = incomingOptions?.requestSizeLimit === undefined ? DEFAULT_REQUEST_SIZE_LIMIT : incomingOptions.requestSizeLimit;
+    if (requestSizeLimit !== Infinity && (!Number.isSafeInteger(requestSizeLimit) || requestSizeLimit < 0)) {
+        throw new TypeError('requestSizeLimit must be Infinity or a non-negative safe integer representing bytes');
+    }
     const options = {
         ...DEFAULT_UPLOAD_OPTIONS,
-        ...incomingOptions
+        ...incomingOptions,
+        abortOnLimit: incomingOptions?.abortOnLimit ?? DEFAULT_UPLOAD_OPTIONS.abortOnLimit,
+        limits: {
+            ...DEFAULT_UPLOAD_OPTIONS.limits
+        },
+        requestSizeLimit
     };
+    for (const [key, value] of Object.entries(incomingOptions?.limits || {})){
+        if (value !== undefined) {
+            options.limits[key] = value;
+        }
+    }
     if (!isEligibleRequest(request)) {
         debugLog(options, 'Request is not eligible for file upload!');
         return {

package/dist/uploads/fetchAPI-multipart/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/index.ts"],"sourcesContent":["import path from 'path'\n\nimport type { FetchAPIFileUploadOptions } from '../../config/types.js'\n\nimport { APIError } from '../../errors/APIError.js'\nimport { isEligibleRequest } from './isEligibleRequest.js'\nimport { processMultipart } from './processMultipart.js'\nimport { debugLog } from './utilities.js'\n\nconst DEFAULT_UPLOAD_OPTIONS: FetchAPIFileUploadOptions = {\n  abortOnLimit: false,\n  createParentPath: false,\n  debug: false,\n  defParamCharset: 'utf8',\n  limitHandler: false,\n  parseNested: false,\n  preserveExtension: false,\n  responseOnLimit: 'File size limit has been reached',\n  safeFileNames: false,\n  tempFileDir: 'tmp', // Relative path is created inside current workdir.\n  uploadTimeout: 60000,\n  uriDecodeFileNames: false,\n  useTempFiles: false,\n}\n\nexport type FileShape = {\n  data: Buffer\n  encoding: string\n  md5: Buffer | string\n  mimetype: string\n  mv: (filePath: string, callback: () => void) => Promise<void> | void\n  name: string\n  size: number\n  tempFilePath: string\n  truncated: boolean\n}\n\ntype FetchAPIFileUploadResponseFile = {\n  data: Buffer\n  mimetype: string\n  name: string\n  size: number\n  tempFilePath?: string\n}\n\nexport type FetchAPIFileUploadResponse = {\n  error?: APIError\n  fields: Record<string, string>\n  files: Record<string, FetchAPIFileUploadResponseFile>\n}\n\ntype FetchAPIFileUpload = (args: {\n  options?: FetchAPIFileUploadOptions\n  request: Request\n}) => Promise<FetchAPIFileUploadResponse>\n\nexport const processMultipartFormdata: FetchAPIFileUpload = async ({\n  options: incomingOptions,\n  request,\n}) => {\n  const options: FetchAPIFileUploadOptions = { ...DEFAULT_UPLOAD_OPTIONS, ...incomingOptions }\n\n  if (!isEligibleRequest(request)) {\n    debugLog(options, 'Request is not eligible for file upload!')\n\n    return {\n      error: new APIError('Request is not eligible for file upload', 500),\n      fields: undefined!,\n      files: undefined!,\n    }\n  } else {\n    return processMultipart({ options, request })\n  }\n}\n"],"names":["APIError","isEligibleRequest","processMultipart","debugLog","DEFAULT_UPLOAD_OPTIONS","abortOnLimit","createParentPath","debug","defParamCharset","limitHandler","parseNested","preserveExtension","responseOnLimit","safeFileNames","tempFileDir","uploadTimeout","uriDecodeFileNames","useTempFiles","processMultipartFormdata","options","incomingOptions","request","error","fields","undefined","files"],"mappings":"AAIA,SAASA,QAAQ,QAAQ,2BAA0B;AACnD,SAASC,iBAAiB,QAAQ,yBAAwB;AAC1D,SAASC,gBAAgB,QAAQ,wBAAuB;AACxD,SAASC,QAAQ,QAAQ,iBAAgB;AAEzC,MAAMC,yBAAoD;IACxDC,cAAc;IACdC,kBAAkB;IAClBC,OAAO;IACPC,iBAAiB;IACjBC,cAAc;IACdC,aAAa;IACbC,mBAAmB;IACnBC,iBAAiB;IACjBC,eAAe;IACfC,aAAa;IACbC,eAAe;IACfC,oBAAoB;IACpBC,cAAc;AAChB;AAiCA,OAAO,MAAMC,2BAA+C,OAAO,EACjEC,SAASC,eAAe,EACxBC,OAAO,EACR;IACC,MAAMF,UAAqC;QAAE,GAAGf,sBAAsB;QAAE,GAAGgB,eAAe;IAAC;IAE3F,IAAI,CAACnB,kBAAkBoB,UAAU;QAC/BlB,SAASgB,SAAS;QAElB,OAAO;YACLG,OAAO,IAAItB,SAAS,2CAA2C;YAC/DuB,QAAQC;YACRC,OAAOD;QACT;IACF,OAAO;QACL,OAAOtB,iBAAiB;YAAEiB;YAASE;QAAQ;IAC7C;AACF,EAAC"}
+{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/index.ts"],"sourcesContent":["import type { FetchAPIFileUploadOptions } from '../../config/types.js'\n\nimport { APIError } from '../../errors/APIError.js'\nimport { isEligibleRequest } from './isEligibleRequest.js'\nimport { processMultipart } from './processMultipart.js'\nimport { debugLog } from './utilities.js'\n\nconst DEFAULT_REQUEST_SIZE_LIMIT = 50 * 1024 * 1024\n\nconst DEFAULT_UPLOAD_OPTIONS: FetchAPIFileUploadOptions = {\n  abortOnLimit: true,\n  createParentPath: false,\n  debug: false,\n  defParamCharset: 'utf8',\n  limitHandler: false,\n  limits: { fields: 20, fieldSize: 1024 * 1024, files: 3, fileSize: 20 * 1024 * 1024 },\n  parseNested: false,\n  preserveExtension: false,\n  requestSizeLimit: DEFAULT_REQUEST_SIZE_LIMIT,\n  responseOnLimit: 'File size limit has been reached',\n  safeFileNames: false,\n  tempFileDir: 'tmp', // Relative path is created inside current workdir.\n  uploadTimeout: 60000,\n  uriDecodeFileNames: false,\n  useTempFiles: false,\n}\n\nexport type FileShape = {\n  data: Buffer\n  encoding: string\n  md5: Buffer | string\n  mimetype: string\n  mv: (filePath: string, callback: () => void) => Promise<void> | void\n  name: string\n  size: number\n  tempFilePath: string\n  truncated: boolean\n}\n\ntype FetchAPIFileUploadResponseFile = {\n  data: Buffer\n  mimetype: string\n  name: string\n  size: number\n  tempFilePath?: string\n}\n\nexport type FetchAPIFileUploadResponse = {\n  error?: APIError\n  fields: Record<string, string>\n  files: Record<string, FetchAPIFileUploadResponseFile>\n}\n\ntype FetchAPIFileUpload = (args: {\n  options?: FetchAPIFileUploadOptions\n  request: Request\n}) => Promise<FetchAPIFileUploadResponse>\n\nexport const processMultipartFormdata: FetchAPIFileUpload = async ({\n  options: incomingOptions,\n  request,\n}) => {\n  const requestSizeLimit =\n    incomingOptions?.requestSizeLimit === undefined\n      ? DEFAULT_REQUEST_SIZE_LIMIT\n      : incomingOptions.requestSizeLimit\n\n  if (\n    requestSizeLimit !== Infinity &&\n    (!Number.isSafeInteger(requestSizeLimit) || requestSizeLimit < 0)\n  ) {\n    throw new TypeError(\n      'requestSizeLimit must be Infinity or a non-negative safe integer representing bytes',\n    )\n  }\n\n  const options: FetchAPIFileUploadOptions = {\n    ...DEFAULT_UPLOAD_OPTIONS,\n    ...incomingOptions,\n    abortOnLimit: incomingOptions?.abortOnLimit ?? DEFAULT_UPLOAD_OPTIONS.abortOnLimit,\n    limits: { ...DEFAULT_UPLOAD_OPTIONS.limits },\n    requestSizeLimit,\n  }\n\n  for (const [key, value] of Object.entries(incomingOptions?.limits || {})) {\n    if (value !== undefined) {\n      options.limits![key as keyof NonNullable<FetchAPIFileUploadOptions['limits']>] = value\n    }\n  }\n\n  if (!isEligibleRequest(request)) {\n    debugLog(options, 'Request is not eligible for file upload!')\n\n    return {\n      error: new APIError('Request is not eligible for file upload', 500),\n      fields: undefined!,\n      files: undefined!,\n    }\n  } else {\n    return processMultipart({ options, request })\n  }\n}\n"],"names":["APIError","isEligibleRequest","processMultipart","debugLog","DEFAULT_REQUEST_SIZE_LIMIT","DEFAULT_UPLOAD_OPTIONS","abortOnLimit","createParentPath","debug","defParamCharset","limitHandler","limits","fields","fieldSize","files","fileSize","parseNested","preserveExtension","requestSizeLimit","responseOnLimit","safeFileNames","tempFileDir","uploadTimeout","uriDecodeFileNames","useTempFiles","processMultipartFormdata","options","incomingOptions","request","undefined","Infinity","Number","isSafeInteger","TypeError","key","value","Object","entries","error"],"mappings":"AAEA,SAASA,QAAQ,QAAQ,2BAA0B;AACnD,SAASC,iBAAiB,QAAQ,yBAAwB;AAC1D,SAASC,gBAAgB,QAAQ,wBAAuB;AACxD,SAASC,QAAQ,QAAQ,iBAAgB;AAEzC,MAAMC,6BAA6B,KAAK,OAAO;AAE/C,MAAMC,yBAAoD;IACxDC,cAAc;IACdC,kBAAkB;IAClBC,OAAO;IACPC,iBAAiB;IACjBC,cAAc;IACdC,QAAQ;QAAEC,QAAQ;QAAIC,WAAW,OAAO;QAAMC,OAAO;QAAGC,UAAU,KAAK,OAAO;IAAK;IACnFC,aAAa;IACbC,mBAAmB;IACnBC,kBAAkBd;IAClBe,iBAAiB;IACjBC,eAAe;IACfC,aAAa;IACbC,eAAe;IACfC,oBAAoB;IACpBC,cAAc;AAChB;AAiCA,OAAO,MAAMC,2BAA+C,OAAO,EACjEC,SAASC,eAAe,EACxBC,OAAO,EACR;IACC,MAAMV,mBACJS,iBAAiBT,qBAAqBW,YAClCzB,6BACAuB,gBAAgBT,gBAAgB;IAEtC,IACEA,qBAAqBY,YACpB,CAAA,CAACC,OAAOC,aAAa,CAACd,qBAAqBA,mBAAmB,CAAA,GAC/D;QACA,MAAM,IAAIe,UACR;IAEJ;IAEA,MAAMP,UAAqC;QACzC,GAAGrB,sBAAsB;QACzB,GAAGsB,eAAe;QAClBrB,cAAcqB,iBAAiBrB,gBAAgBD,uBAAuBC,YAAY;QAClFK,QAAQ;YAAE,GAAGN,uBAAuBM,MAAM;QAAC;QAC3CO;IACF;IAEA,KAAK,MAAM,CAACgB,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACV,iBAAiBhB,UAAU,CAAC,GAAI;QACxE,IAAIwB,UAAUN,WAAW;YACvBH,QAAQf,MAAM,AAAC,CAACuB,IAA8D,GAAGC;QACnF;IACF;IAEA,IAAI,CAAClC,kBAAkB2B,UAAU;QAC/BzB,SAASuB,SAAS;QAElB,OAAO;YACLY,OAAO,IAAItC,SAAS,2CAA2C;YAC/DY,QAAQiB;YACRf,OAAOe;QACT;IACF,OAAO;QACL,OAAO3B,iBAAiB;YAAEwB;YAASE;QAAQ;IAC7C;AACF,EAAC"}

package/dist/uploads/fetchAPI-multipart/processMultipart.d.ts

@@ -1,11 +1,5 @@
 import type { FetchAPIFileUploadOptions } from '../../config/types.js';
 import type { FetchAPIFileUploadResponse } from './index.js';
-declare const waitFlushProperty: unique symbol;
-declare global {
-    interface Request {
-        [waitFlushProperty]?: Promise<any>[];
-    }
-}
 type ProcessMultipart = (args: {
     options: FetchAPIFileUploadOptions;
     request: Request;

package/dist/uploads/fetchAPI-multipart/processMultipart.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processMultipart.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/processMultipart.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAS5D,QAAA,MAAM,iBAAiB,eAAuC,CAAA;AAE9D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,OAAO;QACf,CAAC,iBAAiB,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAA;KACrC;CACF;AAED,KAAK,gBAAgB,GAAG,CAAC,IAAI,EAAE;IAC7B,OAAO,EAAE,yBAAyB,CAAA;IAClC,OAAO,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAA;AACzC,eAAO,MAAM,gBAAgB,EAAE,gBAuN9B,CAAA"}
+{"version":3,"file":"processMultipart.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/processMultipart.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAS5D,KAAK,gBAAgB,GAAG,CAAC,IAAI,EAAE;IAC7B,OAAO,EAAE,yBAAyB,CAAA;IAClC,OAAO,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAA;AAEzC,eAAO,MAAM,gBAAgB,EAAE,gBAgM9B,CAAA"}

package/dist/uploads/fetchAPI-multipart/processMultipart.js

@@ -5,167 +5,187 @@ import { fileFactory } from './fileFactory.js';
 import { memHandler, tempFileHandler } from './handlers.js';
 import { processNested } from './processNested.js';
 import { createUploadTimer } from './uploadTimer.js';
-import { buildFields, debugLog, isFunc, parseFileName } from './utilities.js';
-const waitFlushProperty = Symbol('wait flush property symbol');
+import { buildFields, isFunc, parseFileName } from './utilities.js';
 export const processMultipart = async ({ options, request })=>{
-    let parsingRequest = true;
-    let shouldAbortProccessing = false;
-    let fileCount = 0;
-    let filesCompleted = 0;
-    let allFilesHaveResolved;
-    let failedResolvingFiles;
-    let busboyFinishedResolve;
-    let busboyFinishedReject;
-    const allFilesComplete = new Promise((res, rej)=>{
-        allFilesHaveResolved = res;
-        failedResolvingFiles = rej;
-    });
-    const busboyFinished = new Promise((resolve, reject)=>{
-        busboyFinishedResolve = resolve;
-        busboyFinishedReject = reject;
-    });
+    const { requestSizeLimit = Infinity, ...busboyOptions } = options;
     const result = {
         fields: undefined,
         files: undefined
     };
-    const headersObject = {};
+    const headers = {};
     request.headers.forEach((value, name)=>{
-        headersObject[name] = value;
+        headers[name] = value;
     });
-    const reader = request.body?.getReader();
     const busboy = Busboy({
-        ...options,
-        headers: headersObject
+        ...busboyOptions,
+        headers
     });
-    function abortAndDestroyFile(file, err) {
-        file.destroy();
-        shouldAbortProccessing = true;
-        failedResolvingFiles(err);
-    }
-    // Build multipart req.body fields
-    busboy.on('field', (field, val)=>{
-        result.fields = buildFields(result.fields, field, val);
+    const reader = request.body.getReader();
+    const uploads = [];
+    const writes = [];
+    let failure;
+    let requestSize = 0;
+    let rejectFinished;
+    let resolveFinished;
+    const finished = new Promise((resolve, reject)=>{
+        resolveFinished = resolve;
+        rejectFinished = reject;
+    });
+    const fail = (err)=>{
+        if (failure) {
+            return;
+        }
+        failure = err;
+        rejectFinished(err);
+        // Busboy may still be updating its current file after emitting a limit event.
+        queueMicrotask(()=>{
+            for (const upload of uploads){
+                upload.clear();
+                upload.file.destroy();
+            }
+            busboy.destroy();
+            void reader.cancel(err).catch(()=>{});
+        });
+    };
+    const limitError = ()=>new APIError('Multipart limit has been reached', httpStatus.REQUEST_ENTITY_TOO_LARGE);
+    const requestSizeLimitError = ()=>new APIError('Multipart request size limit has been reached', httpStatus.REQUEST_ENTITY_TOO_LARGE);
+    busboy.on('filesLimit', ()=>fail(limitError()));
+    busboy.on('fieldsLimit', ()=>fail(limitError()));
+    busboy.on('partsLimit', ()=>fail(limitError()));
+    busboy.on('error', fail);
+    busboy.on('field', (field, value, info)=>{
+        if (info.valueTruncated || info.nameTruncated) {
+            fail(limitError());
+        } else if (!failure) {
+            result.fields = buildFields(result.fields, field, value);
+        }
     });
-    // Build req.files fields
     busboy.on('file', (field, file, info)=>{
-        fileCount += 1;
-        // Parse file name(cutting huge names, decoding, etc..).
+        if (failure) {
+            file.resume();
+            return;
+        }
         const { encoding, filename: name, mimeType: mime } = info;
         const filename = parseFileName(options, name);
-        const inferredMimeType = filename && filename.endsWith('.glb') && 'model/gltf-binary' || filename && filename.endsWith('.gltf') && 'model/gltf+json' || mime;
-        // Define methods and handlers for upload process.
-        const { cleanup, complete, dataHandler, getFilePath, getFileSize, getHash, getWritePromise } = options.useTempFiles ? tempFileHandler(options, field, filename) // Upload into temporary file.
-         : memHandler(options, field, filename) // Upload into RAM.
-        ;
-        const writePromise = options.useTempFiles ? getWritePromise().catch(()=>{
-            busboy.end();
-            cleanup();
-        }) : getWritePromise();
-        const uploadTimer = createUploadTimer(options.uploadTimeout, ()=>{
-            return abortAndDestroyFile(file, new APIError(`Upload timeout for ${field}->${filename}, bytes:${getFileSize()}`));
+        const mimetype = filename.endsWith('.glb') && 'model/gltf-binary' || filename.endsWith('.gltf') && 'model/gltf+json' || mime;
+        const handler = options.useTempFiles ? tempFileHandler(options, field, filename) : memHandler(options, field, filename);
+        const timer = createUploadTimer(options.uploadTimeout, ()=>{
+            fail(new APIError(`Upload timeout for ${field}->${filename}, bytes:${handler.getFileSize()}`));
+        });
+        uploads.push({
+            cleanup: handler.cleanup,
+            clear: timer.clear,
+            file
         });
+        // Observe write failures immediately, including failures before file end.
+        const write = handler.getWritePromise();
+        void write.catch(fail);
+        writes.push(write);
         file.on('limit', ()=>{
-            debugLog(options, `Size limit reached for ${field}->${filename}, bytes:${getFileSize()}`);
-            uploadTimer.clear();
-            if (isFunc(options.limitHandler)) {
-                options.limitHandler({
-                    request,
-                    size: getFileSize()
-                });
-            }
-            // Return error and cleanup files if abortOnLimit set.
-            if (options.abortOnLimit) {
-                debugLog(options, `Upload file size limit reached ${field}->${filename}.`);
-                cleanup();
-                abortAndDestroyFile(file, new APIError(options.responseOnLimit, httpStatus.REQUEST_ENTITY_TOO_LARGE, {
-                    size: getFileSize()
-                }));
+            timer.clear();
+            try {
+                if (isFunc(options.limitHandler)) {
+                    options.limitHandler({
+                        request,
+                        size: handler.getFileSize()
+                    });
+                }
+                if (options.abortOnLimit) {
+                    fail(new APIError(options.responseOnLimit, httpStatus.REQUEST_ENTITY_TOO_LARGE, {
+                        size: handler.getFileSize()
+                    }));
+                }
+            } catch (err) {
+                fail(err);
             }
         });
         file.on('data', (data)=>{
-            uploadTimer.set();
-            dataHandler(data);
+            if (failure) {
+                return;
+            }
+            timer.set();
+            const pending = handler.dataHandler(data);
+            if (pending) {
+                file.pause();
+                void pending.then(()=>{
+                    if (!failure) {
+                        file.resume();
+                    }
+                }, fail);
+            }
         });
+        file.on('error', fail);
         file.on('end', ()=>{
-            const size = getFileSize();
-            debugLog(options, `Upload finished ${field}->${filename}, bytes:${size}`);
-            uploadTimer.clear();
+            timer.clear();
+            if (failure) {
+                return;
+            }
+            const size = handler.getFileSize();
+            const buffer = handler.complete();
             if (!name && size === 0) {
-                fileCount -= 1;
-                if (options.useTempFiles) {
-                    cleanup();
-                    debugLog(options, `Removing the empty file ${field}->${filename}`);
-                }
-                return debugLog(options, `Don't add file instance if original name and size are empty`);
+                const cleanup = Promise.resolve(handler.cleanup()).then(()=>true);
+                void cleanup.catch(fail);
+                writes.push(cleanup);
+                return;
             }
-            filesCompleted += 1;
             result.files = buildFields(result.files, field, fileFactory({
                 name: filename,
-                buffer: complete(),
+                buffer,
                 encoding,
-                hash: getHash(),
-                mimetype: inferredMimeType,
+                hash: handler.getHash(),
+                mimetype,
                 size,
-                tempFilePath: getFilePath(),
-                truncated: Boolean('truncated' in file && file.truncated) || false
+                tempFilePath: handler.getFilePath(),
+                truncated: Boolean(file.truncated)
             }, options));
-            if (!request[waitFlushProperty]) {
-                request[waitFlushProperty] = [];
-            }
-            request[waitFlushProperty].push(writePromise);
-            if (filesCompleted === fileCount) {
-                allFilesHaveResolved();
-            }
-        });
-        file.on('error', (err)=>{
-            uploadTimer.clear();
-            debugLog(options, `File Error: ${err.message}`);
-            cleanup();
-            failedResolvingFiles(err);
         });
-        // Start upload process.
-        debugLog(options, `New upload started ${field}->${filename}, bytes:${getFileSize()}`);
-        uploadTimer.set();
+        timer.set();
     });
-    busboy.on('finish', async ()=>{
-        debugLog(options, `Busboy finished parsing request.`);
-        if (options.parseNested) {
-            result.fields = processNested(result.fields);
-            result.files = processNested(result.files);
-        }
-        if (request[waitFlushProperty]) {
-            try {
-                await Promise.all(request[waitFlushProperty]).then(()=>{
-                    delete request[waitFlushProperty];
+    busboy.on('finish', ()=>{
+        void Promise.all(writes).then(()=>resolveFinished(), fail);
+    });
+    // Waiting for each write callback bounds the parser queue and respects its backpressure.
+    const pump = async ()=>{
+        try {
+            while(!failure){
+                const { done, value } = await reader.read();
+                if (failure) {
+                    break;
+                }
+                if (done) {
+                    busboy.end();
+                    break;
+                }
+                requestSize += value.byteLength;
+                if (requestSize > requestSizeLimit) {
+                    const err = requestSizeLimitError();
+                    fail(err);
+                    await reader.cancel(err).catch(()=>{});
+                    break;
+                }
+                await new Promise((resolve, reject)=>{
+                    busboy.write(value, (err)=>err ? reject(err) : resolve());
                 });
-            } catch (err) {
-                debugLog(options, `Error waiting for file write promises: ${err}`);
             }
+        } finally{
+            reader.releaseLock();
         }
-        busboyFinishedResolve();
-    });
-    busboy.on('error', (err = new APIError('Busboy error parsing multipart request', httpStatus.BAD_REQUEST))=>{
-        debugLog(options, `Busboy error`);
-        const busboyError = err instanceof Error ? err : new APIError('Busboy error parsing multipart request', httpStatus.BAD_REQUEST);
-        busboyFinishedReject(busboyError);
-    });
-    while(parsingRequest){
-        const { done, value } = await reader.read();
-        if (done) {
-            parsingRequest = false;
-            busboy.end();
+    };
+    void pump().catch(fail);
+    try {
+        await finished;
+        if (options.parseNested) {
+            result.fields = processNested(result.fields);
+            result.files = processNested(result.files);
         }
-        if (value && !shouldAbortProccessing) {
-            busboy.write(value);
+        return result;
+    } catch (err) {
+        for (const upload of uploads){
+            upload.clear();
         }
+        await Promise.all(uploads.map(async ({ cleanup })=>cleanup()));
+        throw err;
     }
-    if (fileCount !== 0) {
-        await allFilesComplete.catch((e)=>{
-            throw e;
-        });
-    }
-    await busboyFinished;
-    return result;
 };
 
 //# sourceMappingURL=processMultipart.js.map

package/dist/uploads/fetchAPI-multipart/processMultipart.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/processMultipart.ts"],"sourcesContent":["import type { Readable } from 'stream'\n\nimport Busboy from 'busboy'\nimport { status as httpStatus } from 'http-status'\n\nimport type { FetchAPIFileUploadOptions } from '../../config/types.js'\nimport type { FetchAPIFileUploadResponse } from './index.js'\n\nimport { APIError } from '../../errors/APIError.js'\nimport { fileFactory } from './fileFactory.js'\nimport { memHandler, tempFileHandler } from './handlers.js'\nimport { processNested } from './processNested.js'\nimport { createUploadTimer } from './uploadTimer.js'\nimport { buildFields, debugLog, isFunc, parseFileName } from './utilities.js'\n\nconst waitFlushProperty = Symbol('wait flush property symbol')\n\ndeclare global {\n  interface Request {\n    [waitFlushProperty]?: Promise<any>[]\n  }\n}\n\ntype ProcessMultipart = (args: {\n  options: FetchAPIFileUploadOptions\n  request: Request\n}) => Promise<FetchAPIFileUploadResponse>\nexport const processMultipart: ProcessMultipart = async ({ options, request }) => {\n  let parsingRequest = true\n\n  let shouldAbortProccessing = false\n  let fileCount = 0\n  let filesCompleted = 0\n  let allFilesHaveResolved: (value?: unknown) => void\n  let failedResolvingFiles: (err: Error) => void\n  let busboyFinishedResolve: () => void\n  let busboyFinishedReject: (err: Error) => void\n\n  const allFilesComplete = new Promise((res, rej) => {\n    allFilesHaveResolved = res\n    failedResolvingFiles = rej\n  })\n\n  const busboyFinished = new Promise<void>((resolve, reject) => {\n    busboyFinishedResolve = resolve\n    busboyFinishedReject = reject\n  })\n\n  const result: FetchAPIFileUploadResponse = {\n    fields: undefined!,\n    files: undefined!,\n  }\n\n  const headersObject: Record<string, string> = {}\n  request.headers.forEach((value, name) => {\n    headersObject[name] = value\n  })\n\n  const reader = request.body?.getReader()\n\n  const busboy = Busboy({ ...options, headers: headersObject })\n\n  function abortAndDestroyFile(file: Readable, err: APIError) {\n    file.destroy()\n    shouldAbortProccessing = true\n    failedResolvingFiles(err)\n  }\n\n  // Build multipart req.body fields\n  busboy.on('field', (field, val) => {\n    result.fields = buildFields(result.fields, field, val)\n  })\n\n  // Build req.files fields\n  busboy.on('file', (field, file, info) => {\n    fileCount += 1\n    // Parse file name(cutting huge names, decoding, etc..).\n    const { encoding, filename: name, mimeType: mime } = info\n    const filename = parseFileName(options, name)\n\n    const inferredMimeType =\n      (filename && filename.endsWith('.glb') && 'model/gltf-binary') ||\n      (filename && filename.endsWith('.gltf') && 'model/gltf+json') ||\n      mime\n\n    // Define methods and handlers for upload process.\n    const { cleanup, complete, dataHandler, getFilePath, getFileSize, getHash, getWritePromise } =\n      options.useTempFiles\n        ? tempFileHandler(options, field, filename) // Upload into temporary file.\n        : memHandler(options, field, filename) // Upload into RAM.\n\n    const writePromise = options.useTempFiles\n      ? getWritePromise().catch(() => {\n          busboy.end()\n          cleanup()\n        })\n      : getWritePromise()\n\n    const uploadTimer = createUploadTimer(options.uploadTimeout, () => {\n      return abortAndDestroyFile(\n        file,\n        new APIError(`Upload timeout for ${field}->${filename}, bytes:${getFileSize()}`),\n      )\n    })\n\n    file.on('limit', () => {\n      debugLog(options, `Size limit reached for ${field}->${filename}, bytes:${getFileSize()}`)\n      uploadTimer.clear()\n\n      if (isFunc(options.limitHandler)) {\n        options.limitHandler({ request, size: getFileSize() })\n      }\n\n      // Return error and cleanup files if abortOnLimit set.\n      if (options.abortOnLimit) {\n        debugLog(options, `Upload file size limit reached ${field}->${filename}.`)\n        cleanup()\n        abortAndDestroyFile(\n          file,\n          new APIError(options.responseOnLimit!, httpStatus.REQUEST_ENTITY_TOO_LARGE, {\n            size: getFileSize(),\n          }),\n        )\n      }\n    })\n\n    file.on('data', (data) => {\n      uploadTimer.set()\n      dataHandler(data)\n    })\n\n    file.on('end', () => {\n      const size = getFileSize()\n      debugLog(options, `Upload finished ${field}->${filename}, bytes:${size}`)\n      uploadTimer.clear()\n\n      if (!name && size === 0) {\n        fileCount -= 1\n        if (options.useTempFiles) {\n          cleanup()\n          debugLog(options, `Removing the empty file ${field}->${filename}`)\n        }\n        return debugLog(options, `Don't add file instance if original name and size are empty`)\n      }\n\n      filesCompleted += 1\n\n      result.files = buildFields(\n        result.files,\n        field,\n        fileFactory(\n          {\n            name: filename,\n            buffer: complete(),\n            encoding,\n            hash: getHash(),\n            mimetype: inferredMimeType,\n            size,\n            tempFilePath: getFilePath(),\n            truncated: Boolean('truncated' in file && file.truncated) || false,\n          },\n          options,\n        ),\n      )\n\n      if (!request[waitFlushProperty]) {\n        request[waitFlushProperty] = []\n      }\n      request[waitFlushProperty].push(writePromise)\n\n      if (filesCompleted === fileCount) {\n        allFilesHaveResolved()\n      }\n    })\n\n    file.on('error', (err) => {\n      uploadTimer.clear()\n      debugLog(options, `File Error: ${err.message}`)\n      cleanup()\n      failedResolvingFiles(err)\n    })\n\n    // Start upload process.\n    debugLog(options, `New upload started ${field}->${filename}, bytes:${getFileSize()}`)\n    uploadTimer.set()\n  })\n\n  busboy.on('finish', async () => {\n    debugLog(options, `Busboy finished parsing request.`)\n    if (options.parseNested) {\n      result.fields = processNested(result.fields)\n      result.files = processNested(result.files)\n    }\n\n    if (request[waitFlushProperty]) {\n      try {\n        await Promise.all(request[waitFlushProperty]).then(() => {\n          delete request[waitFlushProperty]\n        })\n      } catch (err) {\n        debugLog(options, `Error waiting for file write promises: ${err}`)\n      }\n    }\n\n    busboyFinishedResolve()\n  })\n\n  busboy.on(\n    'error',\n    (err = new APIError('Busboy error parsing multipart request', httpStatus.BAD_REQUEST)) => {\n      debugLog(options, `Busboy error`)\n      const busboyError =\n        err instanceof Error\n          ? err\n          : new APIError('Busboy error parsing multipart request', httpStatus.BAD_REQUEST)\n\n      busboyFinishedReject(busboyError)\n    },\n  )\n\n  while (parsingRequest) {\n    const { done, value } = await reader!.read()\n\n    if (done) {\n      parsingRequest = false\n      busboy.end()\n    }\n\n    if (value && !shouldAbortProccessing) {\n      busboy.write(value)\n    }\n  }\n\n  if (fileCount !== 0) {\n    await allFilesComplete.catch((e) => {\n      throw e\n    })\n  }\n\n  await busboyFinished\n\n  return result\n}\n"],"names":["Busboy","status","httpStatus","APIError","fileFactory","memHandler","tempFileHandler","processNested","createUploadTimer","buildFields","debugLog","isFunc","parseFileName","waitFlushProperty","Symbol","processMultipart","options","request","parsingRequest","shouldAbortProccessing","fileCount","filesCompleted","allFilesHaveResolved","failedResolvingFiles","busboyFinishedResolve","busboyFinishedReject","allFilesComplete","Promise","res","rej","busboyFinished","resolve","reject","result","fields","undefined","files","headersObject","headers","forEach","value","name","reader","body","getReader","busboy","abortAndDestroyFile","file","err","destroy","on","field","val","info","encoding","filename","mimeType","mime","inferredMimeType","endsWith","cleanup","complete","dataHandler","getFilePath","getFileSize","getHash","getWritePromise","useTempFiles","writePromise","catch","end","uploadTimer","uploadTimeout","clear","limitHandler","size","abortOnLimit","responseOnLimit","REQUEST_ENTITY_TOO_LARGE","data","set","buffer","hash","mimetype","tempFilePath","truncated","Boolean","push","message","parseNested","all","then","BAD_REQUEST","busboyError","Error","done","read","write","e"],"mappings":"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"}
+{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/processMultipart.ts"],"sourcesContent":["import type { Readable } from 'stream'\n\nimport Busboy from 'busboy'\nimport { status as httpStatus } from 'http-status'\n\nimport type { FetchAPIFileUploadOptions } from '../../config/types.js'\nimport type { FetchAPIFileUploadResponse } from './index.js'\n\nimport { APIError } from '../../errors/APIError.js'\nimport { fileFactory } from './fileFactory.js'\nimport { memHandler, tempFileHandler } from './handlers.js'\nimport { processNested } from './processNested.js'\nimport { createUploadTimer } from './uploadTimer.js'\nimport { buildFields, isFunc, parseFileName } from './utilities.js'\n\ntype ProcessMultipart = (args: {\n  options: FetchAPIFileUploadOptions\n  request: Request\n}) => Promise<FetchAPIFileUploadResponse>\n\nexport const processMultipart: ProcessMultipart = async ({ options, request }) => {\n  const { requestSizeLimit = Infinity, ...busboyOptions } = options\n  const result: FetchAPIFileUploadResponse = { fields: undefined!, files: undefined! }\n  const headers: Record<string, string> = {}\n  request.headers.forEach((value, name) => {\n    headers[name] = value\n  })\n  const busboy = Busboy({ ...busboyOptions, headers })\n  const reader = request.body!.getReader()\n  const uploads: { cleanup: () => Promise<void> | void; clear: () => void; file: Readable }[] = []\n  const writes: Promise<boolean>[] = []\n  let failure: Error | undefined\n  let requestSize = 0\n  let rejectFinished: (err: Error) => void\n  let resolveFinished: () => void\n  const finished = new Promise<void>((resolve, reject) => {\n    resolveFinished = resolve\n    rejectFinished = reject\n  })\n\n  const fail = (err: Error) => {\n    if (failure) {\n      return\n    }\n    failure = err\n    rejectFinished(err)\n    // Busboy may still be updating its current file after emitting a limit event.\n    queueMicrotask(() => {\n      for (const upload of uploads) {\n        upload.clear()\n        upload.file.destroy()\n      }\n      busboy.destroy()\n      void reader.cancel(err).catch(() => {})\n    })\n  }\n  const limitError = () =>\n    new APIError('Multipart limit has been reached', httpStatus.REQUEST_ENTITY_TOO_LARGE)\n  const requestSizeLimitError = () =>\n    new APIError(\n      'Multipart request size limit has been reached',\n      httpStatus.REQUEST_ENTITY_TOO_LARGE,\n    )\n\n  busboy.on('filesLimit', () => fail(limitError()))\n  busboy.on('fieldsLimit', () => fail(limitError()))\n  busboy.on('partsLimit', () => fail(limitError()))\n  busboy.on('error', fail)\n  busboy.on('field', (field, value, info) => {\n    if (info.valueTruncated || info.nameTruncated) {\n      fail(limitError())\n    } else if (!failure) {\n      result.fields = buildFields(result.fields, field, value)\n    }\n  })\n\n  busboy.on('file', (field, file, info) => {\n    if (failure) {\n      file.resume()\n      return\n    }\n    const { encoding, filename: name, mimeType: mime } = info\n    const filename = parseFileName(options, name)\n    const mimetype =\n      (filename.endsWith('.glb') && 'model/gltf-binary') ||\n      (filename.endsWith('.gltf') && 'model/gltf+json') ||\n      mime\n    const handler = options.useTempFiles\n      ? tempFileHandler(options, field, filename)\n      : memHandler(options, field, filename)\n    const timer = createUploadTimer(options.uploadTimeout, () => {\n      fail(new APIError(`Upload timeout for ${field}->${filename}, bytes:${handler.getFileSize()}`))\n    })\n    uploads.push({ cleanup: handler.cleanup, clear: timer.clear, file })\n    // Observe write failures immediately, including failures before file end.\n    const write = handler.getWritePromise()\n    void write.catch(fail)\n    writes.push(write)\n\n    file.on('limit', () => {\n      timer.clear()\n      try {\n        if (isFunc(options.limitHandler)) {\n          options.limitHandler({ request, size: handler.getFileSize() })\n        }\n        if (options.abortOnLimit) {\n          fail(\n            new APIError(options.responseOnLimit!, httpStatus.REQUEST_ENTITY_TOO_LARGE, {\n              size: handler.getFileSize(),\n            }),\n          )\n        }\n      } catch (err) {\n        fail(err as Error)\n      }\n    })\n    file.on('data', (data: Buffer) => {\n      if (failure) {\n        return\n      }\n      timer.set()\n      const pending = handler.dataHandler(data)\n      if (pending) {\n        file.pause()\n        void pending.then(() => {\n          if (!failure) {\n            file.resume()\n          }\n        }, fail)\n      }\n    })\n    file.on('error', fail)\n    file.on('end', () => {\n      timer.clear()\n      if (failure) {\n        return\n      }\n      const size = handler.getFileSize()\n      const buffer = handler.complete()\n      if (!name && size === 0) {\n        const cleanup = Promise.resolve(handler.cleanup()).then(() => true)\n        void cleanup.catch(fail)\n        writes.push(cleanup)\n        return\n      }\n      result.files = buildFields(\n        result.files,\n        field,\n        fileFactory(\n          {\n            name: filename,\n            buffer,\n            encoding,\n            hash: handler.getHash(),\n            mimetype,\n            size,\n            tempFilePath: handler.getFilePath(),\n            truncated: Boolean(file.truncated),\n          },\n          options,\n        ),\n      )\n    })\n    timer.set()\n  })\n  busboy.on('finish', () => {\n    void Promise.all(writes).then(() => resolveFinished(), fail)\n  })\n\n  // Waiting for each write callback bounds the parser queue and respects its backpressure.\n  const pump = async () => {\n    try {\n      while (!failure) {\n        const { done, value } = await reader.read()\n        if (failure) {\n          break\n        }\n        if (done) {\n          busboy.end()\n          break\n        }\n        requestSize += value.byteLength\n        if (requestSize > requestSizeLimit) {\n          const err = requestSizeLimitError()\n          fail(err)\n          await reader.cancel(err).catch(() => {})\n          break\n        }\n        await new Promise<void>((resolve, reject) => {\n          busboy.write(value, (err?: Error | null) => (err ? reject(err) : resolve()))\n        })\n      }\n    } finally {\n      reader.releaseLock()\n    }\n  }\n  void pump().catch(fail)\n\n  try {\n    await finished\n    if (options.parseNested) {\n      result.fields = processNested(result.fields)\n      result.files = processNested(result.files)\n    }\n    return result\n  } catch (err) {\n    for (const upload of uploads) {\n      upload.clear()\n    }\n    await Promise.all(uploads.map(async ({ cleanup }) => cleanup()))\n    throw err\n  }\n}\n"],"names":["Busboy","status","httpStatus","APIError","fileFactory","memHandler","tempFileHandler","processNested","createUploadTimer","buildFields","isFunc","parseFileName","processMultipart","options","request","requestSizeLimit","Infinity","busboyOptions","result","fields","undefined","files","headers","forEach","value","name","busboy","reader","body","getReader","uploads","writes","failure","requestSize","rejectFinished","resolveFinished","finished","Promise","resolve","reject","fail","err","queueMicrotask","upload","clear","file","destroy","cancel","catch","limitError","REQUEST_ENTITY_TOO_LARGE","requestSizeLimitError","on","field","info","valueTruncated","nameTruncated","resume","encoding","filename","mimeType","mime","mimetype","endsWith","handler","useTempFiles","timer","uploadTimeout","getFileSize","push","cleanup","write","getWritePromise","limitHandler","size","abortOnLimit","responseOnLimit","data","set","pending","dataHandler","pause","then","buffer","complete","hash","getHash","tempFilePath","getFilePath","truncated","Boolean","all","pump","done","read","end","byteLength","releaseLock","parseNested","map"],"mappings":"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"}