payload 3.89.0-internal.4b0e9b6 → 3.89.0-internal.95c9cba

package/dist/uploads/getFileContentRequirement.d.ts

@@ -0,0 +1,9 @@
+import type { SanitizedUploadConfig } from './types.js';
+export declare const HEADER_PROBE_BYTE_LENGTH: number;
+export type FileContentRequirement = 'full' | 'header' | 'none';
+export declare function getFileContentRequirement({ hasSizeEdits, mimeType, uploadConfig, }: {
+    hasSizeEdits?: boolean;
+    mimeType: string;
+    uploadConfig: SanitizedUploadConfig;
+}): FileContentRequirement;
+//# sourceMappingURL=getFileContentRequirement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getFileContentRequirement.d.ts","sourceRoot":"","sources":["../../src/uploads/getFileContentRequirement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAMvD,eAAO,MAAM,wBAAwB,QAAc,CAAA;AAEnD,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAA;AAE/D,wBAAgB,yBAAyB,CAAC,EACxC,YAAY,EACZ,QAAQ,EACR,YAAY,GACb,EAAE;IACD,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,qBAAqB,CAAA;CACpC,GAAG,sBAAsB,CAgCzB"}

package/dist/uploads/getFileContentRequirement.js

@@ -0,0 +1,24 @@
+import { canResizeImage } from './canResizeImage.js';
+import { isAnimatedImage } from './isAnimatedImage.js';
+import { isImage } from './isImage.js';
+export const HEADER_PROBE_BYTE_LENGTH = 1024 * 1024;
+export function getFileContentRequirement({ hasSizeEdits, mimeType, uploadConfig }) {
+    if (!uploadConfig.disableLocalStorage) {
+        return 'full';
+    }
+    const hasMimeTypeAllowList = !uploadConfig.allowRestrictedFileTypes && Array.isArray(uploadConfig.mimeTypes) && uploadConfig.mimeTypes.length > 0;
+    if (hasMimeTypeAllowList) {
+        return 'full';
+    }
+    const isResizableImage = canResizeImage(mimeType);
+    const hasConfiguredAdjustments = Boolean(uploadConfig.resizeOptions || uploadConfig.formatOptions || uploadConfig.trimOptions || uploadConfig.constructorOptions || Array.isArray(uploadConfig.imageSizes) && uploadConfig.imageSizes.length > 0);
+    if (hasSizeEdits || isResizableImage && hasConfiguredAdjustments || isAnimatedImage(mimeType)) {
+        return 'full';
+    }
+    if (isResizableImage || isImage(mimeType)) {
+        return 'header';
+    }
+    return 'none';
+}
+
+//# sourceMappingURL=getFileContentRequirement.js.map

