payload 4.0.0-internal.bc5cf8c → 4.0.0-internal.bf4bcce

package/dist/uploads/getFileContentRequirement.d.ts

@@ -0,0 +1,39 @@
+import type { SanitizedUploadConfig } from './types.js';
+/**
+ * Bytes read from the start of a file to sniff its mime type and, for images, probe its
+ * dimensions. Generous enough to cover real-world header/metadata layouts (EXIF, ICC
+ * profiles, etc.) while staying tiny next to a multi-gigabyte upload.
+ */
+export declare const HEADER_PROBE_BYTE_LENGTH: number;
+export type FileContentRequirement = 'full' | 'header' | 'none';
+/**
+ * Decides how much of an uploaded file's content, if any, is needed to save the document -
+ * so a client upload (e.g. Azure's chunkLargeFiles) only pays for what post-processing
+ * actually reads instead of always being re-downloaded in full.
+ *
+ * - `full`: local storage needs the real bytes, or a registered file transformer will adjust
+ *   the image (`upload.hasImageAdjustments`), or a custom `transformFile` transformer will
+ *   process the file (`hasTransformFileStages`), or the file is animated, or additional image
+ *   sizes will be generated from it, or the collection restricts mime types (which also runs
+ *   SVG/PDF content-safety checks that must see the whole file), or the request itself carries
+ *   a crop/resize edit (`uploadEdits`) that will be applied to the fetched bytes.
+ * - `header`: the file is an image and only its dimensions are needed.
+ * - `none`: nothing downstream reads file content at all.
+ */
+export declare function getFileContentRequirement({ hasSizeEdits, hasTransformFileStages, mimeType, uploadConfig, }: {
+    /**
+     * Whether the request's `uploadEdits` (crop, heightInPixels, widthInPixels) will resize the
+     * fetched file - if so, the full file is needed even when the collection config alone would
+     * only require a header probe.
+     */
+    hasSizeEdits?: boolean;
+    /**
+     * Whether a registered transformer without its own content projection (anything other than a
+     * built-in bridge transformer like `sharpTransformer`) will run `transformFile` on this file.
+     * Such a transformer reads the whole file, so neither a header probe nor no content is enough.
+     */
+    hasTransformFileStages?: 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;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,QAAc,CAAA;AAEnD,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAA;AAE/D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,YAAY,EACZ,sBAAsB,EACtB,QAAQ,EACR,YAAY,GACb,EAAE;IACD;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,qBAAqB,CAAA;CACpC,GAAG,sBAAsB,CA+BzB"}

package/dist/uploads/getFileContentRequirement.js

@@ -0,0 +1,45 @@
+import { canResizeImage } from './canResizeImage.js';
+import { isAnimatedImage } from './isAnimatedImage.js';
+import { isImage } from './isImage.js';
+/**
+ * Bytes read from the start of a file to sniff its mime type and, for images, probe its
+ * dimensions. Generous enough to cover real-world header/metadata layouts (EXIF, ICC
+ * profiles, etc.) while staying tiny next to a multi-gigabyte upload.
+ */ export const HEADER_PROBE_BYTE_LENGTH = 1024 * 1024;
+/**
+ * Decides how much of an uploaded file's content, if any, is needed to save the document -
+ * so a client upload (e.g. Azure's chunkLargeFiles) only pays for what post-processing
+ * actually reads instead of always being re-downloaded in full.
+ *
+ * - `full`: local storage needs the real bytes, or a registered file transformer will adjust
+ *   the image (`upload.hasImageAdjustments`), or a custom `transformFile` transformer will
+ *   process the file (`hasTransformFileStages`), or the file is animated, or additional image
+ *   sizes will be generated from it, or the collection restricts mime types (which also runs
+ *   SVG/PDF content-safety checks that must see the whole file), or the request itself carries
+ *   a crop/resize edit (`uploadEdits`) that will be applied to the fetched bytes.
+ * - `header`: the file is an image and only its dimensions are needed.
+ * - `none`: nothing downstream reads file content at all.
+ */ export function getFileContentRequirement({ hasSizeEdits, hasTransformFileStages, mimeType, uploadConfig }) {
+    if (!uploadConfig.disableLocalStorage) {
+        return 'full';
+    }
+    const hasMimeTypeAllowList = Array.isArray(uploadConfig.mimeTypes) && uploadConfig.mimeTypes.length > 0;
+    if (hasMimeTypeAllowList || hasTransformFileStages) {
+        return 'full';
+    }
+    const isResizableImage = canResizeImage(mimeType);
+    // `hasImageAdjustments` and `variants` are the transformer-agnostic projection a file
+    // transformer writes back onto the sanitized upload config at startup (see
+    // `@payloadcms/transformer-sharp`'s `initSharpCollections`), so core can make this decision
+    // without knowing which transformer is registered or how it is configured.
+    const hasConfiguredAdjustments = Boolean(uploadConfig.hasImageAdjustments || Array.isArray(uploadConfig.variants) && uploadConfig.variants.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\n/**\n * Bytes read from the start of a file to sniff its mime type and, for images, probe its\n * dimensions. Generous enough to cover real-world header/metadata layouts (EXIF, ICC\n * profiles, etc.) while staying tiny next to a multi-gigabyte upload.\n */\nexport const HEADER_PROBE_BYTE_LENGTH = 1024 * 1024\n\nexport type FileContentRequirement = 'full' | 'header' | 'none'\n\n/**\n * Decides how much of an uploaded file's content, if any, is needed to save the document -\n * so a client upload (e.g. Azure's chunkLargeFiles) only pays for what post-processing\n * actually reads instead of always being re-downloaded in full.\n *\n * - `full`: local storage needs the real bytes, or a registered file transformer will adjust\n *   the image (`upload.hasImageAdjustments`), or a custom `transformFile` transformer will\n *   process the file (`hasTransformFileStages`), or the file is animated, or additional image\n *   sizes will be generated from it, or the collection restricts mime types (which also runs\n *   SVG/PDF content-safety checks that must see the whole file), or the request itself carries\n *   a crop/resize edit (`uploadEdits`) that will be applied to the fetched bytes.\n * - `header`: the file is an image and only its dimensions are needed.\n * - `none`: nothing downstream reads file content at all.\n */\nexport function getFileContentRequirement({\n  hasSizeEdits,\n  hasTransformFileStages,\n  mimeType,\n  uploadConfig,\n}: {\n  /**\n   * Whether the request's `uploadEdits` (crop, heightInPixels, widthInPixels) will resize the\n   * fetched file - if so, the full file is needed even when the collection config alone would\n   * only require a header probe.\n   */\n  hasSizeEdits?: boolean\n  /**\n   * Whether a registered transformer without its own content projection (anything other than a\n   * built-in bridge transformer like `sharpTransformer`) will run `transformFile` on this file.\n   * Such a transformer reads the whole file, so neither a header probe nor no content is enough.\n   */\n  hasTransformFileStages?: boolean\n  mimeType: string\n  uploadConfig: SanitizedUploadConfig\n}): FileContentRequirement {\n  if (!uploadConfig.disableLocalStorage) {\n    return 'full'\n  }\n\n  const hasMimeTypeAllowList =\n    Array.isArray(uploadConfig.mimeTypes) && uploadConfig.mimeTypes.length > 0\n\n  if (hasMimeTypeAllowList || hasTransformFileStages) {\n    return 'full'\n  }\n\n  const isResizableImage = canResizeImage(mimeType)\n  // `hasImageAdjustments` and `variants` are the transformer-agnostic projection a file\n  // transformer writes back onto the sanitized upload config at startup (see\n  // `@payloadcms/transformer-sharp`'s `initSharpCollections`), so core can make this decision\n  // without knowing which transformer is registered or how it is configured.\n  const hasConfiguredAdjustments = Boolean(\n    uploadConfig.hasImageAdjustments ||\n      (Array.isArray(uploadConfig.variants) && uploadConfig.variants.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","hasTransformFileStages","mimeType","uploadConfig","disableLocalStorage","hasMimeTypeAllowList","Array","isArray","mimeTypes","length","isResizableImage","hasConfiguredAdjustments","Boolean","hasImageAdjustments","variants"],"mappings":"AAEA,SAASA,cAAc,QAAQ,sBAAqB;AACpD,SAASC,eAAe,QAAQ,uBAAsB;AACtD,SAASC,OAAO,QAAQ,eAAc;AAEtC;;;;CAIC,GACD,OAAO,MAAMC,2BAA2B,OAAO,KAAI;AAInD;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,0BAA0B,EACxCC,YAAY,EACZC,sBAAsB,EACtBC,QAAQ,EACRC,YAAY,EAgBb;IACC,IAAI,CAACA,aAAaC,mBAAmB,EAAE;QACrC,OAAO;IACT;IAEA,MAAMC,uBACJC,MAAMC,OAAO,CAACJ,aAAaK,SAAS,KAAKL,aAAaK,SAAS,CAACC,MAAM,GAAG;IAE3E,IAAIJ,wBAAwBJ,wBAAwB;QAClD,OAAO;IACT;IAEA,MAAMS,mBAAmBf,eAAeO;IACxC,sFAAsF;IACtF,2EAA2E;IAC3E,4FAA4F;IAC5F,2EAA2E;IAC3E,MAAMS,2BAA2BC,QAC/BT,aAAaU,mBAAmB,IAC7BP,MAAMC,OAAO,CAACJ,aAAaW,QAAQ,KAAKX,aAAaW,QAAQ,CAACL,MAAM,GAAG;IAG5E,IAAIT,gBAAiBU,oBAAoBC,4BAA6Bf,gBAAgBM,WAAW;QAC/F,OAAO;IACT;IAEA,IAAIQ,oBAAoBb,QAAQK,WAAW;QACzC,OAAO;IACT;IAEA,OAAO;AACT"}

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;AAexF,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,CA4N9C,CAAA"}

package/dist/uploads/getFileFromUploadInstructions.js

@@ -0,0 +1,400 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import { mkdir, rm, stat } 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 { sanitizeFilename } from '../utilities/sanitizeFilename.js';
+import { sanitizeUploadPrefix } from '../utilities/sanitizeUploadPrefix.js';
+import { verifyClientUploadReceipt } from './clientUploadReceipt.js';
+import { docWithFilenameExists } from './docWithFilenameExists.js';
+import { getOriginalFilename, normalizeStorageKey } from './fileVersioning/naming.js';
+import { getFileContentRequirement, HEADER_PROBE_BYTE_LENGTH } from './getFileContentRequirement.js';
+import { getImageSize } from './getImageSize.js';
+import { hasCropOrResizeEdit } from './hasCropOrResizeEdit.js';
+import { getStagedFile } from './stagedUpload.js';
+import { planTransformerPipeline } from './transformers/planTransformerPipeline.js';
+import { getUploadTransformerInternal } from './transformers/uploadTransformerBridge.js';
+export const getFileFromUploadInstructions = async ({ collectionSlug, file, req })=>{
+    if (req.context) {
+        delete req.context._payloadVerifiedProviderOriginal;
+    }
+    if (!file || typeof file !== 'object' || typeof file.filename !== 'string' || typeof file.mimeType !== 'string' || !Number.isSafeInteger(file.size) || file.size < 0 || !file.uploadReference || typeof file.uploadReference !== 'object' || Array.isArray(file.uploadReference)) {
+        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;
+    let allowOverwrite = false;
+    let providerFilename = file.filename;
+    let verifiedOriginal;
+    if (uploadConfig?.uploadInstructions?.requiresUploadReceipt) {
+        const signedReceipt = 'signedReceipt' in file.uploadReference ? file.uploadReference.signedReceipt : undefined;
+        const receipt = verifyClientUploadReceipt({
+            collectionSlug,
+            filename: file.filename,
+            req,
+            signedReceipt
+        });
+        allowOverwrite = receipt.allowOverwrite === true;
+        let originalFilename;
+        let storageFilePath;
+        try {
+            originalFilename = getOriginalFilename({
+                filename: file.filename
+            });
+            storageFilePath = normalizeStorageKey({
+                key: receipt.storageFilePath
+            });
+        } catch  {
+            throw new APIError('Invalid upload reference.', 400);
+        }
+        const expectedKeySuffix = [
+            receipt.filePrefix,
+            receipt._objectKey,
+            originalFilename
+        ].filter(Boolean).join('/');
+        if (!allowOverwrite && (!receipt._objectKey || path.posix.basename(storageFilePath) !== originalFilename || !`/${storageFilePath}`.endsWith(`/${expectedKeySuffix}`)) || 'prefix' in file.uploadReference && file.uploadReference.prefix !== receipt.filePrefix || '_objectKey' in file.uploadReference && file.uploadReference._objectKey !== receipt._objectKey) {
+            throw new APIError('Invalid upload reference.', 400);
+        }
+        providerFilename = allowOverwrite ? file.filename : originalFilename;
+        if (!allowOverwrite) {
+            verifiedOriginal = {
+                _objectKey: receipt._objectKey,
+                filename: originalFilename,
+                key: storageFilePath,
+                prefix: receipt.filePrefix,
+                signedReceipt: signedReceipt
+            };
+        }
+        file = {
+            ...file,
+            uploadReference: {
+                _objectKey: receipt._objectKey,
+                prefix: receipt.filePrefix,
+                signedReceipt
+            }
+        };
+    }
+    const prefix = 'prefix' in file.uploadReference && typeof file.uploadReference.prefix === 'string' ? file.uploadReference.prefix : undefined;
+    let sanitizedFilename;
+    try {
+        sanitizedFilename = sanitizeFilename(file.filename);
+    } catch  {
+        throw new APIError('Invalid upload reference.', 400);
+    }
+    if (sanitizedFilename !== file.filename || typeof prefix === 'string' && sanitizeUploadPrefix(prefix) !== prefix) {
+        throw new APIError('Invalid upload reference.', 400);
+    }
+    // Provider-backed references are submitted with the document request. They may only claim a
+    // new object identity; existing top-level and generated filenames already belong to another
+    // document and must continue through that document's read access checks.
+    if (!allowOverwrite && await docWithFilenameExists({
+        collectionSlug,
+        filename: file.filename,
+        matchAnyPrefix: true,
+        path: '',
+        prefix,
+        req
+    })) {
+        throw new APIError('Invalid upload reference.', 400);
+    }
+    if (!uploadConfig || !uploadConfig.handlers) {
+        throw new APIError('uploadConfig.handlers is not present for ' + collectionSlug);
+    }
+    const contentRequirement = getFileContentRequirement({
+        hasSizeEdits: requestHasSizeEdits(req),
+        hasTransformFileStages: await hasTransformFileStages({
+            collectionSlug,
+            mimeType: file.mimeType,
+            req
+        }),
+        mimeType: file.mimeType,
+        uploadConfig
+    });
+    const providerFile = {
+        ...file,
+        filename: providerFilename
+    };
+    const rememberVerifiedOriginal = ()=>{
+        if (verifiedOriginal) {
+            req.context ??= {};
+            req.context._payloadVerifiedProviderOriginal = verifiedOriginal;
+        }
+    };
+    // 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') {
+        const response = await fetchUploadResponse({
+            collectionSlug,
+            file: providerFile,
+            rangeHeader: file.size > 0 ? 'bytes=0-0' : undefined,
+            req,
+            uploadConfig
+        });
+        assertProviderFileSize({
+            expectedSize: file.size,
+            response
+        });
+        const prefix = await readBoundedPrefix(response, 1);
+        if (file.size > 0 && prefix.length === 0) {
+            throw new APIError('Uploaded source is not readable.', 400);
+        }
+        rememberVerifiedOriginal();
+        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: providerFile,
+            req,
+            uploadConfig
+        });
+        if (headerFile) {
+            rememberVerifiedOriginal();
+            return {
+                ...headerFile,
+                name: file.filename
+            };
+        }
+    // The header wasn't enough to determine the image's dimensions - fall through to a full fetch.
+    }
+    const response = await fetchUploadResponse({
+        collectionSlug,
+        file: providerFile,
+        req,
+        uploadConfig
+    });
+    const tempFilePath = await streamResponseToTempFile({
+        req,
+        response
+    });
+    if ((await stat(tempFilePath)).size !== file.size) {
+        await rm(tempFilePath, {
+            force: true
+        });
+        throw new APIError('Uploaded source size does not match the declared size.', 400);
+    }
+    req.context ??= {};
+    req.context._payloadClientUploadTempFile = true;
+    rememberVerifiedOriginal();
+    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 - reads the raw
+ * `req.query.uploadEdits`, since a full parse (with its `data`/`originalDoc` focal-point
+ * fallback, done in generateFileData.ts) 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;
+    }
+    return hasCropOrResizeEdit(uploadEdits);
+};
+/**
+ * Whether a transformer that reads the whole file will run `transformFile` on this upload. A
+ * bridge transformer (e.g. `sharpTransformer`) is excluded: it projects what it needs onto the
+ * sanitized upload config (`hasImageAdjustments`, `variants`) at startup instead.
+ */ const hasTransformFileStages = async ({ collectionSlug, mimeType, req })=>{
+    const transformers = req.payload.config.upload?.transformers ?? [];
+    if (transformers.length === 0) {
+        return false;
+    }
+    const pipeline = await planTransformerPipeline({
+        args: {
+            collectionSlug,
+            mimeType,
+            operation: 'upload',
+            req
+        },
+        capability: 'transformFile',
+        transformers
+    });
+    return pipeline.some((transformer)=>!getUploadTransformerInternal(transformer)?.prepareUpload);
+};
+/**
+ * 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
+    });
+    assertProviderFileSize({
+        expectedSize: file.size,
+        response
+    });
+    const headerBuffer = await readBoundedPrefix(response, HEADER_PROBE_BYTE_LENGTH);
+    try {
+        await getImageSize({
+            file: {
+                name: file.filename,
+                data: headerBuffer,
+                mimetype: file.mimeType,
+                size: file.size
+            }
+        });
+    } catch  {
+        return null;
+    }
+    return {
+        name: file.filename,
+        data: headerBuffer,
+        mimetype: response.headers.get('Content-Type') || file.mimeType,
+        size: file.size,
+        uploadReference: file.uploadReference
+    };
+};
+const assertProviderFileSize = ({ expectedSize, response })=>{
+    const contentRange = response.headers.get('Content-Range');
+    const reportedSize = response.status === 206 ? contentRange?.match(/^bytes \d+-\d+\/(\d+)$/)?.[1] : response.headers.get('Content-Length');
+    if (reportedSize === undefined || reportedSize === null || Number(reportedSize) !== expectedSize) {
+        throw new APIError('Uploaded source size does not match the declared size.', 400);
+    }
+};
+/**
+ * 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, {
+                ...rangeHeader && {
+                    headers: {
+                        Range: rangeHeader
+                    }
+                }
+            });
+        }
+    }
+    if (!response.ok) {
+        throw new APIError('Uploaded source is not readable.', 400);
+    }
+    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, stat } 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 { sanitizeFilename } from '../utilities/sanitizeFilename.js'\nimport { sanitizeUploadPrefix } from '../utilities/sanitizeUploadPrefix.js'\nimport { verifyClientUploadReceipt } from './clientUploadReceipt.js'\nimport { docWithFilenameExists } from './docWithFilenameExists.js'\nimport { getOriginalFilename, normalizeStorageKey } from './fileVersioning/naming.js'\nimport { getFileContentRequirement, HEADER_PROBE_BYTE_LENGTH } from './getFileContentRequirement.js'\nimport { getImageSize } from './getImageSize.js'\nimport { hasCropOrResizeEdit } from './hasCropOrResizeEdit.js'\nimport { getStagedFile } from './stagedUpload.js'\nimport { planTransformerPipeline } from './transformers/planTransformerPipeline.js'\nimport { getUploadTransformerInternal } from './transformers/uploadTransformerBridge.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 (req.context) {\n    delete req.context._payloadVerifiedProviderOriginal\n  }\n\n  if (\n    !file ||\n    typeof file !== 'object' ||\n    typeof file.filename !== 'string' ||\n    typeof file.mimeType !== 'string' ||\n    !Number.isSafeInteger(file.size) ||\n    file.size < 0 ||\n    !file.uploadReference ||\n    typeof file.uploadReference !== 'object' ||\n    Array.isArray(file.uploadReference)\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  let allowOverwrite = false\n  let providerFilename = file.filename\n  let verifiedOriginal:\n    | {\n        _objectKey?: string\n        filename: string\n        key: string\n        prefix?: string\n        signedReceipt: string\n      }\n    | undefined\n\n  if (uploadConfig?.uploadInstructions?.requiresUploadReceipt) {\n    const signedReceipt =\n      'signedReceipt' in file.uploadReference ? file.uploadReference.signedReceipt : undefined\n    const receipt = verifyClientUploadReceipt({\n      collectionSlug,\n      filename: file.filename,\n      req,\n      signedReceipt,\n    })\n    allowOverwrite = receipt.allowOverwrite === true\n    let originalFilename: string\n    let storageFilePath: string\n\n    try {\n      originalFilename = getOriginalFilename({ filename: file.filename })\n      storageFilePath = normalizeStorageKey({ key: receipt.storageFilePath })\n    } catch {\n      throw new APIError('Invalid upload reference.', 400)\n    }\n\n    const expectedKeySuffix = [receipt.filePrefix, receipt._objectKey, originalFilename]\n      .filter(Boolean)\n      .join('/')\n\n    if (\n      (!allowOverwrite &&\n        (!receipt._objectKey ||\n          path.posix.basename(storageFilePath) !== originalFilename ||\n          !`/${storageFilePath}`.endsWith(`/${expectedKeySuffix}`))) ||\n      ('prefix' in file.uploadReference && file.uploadReference.prefix !== receipt.filePrefix) ||\n      ('_objectKey' in file.uploadReference &&\n        file.uploadReference._objectKey !== receipt._objectKey)\n    ) {\n      throw new APIError('Invalid upload reference.', 400)\n    }\n\n    providerFilename = allowOverwrite ? file.filename : originalFilename\n    if (!allowOverwrite) {\n      verifiedOriginal = {\n        _objectKey: receipt._objectKey,\n        filename: originalFilename,\n        key: storageFilePath,\n        prefix: receipt.filePrefix,\n        signedReceipt: signedReceipt as string,\n      }\n    }\n    file = {\n      ...file,\n      uploadReference: {\n        _objectKey: receipt._objectKey,\n        prefix: receipt.filePrefix,\n        signedReceipt,\n      },\n    }\n  }\n\n  const prefix =\n    'prefix' in file.uploadReference && typeof file.uploadReference.prefix === 'string'\n      ? file.uploadReference.prefix\n      : undefined\n\n  let sanitizedFilename: string\n\n  try {\n    sanitizedFilename = sanitizeFilename(file.filename)\n  } catch {\n    throw new APIError('Invalid upload reference.', 400)\n  }\n\n  if (\n    sanitizedFilename !== file.filename ||\n    (typeof prefix === 'string' && sanitizeUploadPrefix(prefix) !== prefix)\n  ) {\n    throw new APIError('Invalid upload reference.', 400)\n  }\n\n  // Provider-backed references are submitted with the document request. They may only claim a\n  // new object identity; existing top-level and generated filenames already belong to another\n  // document and must continue through that document's read access checks.\n  if (\n    !allowOverwrite &&\n    (await docWithFilenameExists({\n      collectionSlug,\n      filename: file.filename,\n      matchAnyPrefix: true,\n      path: '',\n      prefix,\n      req,\n    }))\n  ) {\n    throw new APIError('Invalid upload reference.', 400)\n  }\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    hasTransformFileStages: await hasTransformFileStages({\n      collectionSlug,\n      mimeType: file.mimeType,\n      req,\n    }),\n    mimeType: file.mimeType,\n    uploadConfig,\n  })\n  const providerFile = { ...file, filename: providerFilename }\n  const rememberVerifiedOriginal = () => {\n    if (verifiedOriginal) {\n      req.context ??= {}\n      req.context._payloadVerifiedProviderOriginal = verifiedOriginal\n    }\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    const response = await fetchUploadResponse({\n      collectionSlug,\n      file: providerFile,\n      rangeHeader: file.size > 0 ? 'bytes=0-0' : undefined,\n      req,\n      uploadConfig,\n    })\n    assertProviderFileSize({ expectedSize: file.size, response })\n    const prefix = await readBoundedPrefix(response, 1)\n    if (file.size > 0 && prefix.length === 0) {\n      throw new APIError('Uploaded source is not readable.', 400)\n    }\n    rememberVerifiedOriginal()\n\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({\n      collectionSlug,\n      file: providerFile,\n      req,\n      uploadConfig,\n    })\n    if (headerFile) {\n      rememberVerifiedOriginal()\n      return { ...headerFile, name: file.filename }\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({\n    collectionSlug,\n    file: providerFile,\n    req,\n    uploadConfig,\n  })\n\n  const tempFilePath = await streamResponseToTempFile({ req, response })\n  if ((await stat(tempFilePath)).size !== file.size) {\n    await rm(tempFilePath, { force: true })\n    throw new APIError('Uploaded source size does not match the declared size.', 400)\n  }\n  req.context ??= {}\n  req.context._payloadClientUploadTempFile = true\n  rememberVerifiedOriginal()\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 - reads the raw\n * `req.query.uploadEdits`, since a full parse (with its `data`/`originalDoc` focal-point\n * fallback, done in generateFileData.ts) isn't available yet at this point in the request\n * 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  return hasCropOrResizeEdit(uploadEdits as UploadEdits)\n}\n\n/**\n * Whether a transformer that reads the whole file will run `transformFile` on this upload. A\n * bridge transformer (e.g. `sharpTransformer`) is excluded: it projects what it needs onto the\n * sanitized upload config (`hasImageAdjustments`, `variants`) at startup instead.\n */\nconst hasTransformFileStages = async ({\n  collectionSlug,\n  mimeType,\n  req,\n}: {\n  collectionSlug: string\n  mimeType: string\n  req: PayloadRequest\n}): Promise<boolean> => {\n  const transformers = req.payload.config.upload?.transformers ?? []\n\n  if (transformers.length === 0) {\n    return false\n  }\n\n  const pipeline = await planTransformerPipeline({\n    args: { collectionSlug, mimeType, operation: 'upload', req },\n    capability: 'transformFile',\n    transformers,\n  })\n\n  return pipeline.some((transformer) => !getUploadTransformerInternal(transformer)?.prepareUpload)\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  assertProviderFileSize({ expectedSize: file.size, response })\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    })\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\nconst assertProviderFileSize = ({\n  expectedSize,\n  response,\n}: {\n  expectedSize: number\n  response: Response\n}): void => {\n  const contentRange = response.headers.get('Content-Range')\n  const reportedSize =\n    response.status === 206\n      ? contentRange?.match(/^bytes \\d+-\\d+\\/(\\d+)$/)?.[1]\n      : response.headers.get('Content-Length')\n\n  if (\n    reportedSize === undefined ||\n    reportedSize === null ||\n    Number(reportedSize) !== expectedSize\n  ) {\n    throw new APIError('Uploaded source size does not match the declared size.', 400)\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        ...(rangeHeader && { headers: { Range: rangeHeader } }),\n      })\n    }\n  }\n\n  if (!response.ok) {\n    throw new APIError('Uploaded source is not readable.', 400)\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","stat","os","path","Readable","pipeline","APIError","sanitizeFilename","sanitizeUploadPrefix","verifyClientUploadReceipt","docWithFilenameExists","getOriginalFilename","normalizeStorageKey","getFileContentRequirement","HEADER_PROBE_BYTE_LENGTH","getImageSize","hasCropOrResizeEdit","getStagedFile","planTransformerPipeline","getUploadTransformerInternal","getFileFromUploadInstructions","collectionSlug","file","req","context","_payloadVerifiedProviderOriginal","filename","mimeType","Number","isSafeInteger","size","uploadReference","Array","isArray","uploadConfig","payload","collections","config","upload","allowOverwrite","providerFilename","verifiedOriginal","uploadInstructions","requiresUploadReceipt","signedReceipt","undefined","receipt","originalFilename","storageFilePath","key","expectedKeySuffix","filePrefix","_objectKey","filter","Boolean","join","posix","basename","endsWith","prefix","sanitizedFilename","matchAnyPrefix","handlers","contentRequirement","hasSizeEdits","requestHasSizeEdits","hasTransformFileStages","providerFile","rememberVerifiedOriginal","response","fetchUploadResponse","rangeHeader","assertProviderFileSize","expectedSize","readBoundedPrefix","length","name","data","Buffer","alloc","mimetype","headerFile","fetchHeaderOnly","tempFilePath","streamResponseToTempFile","force","_payloadClientUploadTempFile","headers","get","uploadEdits","query","transformers","args","operation","capability","some","transformer","prepareUpload","headerBuffer","contentRange","reportedSize","status","match","scopedReq","withRangeHeader","error","handler","result","doc","params","collection","err","logger","redirectUrl","fetch","Range","ok","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","fromWeb","createWriteStream"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"getFileTypeFallback.d.ts","sourceRoot":"","sources":["../../src/uploads/getFileTypeFallback.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAiBD,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,KAAG,UAOlD,CAAA"}
+{"version":3,"file":"getFileTypeFallback.d.ts","sourceRoot":"","sources":["../../src/uploads/getFileTypeFallback.ts"],"names":[],"mappings":"AAEA,KAAK,UAAU,GAAG;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAkBD,eAAO,MAAM,mBAAmB,SAAU,MAAM,KAAG,UAOlD,CAAA"}

package/dist/uploads/getFileTypeFallback.js

@@ -1,3 +1,4 @@
+import { getFileExtension, getSanitizedUploadFilename } from './getFileTypeIdentity.js';
 const extensionMap = {
     css: 'text/css',
     csv: 'text/csv',
@@ -7,11 +8,12 @@ const extensionMap = {
     json: 'application/json',
     md: 'text/markdown',
     svg: 'image/svg+xml',
+    xhtml: 'application/xhtml+xml',
     xml: 'application/xml',
     yml: 'application/x-yaml'
 };
 export const getFileTypeFallback = (path)=>{
-    const ext = path.split('.').pop() || 'txt';
+    const ext = getFileExtension(getSanitizedUploadFilename(path)).toLowerCase() || 'txt';
     return {
         ext,
         mime: extensionMap[ext] || 'text/plain'

package/dist/uploads/getFileTypeFallback.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/uploads/getFileTypeFallback.ts"],"sourcesContent":["type ReturnType = {\n  ext: string\n  mime: string\n}\n\nconst extensionMap: {\n  [ext: string]: string\n} = {\n  css: 'text/css',\n  csv: 'text/csv',\n  htm: 'text/html',\n  html: 'text/html',\n  js: 'application/javascript',\n  json: 'application/json',\n  md: 'text/markdown',\n  svg: 'image/svg+xml',\n  xml: 'application/xml',\n  yml: 'application/x-yaml',\n}\n\nexport const getFileTypeFallback = (path: string): ReturnType => {\n  const ext = path.split('.').pop() || 'txt'\n\n  return {\n    ext,\n    mime: extensionMap[ext] || 'text/plain',\n  }\n}\n"],"names":["extensionMap","css","csv","htm","html","js","json","md","svg","xml","yml","getFileTypeFallback","path","ext","split","pop","mime"],"mappings":"AAKA,MAAMA,eAEF;IACFC,KAAK;IACLC,KAAK;IACLC,KAAK;IACLC,MAAM;IACNC,IAAI;IACJC,MAAM;IACNC,IAAI;IACJC,KAAK;IACLC,KAAK;IACLC,KAAK;AACP;AAEA,OAAO,MAAMC,sBAAsB,CAACC;IAClC,MAAMC,MAAMD,KAAKE,KAAK,CAAC,KAAKC,GAAG,MAAM;IAErC,OAAO;QACLF;QACAG,MAAMhB,YAAY,CAACa,IAAI,IAAI;IAC7B;AACF,EAAC"}
+{"version":3,"sources":["../../src/uploads/getFileTypeFallback.ts"],"sourcesContent":["import { getFileExtension, getSanitizedUploadFilename } from './getFileTypeIdentity.js'\n\ntype ReturnType = {\n  ext: string\n  mime: string\n}\n\nconst extensionMap: {\n  [ext: string]: string\n} = {\n  css: 'text/css',\n  csv: 'text/csv',\n  htm: 'text/html',\n  html: 'text/html',\n  js: 'application/javascript',\n  json: 'application/json',\n  md: 'text/markdown',\n  svg: 'image/svg+xml',\n  xhtml: 'application/xhtml+xml',\n  xml: 'application/xml',\n  yml: 'application/x-yaml',\n}\n\nexport const getFileTypeFallback = (path: string): ReturnType => {\n  const ext = getFileExtension(getSanitizedUploadFilename(path)).toLowerCase() || 'txt'\n\n  return {\n    ext,\n    mime: extensionMap[ext] || 'text/plain',\n  }\n}\n"],"names":["getFileExtension","getSanitizedUploadFilename","extensionMap","css","csv","htm","html","js","json","md","svg","xhtml","xml","yml","getFileTypeFallback","path","ext","toLowerCase","mime"],"mappings":"AAAA,SAASA,gBAAgB,EAAEC,0BAA0B,QAAQ,2BAA0B;AAOvF,MAAMC,eAEF;IACFC,KAAK;IACLC,KAAK;IACLC,KAAK;IACLC,MAAM;IACNC,IAAI;IACJC,MAAM;IACNC,IAAI;IACJC,KAAK;IACLC,OAAO;IACPC,KAAK;IACLC,KAAK;AACP;AAEA,OAAO,MAAMC,sBAAsB,CAACC;IAClC,MAAMC,MAAMhB,iBAAiBC,2BAA2Bc,OAAOE,WAAW,MAAM;IAEhF,OAAO;QACLD;QACAE,MAAMhB,YAAY,CAACc,IAAI,IAAI;IAC7B;AACF,EAAC"}

package/dist/uploads/getFileTypeIdentity.d.ts

@@ -0,0 +1,19 @@
+export declare const getFileExtension: (filename: string) => string;
+export declare const getSanitizedUploadFilename: (filename: string, outputExtension?: string) => string;
+export declare const getMimeTypeEssence: (mimeType?: null | string) => string;
+export declare const isSvgMimeType: (mimeType?: null | string) => boolean;
+export declare const isXmlMimeType: (mimeType?: null | string) => boolean;
+export declare const isSvgUpload: ({ filename, mimeType, }: {
+    filename: string;
+    mimeType?: null | string;
+}) => boolean;
+export declare const isXmlUpload: ({ filename, mimeType, }: {
+    filename: string;
+    mimeType?: null | string;
+}) => boolean;
+export declare const uploadRequiresServerValidation: (upload: {
+    allowRestrictedFileTypes?: boolean;
+    filename: string;
+    mimeType?: null | string;
+}) => boolean;
+//# sourceMappingURL=getFileTypeIdentity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getFileTypeIdentity.d.ts","sourceRoot":"","sources":["../../src/uploads/getFileTypeIdentity.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB,aAAc,MAAM,KAAG,MASnD,CAAA;AAED,eAAO,MAAM,0BAA0B,aAAc,MAAM,oBAAoB,MAAM,KAAG,MAOvF,CAAA;AAED,eAAO,MAAM,kBAAkB,cAAe,IAAI,GAAG,MAAM,KAAG,MAQ7D,CAAA;AAED,eAAO,MAAM,aAAa,cAAe,IAAI,GAAG,MAAM,KAAG,OACP,CAAA;AAElD,eAAO,MAAM,aAAa,cAAe,IAAI,GAAG,MAAM,KAAG,OAQxD,CAAA;AAED,eAAO,MAAM,WAAW,4BAGrB;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,IAAI,GAAG,MAAM,CAAA;CACzB,KAAG,OAEqB,CAAA;AAEzB,eAAO,MAAM,WAAW,4BAGrB;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,IAAI,GAAG,MAAM,CAAA;CACzB,KAAG,OAEqB,CAAA;AAEzB,eAAO,MAAM,8BAA8B,WAAY;IACrD,wBAAwB,CAAC,EAAE,OAAO,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,IAAI,GAAG,MAAM,CAAA;CACzB,KAAG,OAA2F,CAAA"}