@payloadcms/next 3.0.0-canary.3ab8665 → 3.0.0-canary.3eda767

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/fetchAPI-multipart/fileFactory.ts"],"sourcesContent":["import type { FetchAPIFileUploadOptions, 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"],"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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,SACEA,eAAe,EACfC,QAAQ,EACRC,MAAM,EACNC,QAAQ,EACRC,eAAe,EACfC,gBAAgB,QACX,iBAAgB;AAQvB;;;CAGC,GACD,MAAMC,eAAyB,CAACC,UAAUC,SAASC,oBAAsB,CAACC,SAASC;QACjFV,SAASQ,mBAAmB,CAAC,sBAAsB,EAAED,QAAQI,YAAY,CAAC,IAAI,EAAEL,SAAS,CAAC;QAC1FJ,SAASK,QAAQI,YAAY,EAAEL,UAAUH,gBAAgBM,SAASC;IACpE;AAEA;;;CAGC,GACD,MAAME,iBAA2B,CAACN,UAAUC,SAASC,oBAAsB,CAACC,SAASC;QACnFV,SAASQ,mBAAmB,CAAC,0BAA0B,EAAEF,SAAS,CAAC;QACnEF,iBAAiBG,QAAQM,MAAM,EAAEP,UAAUH,gBAAgBM,SAASC;IACtE;AAgBA,OAAO,MAAMI,cAA2B,CAACP,SAASC;IAChD,qEAAqE;IACrE,oEAAoE;IACpE,mFAAmF;IACnF,yEAAyE;IAEzE,iCAAiC;IACjC,OAAO;QACLO,MAAMR,QAAQQ,IAAI;QAClBC,MAAMT,QAAQM,MAAM;QACpBI,UAAUV,QAAQU,QAAQ;QAC1BC,KAAKX,QAAQY,IAAI;QACjBC,UAAUb,QAAQa,QAAQ;QAC1BC,IAAI,CAACf,UAAkBgB;YACrB,iCAAiC;YACjC,MAAMC,WAAWf,kBAAkBgB,YAAY,GAC3CnB,aAAaC,UAAUC,SAASC,qBAChCI,eAAeN,UAAUC,SAASC;YACtC,8BAA8B;YAC9BT,gBAAgBS,mBAAmBF;YACnC,8EAA8E;YAC9E,MAAMmB,gBAAgB,IAAMC;YAC5B,OAAOzB,OAAOqB,YAAYC,SAASD,UAAUG,iBAAiB,IAAIE,QAAQJ;QAC5E;QACAK,MAAMrB,QAAQqB,IAAI;QAClBjB,cAAcJ,QAAQI,YAAY;QAClCkB,WAAWtB,QAAQsB,SAAS;IAC9B;AACF,EAAC"}
+{"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/fetchAPI-multipart/handlers.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/handlers.ts"],"names":[],"mappings":";AAIA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAI3D,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,OAsD7B,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,OAgCxB,CAAA"}
+{"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

@@ -2,85 +2,86 @@ 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);
-        });
+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
-    };
+  });
+  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)
-    };
+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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/fetchAPI-multipart/handlers.ts"],"sourcesContent":["import crypto from 'crypto'\nimport fs, { WriteStream } from 'fs'\nimport path from 'path'\n\nimport type { FetchAPIFileUploadOptions } from './index.js'\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) writeStream.end()\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"],"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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,OAAOA,YAAY,SAAQ;AAC3B,OAAOC,MAAMC,WAAW,QAAQ,KAAI;AACpC,OAAOC,UAAU,OAAM;AAIvB,SAASC,eAAe,EAAEC,QAAQ,EAAEC,UAAU,EAAEC,eAAe,QAAQ,iBAAgB;AAgBvF,OAAO,MAAMC,kBAA2B,CAACC,SAASC,WAAWC;IAC3D,MAAMC,MAAMT,KAAKU,SAAS,CAACJ,QAAQK,WAAW;IAC9C,MAAMC,eAAeZ,KAAKa,IAAI,CAACC,QAAQC,GAAG,IAAIN,KAAKL;IACnDH,gBAAgB;QAAEe,kBAAkB;IAAK,GAAGJ;IAE5CV,SAASI,SAAS,CAAC,uBAAuB,EAAEM,aAAa,CAAC;IAE1D,MAAMK,OAAOpB,OAAOqB,UAAU,CAAC;IAC/B,IAAIC,WAAW;IACf,IAAIC,YAAY;IAEhBlB,SAASI,SAAS,CAAC,yBAAyB,EAAEC,UAAU,EAAE,EAAEC,SAAS,GAAG,CAAC;IACzE,MAAMa,cAAcvB,GAAGwB,iBAAiB,CAACV;IACzC,MAAMW,eAAe,IAAIC,QAAiB,CAACC,SAASC;QAClDL,YAAYM,EAAE,CAAC,UAAU,IAAMF,QAAQ;QACvCJ,YAAYM,EAAE,CAAC,SAAS,CAACC;YACvB1B,SAASI,SAAS,CAAC,uBAAuB,EAAEsB,IAAI,CAAC;YACjDF,OAAOE;QACT;IACF;IAEA,OAAO;QACLC,SAAS;YACPT,YAAY;YACZlB,SAASI,SAAS,CAAC,2BAA2B,EAAEM,aAAa,GAAG,CAAC;YACjES,YAAYS,GAAG;YACf3B,WAAWS,cAAc,CAACgB,MACxBA,MACI1B,SAASI,SAAS,CAAC,2BAA2B,EAAEM,aAAa,SAAS,EAAEgB,IAAI,CAAC,IAC7E1B,SAASI,SAAS,CAAC,2BAA2B,EAAEM,aAAa,MAAM,CAAC;QAE5E;QACAmB,UAAU;YACRX,YAAY;YACZlB,SAASI,SAAS,CAAC,OAAO,EAAEC,UAAU,EAAE,EAAEC,SAAS,kBAAkB,EAAEW,SAAS,CAAC,CAAC;YAClF,IAAIE,uBAAuBtB,aAAasB,YAAYS,GAAG;YACvD,8DAA8D;YAC9D,OAAOE,OAAOC,MAAM,CAAC,EAAE;QACzB;QACAC,aAAa,CAACC;YACZ,IAAIf,cAAc,MAAM;gBACtBlB,SAASI,SAAS,CAAC,WAAW,EAAEC,UAAU,EAAE,EAAEC,SAAS,iCAAiC,CAAC;gBACzF;YACF;YACAa,YAAYe,KAAK,CAACD;YAClBlB,KAAKoB,MAAM,CAACF;YACZhB,YAAYgB,KAAKG,MAAM;YACvBpC,SAASI,SAAS,CAAC,UAAU,EAAEC,UAAU,EAAE,EAAEC,SAAS,QAAQ,EAAEW,SAAS,GAAG,CAAC;QAC/E;QACAoB,aAAa,IAAM3B;QACnB4B,aAAa,IAAMrB;QACnBsB,SAAS,IAAMxB,KAAKyB,MAAM,CAAC;QAC3BC,iBAAiB,IAAMpB;IACzB;AACF,EAAC;AAED,OAAO,MAAMqB,aAAsB,CAACtC,SAASC,WAAWC;IACtD,MAAMqC,UAAoB,EAAE;IAC5B,MAAM5B,OAAOpB,OAAOqB,UAAU,CAAC;IAC/B,IAAIC,WAAW;IACf,IAAIC,YAAY;IAEhB,MAAM0B,YAAY,IAAMd,OAAOC,MAAM,CAACY,SAAS1B;IAE/C,OAAO;QACLU,SAAS;YACPT,YAAY;QACd;QACAW,UAAU;YACR7B,SAASI,SAAS,CAAC,OAAO,EAAEC,UAAU,EAAE,EAAEC,SAAS,kBAAkB,EAAEW,SAAS,CAAC,CAAC;YAClFC,YAAY;YACZ,OAAO0B;QACT;QACAZ,aAAa,CAACC;YACZ,IAAIf,cAAc,MAAM;gBACtBlB,SAASI,SAAS,CAAC,WAAW,EAAEC,UAAU,EAAE,EAAEC,SAAS,iCAAiC,CAAC;gBACzF;YACF;YACAqC,QAAQE,IAAI,CAACZ;YACblB,KAAKoB,MAAM,CAACF;YACZhB,YAAYgB,KAAKG,MAAM;YACvBpC,SAASI,SAAS,CAAC,UAAU,EAAEC,UAAU,EAAE,EAAEC,SAAS,QAAQ,EAAEW,SAAS,GAAG,CAAC;QAC/E;QACAoB,aAAa,IAAM;QACnBC,aAAa,IAAMrB;QACnBsB,SAAS,IAAMxB,KAAKyB,MAAM,CAAC;QAC3BC,iBAAiB,IAAMnB,QAAQC,OAAO,CAAC;IACzC;AACF,EAAC"}
+{"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

@@ -1,6 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-import type { BusboyConfig } from 'busboy';
-import { APIError } from 'payload/errors';
+import type { FetchAPIFileUploadOptions } from 'payload';
+import { APIError } from 'payload';
 export type FileShape = {
     data: Buffer;
     encoding: string;
@@ -12,106 +11,6 @@ export type FileShape = {
     tempFilePath: string;
     truncated: boolean;
 };
-export type FetchAPIFileUploadOptions = {
-    /**
-     * Returns a HTTP 413 when the file is bigger than the size limit if `true`.
-     * Otherwise, it will add a `truncated = true` to the resulting file structure.
-     * @default false
-     */
-    abortOnLimit?: boolean | undefined;
-    /**
-     * Automatically creates the directory path specified in `.mv(filePathName)`
-     * @default false
-     */
-    createParentPath?: boolean | undefined;
-    /**
-     * Turn on/off upload process logging. Can be useful for troubleshooting.
-     * @default false
-     */
-    debug?: boolean | undefined;
-    /**
-     * User defined limit handler which will be invoked if the file is bigger than configured limits.
-     * @default false
-     */
-    limitHandler?: ((args: {
-        request: Request;
-        size: number;
-    }) => void) | boolean | undefined;
-    /**
-     * By default, `req.body` and `req.files` are flattened like this:
-     * `{'name': 'John', 'hobbies[0]': 'Cinema', 'hobbies[1]': 'Bike'}
-     *
-     * When this option is enabled they are parsed in order to be nested like this:
-     * `{'name': 'John', 'hobbies': ['Cinema', 'Bike']}`
-     * @default false
-     */
-    parseNested?: boolean | undefined;
-    /**
-     * Preserves filename extension when using `safeFileNames` option.
-     * If set to `true`, will default to an extension length of `3`.
-     * If set to `number`, this will be the max allowable extension length.
-     * If an extension is smaller than the extension length, it remains untouched. If the extension is longer,
-     * it is shifted.
-     * @default false
-     *
-     * @example
-     * // true
-     * app.use(fileUpload({ safeFileNames: true, preserveExtension: true }));
-     * // myFileName.ext --> myFileName.ext
-     *
-     * @example
-     * // max extension length 2, extension shifted
-     * app.use(fileUpload({ safeFileNames: true, preserveExtension: 2 }));
-     * // myFileName.ext --> myFileNamee.xt
-     */
-    preserveExtension?: boolean | number | undefined;
-    /**
-     * Response which will be send to client if file size limit exceeded when `abortOnLimit` set to `true`.
-     * @default 'File size limit has been reached'
-     */
-    responseOnLimit?: string | undefined;
-    /**
-     * Strips characters from the upload's filename.
-     * You can use custom regex to determine what to strip.
-     * If set to `true`, non-alphanumeric characters _except_ dashes and underscores will be stripped.
-     * This option is off by default.
-     * @default false
-     *
-     * @example
-     * // strip slashes from file names
-     * app.use(fileUpload({ safeFileNames: /\\/g }))
-     *
-     * @example
-     * app.use(fileUpload({ safeFileNames: true }))
-     */
-    safeFileNames?: RegExp | boolean | undefined;
-    /**
-     * Path to store temporary files.
-     * Used along with the `useTempFiles` option. By default this module uses `'tmp'` folder
-     * in the current working directory.
-     * You can use trailing slash, but it is not necessary.
-     * @default './tmp'
-     */
-    tempFileDir?: string | undefined;
-    /**
-     * This defines how long to wait for data before aborting. Set to `0` if you want to turn off timeout checks.
-     * @default 60_000
-     */
-    uploadTimeout?: number | undefined;
-    /**
-     * Applies uri decoding to file names if set `true`.
-     * @default false
-     */
-    uriDecodeFileNames?: boolean | undefined;
-    /**
-     * By default this module uploads files into RAM.
-     * Setting this option to `true` turns on using temporary files instead of utilising RAM.
-     * This avoids memory overflow issues when uploading large files or in case of uploading
-     * lots of files at same time.
-     * @default false
-     */
-    useTempFiles?: boolean | undefined;
-} & Partial<BusboyConfig>;
 type FetchAPIFileUploadResponseFile = {
     data: Buffer;
     mimetype: string;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/index.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAG1C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAsBzC,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,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAClC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACtC;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC,GAAG,OAAO,GAAG,SAAS,CAAA;IACzF;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACjC;;;;;;;;;;;;;;;;;OAiBG;IACH,iBAAiB,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAA;IAChD;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACpC;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAA;IAC5C;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACxC;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CACnC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;AAEzB,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"}
+{"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

@@ -1,41 +1,43 @@
 import path from 'path';
-import { APIError } from 'payload/errors';
+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,
-    fileHandler: false,
-    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
+  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
+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
     };
-    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
-        });
-    }
+  } else {
+    return processMultipart({
+      options: uploadOptions,
+      request
+    });
+  }
 };
