payload 4.0.0-internal.e7d4ebc → 4.0.0-internal.ee5d8bd

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/isEligibleRequest.js

@@ -1,5 +1,4 @@
-// eslint-disable-next-line regexp/no-super-linear-backtracking, regexp/no-obscure-range
-const ACCEPTABLE_CONTENT_TYPE = /multipart\/['"()+-_]+(?:; ?['"()+-_]*)+$/i;
+const ACCEPTABLE_CONTENT_TYPE = /multipart\/[\w'"()+,./:<=>?@[\\\]^-]+(?:; ?[\w'"()+,./:<=>?@[\\\]^-]*)+$/i;
 const UNACCEPTABLE_METHODS = new Set([
     'CONNECT',
     'DELETE',

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/isEligibleRequest.ts"],"sourcesContent":["// eslint-disable-next-line regexp/no-super-linear-backtracking, regexp/no-obscure-range\nconst ACCEPTABLE_CONTENT_TYPE = /multipart\\/['\"()+-_]+(?:; ?['\"()+-_]*)+$/i\nconst UNACCEPTABLE_METHODS = new Set(['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'TRACE'])\n\nconst hasBody = (req: Request): boolean => {\n  const contentLength = req.headers.get('content-length')\n\n  return Boolean(\n    req.body || req.headers.get('transfer-encoding') || (contentLength && contentLength !== '0'),\n  )\n}\n\nconst hasAcceptableMethod = (req: Request): boolean => !UNACCEPTABLE_METHODS.has(req.method)\n\nconst hasAcceptableContentType = (req: Request): boolean => {\n  const contType = req.headers.get('content-type')\n  return contType!.includes('boundary=') && ACCEPTABLE_CONTENT_TYPE.test(contType!)\n}\n\nexport const isEligibleRequest = (req: Request): boolean => {\n  try {\n    return hasBody(req) && hasAcceptableMethod(req) && hasAcceptableContentType(req)\n  } catch (ignore) {\n    return false\n  }\n}\n"],"names":["ACCEPTABLE_CONTENT_TYPE","UNACCEPTABLE_METHODS","Set","hasBody","req","contentLength","headers","get","Boolean","body","hasAcceptableMethod","has","method","hasAcceptableContentType","contType","includes","test","isEligibleRequest","ignore"],"mappings":"AAAA,wFAAwF;AACxF,MAAMA,0BAA0B;AAChC,MAAMC,uBAAuB,IAAIC,IAAI;IAAC;IAAW;IAAU;IAAO;IAAQ;IAAW;CAAQ;AAE7F,MAAMC,UAAU,CAACC;IACf,MAAMC,gBAAgBD,IAAIE,OAAO,CAACC,GAAG,CAAC;IAEtC,OAAOC,QACLJ,IAAIK,IAAI,IAAIL,IAAIE,OAAO,CAACC,GAAG,CAAC,wBAAyBF,iBAAiBA,kBAAkB;AAE5F;AAEA,MAAMK,sBAAsB,CAACN,MAA0B,CAACH,qBAAqBU,GAAG,CAACP,IAAIQ,MAAM;AAE3F,MAAMC,2BAA2B,CAACT;IAChC,MAAMU,WAAWV,IAAIE,OAAO,CAACC,GAAG,CAAC;IACjC,OAAOO,SAAUC,QAAQ,CAAC,gBAAgBf,wBAAwBgB,IAAI,CAACF;AACzE;AAEA,OAAO,MAAMG,oBAAoB,CAACb;IAChC,IAAI;QACF,OAAOD,QAAQC,QAAQM,oBAAoBN,QAAQS,yBAAyBT;IAC9E,EAAE,OAAOc,QAAQ;QACf,OAAO;IACT;AACF,EAAC"}
+{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/isEligibleRequest.ts"],"sourcesContent":["const ACCEPTABLE_CONTENT_TYPE =\n  /multipart\\/[\\w'\"()+,./:<=>?@[\\\\\\]^-]+(?:; ?[\\w'\"()+,./:<=>?@[\\\\\\]^-]*)+$/i\nconst UNACCEPTABLE_METHODS = new Set(['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'TRACE'])\n\nconst hasBody = (req: Request): boolean => {\n  const contentLength = req.headers.get('content-length')\n\n  return Boolean(\n    req.body || req.headers.get('transfer-encoding') || (contentLength && contentLength !== '0'),\n  )\n}\n\nconst hasAcceptableMethod = (req: Request): boolean => !UNACCEPTABLE_METHODS.has(req.method)\n\nconst hasAcceptableContentType = (req: Request): boolean => {\n  const contType = req.headers.get('content-type')\n  return contType!.includes('boundary=') && ACCEPTABLE_CONTENT_TYPE.test(contType!)\n}\n\nexport const isEligibleRequest = (req: Request): boolean => {\n  try {\n    return hasBody(req) && hasAcceptableMethod(req) && hasAcceptableContentType(req)\n  } catch (ignore) {\n    return false\n  }\n}\n"],"names":["ACCEPTABLE_CONTENT_TYPE","UNACCEPTABLE_METHODS","Set","hasBody","req","contentLength","headers","get","Boolean","body","hasAcceptableMethod","has","method","hasAcceptableContentType","contType","includes","test","isEligibleRequest","ignore"],"mappings":"AAAA,MAAMA,0BACJ;AACF,MAAMC,uBAAuB,IAAIC,IAAI;IAAC;IAAW;IAAU;IAAO;IAAQ;IAAW;CAAQ;AAE7F,MAAMC,UAAU,CAACC;IACf,MAAMC,gBAAgBD,IAAIE,OAAO,CAACC,GAAG,CAAC;IAEtC,OAAOC,QACLJ,IAAIK,IAAI,IAAIL,IAAIE,OAAO,CAACC,GAAG,CAAC,wBAAyBF,iBAAiBA,kBAAkB;AAE5F;AAEA,MAAMK,sBAAsB,CAACN,MAA0B,CAACH,qBAAqBU,GAAG,CAACP,IAAIQ,MAAM;AAE3F,MAAMC,2BAA2B,CAACT;IAChC,MAAMU,WAAWV,IAAIE,OAAO,CAACC,GAAG,CAAC;IACjC,OAAOO,SAAUC,QAAQ,CAAC,gBAAgBf,wBAAwBgB,IAAI,CAACF;AACzE;AAEA,OAAO,MAAMG,oBAAoB,CAACb;IAChC,IAAI;QACF,OAAOD,QAAQC,QAAQM,oBAAoBN,QAAQS,yBAAyBT;IAC9E,EAAE,OAAOc,QAAQ;QACf,OAAO;IACT;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,gBA6N9B,CAAA"}
+{"version":3,"file":"processMultipart.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/processMultipart.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAU5D,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

@@ -1,175 +1,191 @@
 import Busboy from 'busboy';
-import { status as httpStatus } from 'http-status';
 import { APIError } from '../../errors/APIError.js';
+import { httpStatus } from '../../utilities/httpStatus.js';
 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;
-    });
-    // Busboy rejects these from a stream event before the awaits below attach, so
-    // Node reports them as unhandled and kills the process on oversize uploads.
-    allFilesComplete.catch(()=>{});
-    const busboyFinished = new Promise((resolve, reject)=>{
-        busboyFinishedResolve = resolve;
-        busboyFinishedReject = reject;
-    });
-    busboyFinished.catch(()=>{});
+    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  // Busboy rejects these from a stream event before the awaits below attach, so\n  // Node reports them as unhandled and kills the process on oversize uploads.\n  allFilesComplete.catch(() => {})\n\n  const busboyFinished = new Promise<void>((resolve, reject) => {\n    busboyFinishedResolve = resolve\n    busboyFinishedReject = reject\n  })\n\n  busboyFinished.catch(() => {})\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","catch","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","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'\n\nimport type { FetchAPIFileUploadOptions } from '../../config/types.js'\nimport type { FetchAPIFileUploadResponse } from './index.js'\n\nimport { APIError } from '../../errors/APIError.js'\nimport { httpStatus } from '../../utilities/httpStatus.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","APIError","httpStatus","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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"}

package/dist/uploads/fetchAPI-stream-file/index.d.ts

@@ -1,5 +1,8 @@
 import fs from 'fs';
-export declare function iteratorToStream(iterator: AsyncIterator<Uint8Array>): import("stream/web").ReadableStream<any>;
+export declare function iteratorToStream({ iterator, onCancel, }: {
+    iterator: AsyncIterator<Uint8Array>;
+    onCancel?: () => void;
+}): import("stream/web").ReadableStream<any>;
 export declare function nodeStreamToIterator(stream: fs.ReadStream): AsyncGenerator<Uint8Array<any>, void, unknown>;
 export declare function streamFile({ filePath, options, }: {
     filePath: string;

package/dist/uploads/fetchAPI-stream-file/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-stream-file/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAA;AAEnB,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,4CAWnE;AAED,wBAAuB,oBAAoB,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,kDAIhE;AAED,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,OAAO,GACR,EAAE;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAC3C,GAAG,cAAc,CAIjB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-stream-file/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,CAAA;AAEnB,wBAAgB,gBAAgB,CAAC,EAC/B,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IACnC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;CACtB,4CAcA;AAED,wBAAuB,oBAAoB,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,kDAIhE;AAED,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,OAAO,GACR,EAAE;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAC3C,GAAG,cAAc,CAQjB"}

package/dist/uploads/fetchAPI-stream-file/index.js

@@ -1,6 +1,9 @@
 import fs from 'fs';
-export function iteratorToStream(iterator) {
+export function iteratorToStream({ iterator, onCancel }) {
     return new ReadableStream({
+        cancel () {
+            onCancel?.();
+        },
         async pull (controller) {
             const { done, value } = await iterator.next();
             if (done) {
@@ -18,7 +21,11 @@ export async function* nodeStreamToIterator(stream) {
 }
 export function streamFile({ filePath, options }) {
     const nodeStream = fs.createReadStream(filePath, options);
-    const data = iteratorToStream(nodeStreamToIterator(nodeStream));
+    // Destroying the read stream on cancel releases the file handle, even if nothing was read yet.
+    const data = iteratorToStream({
+        iterator: nodeStreamToIterator(nodeStream),
+        onCancel: ()=>nodeStream.destroy()
+    });
     return data;
 }
 

package/dist/uploads/fetchAPI-stream-file/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/uploads/fetchAPI-stream-file/index.ts"],"sourcesContent":["import fs from 'fs'\n\nexport function iteratorToStream(iterator: AsyncIterator<Uint8Array>) {\n  return new ReadableStream({\n    async pull(controller) {\n      const { done, value } = await iterator.next()\n      if (done) {\n        controller.close()\n      } else {\n        controller.enqueue(value)\n      }\n    },\n  })\n}\n\nexport async function* nodeStreamToIterator(stream: fs.ReadStream) {\n  for await (const chunk of stream) {\n    yield new Uint8Array(chunk)\n  }\n}\n\nexport function streamFile({\n  filePath,\n  options,\n}: {\n  filePath: string\n  options?: { end?: number; start?: number }\n}): ReadableStream {\n  const nodeStream = fs.createReadStream(filePath, options)\n  const data: ReadableStream = iteratorToStream(nodeStreamToIterator(nodeStream))\n  return data\n}\n"],"names":["fs","iteratorToStream","iterator","ReadableStream","pull","controller","done","value","next","close","enqueue","nodeStreamToIterator","stream","chunk","Uint8Array","streamFile","filePath","options","nodeStream","createReadStream","data"],"mappings":"AAAA,OAAOA,QAAQ,KAAI;AAEnB,OAAO,SAASC,iBAAiBC,QAAmC;IAClE,OAAO,IAAIC,eAAe;QACxB,MAAMC,MAAKC,UAAU;YACnB,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAG,MAAML,SAASM,IAAI;YAC3C,IAAIF,MAAM;gBACRD,WAAWI,KAAK;YAClB,OAAO;gBACLJ,WAAWK,OAAO,CAACH;YACrB;QACF;IACF;AACF;AAEA,OAAO,gBAAgBI,qBAAqBC,MAAqB;IAC/D,WAAW,MAAMC,SAASD,OAAQ;QAChC,MAAM,IAAIE,WAAWD;IACvB;AACF;AAEA,OAAO,SAASE,WAAW,EACzBC,QAAQ,EACRC,OAAO,EAIR;IACC,MAAMC,aAAalB,GAAGmB,gBAAgB,CAACH,UAAUC;IACjD,MAAMG,OAAuBnB,iBAAiBU,qBAAqBO;IACnE,OAAOE;AACT"}
+{"version":3,"sources":["../../../src/uploads/fetchAPI-stream-file/index.ts"],"sourcesContent":["import fs from 'fs'\n\nexport function iteratorToStream({\n  iterator,\n  onCancel,\n}: {\n  iterator: AsyncIterator<Uint8Array>\n  onCancel?: () => void\n}) {\n  return new ReadableStream({\n    cancel() {\n      onCancel?.()\n    },\n    async pull(controller) {\n      const { done, value } = await iterator.next()\n      if (done) {\n        controller.close()\n      } else {\n        controller.enqueue(value)\n      }\n    },\n  })\n}\n\nexport async function* nodeStreamToIterator(stream: fs.ReadStream) {\n  for await (const chunk of stream) {\n    yield new Uint8Array(chunk)\n  }\n}\n\nexport function streamFile({\n  filePath,\n  options,\n}: {\n  filePath: string\n  options?: { end?: number; start?: number }\n}): ReadableStream {\n  const nodeStream = fs.createReadStream(filePath, options)\n  // Destroying the read stream on cancel releases the file handle, even if nothing was read yet.\n  const data: ReadableStream = iteratorToStream({\n    iterator: nodeStreamToIterator(nodeStream),\n    onCancel: () => nodeStream.destroy(),\n  })\n  return data\n}\n"],"names":["fs","iteratorToStream","iterator","onCancel","ReadableStream","cancel","pull","controller","done","value","next","close","enqueue","nodeStreamToIterator","stream","chunk","Uint8Array","streamFile","filePath","options","nodeStream","createReadStream","data","destroy"],"mappings":"AAAA,OAAOA,QAAQ,KAAI;AAEnB,OAAO,SAASC,iBAAiB,EAC/BC,QAAQ,EACRC,QAAQ,EAIT;IACC,OAAO,IAAIC,eAAe;QACxBC;YACEF;QACF;QACA,MAAMG,MAAKC,UAAU;YACnB,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAG,MAAMP,SAASQ,IAAI;YAC3C,IAAIF,MAAM;gBACRD,WAAWI,KAAK;YAClB,OAAO;gBACLJ,WAAWK,OAAO,CAACH;YACrB;QACF;IACF;AACF;AAEA,OAAO,gBAAgBI,qBAAqBC,MAAqB;IAC/D,WAAW,MAAMC,SAASD,OAAQ;QAChC,MAAM,IAAIE,WAAWD;IACvB;AACF;AAEA,OAAO,SAASE,WAAW,EACzBC,QAAQ,EACRC,OAAO,EAIR;IACC,MAAMC,aAAapB,GAAGqB,gBAAgB,CAACH,UAAUC;IACjD,+FAA+F;IAC/F,MAAMG,OAAuBrB,iBAAiB;QAC5CC,UAAUW,qBAAqBO;QAC/BjB,UAAU,IAAMiB,WAAWG,OAAO;IACpC;IACA,OAAOD;AACT"}

package/dist/uploads/fetchWithRedirects.d.ts

@@ -0,0 +1,19 @@
+import type { AllowList, UploadConfig } from './types.js';
+export declare const parseFileURL: (url: string, base?: URL) => URL;
+/**
+ * Fetches a file, checking each redirect against the allow list and SSRF restrictions.
+ * Returns the unread response so callers can either stream it or buffer it into a Payload File.
+ * Callers enforce any initial URL restrictions; existing uploads may also use same-origin URLs.
+ */
+export declare const fetchWithRedirects: ({ allowList, getHeaders, headers, skipSafeFetch, timeout, url, }: {
+    allowList?: AllowList;
+    getHeaders?: (url: string) => Record<string, string>;
+    headers?: Record<string, string>;
+    skipSafeFetch?: UploadConfig['skipSafeFetch'];
+    timeout?: number;
+    url: string;
+}) => Promise<{
+    response: Response;
+    url: string;
+}>;
+//# sourceMappingURL=fetchWithRedirects.d.ts.map

package/dist/uploads/fetchWithRedirects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchWithRedirects.d.ts","sourceRoot":"","sources":["../../src/uploads/fetchWithRedirects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAMzD,eAAO,MAAM,YAAY,QAAS,MAAM,SAAS,GAAG,KAAG,GAgBtD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,qEAO5B;IACD,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,aAAa,CAAC,EAAE,YAAY,CAAC,eAAe,CAAC,CAAA;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;CACZ,KAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAqC9C,CAAA"}