package/dist/uploads/getFileContentRequirement.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/getFileContentRequirement.ts"],"sourcesContent":["import type { SanitizedUploadConfig } from './types.js'\n\nimport { canResizeImage } from './canResizeImage.js'\nimport { isAnimatedImage } from './isAnimatedImage.js'\nimport { isImage } from './isImage.js'\n\nexport const HEADER_PROBE_BYTE_LENGTH = 1024 * 1024\n\nexport type FileContentRequirement = 'full' | 'header' | 'none'\n\nexport function getFileContentRequirement({\n  hasSizeEdits,\n  mimeType,\n  uploadConfig,\n}: {\n  hasSizeEdits?: boolean\n  mimeType: string\n  uploadConfig: SanitizedUploadConfig\n}): FileContentRequirement {\n  if (!uploadConfig.disableLocalStorage) {\n    return 'full'\n  }\n\n  const hasMimeTypeAllowList =\n    !uploadConfig.allowRestrictedFileTypes &&\n    Array.isArray(uploadConfig.mimeTypes) &&\n    uploadConfig.mimeTypes.length > 0\n\n  if (hasMimeTypeAllowList) {\n    return 'full'\n  }\n\n  const isResizableImage = canResizeImage(mimeType)\n  const hasConfiguredAdjustments = Boolean(\n    uploadConfig.resizeOptions ||\n      uploadConfig.formatOptions ||\n      uploadConfig.trimOptions ||\n      uploadConfig.constructorOptions ||\n      (Array.isArray(uploadConfig.imageSizes) && uploadConfig.imageSizes.length > 0),\n  )\n\n  if (hasSizeEdits || (isResizableImage && hasConfiguredAdjustments) || isAnimatedImage(mimeType)) {\n    return 'full'\n  }\n\n  if (isResizableImage || isImage(mimeType)) {\n    return 'header'\n  }\n\n  return 'none'\n}\n"],"names":["canResizeImage","isAnimatedImage","isImage","HEADER_PROBE_BYTE_LENGTH","getFileContentRequirement","hasSizeEdits","mimeType","uploadConfig","disableLocalStorage","hasMimeTypeAllowList","allowRestrictedFileTypes","Array","isArray","mimeTypes","length","isResizableImage","hasConfiguredAdjustments","Boolean","resizeOptions","formatOptions","trimOptions","constructorOptions","imageSizes"],"mappings":"AAEA,SAASA,cAAc,QAAQ,sBAAqB;AACpD,SAASC,eAAe,QAAQ,uBAAsB;AACtD,SAASC,OAAO,QAAQ,eAAc;AAEtC,OAAO,MAAMC,2BAA2B,OAAO,KAAI;AAInD,OAAO,SAASC,0BAA0B,EACxCC,YAAY,EACZC,QAAQ,EACRC,YAAY,EAKb;IACC,IAAI,CAACA,aAAaC,mBAAmB,EAAE;QACrC,OAAO;IACT;IAEA,MAAMC,uBACJ,CAACF,aAAaG,wBAAwB,IACtCC,MAAMC,OAAO,CAACL,aAAaM,SAAS,KACpCN,aAAaM,SAAS,CAACC,MAAM,GAAG;IAElC,IAAIL,sBAAsB;QACxB,OAAO;IACT;IAEA,MAAMM,mBAAmBf,eAAeM;IACxC,MAAMU,2BAA2BC,QAC/BV,aAAaW,aAAa,IACxBX,aAAaY,aAAa,IAC1BZ,aAAaa,WAAW,IACxBb,aAAac,kBAAkB,IAC9BV,MAAMC,OAAO,CAACL,aAAae,UAAU,KAAKf,aAAae,UAAU,CAACR,MAAM,GAAG;IAGhF,IAAIT,gBAAiBU,oBAAoBC,4BAA6Bf,gBAAgBK,WAAW;QAC/F,OAAO;IACT;IAEA,IAAIS,oBAAoBb,QAAQI,WAAW;QACzC,OAAO;IACT;IAEA,OAAO;AACT"}

