@payloadcms/next 3.0.0-beta.13 → 3.0.0-beta.130

package/dist/exports/utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/exports/utilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oDAAoD,CAAA;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAA;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAA;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA"}
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/exports/utilities.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAA;AACjF,OAAO,EAAE,2BAA2B,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAA;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAA;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/exports/utilities.js

@@ -1,7 +1,9 @@
-export { traverseFields } from '../utilities/buildFieldSchemaMap/traverseFields.js';
+// NOTICE: Server-only utilities, do not import anything client-side here.
+export { addDataAndFileToRequest } from '../utilities/addDataAndFileToRequest.js';
+export { addLocalesToRequestFromData, sanitizeLocales } from '../utilities/addLocalesToRequest.js';
 export { createPayloadRequest } from '../utilities/createPayloadRequest.js';
 export { getNextRequestI18n } from '../utilities/getNextRequestI18n.js';
 export { getPayloadHMR, reload } from '../utilities/getPayloadHMR.js';
 export { headersWithCors } from '../utilities/headersWithCors.js';
-
+export { mergeHeaders } from '../utilities/mergeHeaders.js';
 //# sourceMappingURL=utilities.js.map

package/dist/exports/utilities.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/exports/utilities.ts"],"sourcesContent":["export { traverseFields } from '../utilities/buildFieldSchemaMap/traverseFields.js'\nexport { createPayloadRequest } from '../utilities/createPayloadRequest.js'\nexport { getNextRequestI18n } from '../utilities/getNextRequestI18n.js'\nexport { getPayloadHMR, reload } from '../utilities/getPayloadHMR.js'\nexport { headersWithCors } from '../utilities/headersWithCors.js'\n"],"names":["traverseFields","createPayloadRequest","getNextRequestI18n","getPayloadHMR","reload","headersWithCors"],"rangeMappings":";;;;","mappings":"AAAA,SAASA,cAAc,QAAQ,qDAAoD;AACnF,SAASC,oBAAoB,QAAQ,uCAAsC;AAC3E,SAASC,kBAAkB,QAAQ,qCAAoC;AACvE,SAASC,aAAa,EAAEC,MAAM,QAAQ,gCAA+B;AACrE,SAASC,eAAe,QAAQ,kCAAiC"}
+{"version":3,"file":"utilities.js","names":["addDataAndFileToRequest","addLocalesToRequestFromData","sanitizeLocales","createPayloadRequest","getNextRequestI18n","getPayloadHMR","reload","headersWithCors","mergeHeaders"],"sources":["../../src/exports/utilities.ts"],"sourcesContent":["// NOTICE: Server-only utilities, do not import anything client-side here.\nexport { addDataAndFileToRequest } from '../utilities/addDataAndFileToRequest.js'\nexport { addLocalesToRequestFromData, sanitizeLocales } from '../utilities/addLocalesToRequest.js'\nexport { createPayloadRequest } from '../utilities/createPayloadRequest.js'\nexport { getNextRequestI18n } from '../utilities/getNextRequestI18n.js'\nexport { getPayloadHMR, reload } from '../utilities/getPayloadHMR.js'\nexport { headersWithCors } from '../utilities/headersWithCors.js'\nexport { mergeHeaders } from '../utilities/mergeHeaders.js'\n"],"mappings":"AAAA;AACA,SAASA,uBAAuB,QAAQ;AACxC,SAASC,2BAA2B,EAAEC,eAAe,QAAQ;AAC7D,SAASC,oBAAoB,QAAQ;AACrC,SAASC,kBAAkB,QAAQ;AACnC,SAASC,aAAa,EAAEC,MAAM,QAAQ;AACtC,SAASC,eAAe,QAAQ;AAChC,SAASC,YAAY,QAAQ","ignoreList":[]}

package/dist/exports/views.d.ts

@@ -1,4 +1,3 @@
-export { EditView } from '../views/Edit/index.js';
 export { NotFoundPage } from '../views/NotFound/index.js';
-export { type GenerateViewMetadata, RootPage, generatePageMetadata } from '../views/Root/index.js';
+export { generatePageMetadata, type GenerateViewMetadata, RootPage } from '../views/Root/index.js';
 //# sourceMappingURL=views.d.ts.map