-
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/fetchAPI-multipart/index.ts"],"sourcesContent":["import type { BusboyConfig } from 'busboy'\n\nimport path from 'path'\nimport { APIError } from 'payload/errors'\n\nimport { isEligibleRequest } from './isEligibleRequest.js'\nimport { processMultipart } from './processMultipart.js'\nimport { debugLog } from './utilities.js'\n\nconst DEFAULT_OPTIONS = {\n  abortOnLimit: false,\n  createParentPath: false,\n  debug: false,\n  fileHandler: false,\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\nexport type FetchAPIFileUploadOptions = {\n  /**\n   * Returns a HTTP 413 when the file is bigger than the size limit if `true`.\n   * Otherwise, it will add a `truncated = true` to the resulting file structure.\n   * @default false\n   */\n  abortOnLimit?: boolean | undefined\n  /**\n   * Automatically creates the directory path specified in `.mv(filePathName)`\n   * @default false\n   */\n  createParentPath?: boolean | undefined\n  /**\n   * Turn on/off upload process logging. Can be useful for troubleshooting.\n   * @default false\n   */\n  debug?: boolean | undefined\n  /**\n   * User defined limit handler which will be invoked if the file is bigger than configured limits.\n   * @default false\n   */\n  limitHandler?: ((args: { request: Request; size: number }) => void) | boolean | undefined\n  /**\n   * By default, `req.body` and `req.files` are flattened like this:\n   * `{'name': 'John', 'hobbies[0]': 'Cinema', 'hobbies[1]': 'Bike'}\n   *\n   * When this option is enabled they are parsed in order to be nested like this:\n   * `{'name': 'John', 'hobbies': ['Cinema', 'Bike']}`\n   * @default false\n   */\n  parseNested?: boolean | undefined\n  /**\n   * Preserves filename extension when using `safeFileNames` option.\n   * If set to `true`, will default to an extension length of `3`.\n   * If set to `number`, this will be the max allowable extension length.\n   * If an extension is smaller than the extension length, it remains untouched. If the extension is longer,\n   * it is shifted.\n   * @default false\n   *\n   * @example\n   * // true\n   * app.use(fileUpload({ safeFileNames: true, preserveExtension: true }));\n   * // myFileName.ext --> myFileName.ext\n   *\n   * @example\n   * // max extension length 2, extension shifted\n   * app.use(fileUpload({ safeFileNames: true, preserveExtension: 2 }));\n   * // myFileName.ext --> myFileNamee.xt\n   */\n  preserveExtension?: boolean | number | undefined\n  /**\n   * Response which will be send to client if file size limit exceeded when `abortOnLimit` set to `true`.\n   * @default 'File size limit has been reached'\n   */\n  responseOnLimit?: string | undefined\n  /**\n   * Strips characters from the upload's filename.\n   * You can use custom regex to determine what to strip.\n   * If set to `true`, non-alphanumeric characters _except_ dashes and underscores will be stripped.\n   * This option is off by default.\n   * @default false\n   *\n   * @example\n   * // strip slashes from file names\n   * app.use(fileUpload({ safeFileNames: /\\\\/g }))\n   *\n   * @example\n   * app.use(fileUpload({ safeFileNames: true }))\n   */\n  safeFileNames?: RegExp | boolean | undefined\n  /**\n   * Path to store temporary files.\n   * Used along with the `useTempFiles` option. By default this module uses `'tmp'` folder\n   * in the current working directory.\n   * You can use trailing slash, but it is not necessary.\n   * @default './tmp'\n   */\n  tempFileDir?: string | undefined\n  /**\n   * This defines how long to wait for data before aborting. Set to `0` if you want to turn off timeout checks.\n   * @default 60_000\n   */\n  uploadTimeout?: number | undefined\n  /**\n   * Applies uri decoding to file names if set `true`.\n   * @default false\n   */\n  uriDecodeFileNames?: boolean | undefined\n  /**\n   * By default this module uploads files into RAM.\n   * Setting this option to `true` turns on using temporary files instead of utilising RAM.\n   * This avoids memory overflow issues when uploading large files or in case of uploading\n   * lots of files at same time.\n   * @default false\n   */\n  useTempFiles?: boolean | undefined\n} & Partial<BusboyConfig>\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"],"names":["path","APIError","isEligibleRequest","processMultipart","debugLog","DEFAULT_OPTIONS","abortOnLimit","createParentPath","debug","fileHandler","limitHandler","parseNested","preserveExtension","responseOnLimit","safeFileNames","tempFileDir","join","process","cwd","uploadTimeout","uriDecodeFileNames","useTempFiles","fetchAPIFileUpload","options","request","uploadOptions","error","fields","undefined","files"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAOA,UAAU,OAAM;AACvB,SAASC,QAAQ,QAAQ,iBAAgB;AAEzC,SAASC,iBAAiB,QAAQ,yBAAwB;AAC1D,SAASC,gBAAgB,QAAQ,wBAAuB;AACxD,SAASC,QAAQ,QAAQ,iBAAgB;AAEzC,MAAMC,kBAAkB;IACtBC,cAAc;IACdC,kBAAkB;IAClBC,OAAO;IACPC,aAAa;IACbC,cAAc;IACdC,aAAa;IACbC,mBAAmB;IACnBC,iBAAiB;IACjBC,eAAe;IACfC,aAAaf,KAAKgB,IAAI,CAACC,QAAQC,GAAG,IAAI;IACtCC,eAAe;IACfC,oBAAoB;IACpBC,cAAc;AAChB;AAkIA,OAAO,MAAMC,qBAAyC,OAAO,EAAEC,OAAO,EAAEC,OAAO,EAAE;IAC/E,MAAMC,gBAA2C;QAAE,GAAGpB,eAAe;QAAE,GAAGkB,OAAO;IAAC;IAClF,IAAI,CAACrB,kBAAkBsB,UAAU;QAC/BpB,SAASqB,eAAe;QACxB,OAAO;YACLC,OAAO,IAAIzB,SAAS,2CAA2C;YAC/D0B,QAAQC;YACRC,OAAOD;QACT;IACF,OAAO;QACL,OAAOzB,iBAAiB;YAAEoB,SAASE;YAAeD;QAAQ;IAC5D;AACF,EAAC"}
+{"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.js

@@ -1,26 +1,18 @@
 const ACCEPTABLE_CONTENT_TYPE = /multipart\/['"()+-_]+(?:; ?['"()+-_]*)+$/i;
-const UNACCEPTABLE_METHODS = new Set([
-    'GET',
-    'HEAD',
-    'DELETE',
-    'OPTIONS',
-    'CONNECT',
-    'TRACE'
-]);
-const hasBody = (req)=>{
-    return Boolean(req.headers.get('transfer-encoding') || req.headers.get('content-length') && req.headers.get('content-length') !== '0');
+const UNACCEPTABLE_METHODS = new Set(['GET', 'HEAD', 'DELETE', 'OPTIONS', 'CONNECT', '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);
+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;
-    }
+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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/fetchAPI-multipart/isEligibleRequest.ts"],"sourcesContent":["const ACCEPTABLE_CONTENT_TYPE = /multipart\\/['\"()+-_]+(?:; ?['\"()+-_]*)+$/i\nconst UNACCEPTABLE_METHODS = new Set(['GET', 'HEAD', 'DELETE', 'OPTIONS', 'CONNECT', '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"],"names":["ACCEPTABLE_CONTENT_TYPE","UNACCEPTABLE_METHODS","Set","hasBody","req","Boolean","headers","get","hasAcceptableMethod","has","method","hasAcceptableContentType","contType","includes","test","isEligibleRequest","e"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,MAAMA,0BAA0B;AAChC,MAAMC,uBAAuB,IAAIC,IAAI;IAAC;IAAO;IAAQ;IAAU;IAAW;IAAW;CAAQ;AAE7F,MAAMC,UAAU,CAACC;IACf,OAAOC,QACLD,IAAIE,OAAO,CAACC,GAAG,CAAC,wBACbH,IAAIE,OAAO,CAACC,GAAG,CAAC,qBAAqBH,IAAIE,OAAO,CAACC,GAAG,CAAC,sBAAsB;AAElF;AAEA,MAAMC,sBAAsB,CAACJ,MAA0B,CAACH,qBAAqBQ,GAAG,CAACL,IAAIM,MAAM;AAE3F,MAAMC,2BAA2B,CAACP;IAChC,MAAMQ,WAAWR,IAAIE,OAAO,CAACC,GAAG,CAAC;IACjC,OAAOK,SAASC,QAAQ,CAAC,gBAAgBb,wBAAwBc,IAAI,CAACF;AACxE;AAEA,OAAO,MAAMG,oBAAoB,CAACX;IAChC,IAAI;QACF,OAAOD,QAAQC,QAAQI,oBAAoBJ,QAAQO,yBAAyBP;IAC9E,EAAE,OAAOY,GAAG;QACV,OAAO;IACT;AACF,EAAC"}
+{"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(['GET', 'HEAD', 'DELETE', 'OPTIONS', 'CONNECT', '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,OAAO,QAAQ,UAAU,WAAW,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

@@ -1,4 +1,5 @@
-import type { FetchAPIFileUploadOptions, FetchAPIFileUploadResponse } from './index.js';
+import type { FetchAPIFileUploadOptions } from 'payload';
+import type { FetchAPIFileUploadResponse } from './index.js';
 type ProcessMultipart = (args: {
     options: FetchAPIFileUploadOptions;
     request: Request;

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

@@ -1 +1 @@
-{"version":3,"file":"processMultipart.d.ts","sourceRoot":"","sources":["../../src/fetchAPI-multipart/processMultipart.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAUvF,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,gBAoM9B,CAAA"}
+{"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,gBAsM9B,CAAA"}