package/dist/uploads/getFileContentRequirement.spec.js

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest';
+import { getFileContentRequirement } from './getFileContentRequirement.js';
+describe('getFileContentRequirement', ()=>{
+    it.each([
+        {
+            expected: 'full',
+            mimeType: 'video/mp4',
+            upload: {
+                disableLocalStorage: false
+            }
+        },
+        {
+            expected: 'full',
+            mimeType: 'video/mp4',
+            upload: {
+                disableLocalStorage: true,
+                mimeTypes: [
+                    'video/*'
+                ]
+            }
+        },
+        {
+            expected: 'none',
+            mimeType: 'video/mp4',
+            upload: {
+                disableLocalStorage: true
+            }
+        },
+        {
+            expected: 'header',
+            mimeType: 'image/png',
+            upload: {
+                disableLocalStorage: true
+            }
+        },
+        {
+            expected: 'full',
+            mimeType: 'image/png',
+            upload: {
+                disableLocalStorage: true,
+                resizeOptions: {
+                    width: 100
+                }
+            }
+        },
+        {
+            expected: 'full',
+            mimeType: 'image/png',
+            upload: {
+                disableLocalStorage: true,
+                imageSizes: [
+                    {
+                        name: 'thumb',
+                        width: 100
+                    }
+                ]
+            }
+        },
+        {
+            expected: 'full',
+            mimeType: 'image/gif',
+            upload: {
+                disableLocalStorage: true
+            }
+        }
+    ])('returns $expected for $mimeType and $upload', ({ expected, mimeType, upload })=>{
+        expect(getFileContentRequirement({
+            mimeType,
+            uploadConfig: upload
+        })).toBe(expected);
+    });
+    it('requires full content when the request includes crop or size edits', ()=>{
+        expect(getFileContentRequirement({
+            hasSizeEdits: true,
+            mimeType: 'image/png',
+            uploadConfig: {
+                disableLocalStorage: true
+            }
+        })).toBe('full');
+    });
+    it('returns none for a restricted-type-allowed non-image when mimeTypes validation is bypassed', ()=>{
+        expect(getFileContentRequirement({
+            mimeType: 'video/mp4',
+            uploadConfig: {
+                allowRestrictedFileTypes: true,
+                disableLocalStorage: true,
+                mimeTypes: [
+                    'video/*'
+                ]
+            }
+        })).toBe('none');
+    });
+});
+
+//# 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\ndescribe('getFileContentRequirement', () => {\n  it.each([\n    { expected: 'full', mimeType: 'video/mp4', upload: { disableLocalStorage: false } },\n    {\n      expected: 'full',\n      mimeType: 'video/mp4',\n      upload: { disableLocalStorage: true, mimeTypes: ['video/*'] },\n    },\n    { expected: 'none', mimeType: 'video/mp4', upload: { disableLocalStorage: true } },\n    { expected: 'header', mimeType: 'image/png', upload: { disableLocalStorage: true } },\n    {\n      expected: 'full',\n      mimeType: 'image/png',\n      upload: { disableLocalStorage: true, resizeOptions: { width: 100 } },\n    },\n    {\n      expected: 'full',\n      mimeType: 'image/png',\n      upload: { disableLocalStorage: true, imageSizes: [{ name: 'thumb', width: 100 }] },\n    },\n    { expected: 'full', mimeType: 'image/gif', upload: { disableLocalStorage: true } },\n  ])('returns $expected for $mimeType and $upload', ({ expected, mimeType, upload }) => {\n    expect(\n      getFileContentRequirement({\n        mimeType,\n        uploadConfig: upload as SanitizedUploadConfig,\n      }),\n    ).toBe(expected)\n  })\n\n  it('requires full content when the request includes crop or size edits', () => {\n    expect(\n      getFileContentRequirement({\n        hasSizeEdits: true,\n        mimeType: 'image/png',\n        uploadConfig: { disableLocalStorage: true } as SanitizedUploadConfig,\n      }),\n    ).toBe('full')\n  })\n\n  it('returns none for a restricted-type-allowed non-image when mimeTypes validation is bypassed', () => {\n    expect(\n      getFileContentRequirement({\n        mimeType: 'video/mp4',\n        uploadConfig: {\n          allowRestrictedFileTypes: true,\n          disableLocalStorage: true,\n          mimeTypes: ['video/*'],\n        } as SanitizedUploadConfig,\n      }),\n    ).toBe('none')\n  })\n})\n"],"names":["describe","expect","it","getFileContentRequirement","each","expected","mimeType","upload","disableLocalStorage","mimeTypes","resizeOptions","width","imageSizes","name","uploadConfig","toBe","hasSizeEdits","allowRestrictedFileTypes"],"mappings":"AAEA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAE7C,SAASC,yBAAyB,QAAQ,iCAAgC;AAE1EH,SAAS,6BAA6B;IACpCE,GAAGE,IAAI,CAAC;QACN;YAAEC,UAAU;YAAQC,UAAU;YAAaC,QAAQ;gBAAEC,qBAAqB;YAAM;QAAE;QAClF;YACEH,UAAU;YACVC,UAAU;YACVC,QAAQ;gBAAEC,qBAAqB;gBAAMC,WAAW;oBAAC;iBAAU;YAAC;QAC9D;QACA;YAAEJ,UAAU;YAAQC,UAAU;YAAaC,QAAQ;gBAAEC,qBAAqB;YAAK;QAAE;QACjF;YAAEH,UAAU;YAAUC,UAAU;YAAaC,QAAQ;gBAAEC,qBAAqB;YAAK;QAAE;QACnF;YACEH,UAAU;YACVC,UAAU;YACVC,QAAQ;gBAAEC,qBAAqB;gBAAME,eAAe;oBAAEC,OAAO;gBAAI;YAAE;QACrE;QACA;YACEN,UAAU;YACVC,UAAU;YACVC,QAAQ;gBAAEC,qBAAqB;gBAAMI,YAAY;oBAAC;wBAAEC,MAAM;wBAASF,OAAO;oBAAI;iBAAE;YAAC;QACnF;QACA;YAAEN,UAAU;YAAQC,UAAU;YAAaC,QAAQ;gBAAEC,qBAAqB;YAAK;QAAE;KAClF,EAAE,+CAA+C,CAAC,EAAEH,QAAQ,EAAEC,QAAQ,EAAEC,MAAM,EAAE;QAC/EN,OACEE,0BAA0B;YACxBG;YACAQ,cAAcP;QAChB,IACAQ,IAAI,CAACV;IACT;IAEAH,GAAG,sEAAsE;QACvED,OACEE,0BAA0B;YACxBa,cAAc;YACdV,UAAU;YACVQ,cAAc;gBAAEN,qBAAqB;YAAK;QAC5C,IACAO,IAAI,CAAC;IACT;IAEAb,GAAG,8FAA8F;QAC/FD,OACEE,0BAA0B;YACxBG,UAAU;YACVQ,cAAc;gBACZG,0BAA0B;gBAC1BT,qBAAqB;gBACrBC,WAAW;oBAAC;iBAAU;YACxB;QACF,IACAM,IAAI,CAAC;IACT;AACF"}

