payload 4.0.0-internal.4cbdd50 → 4.0.0-internal.4e1f822

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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"}

package/dist/uploads/getFileFromUploadInstructions.spec.js

@@ -0,0 +1,378 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { HEADER_PROBE_BYTE_LENGTH } from './getFileContentRequirement.js';
+import { getFileFromUploadInstructions } from './getFileFromUploadInstructions.js';
+// A minimal valid 1x1 transparent PNG, small enough that a header-only fetch gets all of it.
+const MINIMAL_PNG = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg==', 'base64');
+const createReq = (handlers, uploadConfigOverrides = {
+    mimeTypes: [
+        'video/*'
+    ]
+})=>({
+        payload: {
+            collections: {
+                media: {
+                    config: {
+                        upload: {
+                            disableLocalStorage: true,
+                            handlers,
+                            ...uploadConfigOverrides
+                        }
+                    }
+                }
+            },
+            config: {
+                upload: {}
+            },
+            logger: {
+                error: vi.fn()
+            }
+        },
+        headers: new Headers()
+    });
+const createUploadReferenceFile = (overrides = {})=>({
+        filename: 'video.mp4',
+        mimeType: 'video/mp4',
+        size: 18,
+        uploadReference: {
+            key: 'media/video.mp4'
+        },
+        ...overrides
+    });
+describe('getFileFromUploadInstructions', ()=>{
+    const tempFilesToClean = [];
+    afterEach(()=>{
+        for (const filePath of tempFilesToClean){
+            fs.rmSync(filePath, {
+                force: true
+            });
+        }
+        tempFilesToClean.length = 0;
+        vi.clearAllMocks();
+    });
+    it('streams the fetched file to a temp file instead of buffering it in memory', async ()=>{
+        const handler = vi.fn(async ()=>new Response('some file contents', {
+                headers: {
+                    'Content-Type': 'video/mp4'
+                },
+                status: 200
+            }));
+        const req = createReq([
+            handler
+        ]);
+        const uploadReferenceFile = createUploadReferenceFile();
+        const file = await getFileFromUploadInstructions({
+            collectionSlug: 'media',
+            file: uploadReferenceFile,
+            req
+        });
+        expect(file.tempFilePath).toBeTruthy();
+        tempFilesToClean.push(file.tempFilePath);
+        expect(file.data.length).toBe(0);
+        expect(fs.readFileSync(file.tempFilePath, 'utf8')).toBe('some file contents');
+        expect(file.uploadReference).toBe(uploadReferenceFile.uploadReference);
+        expect(file.mimetype).toBe('video/mp4');
+    });
+    it('writes the temp file under the configured tempFileDir', async ()=>{
+        const customTempDir = path.join(os.tmpdir(), `payload-test-temp-dir-${Date.now()}`);
+        const handler = vi.fn(async ()=>new Response('x', {
+                status: 200
+            }));
+        const req = createReq([
+            handler
+        ]);
+        req.payload.config.upload = {
+            tempFileDir: customTempDir
+        };
+        const file = await getFileFromUploadInstructions({
+            collectionSlug: 'media',
+            file: createUploadReferenceFile({
+                filename: 'x.bin',
+                mimeType: 'application/octet-stream'
+            }),
+            req
+        });
+        tempFilesToClean.push(file.tempFilePath);
+        expect(path.dirname(file.tempFilePath)).toBe(customTempDir);
+        fs.rmSync(customTempDir, {
+            force: true,
+            recursive: true
+        });
+    });
+    it('throws when no handler returns a response with a body', async ()=>{
+        const handler = vi.fn(async ()=>new Response(null, {
+                status: 204
+            }));
+        const req = createReq([
+            handler
+        ]);
+        await expect(getFileFromUploadInstructions({
+            collectionSlug: 'media',
+            file: createUploadReferenceFile(),
+            req
+        })).rejects.toThrow();
+    });
+    it('skips fetching entirely when nothing downstream needs the file content', async ()=>{
+        const handler = vi.fn(async ()=>new Response('unused', {
+                status: 200
+            }));
+        const req = createReq([
+            handler
+        ], {});
+        const file = await getFileFromUploadInstructions({
+            collectionSlug: 'media',
+            file: createUploadReferenceFile(),
+            req
+        });
+        expect(handler).not.toHaveBeenCalled();
+        expect(file.tempFilePath).toBeUndefined();
+        expect(file.data.length).toBe(0);
+        expect(file.size).toBe(18);
+        expect(file.mimetype).toBe('video/mp4');
+    });
+    it('fetches only a bounded header for an image with no configured adjustments', async ()=>{
+        const handler = vi.fn(async (handlerReq)=>{
+            expect(handlerReq.headers.get('range')).toBe(`bytes=0-${HEADER_PROBE_BYTE_LENGTH - 1}`);
+            return new Response(MINIMAL_PNG, {
+                headers: {
+                    'Content-Type': 'image/png'
+                },
+                status: 206
+            });
+        });
+        const req = createReq([
+            handler
+        ], {});
+        const file = await getFileFromUploadInstructions({
+            collectionSlug: 'media',
+            file: createUploadReferenceFile({
+                filename: 'photo.png',
+                mimeType: 'image/png',
+                size: MINIMAL_PNG.length
+            }),
+            req
+        });
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(file.tempFilePath).toBeUndefined();
+        expect(file.data.equals(MINIMAL_PNG)).toBe(true);
+        expect(file.mimetype).toBe('image/png');
+    });
+    it('fetches the full file for an image with no configured adjustments when the request includes a crop edit', async ()=>{
+        const handler = vi.fn(async (handlerReq)=>{
+            expect(handlerReq.headers.get('range')).toBeNull();
+            return new Response(MINIMAL_PNG, {
+                headers: {
+                    'Content-Type': 'image/png'
+                },
+                status: 200
+            });
+        });
+        const req = createReq([
+            handler
+        ], {});
+        req.query = {
+            uploadEdits: {
+                crop: {
+                    height: 10,
+                    unit: 'px',
+                    width: 10,
+                    x: 0,
+                    y: 0
+                }
+            }
+        };
+        const file = await getFileFromUploadInstructions({
+            collectionSlug: 'media',
+            file: createUploadReferenceFile({
+                filename: 'photo.png',
+                mimeType: 'image/png',
+                size: MINIMAL_PNG.length
+            }),
+            req
+        });
+        expect(handler).toHaveBeenCalledTimes(1);
+        expect(file.tempFilePath).toBeTruthy();
+        tempFilesToClean.push(file.tempFilePath);
+        expect(file.data.length).toBe(0);
+        expect(fs.readFileSync(file.tempFilePath)).toEqual(MINIMAL_PNG);
+    });
+    it('stops reading once it has enough bytes to probe dimensions, even if the handler ignores the range hint', async ()=>{
+        const totalSize = HEADER_PROBE_BYTE_LENGTH * 4;
+        let cancelled = false;
+        let bytesProduced = 0;
+        const stream = new ReadableStream({
+            cancel () {
+                cancelled = true;
+            },
+            pull (controller) {
+                if (bytesProduced === 0) {
+                    controller.enqueue(MINIMAL_PNG);
+                    bytesProduced += MINIMAL_PNG.length;
+                    return;
+                }
+                if (bytesProduced >= totalSize) {
+                    controller.close();
+                    return;
+                }
+                const chunkSize = Math.min(64 * 1024, totalSize - bytesProduced);
+                controller.enqueue(new Uint8Array(chunkSize));
+                bytesProduced += chunkSize;
+            }
+        });
+        const handler = vi.fn(async ()=>new Response(stream, {
+                headers: {
+                    'Content-Type': 'image/png'
+                },
+                status: 200
+            }));
+        const req = createReq([
+            handler
+        ], {});
+        const file = await getFileFromUploadInstructions({
+            collectionSlug: 'media',
+            file: createUploadReferenceFile({
+                filename: 'photo.png',
+                mimeType: 'image/png',
+                size: totalSize
+            }),
+            req
+        });
+        expect(file.tempFilePath).toBeUndefined();
+        expect(file.data.length).toBeLessThanOrEqual(HEADER_PROBE_BYTE_LENGTH);
+        expect(cancelled).toBe(true);
+    });
+    it('preserves native Request accessors like signal on the request passed to a range-scoped handler', async ()=>{
+        const abortController = new AbortController();
+        const baseRequest = new Request('http://localhost/api/media', {
+            signal: abortController.signal
+        });
+        let observedSignal;
+        const handler = vi.fn(async (handlerReq)=>{
+            observedSignal = handlerReq.signal;
+            return new Response(MINIMAL_PNG, {
+                headers: {
+                    'Content-Type': 'image/png'
+                },
+                status: 206
+            });
+        });
+        const req = Object.assign(baseRequest, {
+            payload: {
+                collections: {
+                    media: {
+                        config: {
+                            upload: {
+                                disableLocalStorage: true,
+                                handlers: [
+                                    handler
+                                ]
+                            }
+                        }
+                    }
+                },
+                config: {
+                    upload: {}
+                },
+                logger: {
+                    error: vi.fn()
+                }
+            }
+        });
+        const file = await getFileFromUploadInstructions({
+            collectionSlug: 'media',
+            file: createUploadReferenceFile({
+                filename: 'photo.png',
+                mimeType: 'image/png',
+                size: MINIMAL_PNG.length
+            }),
+            req
+        });
+        // req.signal is the Request's own internal signal, which follows the one passed into the
+        // constructor rather than being the same object - reading it without throwing, and it
+        // reflecting an abort, is what proves the accessor still works on the scoped request.
+        expect(observedSignal).toBeInstanceOf(AbortSignal);
+        expect(observedSignal?.aborted).toBe(false);
+        abortController.abort();
+        expect(observedSignal?.aborted).toBe(true);
+        expect(file.data.equals(MINIMAL_PNG)).toBe(true);
+    });
+    it('removes the partial temp file if the response stream fails partway through', async ()=>{
+        const customTempDir = path.join(os.tmpdir(), `payload-test-stream-failure-${randomUUID()}`);
+        const streamError = new Error('stream boom');
+        const stream = new ReadableStream({
+            pull (controller) {
+                controller.enqueue(new Uint8Array([
+                    1,
+                    2,
+                    3
+                ]));
+                controller.error(streamError);
+            }
+        });
+        const handler = vi.fn(async ()=>new Response(stream, {
+                headers: {
+                    'Content-Type': 'video/mp4'
+                },
+                status: 200
+            }));
+        const req = createReq([
+            handler
+        ]);
+        req.payload.config.upload = {
+            tempFileDir: customTempDir
+        };
+        await expect(getFileFromUploadInstructions({
+            collectionSlug: 'media',
+            file: createUploadReferenceFile(),
+            req
+        })).rejects.toThrow('stream boom');
+        const filesLeftBehind = await fs.promises.readdir(customTempDir).catch(()=>[]);
+        expect(filesLeftBehind).toEqual([]);
+        await fs.promises.rm(customTempDir, {
+            force: true,
+            recursive: true
+        });
+    });
+    it('falls back to a full fetch when the header is not enough to determine image dimensions', async ()=>{
+        const garbage = Buffer.from('not a real image');
+        let callCount = 0;
+        const handler = vi.fn(async (handlerReq)=>{
+            callCount += 1;
+            if (handlerReq.headers.get('range')) {
+                return new Response(garbage, {
+                    headers: {
+                        'Content-Type': 'image/png'
+                    },
+                    status: 206
+                });
+            }
+            return new Response('full-image-bytes-stand-in', {
+                headers: {
+                    'Content-Type': 'image/png'
+                },
+                status: 200
+            });
+        });
+        const req = createReq([
+            handler
+        ], {});
+        const file = await getFileFromUploadInstructions({
+            collectionSlug: 'media',
+            file: createUploadReferenceFile({
+                filename: 'photo.png',
+                mimeType: 'image/png',
+                size: 26
+            }),
+            req
+        });
+        expect(callCount).toBe(2);
+        expect(file.tempFilePath).toBeTruthy();
+        tempFilesToClean.push(file.tempFilePath);
+        expect(fs.readFileSync(file.tempFilePath, 'utf8')).toBe('full-image-bytes-stand-in');
+    });
+});
+
+//# sourceMappingURL=getFileFromUploadInstructions.spec.js.map