payload 4.0.0-internal.fa345ef → 4.0.0-internal.fec2230

package/dist/uploads/getFileContentRequirement.spec.js

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'vitest';
+import { getFileContentRequirement } from './getFileContentRequirement.js';
+const createUploadConfig = (overrides = {})=>({
+        disableLocalStorage: true,
+        staticDir: '/tmp/media',
+        ...overrides
+    });
+describe('getFileContentRequirement', ()=>{
+    it('requires the full file when local storage is enabled', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'video/mp4',
+            uploadConfig: createUploadConfig({
+                disableLocalStorage: false
+            })
+        })).toBe('full');
+    });
+    it('requires nothing for a non-image file with no mime type allow list', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'video/mp4',
+            uploadConfig: createUploadConfig()
+        })).toBe('none');
+    });
+    it('requires the full file when a mime type allow list is configured', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'video/mp4',
+            uploadConfig: createUploadConfig({
+                mimeTypes: [
+                    'video/*'
+                ]
+            })
+        })).toBe('full');
+    });
+    it('does not require content when allowRestrictedFileTypes bypasses the mime type check', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'video/mp4',
+            uploadConfig: createUploadConfig({
+                allowRestrictedFileTypes: true,
+                mimeTypes: [
+                    'video/*'
+                ]
+            })
+        })).toBe('none');
+    });
+    it('requires only the header for an image with no configured adjustments', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'image/png',
+            uploadConfig: createUploadConfig()
+        })).toBe('header');
+    });
+    it('requires the full file for an image with resize options configured', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'image/png',
+            uploadConfig: createUploadConfig({
+                resizeOptions: {
+                    width: 100
+                }
+            })
+        })).toBe('full');
+    });
+    it('requires the full file for an image with imageSizes configured, even with no other adjustments', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'image/png',
+            uploadConfig: createUploadConfig({
+                imageSizes: [
+                    {
+                        name: 'thumbnail',
+                        width: 100
+                    }
+                ]
+            })
+        })).toBe('full');
+    });
+    it('requires only the header for an image with an empty imageSizes array', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'image/png',
+            uploadConfig: createUploadConfig({
+                imageSizes: []
+            })
+        })).toBe('header');
+    });
+    it('requires the full file for an animated image even with no configured adjustments', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'image/gif',
+            uploadConfig: createUploadConfig()
+        })).toBe('full');
+    });
+    it('requires the full file when the request includes a crop edit, even with no configured adjustments', ()=>{
+        expect(getFileContentRequirement({
+            hasSizeEdits: true,
+            mimeType: 'image/png',
+            uploadConfig: createUploadConfig()
+        })).toBe('full');
+    });
+    it('requires only the header when the request has no size edits and no configured adjustments', ()=>{
+        expect(getFileContentRequirement({
+            hasSizeEdits: false,
+            mimeType: 'image/png',
+            uploadConfig: createUploadConfig()
+        })).toBe('header');
+    });
+    it('requires only the header for a non-resizable but recognized image type', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'image/svg+xml',
+            uploadConfig: createUploadConfig()
+        })).toBe('header');
+    });
+    it('requires the full file for an image when disableLocalStorage is not set', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'image/png',
+            uploadConfig: {
+                staticDir: '/tmp/media'
+            }
+        })).toBe('full');
+    });
+    it('requires the full file for a non-image type when disableLocalStorage is not set', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'video/mp4',
+            uploadConfig: {
+                staticDir: '/tmp/media'
+            }
+        })).toBe('full');
+    });
+});
+
+//# sourceMappingURL=getFileContentRequirement.spec.js.map