package/dist/uploads/getFileFromClientUpload.d.ts

@@ -0,0 +1,20 @@
+import type { PayloadRequest } from '../types/index.js';
+export type ClientUploadData = {
+    clientUploadContext?: unknown;
+    collectionSlug: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+};
+/**
+ * `req.context` key `unlinkTempFiles` reads to find a materializer-created temp file once
+ * `req.file` is gone - plugin-cloud-storage's afterChange hook clears `req.file` after
+ * uploading generated image sizes, before cleanup runs, so tracking it only on `req.file`
+ * would leak the temp file.
+ */
+export declare const CLIENT_UPLOAD_TEMP_FILE_PATH_CONTEXT_KEY = "payloadClientUploadTempFilePath";
+export declare function getFileFromClientUpload({ file, req, }: {
+    file: ClientUploadData;
+    req: PayloadRequest;
+}): Promise<NonNullable<PayloadRequest['file']>>;
+//# sourceMappingURL=getFileFromClientUpload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getFileFromClientUpload.d.ts","sourceRoot":"","sources":["../../src/uploads/getFileFromClientUpload.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAQvD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,cAAc,EAAE,MAAM,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,wCAAwC,oCAAoC,CAAA;AAEzF,wBAAsB,uBAAuB,CAAC,EAC5C,IAAI,EACJ,GAAG,GACJ,EAAE;IACD,IAAI,EAAE,gBAAgB,CAAA;IACtB,GAAG,EAAE,cAAc,CAAA;CACpB,GAAG,OAAO,CAAC,WAAW,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CA8C/C"}

package/dist/uploads/getFileFromClientUpload.js

