payload 4.0.0-internal.cd69eef → 4.0.0-internal.ce66a41

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/uploads/fetchWithRedirects.d.ts

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

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

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

package/dist/uploads/fetchWithRedirects.js

@@ -0,0 +1,53 @@
+import { APIError } from '../errors/APIError.js';
+import { isURLAllowed } from '../utilities/isURLAllowed.js';
+import { safeFetch } from './safeFetch.js';
+export const parseFileURL = (url, base)=>{
+    try {
+        const parsedURL = new URL(url, base);
+        if (parsedURL.protocol !== 'http:' && parsedURL.protocol !== 'https:') {
+            throw new APIError('External file URLs must use HTTP or HTTPS.', 400);
+        }
+        return parsedURL;
+    } catch (error) {
+        if (error instanceof APIError) {
+            throw error;
+        }
+        throw new APIError('Invalid external file URL.', 400);
+    }
+};
+/**
+ * Fetches a file, checking each redirect against the allow list and SSRF restrictions.
+ * Returns the unread response so callers can either stream it or buffer it into a Payload File.
+ * Callers enforce any initial URL restrictions; existing uploads may also use same-origin URLs.
+ */ export const fetchWithRedirects = async ({ allowList, getHeaders, headers, skipSafeFetch, timeout, url })=>{
+    const maxRedirects = 3;
+    for(let redirectCount = 0;; redirectCount++){
+        // Explicitly allowed URLs may point to private hosts, such as an internal CDN.
+        const shouldSkipSafeFetch = skipSafeFetch === true || Array.isArray(skipSafeFetch) && isURLAllowed(url, skipSafeFetch) || allowList && isURLAllowed(url, allowList);
+        const response = await (shouldSkipSafeFetch ? fetch : safeFetch)(url, {
+            credentials: 'include',
+            headers: getHeaders ? getHeaders(url) : headers,
+            redirect: 'manual',
+            signal: timeout ? AbortSignal.timeout(timeout) : undefined
+        });
+        if (response.status >= 300 && response.status < 400) {
+            if (redirectCount >= maxRedirects) {
+                throw new APIError(`Too many redirects (max ${maxRedirects})`, 403);
+            }
+            const location = response.headers.get('location');
+            if (location) {
+                url = parseFileURL(location, parseFileURL(url)).href;
+                if (allowList && !isURLAllowed(url, allowList)) {
+                    throw new APIError('Redirect target is not allowed.', 400);
+                }
+                continue;
+            }
+        }
+        return {
+            response,
+            url
+        };
+    }
+};
+
+//# sourceMappingURL=fetchWithRedirects.js.map