package/dist/exports/views.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"views.d.ts","sourceRoot":"","sources":["../../src/exports/views.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,KAAK,oBAAoB,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA"}
+{"version":3,"file":"views.d.ts","sourceRoot":"","sources":["../../src/exports/views.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,oBAAoB,EAAE,KAAK,oBAAoB,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/exports/views.js

@@ -1,5 +1,3 @@
-export { EditView } from '../views/Edit/index.js';
 export { NotFoundPage } from '../views/NotFound/index.js';
-export { RootPage, generatePageMetadata } from '../views/Root/index.js';
-
+export { generatePageMetadata, RootPage } from '../views/Root/index.js';
 //# sourceMappingURL=views.js.map

package/dist/exports/views.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/exports/views.ts"],"sourcesContent":["export { EditView } from '../views/Edit/index.js'\nexport { NotFoundPage } from '../views/NotFound/index.js'\nexport { type GenerateViewMetadata, RootPage, generatePageMetadata } from '../views/Root/index.js'\n"],"names":["EditView","NotFoundPage","RootPage","generatePageMetadata"],"rangeMappings":";;","mappings":"AAAA,SAASA,QAAQ,QAAQ,yBAAwB;AACjD,SAASC,YAAY,QAAQ,6BAA4B;AACzD,SAAoCC,QAAQ,EAAEC,oBAAoB,QAAQ,yBAAwB"}
+{"version":3,"file":"views.js","names":["NotFoundPage","generatePageMetadata","RootPage"],"sources":["../../src/exports/views.ts"],"sourcesContent":["export { NotFoundPage } from '../views/NotFound/index.js'\nexport { generatePageMetadata, type GenerateViewMetadata, RootPage } from '../views/Root/index.js'\n"],"mappings":"AAAA,SAASA,YAAY,QAAQ;AAC7B,SAASC,oBAAoB,EAA6BC,QAAQ,QAAQ","ignoreList":[]}

package/dist/{next-fileupload → fetchAPI-multipart}/fileFactory.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-import type { FileShape, NextFileUploadOptions } from './index.js';
+import type { FetchAPIFileUploadOptions } from 'payload';
+import type { FileShape } from './index.js';
 type FileFactoryOptions = {
     buffer: Buffer;
     encoding: string;
@@ -10,7 +10,7 @@ type FileFactoryOptions = {
     tempFilePath: string;
     truncated: boolean;
 };
-type FileFactory = (options: FileFactoryOptions, fileUploadOptions: NextFileUploadOptions) => FileShape;
+type FileFactory = (options: FileFactoryOptions, fileUploadOptions: FetchAPIFileUploadOptions) => FileShape;
 export declare const fileFactory: FileFactory;
 export {};
 //# sourceMappingURL=fileFactory.d.ts.map

package/dist/fetchAPI-multipart/fileFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileFactory.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/fileFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAmC3C,KAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AACD,KAAK,WAAW,GAAG,CACjB,OAAO,EAAE,kBAAkB,EAC3B,iBAAiB,EAAE,yBAAyB,KACzC,SAAS,CAAA;AACd,eAAO,MAAM,WAAW,EAAE,WA4BzB,CAAA"}

package/dist/fetchAPI-multipart/fileFactory.js

@@ -0,0 +1,44 @@
+import { checkAndMakeDir, debugLog, isFunc, moveFile, promiseCallback, saveBufferToFile } from './utilities.js';
+/**
+ * Returns Local function that moves the file to a different location on the filesystem
+ * which takes two function arguments to make it compatible w/ Promise or Callback APIs
+ */
+const moveFromTemp = (filePath, options, fileUploadOptions) => (resolve, reject) => {
+  debugLog(fileUploadOptions, `Moving temporary file ${options.tempFilePath} to ${filePath}`);
+  moveFile(options.tempFilePath, filePath, promiseCallback(resolve, reject));
+};
+/**
+ * Returns Local function that moves the file from buffer to a different location on the filesystem
+ * which takes two function arguments to make it compatible w/ Promise or Callback APIs
+ */
+const moveFromBuffer = (filePath, options, fileUploadOptions) => (resolve, reject) => {
+  debugLog(fileUploadOptions, `Moving uploaded buffer to ${filePath}`);
+  saveBufferToFile(options.buffer, filePath, promiseCallback(resolve, reject));
+};
+export const fileFactory = (options, fileUploadOptions) => {
+  // see: https://github.com/richardgirges/express-fileupload/issues/14
+  // firefox uploads empty file in case of cache miss when f5ing page.
+  // resulting in unexpected behavior. if there is no file data, the file is invalid.
+  // if (!fileUploadOptions.useTempFiles && !options.buffer.length) return;
+  // Create and return file object.
+  return {
+    name: options.name,
+    data: options.buffer,
+    encoding: options.encoding,
+    md5: options.hash,
+    mimetype: options.mimetype,
+    mv: (filePath, callback) => {
+      // Define a proper move function.
+      const moveFunc = fileUploadOptions.useTempFiles ? moveFromTemp(filePath, options, fileUploadOptions) : moveFromBuffer(filePath, options, fileUploadOptions);
+      // Create a folder for a file.
+      checkAndMakeDir(fileUploadOptions, filePath);
+      // If callback is passed in, use the callback API, otherwise return a promise.
+      const defaultReject = () => undefined;
+      return isFunc(callback) ? moveFunc(callback, defaultReject) : new Promise(moveFunc);
+    },
+    size: options.size,
+    tempFilePath: options.tempFilePath,
+    truncated: options.truncated
+  };
+};
+//# sourceMappingURL=fileFactory.js.map

package/dist/fetchAPI-multipart/fileFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileFactory.js","names":["checkAndMakeDir","debugLog","isFunc","moveFile","promiseCallback","saveBufferToFile","moveFromTemp","filePath","options","fileUploadOptions","resolve","reject","tempFilePath","moveFromBuffer","buffer","fileFactory","name","data","encoding","md5","hash","mimetype","mv","callback","moveFunc","useTempFiles","defaultReject","undefined","Promise","size","truncated"],"sources":["../../src/fetchAPI-multipart/fileFactory.ts"],"sourcesContent":["import type { FetchAPIFileUploadOptions } from 'payload'\n\nimport type { FileShape } from './index.js'\n\nimport {\n  checkAndMakeDir,\n  debugLog,\n  isFunc,\n  moveFile,\n  promiseCallback,\n  saveBufferToFile,\n} from './utilities.js'\n\ntype MoveFile = (\n  filePath: string,\n  options: FileFactoryOptions,\n  fileUploadOptions: FetchAPIFileUploadOptions,\n) => (resolve: () => void, reject: () => void) => void\n\n/**\n * Returns Local function that moves the file to a different location on the filesystem\n * which takes two function arguments to make it compatible w/ Promise or Callback APIs\n */\nconst moveFromTemp: MoveFile = (filePath, options, fileUploadOptions) => (resolve, reject) => {\n  debugLog(fileUploadOptions, `Moving temporary file ${options.tempFilePath} to ${filePath}`)\n  moveFile(options.tempFilePath, filePath, promiseCallback(resolve, reject))\n}\n\n/**\n * Returns Local function that moves the file from buffer to a different location on the filesystem\n * which takes two function arguments to make it compatible w/ Promise or Callback APIs\n */\nconst moveFromBuffer: MoveFile = (filePath, options, fileUploadOptions) => (resolve, reject) => {\n  debugLog(fileUploadOptions, `Moving uploaded buffer to ${filePath}`)\n  saveBufferToFile(options.buffer, filePath, promiseCallback(resolve, reject))\n}\n\ntype FileFactoryOptions = {\n  buffer: Buffer\n  encoding: string\n  hash: Buffer | string\n  mimetype: string\n  name: string\n  size: number\n  tempFilePath: string\n  truncated: boolean\n}\ntype FileFactory = (\n  options: FileFactoryOptions,\n  fileUploadOptions: FetchAPIFileUploadOptions,\n) => FileShape\nexport const fileFactory: FileFactory = (options, fileUploadOptions) => {\n  // see: https://github.com/richardgirges/express-fileupload/issues/14\n  // firefox uploads empty file in case of cache miss when f5ing page.\n  // resulting in unexpected behavior. if there is no file data, the file is invalid.\n  // if (!fileUploadOptions.useTempFiles && !options.buffer.length) return;\n\n  // Create and return file object.\n  return {\n    name: options.name,\n    data: options.buffer,\n    encoding: options.encoding,\n    md5: options.hash,\n    mimetype: options.mimetype,\n    mv: (filePath: string, callback) => {\n      // Define a proper move function.\n      const moveFunc = fileUploadOptions.useTempFiles\n        ? moveFromTemp(filePath, options, fileUploadOptions)\n        : moveFromBuffer(filePath, options, fileUploadOptions)\n      // Create a folder for a file.\n      checkAndMakeDir(fileUploadOptions, filePath)\n      // If callback is passed in, use the callback API, otherwise return a promise.\n      const defaultReject = () => undefined\n      return isFunc(callback) ? moveFunc(callback, defaultReject) : new Promise(moveFunc)\n    },\n    size: options.size,\n    tempFilePath: options.tempFilePath,\n    truncated: options.truncated,\n  }\n}\n"],"mappings":"AAIA,SACEA,eAAe,EACfC,QAAQ,EACRC,MAAM,EACNC,QAAQ,EACRC,eAAe,EACfC,gBAAgB,QACX;AAQP;;;;AAIA,MAAMC,YAAA,GAAyBA,CAACC,QAAA,EAAUC,OAAA,EAASC,iBAAA,KAAsB,CAACC,OAAA,EAASC,MAAA;EACjFV,QAAA,CAASQ,iBAAA,EAAmB,yBAAyBD,OAAA,CAAQI,YAAY,OAAOL,QAAA,EAAU;EAC1FJ,QAAA,CAASK,OAAA,CAAQI,YAAY,EAAEL,QAAA,EAAUH,eAAA,CAAgBM,OAAA,EAASC,MAAA;AACpE;AAEA;;;;AAIA,MAAME,cAAA,GAA2BA,CAACN,QAAA,EAAUC,OAAA,EAASC,iBAAA,KAAsB,CAACC,OAAA,EAASC,MAAA;EACnFV,QAAA,CAASQ,iBAAA,EAAmB,6BAA6BF,QAAA,EAAU;EACnEF,gBAAA,CAAiBG,OAAA,CAAQM,MAAM,EAAEP,QAAA,EAAUH,eAAA,CAAgBM,OAAA,EAASC,MAAA;AACtE;AAgBA,OAAO,MAAMI,WAAA,GAA2BA,CAACP,OAAA,EAASC,iBAAA;EAChD;EACA;EACA;EACA;EAEA;EACA,OAAO;IACLO,IAAA,EAAMR,OAAA,CAAQQ,IAAI;IAClBC,IAAA,EAAMT,OAAA,CAAQM,MAAM;IACpBI,QAAA,EAAUV,OAAA,CAAQU,QAAQ;IAC1BC,GAAA,EAAKX,OAAA,CAAQY,IAAI;IACjBC,QAAA,EAAUb,OAAA,CAAQa,QAAQ;IAC1BC,EAAA,EAAIA,CAACf,QAAA,EAAkBgB,QAAA;MACrB;MACA,MAAMC,QAAA,GAAWf,iBAAA,CAAkBgB,YAAY,GAC3CnB,YAAA,CAAaC,QAAA,EAAUC,OAAA,EAASC,iBAAA,IAChCI,cAAA,CAAeN,QAAA,EAAUC,OAAA,EAASC,iBAAA;MACtC;MACAT,eAAA,CAAgBS,iBAAA,EAAmBF,QAAA;MACnC;MACA,MAAMmB,aAAA,GAAgBA,CAAA,KAAMC,SAAA;MAC5B,OAAOzB,MAAA,CAAOqB,QAAA,IAAYC,QAAA,CAASD,QAAA,EAAUG,aAAA,IAAiB,IAAIE,OAAA,CAAQJ,QAAA;IAC5E;IACAK,IAAA,EAAMrB,OAAA,CAAQqB,IAAI;IAClBjB,YAAA,EAAcJ,OAAA,CAAQI,YAAY;IAClCkB,SAAA,EAAWtB,OAAA,CAAQsB;EACrB;AACF","ignoreList":[]}

package/dist/{next-fileupload → fetchAPI-multipart}/handlers.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-import type { NextFileUploadOptions } from './index.js';
-type Handler = (options: NextFileUploadOptions, fieldname: string, filename: string) => {
+import type { FetchAPIFileUploadOptions } from 'payload';
+type Handler = (options: FetchAPIFileUploadOptions, fieldname: string, filename: string) => {
     cleanup: () => void;
     complete: () => Buffer;
     dataHandler: (data: Buffer) => void;

package/dist/fetchAPI-multipart/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AAQxD,KAAK,OAAO,GAAG,CACb,OAAO,EAAE,yBAAyB,EAClC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,KACb;IACH,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,QAAQ,EAAE,MAAM,MAAM,CAAA;IACtB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,OAAO,EAAE,MAAM,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,OAwD7B,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,OAgCxB,CAAA"}

package/dist/fetchAPI-multipart/handlers.js

@@ -0,0 +1,87 @@
+import crypto from 'crypto';
+import fs, { WriteStream } from 'fs';
+import path from 'path';
+import { checkAndMakeDir, debugLog, deleteFile, getTempFilename } from './utilities.js';
+export const tempFileHandler = (options, fieldname, filename) => {
+  const dir = path.normalize(options.tempFileDir);
+  const tempFilePath = path.join(process.cwd(), dir, getTempFilename());
+  checkAndMakeDir({
+    createParentPath: true
+  }, tempFilePath);
+  debugLog(options, `Temporary file path is ${tempFilePath}`);
+  const hash = crypto.createHash('md5');
+  let fileSize = 0;
+  let completed = false;
+  debugLog(options, `Opening write stream for ${fieldname}->${filename}...`);
+  const writeStream = fs.createWriteStream(tempFilePath);
+  const writePromise = new Promise((resolve, reject) => {
+    writeStream.on('finish', () => resolve(true));
+    writeStream.on('error', err => {
+      debugLog(options, `Error write temp file: ${err}`);
+      reject(err);
+    });
+  });
+  return {
+    cleanup: () => {
+      completed = true;
+      debugLog(options, `Cleaning up temporary file ${tempFilePath}...`);
+      writeStream.end();
+      deleteFile(tempFilePath, err => err ? debugLog(options, `Cleaning up temporary file ${tempFilePath} failed: ${err}`) : debugLog(options, `Cleaning up temporary file ${tempFilePath} done.`));
+    },
+    complete: () => {
+      completed = true;
+      debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`);
+      if (writeStream instanceof WriteStream) {
+        writeStream.end();
+      }
+      // Return empty buff since data was uploaded into a temp file.
+      return Buffer.concat([]);
+    },
+    dataHandler: data => {
+      if (completed === true) {
+        debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`);
+        return;
+      }
+      writeStream.write(data);
+      hash.update(data);
+      fileSize += data.length;
+      debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`);
+    },
+    getFilePath: () => tempFilePath,
+    getFileSize: () => fileSize,
+    getHash: () => hash.digest('hex'),
+    getWritePromise: () => writePromise
+  };
+};
+export const memHandler = (options, fieldname, filename) => {
+  const buffers = [];
+  const hash = crypto.createHash('md5');
+  let fileSize = 0;
+  let completed = false;
+  const getBuffer = () => Buffer.concat(buffers, fileSize);
+  return {
+    cleanup: () => {
+      completed = true;
+    },
+    complete: () => {
+      debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`);
+      completed = true;
+      return getBuffer();
+    },
+    dataHandler: data => {
+      if (completed === true) {
+        debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`);
+        return;
+      }
+      buffers.push(data);
+      hash.update(data);
+      fileSize += data.length;
+      debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`);
+    },
+    getFilePath: () => '',
+    getFileSize: () => fileSize,
+    getHash: () => hash.digest('hex'),
+    getWritePromise: () => Promise.resolve(true)
+  };
+};
+//# sourceMappingURL=handlers.js.map

package/dist/fetchAPI-multipart/handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.js","names":["crypto","fs","WriteStream","path","checkAndMakeDir","debugLog","deleteFile","getTempFilename","tempFileHandler","options","fieldname","filename","dir","normalize","tempFileDir","tempFilePath","join","process","cwd","createParentPath","hash","createHash","fileSize","completed","writeStream","createWriteStream","writePromise","Promise","resolve","reject","on","err","cleanup","end","complete","Buffer","concat","dataHandler","data","write","update","length","getFilePath","getFileSize","getHash","digest","getWritePromise","memHandler","buffers","getBuffer","push"],"sources":["../../src/fetchAPI-multipart/handlers.ts"],"sourcesContent":["import type { FetchAPIFileUploadOptions } from 'payload'\n\nimport crypto from 'crypto'\nimport fs, { WriteStream } from 'fs'\nimport path from 'path'\n\nimport { checkAndMakeDir, debugLog, deleteFile, getTempFilename } from './utilities.js'\n\ntype Handler = (\n  options: FetchAPIFileUploadOptions,\n  fieldname: string,\n  filename: string,\n) => {\n  cleanup: () => void\n  complete: () => Buffer\n  dataHandler: (data: Buffer) => void\n  getFilePath: () => string\n  getFileSize: () => number\n  getHash: () => string\n  getWritePromise: () => Promise<boolean>\n}\n\nexport const tempFileHandler: Handler = (options, fieldname, filename) => {\n  const dir = path.normalize(options.tempFileDir)\n  const tempFilePath = path.join(process.cwd(), dir, getTempFilename())\n  checkAndMakeDir({ createParentPath: true }, tempFilePath)\n\n  debugLog(options, `Temporary file path is ${tempFilePath}`)\n\n  const hash = crypto.createHash('md5')\n  let fileSize = 0\n  let completed = false\n\n  debugLog(options, `Opening write stream for ${fieldname}->${filename}...`)\n  const writeStream = fs.createWriteStream(tempFilePath)\n  const writePromise = new Promise<boolean>((resolve, reject) => {\n    writeStream.on('finish', () => resolve(true))\n    writeStream.on('error', (err) => {\n      debugLog(options, `Error write temp file: ${err}`)\n      reject(err)\n    })\n  })\n\n  return {\n    cleanup: () => {\n      completed = true\n      debugLog(options, `Cleaning up temporary file ${tempFilePath}...`)\n      writeStream.end()\n      deleteFile(tempFilePath, (err) =>\n        err\n          ? debugLog(options, `Cleaning up temporary file ${tempFilePath} failed: ${err}`)\n          : debugLog(options, `Cleaning up temporary file ${tempFilePath} done.`),\n      )\n    },\n    complete: () => {\n      completed = true\n      debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`)\n      if (writeStream instanceof WriteStream) {\n        writeStream.end()\n      }\n      // Return empty buff since data was uploaded into a temp file.\n      return Buffer.concat([])\n    },\n    dataHandler: (data) => {\n      if (completed === true) {\n        debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`)\n        return\n      }\n      writeStream.write(data)\n      hash.update(data)\n      fileSize += data.length\n      debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`)\n    },\n    getFilePath: () => tempFilePath,\n    getFileSize: () => fileSize,\n    getHash: () => hash.digest('hex'),\n    getWritePromise: () => writePromise,\n  }\n}\n\nexport const memHandler: Handler = (options, fieldname, filename) => {\n  const buffers: Buffer[] = []\n  const hash = crypto.createHash('md5')\n  let fileSize = 0\n  let completed = false\n\n  const getBuffer = () => Buffer.concat(buffers, fileSize)\n\n  return {\n    cleanup: () => {\n      completed = true\n    },\n    complete: () => {\n      debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`)\n      completed = true\n      return getBuffer()\n    },\n    dataHandler: (data) => {\n      if (completed === true) {\n        debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`)\n        return\n      }\n      buffers.push(data)\n      hash.update(data)\n      fileSize += data.length\n      debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`)\n    },\n    getFilePath: () => '',\n    getFileSize: () => fileSize,\n    getHash: () => hash.digest('hex'),\n    getWritePromise: () => Promise.resolve(true),\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/fetchAPI-multipart/index.d.ts

@@ -0,0 +1,32 @@
+import type { FetchAPIFileUploadOptions } from 'payload';
+import { APIError } from 'payload';
+export type FileShape = {
+    data: Buffer;
+    encoding: string;
+    md5: Buffer | string;
+    mimetype: string;
+    mv: (filePath: string, callback: () => void) => Promise<void> | void;
+    name: string;
+    size: number;
+    tempFilePath: string;
+    truncated: boolean;
+};
+type FetchAPIFileUploadResponseFile = {
+    data: Buffer;
+    mimetype: string;
+    name: string;
+    size: number;
+    tempFilePath?: string;
+};
+export type FetchAPIFileUploadResponse = {
+    error?: APIError;
+    fields: Record<string, string>;
+    files: Record<string, FetchAPIFileUploadResponseFile>;
+};
+type FetchAPIFileUpload = (args: {
+    options?: FetchAPIFileUploadOptions;
+    request: Request;
+}) => Promise<FetchAPIFileUploadResponse>;
+export declare const fetchAPIFileUpload: FetchAPIFileUpload;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/fetchAPI-multipart/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AAGxD,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAsBlC,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,EAAE,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,KAAK,8BAA8B,GAAG;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAA;CACtD,CAAA;AAED,KAAK,kBAAkB,GAAG,CAAC,IAAI,EAAE;IAC/B,OAAO,CAAC,EAAE,yBAAyB,CAAA;IACnC,OAAO,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAA;AACzC,eAAO,MAAM,kBAAkB,EAAE,kBAYhC,CAAA"}

package/dist/fetchAPI-multipart/index.js

@@ -0,0 +1,43 @@
+import path from 'path';
+import { APIError } from 'payload';
+import { isEligibleRequest } from './isEligibleRequest.js';
+import { processMultipart } from './processMultipart.js';
+import { debugLog } from './utilities.js';
+const DEFAULT_OPTIONS = {
+  abortOnLimit: false,
+  createParentPath: false,
+  debug: false,
+  defParamCharset: 'utf8',
+  limitHandler: false,
+  parseNested: false,
+  preserveExtension: false,
+  responseOnLimit: 'File size limit has been reached',
+  safeFileNames: false,
+  tempFileDir: path.join(process.cwd(), 'tmp'),
+  uploadTimeout: 60000,
+  uriDecodeFileNames: false,
+  useTempFiles: false
+};
+export const fetchAPIFileUpload = async ({
+  options,
+  request
+}) => {
+  const uploadOptions = {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+  if (!isEligibleRequest(request)) {
+    debugLog(uploadOptions, 'Request is not eligible for file upload!');
+    return {
+      error: new APIError('Request is not eligible for file upload', 500),
+      fields: undefined,
+      files: undefined
+    };
+  } else {
+    return processMultipart({
+      options: uploadOptions,
+      request
+    });
+  }
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["path","APIError","isEligibleRequest","processMultipart","debugLog","DEFAULT_OPTIONS","abortOnLimit","createParentPath","debug","defParamCharset","limitHandler","parseNested","preserveExtension","responseOnLimit","safeFileNames","tempFileDir","join","process","cwd","uploadTimeout","uriDecodeFileNames","useTempFiles","fetchAPIFileUpload","options","request","uploadOptions","error","fields","undefined","files"],"sources":["../../src/fetchAPI-multipart/index.ts"],"sourcesContent":["import type { FetchAPIFileUploadOptions } from 'payload'\n\nimport path from 'path'\nimport { APIError } from 'payload'\n\nimport { isEligibleRequest } from './isEligibleRequest.js'\nimport { processMultipart } from './processMultipart.js'\nimport { debugLog } from './utilities.js'\n\nconst DEFAULT_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: path.join(process.cwd(), 'tmp'),\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>\nexport const fetchAPIFileUpload: FetchAPIFileUpload = async ({ options, request }) => {\n  const uploadOptions: FetchAPIFileUploadOptions = { ...DEFAULT_OPTIONS, ...options }\n  if (!isEligibleRequest(request)) {\n    debugLog(uploadOptions, 'Request is not eligible for file upload!')\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: uploadOptions, request })\n  }\n}\n"],"mappings":"AAEA,OAAOA,IAAA,MAAU;AACjB,SAASC,QAAQ,QAAQ;AAEzB,SAASC,iBAAiB,QAAQ;AAClC,SAASC,gBAAgB,QAAQ;AACjC,SAASC,QAAQ,QAAQ;AAEzB,MAAMC,eAAA,GAA6C;EACjDC,YAAA,EAAc;EACdC,gBAAA,EAAkB;EAClBC,KAAA,EAAO;EACPC,eAAA,EAAiB;EACjBC,YAAA,EAAc;EACdC,WAAA,EAAa;EACbC,iBAAA,EAAmB;EACnBC,eAAA,EAAiB;EACjBC,aAAA,EAAe;EACfC,WAAA,EAAaf,IAAA,CAAKgB,IAAI,CAACC,OAAA,CAAQC,GAAG,IAAI;EACtCC,aAAA,EAAe;EACfC,kBAAA,EAAoB;EACpBC,YAAA,EAAc;AAChB;AAgCA,OAAO,MAAMC,kBAAA,GAAyC,MAAAA,CAAO;EAAEC,OAAO;EAAEC;AAAO,CAAE;EAC/E,MAAMC,aAAA,GAA2C;IAAE,GAAGpB,eAAe;IAAE,GAAGkB;EAAQ;EAClF,IAAI,CAACrB,iBAAA,CAAkBsB,OAAA,GAAU;IAC/BpB,QAAA,CAASqB,aAAA,EAAe;IACxB,OAAO;MACLC,KAAA,EAAO,IAAIzB,QAAA,CAAS,2CAA2C;MAC/D0B,MAAA,EAAQC,SAAA;MACRC,KAAA,EAAOD;IACT;EACF,OAAO;IACL,OAAOzB,gBAAA,CAAiB;MAAEoB,OAAA,EAASE,aAAA;MAAeD;IAAQ;EAC5D;AACF","ignoreList":[]}

package/dist/fetchAPI-multipart/isEligibleRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEligibleRequest.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/isEligibleRequest.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,iBAAiB,QAAS,OAAO,KAAG,OAMhD,CAAA"}

package/dist/fetchAPI-multipart/isEligibleRequest.js

@@ -0,0 +1,18 @@
+const ACCEPTABLE_CONTENT_TYPE = /multipart\/['"()+-_]+(?:; ?['"()+-_]*)+$/i;
+const UNACCEPTABLE_METHODS = new Set(['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'TRACE']);
+const hasBody = req => {
+  return Boolean(req.headers.get('transfer-encoding') || req.headers.get('content-length') && req.headers.get('content-length') !== '0');
+};
+const hasAcceptableMethod = req => !UNACCEPTABLE_METHODS.has(req.method);
+const hasAcceptableContentType = req => {
+  const contType = req.headers.get('content-type');
+  return contType.includes('boundary=') && ACCEPTABLE_CONTENT_TYPE.test(contType);
+};
+export const isEligibleRequest = req => {
+  try {
+    return hasBody(req) && hasAcceptableMethod(req) && hasAcceptableContentType(req);
+  } catch (e) {
+    return false;
+  }
+};
+//# sourceMappingURL=isEligibleRequest.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isEligibleRequest.js","names":["ACCEPTABLE_CONTENT_TYPE","UNACCEPTABLE_METHODS","Set","hasBody","req","Boolean","headers","get","hasAcceptableMethod","has","method","hasAcceptableContentType","contType","includes","test","isEligibleRequest","e"],"sources":["../../src/fetchAPI-multipart/isEligibleRequest.ts"],"sourcesContent":["const ACCEPTABLE_CONTENT_TYPE = /multipart\\/['\"()+-_]+(?:; ?['\"()+-_]*)+$/i\nconst UNACCEPTABLE_METHODS = new Set(['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'TRACE'])\n\nconst hasBody = (req: Request): boolean => {\n  return Boolean(\n    req.headers.get('transfer-encoding') ||\n      (req.headers.get('content-length') && req.headers.get('content-length') !== '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 (e) {\n    return false\n  }\n}\n"],"mappings":"AAAA,MAAMA,uBAAA,GAA0B;AAChC,MAAMC,oBAAA,GAAuB,IAAIC,GAAA,CAAI,CAAC,WAAW,UAAU,OAAO,QAAQ,WAAW,QAAQ;AAE7F,MAAMC,OAAA,GAAWC,GAAA;EACf,OAAOC,OAAA,CACLD,GAAA,CAAIE,OAAO,CAACC,GAAG,CAAC,wBACbH,GAAA,CAAIE,OAAO,CAACC,GAAG,CAAC,qBAAqBH,GAAA,CAAIE,OAAO,CAACC,GAAG,CAAC,sBAAsB;AAElF;AAEA,MAAMC,mBAAA,GAAuBJ,GAAA,IAA0B,CAACH,oBAAA,CAAqBQ,GAAG,CAACL,GAAA,CAAIM,MAAM;AAE3F,MAAMC,wBAAA,GAA4BP,GAAA;EAChC,MAAMQ,QAAA,GAAWR,GAAA,CAAIE,OAAO,CAACC,GAAG,CAAC;EACjC,OAAOK,QAAA,CAASC,QAAQ,CAAC,gBAAgBb,uBAAA,CAAwBc,IAAI,CAACF,QAAA;AACxE;AAEA,OAAO,MAAMG,iBAAA,GAAqBX,GAAA;EAChC,IAAI;IACF,OAAOD,OAAA,CAAQC,GAAA,KAAQI,mBAAA,CAAoBJ,GAAA,KAAQO,wBAAA,CAAyBP,GAAA;EAC9E,EAAE,OAAOY,CAAA,EAAG;IACV,OAAO;EACT;AACF","ignoreList":[]}

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

@@ -0,0 +1,9 @@
+import type { FetchAPIFileUploadOptions } from 'payload';
+import type { FetchAPIFileUploadResponse } from './index.js';
+type ProcessMultipart = (args: {
+    options: FetchAPIFileUploadOptions;
+    request: Request;
+}) => Promise<FetchAPIFileUploadResponse>;
+export declare const processMultipart: ProcessMultipart;
+export {};
+//# sourceMappingURL=processMultipart.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"processMultipart.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/processMultipart.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AAOxD,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;AACzC,eAAO,MAAM,gBAAgB,EAAE,gBAmM9B,CAAA"}

package/dist/fetchAPI-multipart/processMultipart.js

@@ -0,0 +1,178 @@
+import Busboy from 'busboy';
+import httpStatus from 'http-status';
+import { APIError } from 'payload';
+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');
+export const processMultipart = async ({
+  options,
+  request
+}) => {
+  let parsingRequest = true;
+  let shouldAbortProccessing = false;
+  let fileCount = 0;
+  let filesCompleted = 0;
+  let allFilesHaveResolved;
+  let failedResolvingFiles;
+  const allFilesComplete = new Promise((res, rej) => {
+    allFilesHaveResolved = res;
+    failedResolvingFiles = rej;
+  });
+  const result = {
+    fields: undefined,
+    files: undefined
+  };
+  const headersObject = {};
+  request.headers.forEach((value, name) => {
+    headersObject[name] = value;
+  });
+  const reader = request.body.getReader();
+  const busboy = Busboy({
+    ...options,
+    headers: headersObject
+  });
+  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);
+  });
+  // Build req.files fields
+  busboy.on('file', (field, file, info) => {
+    fileCount += 1;
+    // Parse file name(cutting huge names, decoding, etc..).
+    const {
+      encoding,
+      filename: name,
+      mimeType: mime
+    } = info;
+    const filename = parseFileName(options, name);
+    // 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(err => {
+      busboy.end();
+      cleanup();
+    }) : getWritePromise();
+    const uploadTimer = createUploadTimer(options.uploadTimeout, () => {
+      return abortAndDestroyFile(file, new APIError(`Upload timeout for ${field}->${filename}, bytes:${getFileSize()}`));
+    });
+    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()
+        }));
+      }
+    });
+    file.on('data', data => {
+      uploadTimer.set();
+      dataHandler(data);
+    });
+    file.on('end', () => {
+      const size = getFileSize();
+      debugLog(options, `Upload finished ${field}->${filename}, bytes:${size}`);
+      uploadTimer.clear();
+      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`);
+      }
+      filesCompleted += 1;
+      result.files = buildFields(result.files, field, fileFactory({
+        name: filename,
+        buffer: complete(),
+        encoding,
+        hash: getHash(),
+        mimetype: mime,
+        size,
+        tempFilePath: getFilePath(),
+        truncated: Boolean('truncated' in file && file.truncated) || false
+      }, 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();
+  });
+  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];
+        });
+      } catch (err) {
+        debugLog(options, `Error waiting for file write promises: ${err}`);
+      }
+    }
+    return result;
+  });
+  busboy.on('error', (err = new APIError('Busboy error parsing multipart request', httpStatus.BAD_REQUEST)) => {
+    debugLog(options, `Busboy error`);
+    throw err;
+  });
+  while (parsingRequest) {
+    const {
+      done,
+      value
+    } = await reader.read();
+    if (done) {
+      parsingRequest = false;
+    }
+    if (value && !shouldAbortProccessing) {
+      busboy.write(value);
+    }
+  }
+  if (fileCount !== 0) {
+    await allFilesComplete.catch(e => {
+      throw e;
+    });
+  }
+  return result;
+};
+//# sourceMappingURL=processMultipart.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"processMultipart.js","names":["Busboy","httpStatus","APIError","fileFactory","memHandler","tempFileHandler","processNested","createUploadTimer","buildFields","debugLog","isFunc","parseFileName","waitFlushProperty","Symbol","processMultipart","options","request","parsingRequest","shouldAbortProccessing","fileCount","filesCompleted","allFilesHaveResolved","failedResolvingFiles","allFilesComplete","Promise","res","rej","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","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","done","read","write","e"],"sources":["../../src/fetchAPI-multipart/processMultipart.ts"],"sourcesContent":["import type { FetchAPIFileUploadOptions } from 'payload'\nimport type { Readable } from 'stream'\n\nimport Busboy from 'busboy'\nimport httpStatus from 'http-status'\nimport { APIError } from 'payload'\n\nimport type { FetchAPIFileUploadResponse } from './index.js'\n\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\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\n  const allFilesComplete = new Promise((res, rej) => {\n    allFilesHaveResolved = res\n    failedResolvingFiles = rej\n  })\n\n  const result: FetchAPIFileUploadResponse = {\n    fields: undefined,\n    files: undefined,\n  }\n\n  const headersObject = {}\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    // 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((err) => {\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: mime,\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    return result\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      throw err\n    },\n  )\n\n  while (parsingRequest) {\n    const { done, value } = await reader.read()\n\n    if (done) {\n      parsingRequest = false\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  return result\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/fetchAPI-multipart/processNested.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processNested.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/processNested.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,oBAiCzB,CAAA"}