@@ -0,0 +1,199 @@
+import { randomUUID } from 'crypto';
+import fs from 'fs';
+import { mkdir, rm, writeFile } from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { APIError } from '../errors/APIError.js';
+import { isolateObjectProperty } from '../utilities/isolateObjectProperty.js';
+import { getFileContentRequirement, HEADER_PROBE_BYTE_LENGTH } from './getFileContentRequirement.js';
+import { getImageSize } from './getImageSize.js';
+/**
+ * `req.context` key `unlinkTempFiles` reads to find a materializer-created temp file once
+ * `req.file` is gone - plugin-cloud-storage's afterChange hook clears `req.file` after
+ * uploading generated image sizes, before cleanup runs, so tracking it only on `req.file`
+ * would leak the temp file.
+ */ export const CLIENT_UPLOAD_TEMP_FILE_PATH_CONTEXT_KEY = 'payloadClientUploadTempFilePath';
+export async function getFileFromClientUpload({ file, req }) {
+    const uploadConfig = req.payload.collections[file.collectionSlug]?.config.upload;
+    if (!uploadConfig || !uploadConfig.handlers) {
+        throw new APIError(`uploadConfig.handlers is not present for ${file.collectionSlug}`);
+    }
+    const contentRequirement = getFileContentRequirement({
+        hasSizeEdits: requestHasSizeEdits(req),
+        mimeType: file.mimeType,
+        uploadConfig
+    });
+    if (contentRequirement === 'none') {
+        return {
+            name: file.filename,
+            clientUploadContext: file.clientUploadContext,
+            data: Buffer.alloc(0),
+            mimetype: file.mimeType,
+            size: file.size
+        };
+    }
+    if (contentRequirement === 'header') {
+        const headerFile = await fetchHeaderOnly({
+            file,
+            req,
+            uploadConfig
+        });
+        if (headerFile) {
+            return headerFile;
+        }
+    }
+    const response = await fetchUploadResponse({
+        file,
+        req,
+        uploadConfig
+    });
+    const tempFilePath = await streamResponseToTempFile({
+        req,
+        response
+    });
+    if (!req.context) {
+        req.context = {};
+    }
+    req.context[CLIENT_UPLOAD_TEMP_FILE_PATH_CONTEXT_KEY] = tempFilePath;
+    return {
+        name: file.filename,
+        clientUploadContext: file.clientUploadContext,
+        data: Buffer.alloc(0),
+        mimetype: response.headers.get('Content-Type') || file.mimeType,
+        size: file.size,
+        tempFilePath
+    };
+}
+/**
+ * Only crop and explicit pixel edits require the original bytes - a focal-point-only
+ * change re-derives from data already on the document, not the incoming upload.
+ */ function requestHasSizeEdits(req) {
+    const uploadEdits = req.query?.uploadEdits && typeof req.query.uploadEdits === 'object' ? req.query.uploadEdits : undefined;
+    return Boolean(uploadEdits?.crop || uploadEdits?.heightInPixels || uploadEdits?.widthInPixels);
+}
+/**
+ * Runs every configured handler and returns the last one that responds, following a single
+ * redirect if that response is one - matching the pre-existing v3 handler contract exactly
+ * (v3 always ran every handler; only v4 stops at the first response, via an unrelated PR).
+ */ async function fetchUploadResponse({ file, req, uploadConfig }) {
+    let response = null;
+    let error;
+    for (const handler of uploadConfig.handlers){
+        try {
+            const result = await handler(req, {
+                doc: null,
+                params: {
+                    clientUploadContext: file.clientUploadContext,
+                    collection: file.collectionSlug,
+                    filename: file.filename
+                }
+            });
+            if (result) {
+                response = result;
+            }
+        // If we couldn't get the file from that handler, save the error and try other.
+        } 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) {
+            // Forward the Range header (if any) so a redirect from the header-probe path still
+            // fetches only the bounded slice, instead of the whole object, from the redirect target.
+            const rangeHeader = req.headers.get('Range');
+            response = rangeHeader ? await fetch(redirectUrl, {
+                headers: {
+                    Range: rangeHeader
+                }
+            }) : await fetch(redirectUrl);
+        }
+    }
+    return response;
+}
+/**
+ * Requests a bounded byte range from the handlers and probes it for image dimensions, without
+ * ever reading past `HEADER_PROBE_BYTE_LENGTH`. Returns `null` when the bounded bytes cannot be
+ * probed, so the caller falls back to a full streamed fetch.
+ */ async function fetchHeaderOnly({ file, req, uploadConfig }) {
+    const rangedHeaders = new Headers(req.headers);
+    rangedHeaders.set('Range', `bytes=0-${HEADER_PROBE_BYTE_LENGTH - 1}`);
+    const scopedReq = isolateObjectProperty(req, 'headers');
+    scopedReq.headers = rangedHeaders;
+    const response = await fetchUploadResponse({
+        file,
+        req: scopedReq,
+        uploadConfig
+    });
+    if (!response.body) {
+        return null;
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let bytesRead = 0;
+    try {
+        while(bytesRead < HEADER_PROBE_BYTE_LENGTH){
+            const { done, value } = await reader.read();
+            if (done || !value) {
+                break;
+            }
+            const remaining = HEADER_PROBE_BYTE_LENGTH - bytesRead;
+            const chunk = value.length > remaining ? value.slice(0, remaining) : value;
+            chunks.push(chunk);
+            bytesRead += chunk.length;
+        }
+    } finally{
+        await reader.cancel().catch(()=>undefined);
+    }
+    const probedFile = {
+        name: file.filename,
+        clientUploadContext: file.clientUploadContext,
+        data: Buffer.concat(chunks),
+        mimetype: response.headers.get('Content-Type') || file.mimeType,
+        size: file.size
+    };
+    try {
+        await getImageSize({
+            file: probedFile,
+            sharp: req.payload.config.sharp
+        });
+    } catch  {
+        return null;
+    }
+    return probedFile;
+}
+/**
+ * Streams the full response body straight to disk so a cloud object of unbounded size never
+ * becomes a single in-memory Buffer.
+ */ async function streamResponseToTempFile({ req, response }) {
+    const tempFileDir = req.payload.config.upload?.tempFileDir || os.tmpdir();
+    await mkdir(tempFileDir, {
+        recursive: true
+    });
+    const tempFilePath = path.join(tempFileDir, `payload-client-upload-${randomUUID()}`);
+    // A null body is a legitimate zero-byte file (the Fetch API allows a Response to omit a
+    // body entirely), not a failure - `response.arrayBuffer()` tolerated this the same way.
+    if (!response.body) {
+        await writeFile(tempFilePath, Buffer.alloc(0));
+        return tempFilePath;
+    }
+    try {
+        await pipeline(Readable.fromWeb(response.body), fs.createWriteStream(tempFilePath));
+    } catch (error) {
+        await rm(tempFilePath, {
+            force: true
+        });
+        throw error;
+    }
+    return tempFilePath;
+}
+
+//# sourceMappingURL=getFileFromClientUpload.js.map

package/dist/uploads/getFileFromClientUpload.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/getFileFromClientUpload.ts"],"sourcesContent":["import { randomUUID } from 'crypto'\nimport fs from 'fs'\nimport { mkdir, rm, writeFile } from 'fs/promises'\nimport os from 'os'\nimport path from 'path'\nimport { Readable } from 'stream'\nimport { pipeline } from 'stream/promises'\n\nimport type { PayloadRequest } from '../types/index.js'\nimport type { SanitizedUploadConfig, UploadEdits } from './types.js'\n\nimport { APIError } from '../errors/APIError.js'\nimport { isolateObjectProperty } from '../utilities/isolateObjectProperty.js'\nimport { getFileContentRequirement, HEADER_PROBE_BYTE_LENGTH } from './getFileContentRequirement.js'\nimport { getImageSize } from './getImageSize.js'\n\nexport type ClientUploadData = {\n  clientUploadContext?: unknown\n  collectionSlug: string\n  filename: string\n  mimeType: string\n  size: number\n}\n\n/**\n * `req.context` key `unlinkTempFiles` reads to find a materializer-created temp file once\n * `req.file` is gone - plugin-cloud-storage's afterChange hook clears `req.file` after\n * uploading generated image sizes, before cleanup runs, so tracking it only on `req.file`\n * would leak the temp file.\n */\nexport const CLIENT_UPLOAD_TEMP_FILE_PATH_CONTEXT_KEY = 'payloadClientUploadTempFilePath'\n\nexport async function getFileFromClientUpload({\n  file,\n  req,\n}: {\n  file: ClientUploadData\n  req: PayloadRequest\n}): Promise<NonNullable<PayloadRequest['file']>> {\n  const uploadConfig = req.payload.collections[file.collectionSlug]?.config.upload\n\n  if (!uploadConfig || !uploadConfig.handlers) {\n    throw new APIError(`uploadConfig.handlers is not present for ${file.collectionSlug}`)\n  }\n\n  const contentRequirement = getFileContentRequirement({\n    hasSizeEdits: requestHasSizeEdits(req),\n    mimeType: file.mimeType,\n    uploadConfig,\n  })\n\n  if (contentRequirement === 'none') {\n    return {\n      name: file.filename,\n      clientUploadContext: file.clientUploadContext,\n      data: Buffer.alloc(0),\n      mimetype: file.mimeType,\n      size: file.size,\n    }\n  }\n\n  if (contentRequirement === 'header') {\n    const headerFile = await fetchHeaderOnly({ file, req, uploadConfig })\n    if (headerFile) {\n      return headerFile\n    }\n  }\n\n  const response = await fetchUploadResponse({ file, req, uploadConfig })\n  const tempFilePath = await streamResponseToTempFile({ req, response })\n\n  if (!req.context) {\n    req.context = {}\n  }\n  req.context[CLIENT_UPLOAD_TEMP_FILE_PATH_CONTEXT_KEY] = tempFilePath\n\n  return {\n    name: file.filename,\n    clientUploadContext: file.clientUploadContext,\n    data: Buffer.alloc(0),\n    mimetype: response.headers.get('Content-Type') || file.mimeType,\n    size: file.size,\n    tempFilePath,\n  }\n}\n\n/**\n * Only crop and explicit pixel edits require the original bytes - a focal-point-only\n * change re-derives from data already on the document, not the incoming upload.\n */\nfunction requestHasSizeEdits(req: PayloadRequest): boolean {\n  const uploadEdits =\n    req.query?.uploadEdits && typeof req.query.uploadEdits === 'object'\n      ? (req.query.uploadEdits as UploadEdits)\n      : undefined\n\n  return Boolean(uploadEdits?.crop || uploadEdits?.heightInPixels || uploadEdits?.widthInPixels)\n}\n\n/**\n * Runs every configured handler and returns the last one that responds, following a single\n * redirect if that response is one - matching the pre-existing v3 handler contract exactly\n * (v3 always ran every handler; only v4 stops at the first response, via an unrelated PR).\n */\nasync function fetchUploadResponse({\n  file,\n  req,\n  uploadConfig,\n}: {\n  file: ClientUploadData\n  req: PayloadRequest\n  uploadConfig: SanitizedUploadConfig\n}): Promise<Response> {\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(req, {\n        doc: null!,\n        params: {\n          clientUploadContext: file.clientUploadContext,\n          collection: file.collectionSlug,\n          filename: file.filename,\n        },\n      })\n\n      if (result) {\n        response = result\n      }\n      // If we couldn't get the file from that handler, save the error and try other.\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      // Forward the Range header (if any) so a redirect from the header-probe path still\n      // fetches only the bounded slice, instead of the whole object, from the redirect target.\n      const rangeHeader = req.headers.get('Range')\n      response = rangeHeader\n        ? await fetch(redirectUrl, { headers: { Range: rangeHeader } })\n        : await fetch(redirectUrl)\n    }\n  }\n\n  return response\n}\n\n/**\n * Requests a bounded byte range from the handlers and probes it for image dimensions, without\n * ever reading past `HEADER_PROBE_BYTE_LENGTH`. Returns `null` when the bounded bytes cannot be\n * probed, so the caller falls back to a full streamed fetch.\n */\nasync function fetchHeaderOnly({\n  file,\n  req,\n  uploadConfig,\n}: {\n  file: ClientUploadData\n  req: PayloadRequest\n  uploadConfig: SanitizedUploadConfig\n}): Promise<NonNullable<PayloadRequest['file']> | null> {\n  const rangedHeaders = new Headers(req.headers)\n  rangedHeaders.set('Range', `bytes=0-${HEADER_PROBE_BYTE_LENGTH - 1}`)\n\n  const scopedReq = isolateObjectProperty(req, 'headers')\n  scopedReq.headers = rangedHeaders\n\n  const response = await fetchUploadResponse({ file, req: scopedReq, uploadConfig })\n\n  if (!response.body) {\n    return null\n  }\n\n  const reader = response.body.getReader()\n  const chunks: Uint8Array[] = []\n  let bytesRead = 0\n\n  try {\n    while (bytesRead < HEADER_PROBE_BYTE_LENGTH) {\n      const { done, value } = await reader.read()\n      if (done || !value) {\n        break\n      }\n\n      const remaining = HEADER_PROBE_BYTE_LENGTH - bytesRead\n      const chunk = value.length > remaining ? value.slice(0, remaining) : value\n\n      chunks.push(chunk)\n      bytesRead += chunk.length\n    }\n  } finally {\n    await reader.cancel().catch(() => undefined)\n  }\n\n  const probedFile = {\n    name: file.filename,\n    clientUploadContext: file.clientUploadContext,\n    data: Buffer.concat(chunks),\n    mimetype: response.headers.get('Content-Type') || file.mimeType,\n    size: file.size,\n  }\n\n  try {\n    await getImageSize({ file: probedFile, sharp: req.payload.config.sharp })\n  } catch {\n    return null\n  }\n\n  return probedFile\n}\n\n/**\n * Streams the full response body straight to disk so a cloud object of unbounded size never\n * becomes a single in-memory Buffer.\n */\nasync function streamResponseToTempFile({\n  req,\n  response,\n}: {\n  req: PayloadRequest\n  response: Response\n}): Promise<string> {\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  // A null body is a legitimate zero-byte file (the Fetch API allows a Response to omit a\n  // body entirely), not a failure - `response.arrayBuffer()` tolerated this the same way.\n  if (!response.body) {\n    await writeFile(tempFilePath, Buffer.alloc(0))\n    return tempFilePath\n  }\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","writeFile","os","path","Readable","pipeline","APIError","isolateObjectProperty","getFileContentRequirement","HEADER_PROBE_BYTE_LENGTH","getImageSize","CLIENT_UPLOAD_TEMP_FILE_PATH_CONTEXT_KEY","getFileFromClientUpload","file","req","uploadConfig","payload","collections","collectionSlug","config","upload","handlers","contentRequirement","hasSizeEdits","requestHasSizeEdits","mimeType","name","filename","clientUploadContext","data","Buffer","alloc","mimetype","size","headerFile","fetchHeaderOnly","response","fetchUploadResponse","tempFilePath","streamResponseToTempFile","context","headers","get","uploadEdits","query","undefined","Boolean","crop","heightInPixels","widthInPixels","error","handler","result","doc","params","collection","err","logger","status","redirectUrl","rangeHeader","fetch","Range","rangedHeaders","Headers","set","scopedReq","body","reader","getReader","chunks","bytesRead","done","value","read","remaining","chunk","length","slice","push","cancel","catch","probedFile","concat","sharp","tempFileDir","tmpdir","recursive","join","fromWeb","createWriteStream","force"],"mappings":"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"}