package/dist/uploads/fetchWithRedirects.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/fetchWithRedirects.ts"],"sourcesContent":["import type { AllowList, UploadConfig } from './types.js'\n\nimport { APIError } from '../errors/APIError.js'\nimport { isURLAllowed } from '../utilities/isURLAllowed.js'\nimport { safeFetch } from './safeFetch.js'\n\nexport const parseFileURL = (url: string, base?: URL): URL => {\n  try {\n    const parsedURL = new URL(url, base)\n\n    if (parsedURL.protocol !== 'http:' && parsedURL.protocol !== 'https:') {\n      throw new APIError('External file URLs must use HTTP or HTTPS.', 400)\n    }\n\n    return parsedURL\n  } catch (error) {\n    if (error instanceof APIError) {\n      throw error\n    }\n\n    throw new APIError('Invalid external file URL.', 400)\n  }\n}\n\n/**\n * Fetches a file, checking each redirect against the allow list and SSRF restrictions.\n * Returns the unread response so callers can either stream it or buffer it into a Payload File.\n * Callers enforce any initial URL restrictions; existing uploads may also use same-origin URLs.\n */\nexport const fetchWithRedirects = async ({\n  allowList,\n  getHeaders,\n  headers,\n  skipSafeFetch,\n  timeout,\n  url,\n}: {\n  allowList?: AllowList\n  getHeaders?: (url: string) => Record<string, string>\n  headers?: Record<string, string>\n  skipSafeFetch?: UploadConfig['skipSafeFetch']\n  timeout?: number\n  url: string\n}): Promise<{ response: Response; url: string }> => {\n  const maxRedirects = 3\n\n  for (let redirectCount = 0; ; redirectCount++) {\n    // Explicitly allowed URLs may point to private hosts, such as an internal CDN.\n    const shouldSkipSafeFetch =\n      skipSafeFetch === true ||\n      (Array.isArray(skipSafeFetch) && isURLAllowed(url, skipSafeFetch)) ||\n      (allowList && isURLAllowed(url, allowList))\n\n    const response = await (shouldSkipSafeFetch ? fetch : safeFetch)(url, {\n      credentials: 'include',\n      headers: getHeaders ? getHeaders(url) : headers,\n      redirect: 'manual',\n      signal: timeout ? AbortSignal.timeout(timeout) : undefined,\n    })\n\n    if (response.status >= 300 && response.status < 400) {\n      if (redirectCount >= maxRedirects) {\n        throw new APIError(`Too many redirects (max ${maxRedirects})`, 403)\n      }\n\n      const location = response.headers.get('location')\n\n      if (location) {\n        url = parseFileURL(location, parseFileURL(url)).href\n\n        if (allowList && !isURLAllowed(url, allowList)) {\n          throw new APIError('Redirect target is not allowed.', 400)\n        }\n\n        continue\n      }\n    }\n\n    return { response, url }\n  }\n}\n"],"names":["APIError","isURLAllowed","safeFetch","parseFileURL","url","base","parsedURL","URL","protocol","error","fetchWithRedirects","allowList","getHeaders","headers","skipSafeFetch","timeout","maxRedirects","redirectCount","shouldSkipSafeFetch","Array","isArray","response","fetch","credentials","redirect","signal","AbortSignal","undefined","status","location","get","href"],"mappings":"AAEA,SAASA,QAAQ,QAAQ,wBAAuB;AAChD,SAASC,YAAY,QAAQ,+BAA8B;AAC3D,SAASC,SAAS,QAAQ,iBAAgB;AAE1C,OAAO,MAAMC,eAAe,CAACC,KAAaC;IACxC,IAAI;QACF,MAAMC,YAAY,IAAIC,IAAIH,KAAKC;QAE/B,IAAIC,UAAUE,QAAQ,KAAK,WAAWF,UAAUE,QAAQ,KAAK,UAAU;YACrE,MAAM,IAAIR,SAAS,8CAA8C;QACnE;QAEA,OAAOM;IACT,EAAE,OAAOG,OAAO;QACd,IAAIA,iBAAiBT,UAAU;YAC7B,MAAMS;QACR;QAEA,MAAM,IAAIT,SAAS,8BAA8B;IACnD;AACF,EAAC;AAED;;;;CAIC,GACD,OAAO,MAAMU,qBAAqB,OAAO,EACvCC,SAAS,EACTC,UAAU,EACVC,OAAO,EACPC,aAAa,EACbC,OAAO,EACPX,GAAG,EAQJ;IACC,MAAMY,eAAe;IAErB,IAAK,IAAIC,gBAAgB,IAAKA,gBAAiB;QAC7C,+EAA+E;QAC/E,MAAMC,sBACJJ,kBAAkB,QACjBK,MAAMC,OAAO,CAACN,kBAAkBb,aAAaG,KAAKU,kBAClDH,aAAaV,aAAaG,KAAKO;QAElC,MAAMU,WAAW,MAAM,AAACH,CAAAA,sBAAsBI,QAAQpB,SAAQ,EAAGE,KAAK;YACpEmB,aAAa;YACbV,SAASD,aAAaA,WAAWR,OAAOS;YACxCW,UAAU;YACVC,QAAQV,UAAUW,YAAYX,OAAO,CAACA,WAAWY;QACnD;QAEA,IAAIN,SAASO,MAAM,IAAI,OAAOP,SAASO,MAAM,GAAG,KAAK;YACnD,IAAIX,iBAAiBD,cAAc;gBACjC,MAAM,IAAIhB,SAAS,CAAC,wBAAwB,EAAEgB,aAAa,CAAC,CAAC,EAAE;YACjE;YAEA,MAAMa,WAAWR,SAASR,OAAO,CAACiB,GAAG,CAAC;YAEtC,IAAID,UAAU;gBACZzB,MAAMD,aAAa0B,UAAU1B,aAAaC,MAAM2B,IAAI;gBAEpD,IAAIpB,aAAa,CAACV,aAAaG,KAAKO,YAAY;oBAC9C,MAAM,IAAIX,SAAS,mCAAmC;gBACxD;gBAEA;YACF;QACF;QAEA,OAAO;YAAEqB;YAAUjB;QAAI;IACzB;AACF,EAAC"}

package/dist/uploads/generateFileData.d.ts

@@ -1,12 +1,14 @@
 import type { Collection } from '../collections/config/types.js';
 import type { SanitizedConfig } from '../config/types.js';
 import type { PayloadRequest } from '../types/index.js';
+import type { ExternalUploadSource } from './sanitizeUploadData.js';
 import type { FileToSave } from './types.js';
 type Args<T> = {
     collection: Collection;
     config: SanitizedConfig;
     data: T;
     draft?: boolean;
+    externalUploadSource?: ExternalUploadSource;
     isDuplicating?: boolean;
     operation: 'create' | 'update';
     originalDoc?: T;
@@ -18,6 +20,34 @@ type Result<T> = Promise<{
     data: T;
     files: FileToSave[];
 }>;
-export declare const generateFileData: <T>({ collection: { config: collectionConfig }, data, draft, isDuplicating, operation, originalDoc, overwriteExistingFiles, req, throwOnMissingFile, }: Args<T>) => Result<T>;
+export type TempFileHandling = {
+    sourcePath: string;
+    type: 'copyFromTempFile';
+} | {
+    type: 'skip';
+} | {
+    type: 'useBuffer';
+};
+/**
+ * Decides how to get a file's bytes onto disk when no transformer rewrote it (a transformed
+ * file is already an in-memory buffer, so it always takes the `useBuffer` path). Copies straight
+ * from the temp file when possible, rather than reading a potentially large temp file into memory
+ * just to write it back out - see the `generateFileData` function doc for why.
+ */
+export declare const resolveTempFileHandling: ({ disableLocalStorage, hasProcessedBuffer, tempFilePath, }: {
+    disableLocalStorage: boolean;
+    hasProcessedBuffer: boolean;
+    tempFilePath: string | undefined;
+}) => TempFileHandling;
+/**
+ * Builds the document's file metadata and the list of files to write to disk.
+ *
+ * A large client upload may arrive as a temp file instead of an in-memory buffer (see
+ * getFileFromUploadInstructions.ts), and `file.data` can hold only a partial probe rather than
+ * the full file. To avoid loading such files into memory unnecessarily, no transformer runs
+ * unless the full bytes are available, this skips reading a temp file entirely when local
+ * storage is disabled, and copies it straight to its destination when local storage is enabled.
+ */
+export declare const generateFileData: <T>({ collection: { config: collectionConfig }, data, draft, externalUploadSource, isDuplicating, operation, originalDoc, overwriteExistingFiles, req, throwOnMissingFile, }: Args<T>) => Result<T>;
 export {};
 //# sourceMappingURL=generateFileData.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generateFileData.d.ts","sourceRoot":"","sources":["../../src/uploads/generateFileData.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,KAAK,EAAY,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACjE,OAAO,KAAK,EAAY,UAAU,EAAgC,MAAM,YAAY,CAAA;AAcpF,KAAK,IAAI,CAAC,CAAC,IAAI;IACb,UAAU,EAAE,UAAU,CAAA;IACtB,MAAM,EAAE,eAAe,CAAA;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC9B,WAAW,CAAC,EAAE,CAAC,CAAA;IACf,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,GAAG,EAAE,cAAc,CAAA;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,KAAK,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB,CAAC,CAAA;AA6BF,eAAO,MAAM,gBAAgB,GAAU,CAAC,sJAUrC,IAAI,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CAmWpB,CAAA"}
+{"version":3,"file":"generateFileData.d.ts","sourceRoot":"","sources":["../../src/uploads/generateFileData.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,KAAK,EAAY,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAEnE,OAAO,KAAK,EAAuB,UAAU,EAAe,MAAM,YAAY,CAAA;AAsB9E,KAAK,IAAI,CAAC,CAAC,IAAI;IACb,UAAU,EAAE,UAAU,CAAA;IACtB,MAAM,EAAE,eAAe,CAAA;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,oBAAoB,CAAC,EAAE,oBAAoB,CAAA;IAC3C,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC9B,WAAW,CAAC,EAAE,CAAC,CAAA;IACf,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,GAAG,EAAE,cAAc,CAAA;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,KAAK,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB,CAAC,CAAA;AA6BF,MAAM,MAAM,gBAAgB,GACxB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAA;AAEzB;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,+DAIjC;IACD,mBAAmB,EAAE,OAAO,CAAA;IAC5B,kBAAkB,EAAE,OAAO,CAAA;IAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,CAAA;CACjC,KAAG,gBAQH,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAU,CAAC,4KAWrC,IAAI,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CA4ZpB,CAAA"}