package/dist/uploads/getFileContentRequirement.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/getFileContentRequirement.spec.ts"],"sourcesContent":["import type { SanitizedUploadConfig } from './types.js'\n\nimport { describe, expect, it } from 'vitest'\n\nimport { getFileContentRequirement } from './getFileContentRequirement.js'\n\nconst createUploadConfig = (\n  overrides: Partial<SanitizedUploadConfig> = {},\n): SanitizedUploadConfig =>\n  ({\n    disableLocalStorage: true,\n    staticDir: '/tmp/media',\n    ...overrides,\n  }) as SanitizedUploadConfig\n\ndescribe('getFileContentRequirement', () => {\n  it('requires the full file when local storage is enabled', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'video/mp4',\n        uploadConfig: createUploadConfig({ disableLocalStorage: false }),\n      }),\n    ).toBe('full')\n  })\n\n  it('requires nothing for a non-image file with no mime type allow list', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'video/mp4',\n        uploadConfig: createUploadConfig(),\n      }),\n    ).toBe('none')\n  })\n\n  it('requires the full file when a mime type allow list is configured', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'video/mp4',\n        uploadConfig: createUploadConfig({ mimeTypes: ['video/*'] }),\n      }),\n    ).toBe('full')\n  })\n\n  it('does not require content when allowRestrictedFileTypes bypasses the mime type check', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'video/mp4',\n        uploadConfig: createUploadConfig({\n          allowRestrictedFileTypes: true,\n          mimeTypes: ['video/*'],\n        }),\n      }),\n    ).toBe('none')\n  })\n\n  it('requires only the header for an image with no configured adjustments', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'image/png',\n        uploadConfig: createUploadConfig(),\n      }),\n    ).toBe('header')\n  })\n\n  it('requires the full file for an image with resize options configured', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'image/png',\n        uploadConfig: createUploadConfig({ resizeOptions: { width: 100 } }),\n      }),\n    ).toBe('full')\n  })\n\n  it('requires the full file for an image with imageSizes configured, even with no other adjustments', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'image/png',\n        uploadConfig: createUploadConfig({ imageSizes: [{ name: 'thumbnail', width: 100 }] }),\n      }),\n    ).toBe('full')\n  })\n\n  it('requires only the header for an image with an empty imageSizes array', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'image/png',\n        uploadConfig: createUploadConfig({ imageSizes: [] }),\n      }),\n    ).toBe('header')\n  })\n\n  it('requires the full file for an animated image even with no configured adjustments', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'image/gif',\n        uploadConfig: createUploadConfig(),\n      }),\n    ).toBe('full')\n  })\n\n  it('requires the full file when the request includes a crop edit, even with no configured adjustments', () => {\n    expect(\n      getFileContentRequirement({\n        hasSizeEdits: true,\n        mimeType: 'image/png',\n        uploadConfig: createUploadConfig(),\n      }),\n    ).toBe('full')\n  })\n\n  it('requires only the header when the request has no size edits and no configured adjustments', () => {\n    expect(\n      getFileContentRequirement({\n        hasSizeEdits: false,\n        mimeType: 'image/png',\n        uploadConfig: createUploadConfig(),\n      }),\n    ).toBe('header')\n  })\n\n  it('requires only the header for a non-resizable but recognized image type', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'image/svg+xml',\n        uploadConfig: createUploadConfig(),\n      }),\n    ).toBe('header')\n  })\n\n  it('requires the full file for an image when disableLocalStorage is not set', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'image/png',\n        uploadConfig: { staticDir: '/tmp/media' } as SanitizedUploadConfig,\n      }),\n    ).toBe('full')\n  })\n\n  it('requires the full file for a non-image type when disableLocalStorage is not set', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'video/mp4',\n        uploadConfig: { staticDir: '/tmp/media' } as SanitizedUploadConfig,\n      }),\n    ).toBe('full')\n  })\n})\n"],"names":["describe","expect","it","getFileContentRequirement","createUploadConfig","overrides","disableLocalStorage","staticDir","mimeType","uploadConfig","toBe","mimeTypes","allowRestrictedFileTypes","resizeOptions","width","imageSizes","name","hasSizeEdits"],"mappings":"AAEA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAE7C,SAASC,yBAAyB,QAAQ,iCAAgC;AAE1E,MAAMC,qBAAqB,CACzBC,YAA4C,CAAC,CAAC,GAE7C,CAAA;QACCC,qBAAqB;QACrBC,WAAW;QACX,GAAGF,SAAS;IACd,CAAA;AAEFL,SAAS,6BAA6B;IACpCE,GAAG,wDAAwD;QACzDD,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAcL,mBAAmB;gBAAEE,qBAAqB;YAAM;QAChE,IACAI,IAAI,CAAC;IACT;IAEAR,GAAG,sEAAsE;QACvED,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAcL;QAChB,IACAM,IAAI,CAAC;IACT;IAEAR,GAAG,oEAAoE;QACrED,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAcL,mBAAmB;gBAAEO,WAAW;oBAAC;iBAAU;YAAC;QAC5D,IACAD,IAAI,CAAC;IACT;IAEAR,GAAG,uFAAuF;QACxFD,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAcL,mBAAmB;gBAC/BQ,0BAA0B;gBAC1BD,WAAW;oBAAC;iBAAU;YACxB;QACF,IACAD,IAAI,CAAC;IACT;IAEAR,GAAG,wEAAwE;QACzED,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAcL;QAChB,IACAM,IAAI,CAAC;IACT;IAEAR,GAAG,sEAAsE;QACvED,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAcL,mBAAmB;gBAAES,eAAe;oBAAEC,OAAO;gBAAI;YAAE;QACnE,IACAJ,IAAI,CAAC;IACT;IAEAR,GAAG,kGAAkG;QACnGD,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAcL,mBAAmB;gBAAEW,YAAY;oBAAC;wBAAEC,MAAM;wBAAaF,OAAO;oBAAI;iBAAE;YAAC;QACrF,IACAJ,IAAI,CAAC;IACT;IAEAR,GAAG,wEAAwE;QACzED,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAcL,mBAAmB;gBAAEW,YAAY,EAAE;YAAC;QACpD,IACAL,IAAI,CAAC;IACT;IAEAR,GAAG,oFAAoF;QACrFD,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAcL;QAChB,IACAM,IAAI,CAAC;IACT;IAEAR,GAAG,qGAAqG;QACtGD,OACEE,0BAA0B;YACxBc,cAAc;YACdT,UAAU;YACVC,cAAcL;QAChB,IACAM,IAAI,CAAC;IACT;IAEAR,GAAG,6FAA6F;QAC9FD,OACEE,0BAA0B;YACxBc,cAAc;YACdT,UAAU;YACVC,cAAcL;QAChB,IACAM,IAAI,CAAC;IACT;IAEAR,GAAG,0EAA0E;QAC3ED,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAcL;QAChB,IACAM,IAAI,CAAC;IACT;IAEAR,GAAG,2EAA2E;QAC5ED,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAc;gBAAEF,WAAW;YAAa;QAC1C,IACAG,IAAI,CAAC;IACT;IAEAR,GAAG,mFAAmF;QACpFD,OACEE,0BAA0B;YACxBK,UAAU;YACVC,cAAc;gBAAEF,WAAW;YAAa;QAC1C,IACAG,IAAI,CAAC;IACT;AACF"}

package/dist/uploads/getFileFromUploadInstructions.d.ts

@@ -0,0 +1,8 @@
+import type { PayloadRequest } from '../types/index.js';
+import type { UploadInstructions } from './types.js';
+export declare const getFileFromUploadInstructions: ({ collectionSlug, file, req, }: {
+    collectionSlug: string;
+    file: UploadInstructions['file'];
+    req: PayloadRequest;
+}) => Promise<NonNullable<PayloadRequest['file']>>;
+//# sourceMappingURL=getFileFromUploadInstructions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getFileFromUploadInstructions.d.ts","sourceRoot":"","sources":["../../src/uploads/getFileFromUploadInstructions.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAsC,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAOxF,eAAO,MAAM,6BAA6B,mCAIvC;IACD,cAAc,EAAE,MAAM,CAAA;IACtB,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAA;IAChC,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CA+D9C,CAAA"}

package/dist/uploads/getFileFromUploadInstructions.js

@@ -0,0 +1,232 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import { mkdir, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { APIError } from '../errors/APIError.js';
+import { getFileContentRequirement, HEADER_PROBE_BYTE_LENGTH } from './getFileContentRequirement.js';
+import { getImageSize } from './getImageSize.js';
+import { getStagedFile } from './stagedUpload.js';
+export const getFileFromUploadInstructions = async ({ collectionSlug, file, req })=>{
+    if (!file || typeof file !== 'object' || !file.uploadReference || typeof file.uploadReference !== 'object') {
+        throw new APIError('Invalid upload reference.', 400);
+    }
+    /**
+   * Handlers fetch files uploaded to a storage provider. An uploadId points to a temporary file
+   * already stored by Payload, so no handler is needed.
+   */ if ('uploadId' in file.uploadReference) {
+        return getStagedFile({
+            collectionSlug,
+            req,
+            uploadReference: file.uploadReference
+        });
+    }
+    const uploadConfig = req.payload.collections[collectionSlug].config.upload;
+    if (!uploadConfig || !uploadConfig.handlers) {
+        throw new APIError('uploadConfig.handlers is not present for ' + collectionSlug);
+    }
+    const contentRequirement = getFileContentRequirement({
+        hasSizeEdits: requestHasSizeEdits(req),
+        mimeType: file.mimeType,
+        uploadConfig
+    });
+    // Nothing downstream reads this file's content - use the client-reported metadata directly
+    // instead of re-downloading a file that, for a chunked upload, can be far larger than
+    // the server's available memory or disk.
+    if (contentRequirement === 'none') {
+        return {
+            name: file.filename,
+            data: Buffer.alloc(0),
+            mimetype: file.mimeType,
+            size: file.size,
+            uploadReference: file.uploadReference
+        };
+    }
+    if (contentRequirement === 'header') {
+        const headerFile = await fetchHeaderOnly({
+            collectionSlug,
+            file,
+            req,
+            uploadConfig
+        });
+        if (headerFile) {
+            return headerFile;
+        }
+    // The header wasn't enough to determine the image's dimensions - fall through to a full fetch.
+    }
+    const response = await fetchUploadResponse({
+        collectionSlug,
+        file,
+        req,
+        uploadConfig
+    });
+    const tempFilePath = await streamResponseToTempFile({
+        req,
+        response
+    });
+    return {
+        name: file.filename,
+        data: Buffer.alloc(0),
+        mimetype: response.headers.get('Content-Type') || file.mimeType,
+        size: file.size,
+        tempFilePath,
+        uploadReference: file.uploadReference
+    };
+};
+/**
+ * Whether the request's `uploadEdits` query param carries a crop or resize edit - mirrors the
+ * raw `req.query.uploadEdits` read in generateFileData.ts's `shouldReupload`/`cropData` checks,
+ * since a full parse (with its `data`/`originalDoc` focal-point fallback) isn't available yet
+ * at this point in the request lifecycle.
+ */ const requestHasSizeEdits = (req)=>{
+    const uploadEdits = req.query?.uploadEdits;
+    if (typeof uploadEdits !== 'object' || uploadEdits === null) {
+        return false;
+    }
+    const { crop, heightInPixels, widthInPixels } = uploadEdits;
+    return Boolean(crop || heightInPixels || widthInPixels);
+};
+/**
+ * Fetches only the first `HEADER_PROBE_BYTE_LENGTH` bytes of the upload (via a best-effort byte
+ * range request) and uses them to probe an image's dimensions, without downloading the rest of
+ * the file. Returns null if that isn't enough to determine the dimensions, so the caller can
+ * fall back to a full fetch.
+ */ const fetchHeaderOnly = async ({ collectionSlug, file, req, uploadConfig })=>{
+    const response = await fetchUploadResponse({
+        collectionSlug,
+        file,
+        rangeHeader: `bytes=0-${HEADER_PROBE_BYTE_LENGTH - 1}`,
+        req,
+        uploadConfig
+    });
+    const headerBuffer = await readBoundedPrefix(response, HEADER_PROBE_BYTE_LENGTH);
+    try {
+        await getImageSize({
+            file: {
+                name: file.filename,
+                data: headerBuffer,
+                mimetype: file.mimeType,
+                size: file.size
+            },
+            sharp: req.payload.config.sharp
+        });
+    } catch  {
+        return null;
+    }
+    return {
+        name: file.filename,
+        data: headerBuffer,
+        mimetype: response.headers.get('Content-Type') || file.mimeType,
+        size: file.size,
+        uploadReference: file.uploadReference
+    };
+};
+/**
+ * Runs the collection's upload handlers, following a single redirect if one is returned.
+ * `rangeHeader`, when passed, is a best-effort hint - handlers that ignore it simply return the
+ * full file, which callers must still bound their own reads against.
+ */ const fetchUploadResponse = async ({ collectionSlug, file, rangeHeader, req, uploadConfig })=>{
+    const scopedReq = rangeHeader ? withRangeHeader(req, rangeHeader) : req;
+    let response = null;
+    let error;
+    for (const handler of uploadConfig.handlers){
+        try {
+            const result = await handler(scopedReq, {
+                doc: null,
+                params: {
+                    collection: collectionSlug,
+                    filename: file.filename,
+                    uploadReference: file.uploadReference
+                }
+            });
+            if (result) {
+                response = result;
+                break;
+            }
+        } catch (err) {
+            error = err;
+        }
+    }
+    if (!response) {
+        if (error) {
+            req.payload.logger.error(error);
+        }
+        throw new APIError('Expected response from the upload handler.');
+    }
+    if (response.status >= 300 && response.status < 400) {
+        const redirectUrl = response.headers.get('Location');
+        if (redirectUrl) {
+            response = await fetch(redirectUrl);
+        }
+    }
+    return response;
+};
+/**
+ * Overrides `req.headers` with a `Range` header while leaving the real incoming request
+ * untouched. Uses a Proxy, rather than cloning `req`, because `req` is a native `Request`
+ * instance at runtime - accessors like `.signal` are brand-checked against `req`'s internal
+ * slots, so a plain clone (e.g. `Object.create(req)`) throws once a handler reads one of them.
+ * Forwarding reads through `Reflect.get(req, prop, req)` keeps `this` bound to the real `req`
+ * so those accessors keep working.
+ */ const withRangeHeader = (req, rangeHeader)=>{
+    const headers = new Headers(req.headers);
+    headers.set('range', rangeHeader);
+    return new Proxy(req, {
+        get (target, prop) {
+            return prop === 'headers' ? headers : Reflect.get(target, prop, target);
+        }
+    });
+};
+/**
+ * Reads at most `maxBytes` from the response body, then cancels the reader - so a handler that
+ * ignores the range hint and starts streaming the whole file is still cut short on our end.
+ */ const readBoundedPrefix = async (response, maxBytes)=>{
+    if (!response.body) {
+        return Buffer.alloc(0);
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while(total < maxBytes){
+            const { done, value } = await reader.read();
+            if (done || !value) {
+                break;
+            }
+            const remaining = maxBytes - total;
+            const chunk = value.byteLength > remaining ? value.subarray(0, remaining) : value;
+            chunks.push(Buffer.from(chunk));
+            total += chunk.byteLength;
+        }
+    } finally{
+        await reader.cancel().catch(()=>{});
+    }
+    return Buffer.concat(chunks, total);
+};
+/**
+ * Streams the fetched upload straight to disk instead of buffering it in memory. A client upload
+ * (e.g. Azure's chunkLargeFiles) can be far larger than the server's available memory, so this
+ * avoids re-downloading the whole file into a single in-memory buffer just to read it back out.
+ */ const streamResponseToTempFile = async ({ req, response })=>{
+    if (!response.body) {
+        throw new APIError('Expected a response body from the upload handler.');
+    }
+    const tempFileDir = req.payload.config.upload?.tempFileDir || os.tmpdir();
+    await mkdir(tempFileDir, {
+        recursive: true
+    });
+    const tempFilePath = path.join(tempFileDir, `payload-client-upload-${randomUUID()}`);
+    try {
+        await pipeline(Readable.fromWeb(response.body), fs.createWriteStream(tempFilePath));
+    } catch (error) {
+        await rm(tempFilePath, {
+            force: true
+        });
+        throw error;
+    }
+    return tempFilePath;
+};
+
+//# sourceMappingURL=getFileFromUploadInstructions.js.map

package/dist/uploads/getFileFromUploadInstructions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/getFileFromUploadInstructions.ts"],"sourcesContent":["import type { ReadableStream } from 'node:stream/web'\n\nimport { randomUUID } from 'node:crypto'\nimport fs from 'node:fs'\nimport { mkdir, rm } from 'node:fs/promises'\nimport os from 'node:os'\nimport path from 'node:path'\nimport { Readable } from 'node:stream'\nimport { pipeline } from 'node:stream/promises'\n\nimport type { PayloadRequest } from '../types/index.js'\nimport type { SanitizedUploadConfig, UploadEdits, UploadInstructions } from './types.js'\n\nimport { APIError } from '../errors/APIError.js'\nimport { getFileContentRequirement, HEADER_PROBE_BYTE_LENGTH } from './getFileContentRequirement.js'\nimport { getImageSize } from './getImageSize.js'\nimport { getStagedFile } from './stagedUpload.js'\n\nexport const getFileFromUploadInstructions = async ({\n  collectionSlug,\n  file,\n  req,\n}: {\n  collectionSlug: string\n  file: UploadInstructions['file']\n  req: PayloadRequest\n}): Promise<NonNullable<PayloadRequest['file']>> => {\n  if (\n    !file ||\n    typeof file !== 'object' ||\n    !file.uploadReference ||\n    typeof file.uploadReference !== 'object'\n  ) {\n    throw new APIError('Invalid upload reference.', 400)\n  }\n\n  /**\n   * Handlers fetch files uploaded to a storage provider. An uploadId points to a temporary file\n   * already stored by Payload, so no handler is needed.\n   */\n  if ('uploadId' in file.uploadReference) {\n    return getStagedFile({ collectionSlug, req, uploadReference: file.uploadReference })\n  }\n\n  const uploadConfig = req.payload.collections[collectionSlug]!.config.upload\n\n  if (!uploadConfig || !uploadConfig.handlers) {\n    throw new APIError('uploadConfig.handlers is not present for ' + collectionSlug)\n  }\n\n  const contentRequirement = getFileContentRequirement({\n    hasSizeEdits: requestHasSizeEdits(req),\n    mimeType: file.mimeType,\n    uploadConfig,\n  })\n\n  // Nothing downstream reads this file's content - use the client-reported metadata directly\n  // instead of re-downloading a file that, for a chunked upload, can be far larger than\n  // the server's available memory or disk.\n  if (contentRequirement === 'none') {\n    return {\n      name: file.filename,\n      data: Buffer.alloc(0),\n      mimetype: file.mimeType,\n      size: file.size,\n      uploadReference: file.uploadReference,\n    }\n  }\n\n  if (contentRequirement === 'header') {\n    const headerFile = await fetchHeaderOnly({ collectionSlug, file, req, uploadConfig })\n    if (headerFile) {\n      return headerFile\n    }\n    // The header wasn't enough to determine the image's dimensions - fall through to a full fetch.\n  }\n\n  const response = await fetchUploadResponse({ collectionSlug, file, req, uploadConfig })\n\n  const tempFilePath = await streamResponseToTempFile({ req, response })\n\n  return {\n    name: file.filename,\n    data: Buffer.alloc(0),\n    mimetype: response.headers.get('Content-Type') || file.mimeType,\n    size: file.size,\n    tempFilePath,\n    uploadReference: file.uploadReference,\n  }\n}\n\n/**\n * Whether the request's `uploadEdits` query param carries a crop or resize edit - mirrors the\n * raw `req.query.uploadEdits` read in generateFileData.ts's `shouldReupload`/`cropData` checks,\n * since a full parse (with its `data`/`originalDoc` focal-point fallback) isn't available yet\n * at this point in the request lifecycle.\n */\nconst requestHasSizeEdits = (req: PayloadRequest): boolean => {\n  const uploadEdits = req.query?.uploadEdits\n  if (typeof uploadEdits !== 'object' || uploadEdits === null) {\n    return false\n  }\n\n  const { crop, heightInPixels, widthInPixels } = uploadEdits as UploadEdits\n  return Boolean(crop || heightInPixels || widthInPixels)\n}\n\n/**\n * Fetches only the first `HEADER_PROBE_BYTE_LENGTH` bytes of the upload (via a best-effort byte\n * range request) and uses them to probe an image's dimensions, without downloading the rest of\n * the file. Returns null if that isn't enough to determine the dimensions, so the caller can\n * fall back to a full fetch.\n */\nconst fetchHeaderOnly = async ({\n  collectionSlug,\n  file,\n  req,\n  uploadConfig,\n}: {\n  collectionSlug: string\n  file: UploadInstructions['file']\n  req: PayloadRequest\n  uploadConfig: SanitizedUploadConfig\n}): Promise<NonNullable<PayloadRequest['file']> | null> => {\n  const response = await fetchUploadResponse({\n    collectionSlug,\n    file,\n    rangeHeader: `bytes=0-${HEADER_PROBE_BYTE_LENGTH - 1}`,\n    req,\n    uploadConfig,\n  })\n\n  const headerBuffer = await readBoundedPrefix(response, HEADER_PROBE_BYTE_LENGTH)\n\n  try {\n    await getImageSize({\n      file: {\n        name: file.filename,\n        data: headerBuffer,\n        mimetype: file.mimeType,\n        size: file.size,\n      },\n      sharp: req.payload.config.sharp,\n    })\n  } catch {\n    return null\n  }\n\n  return {\n    name: file.filename,\n    data: headerBuffer,\n    mimetype: response.headers.get('Content-Type') || file.mimeType,\n    size: file.size,\n    uploadReference: file.uploadReference,\n  }\n}\n\n/**\n * Runs the collection's upload handlers, following a single redirect if one is returned.\n * `rangeHeader`, when passed, is a best-effort hint - handlers that ignore it simply return the\n * full file, which callers must still bound their own reads against.\n */\nconst fetchUploadResponse = async ({\n  collectionSlug,\n  file,\n  rangeHeader,\n  req,\n  uploadConfig,\n}: {\n  collectionSlug: string\n  file: UploadInstructions['file']\n  rangeHeader?: string\n  req: PayloadRequest\n  uploadConfig: SanitizedUploadConfig\n}): Promise<Response> => {\n  const scopedReq = rangeHeader ? withRangeHeader(req, rangeHeader) : req\n\n  let response: null | Response = null\n  let error: unknown\n\n  for (const handler of uploadConfig.handlers!) {\n    try {\n      const result = await handler(scopedReq, {\n        doc: null!,\n        params: {\n          collection: collectionSlug,\n          filename: file.filename,\n          uploadReference: file.uploadReference,\n        },\n      })\n      if (result) {\n        response = result\n        /**\n         * - If a handler returns a Response, the response will be sent to the client and no further handlers will be run.\n         * - If a handler returns null, the next handler will be run.\n         *\n         * @see packages/payload/src/uploads/types.ts\n         */\n        break\n      }\n    } catch (err) {\n      error = err\n    }\n  }\n\n  if (!response) {\n    if (error) {\n      req.payload.logger.error(error)\n    }\n\n    throw new APIError('Expected response from the upload handler.')\n  }\n\n  if (response.status >= 300 && response.status < 400) {\n    const redirectUrl = response.headers.get('Location')\n    if (redirectUrl) {\n      response = await fetch(redirectUrl)\n    }\n  }\n\n  return response\n}\n\n/**\n * Overrides `req.headers` with a `Range` header while leaving the real incoming request\n * untouched. Uses a Proxy, rather than cloning `req`, because `req` is a native `Request`\n * instance at runtime - accessors like `.signal` are brand-checked against `req`'s internal\n * slots, so a plain clone (e.g. `Object.create(req)`) throws once a handler reads one of them.\n * Forwarding reads through `Reflect.get(req, prop, req)` keeps `this` bound to the real `req`\n * so those accessors keep working.\n */\nconst withRangeHeader = (req: PayloadRequest, rangeHeader: string): PayloadRequest => {\n  const headers = new Headers(req.headers)\n  headers.set('range', rangeHeader)\n\n  return new Proxy(req, {\n    get(target, prop) {\n      return prop === 'headers' ? headers : Reflect.get(target, prop, target)\n    },\n  })\n}\n\n/**\n * Reads at most `maxBytes` from the response body, then cancels the reader - so a handler that\n * ignores the range hint and starts streaming the whole file is still cut short on our end.\n */\nconst readBoundedPrefix = async (response: Response, maxBytes: number): Promise<Buffer> => {\n  if (!response.body) {\n    return Buffer.alloc(0)\n  }\n\n  const reader = response.body.getReader()\n  const chunks: Buffer[] = []\n  let total = 0\n\n  try {\n    while (total < maxBytes) {\n      const { done, value } = await reader.read()\n      if (done || !value) {\n        break\n      }\n\n      const remaining = maxBytes - total\n      const chunk = value.byteLength > remaining ? value.subarray(0, remaining) : value\n      chunks.push(Buffer.from(chunk))\n      total += chunk.byteLength\n    }\n  } finally {\n    await reader.cancel().catch(() => {})\n  }\n\n  return Buffer.concat(chunks, total)\n}\n\n/**\n * Streams the fetched upload straight to disk instead of buffering it in memory. A client upload\n * (e.g. Azure's chunkLargeFiles) can be far larger than the server's available memory, so this\n * avoids re-downloading the whole file into a single in-memory buffer just to read it back out.\n */\nconst streamResponseToTempFile = async ({\n  req,\n  response,\n}: {\n  req: PayloadRequest\n  response: Response\n}): Promise<string> => {\n  if (!response.body) {\n    throw new APIError('Expected a response body from the upload handler.')\n  }\n\n  const tempFileDir = req.payload.config.upload?.tempFileDir || os.tmpdir()\n  await mkdir(tempFileDir, { recursive: true })\n  const tempFilePath = path.join(tempFileDir, `payload-client-upload-${randomUUID()}`)\n\n  try {\n    await pipeline(\n      Readable.fromWeb(response.body as ReadableStream<Uint8Array>),\n      fs.createWriteStream(tempFilePath),\n    )\n  } catch (error) {\n    await rm(tempFilePath, { force: true })\n    throw error\n  }\n\n  return tempFilePath\n}\n"],"names":["randomUUID","fs","mkdir","rm","os","path","Readable","pipeline","APIError","getFileContentRequirement","HEADER_PROBE_BYTE_LENGTH","getImageSize","getStagedFile","getFileFromUploadInstructions","collectionSlug","file","req","uploadReference","uploadConfig","payload","collections","config","upload","handlers","contentRequirement","hasSizeEdits","requestHasSizeEdits","mimeType","name","filename","data","Buffer","alloc","mimetype","size","headerFile","fetchHeaderOnly","response","fetchUploadResponse","tempFilePath","streamResponseToTempFile","headers","get","uploadEdits","query","crop","heightInPixels","widthInPixels","Boolean","rangeHeader","headerBuffer","readBoundedPrefix","sharp","scopedReq","withRangeHeader","error","handler","result","doc","params","collection","err","logger","status","redirectUrl","fetch","Headers","set","Proxy","target","prop","Reflect","maxBytes","body","reader","getReader","chunks","total","done","value","read","remaining","chunk","byteLength","subarray","push","from","cancel","catch","concat","tempFileDir","tmpdir","recursive","join","fromWeb","createWriteStream","force"],"mappings":"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"}