@payloadcms/plugin-cloud-storage 4.0.0-internal.567a487 → 4.0.0-internal.58473b9

package/dist/utilities/buildStoragePathData.js

@@ -0,0 +1,67 @@
+import path from 'path';
+import { sanitizeFilename } from 'payload/shared';
+import { sanitizePrefix } from './sanitizePrefix.js';
+export function isStoragePathWithinCollectionPrefix({ collectionPrefix, docPrefix }) {
+    const safeCollectionPrefix = sanitizePrefix(collectionPrefix || '');
+    return !safeCollectionPrefix || docPrefix === safeCollectionPrefix || docPrefix.startsWith(`${safeCollectionPrefix}/`);
+}
+/**
+ * Resolves where a new upload must be stored, without needing a filename.
+ *
+ * In non-composite mode (useCompositePrefixes: false), docPrefix is treated as a complete prefix
+ * when it is already within collectionPrefix and is otherwise nested beneath collectionPrefix.
+ * In composite mode (useCompositePrefixes: true), the collection prefix is joined when the key is
+ * built, so the persisted document prefix stays relative to it.
+ *
+ * Prefix-only callers (such as the upload prefix hooks) use this directly; use
+ * {@link buildUploadStoragePathData} when a full object key is needed.
+ */ export function buildUploadPrefix({ collectionPrefix, docPrefix, useCompositePrefixes = false }) {
+    const safeCollectionPrefix = sanitizePrefix(collectionPrefix || '');
+    const safeDocPrefix = sanitizePrefix(docPrefix || '');
+    const uploadPrefix = safeDocPrefix && !isStoragePathWithinCollectionPrefix({
+        collectionPrefix: safeCollectionPrefix,
+        docPrefix: safeDocPrefix
+    }) ? path.posix.join(safeCollectionPrefix, safeDocPrefix) : safeDocPrefix || safeCollectionPrefix;
+    return {
+        sanitizedCollectionPrefix: safeCollectionPrefix,
+        sanitizedDocPrefix: !useCompositePrefixes && safeDocPrefix ? uploadPrefix : safeDocPrefix,
+        uploadPrefix
+    };
+}
+/**
+ * Resolves a new upload destination beneath the configured collection prefix.
+ * Both prefixes are passed through {@link sanitizePrefix} so keys stay normalized.
+ */ export function buildUploadStoragePathData({ collectionPrefix, docPrefix, filename, useCompositePrefixes = false }) {
+    const { sanitizedCollectionPrefix, sanitizedDocPrefix, uploadPrefix } = buildUploadPrefix({
+        collectionPrefix,
+        docPrefix,
+        useCompositePrefixes
+    });
+    const safeFilename = sanitizeFilename(filename);
+    const storageFilePath = useCompositePrefixes ? path.posix.join(sanitizedCollectionPrefix, sanitizedDocPrefix, safeFilename) : path.posix.join(uploadPrefix, safeFilename);
+    return {
+        sanitizedCollectionPrefix,
+        sanitizedDocPrefix,
+        sanitizedFilename: safeFilename,
+        storageFilePath
+    };
+}
+/**
+ * Resolves the exact location represented by persisted upload metadata.
+ * Non-composite document prefixes historically override the collection prefix;
+ * keep that behavior for reads, URLs, and cleanup of pre-upgrade files.
+ * New writes must use buildUploadStoragePathData instead.
+ */ export function buildStoragePathData({ collectionPrefix, docPrefix, filename, useCompositePrefixes = false }) {
+    const sanitizedCollectionPrefix = sanitizePrefix(collectionPrefix || '');
+    const sanitizedDocPrefix = sanitizePrefix(docPrefix || '');
+    const sanitizedFilename = sanitizeFilename(filename);
+    const storageFilePath = useCompositePrefixes ? path.posix.join(sanitizedCollectionPrefix, sanitizedDocPrefix, sanitizedFilename) : path.posix.join(sanitizedDocPrefix || sanitizedCollectionPrefix, sanitizedFilename);
+    return {
+        sanitizedCollectionPrefix,
+        sanitizedDocPrefix,
+        sanitizedFilename,
+        storageFilePath
+    };
+}
+
+//# sourceMappingURL=buildStoragePathData.js.map

package/dist/utilities/buildStoragePathData.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/buildStoragePathData.ts"],"sourcesContent":["import path from 'path'\nimport { sanitizeFilename } from 'payload/shared'\n\nimport { sanitizePrefix } from './sanitizePrefix.js'\n\ntype BuildFilePathDataArgs = {\n  collectionPrefix?: string\n  docPrefix?: string\n  filename: string\n  useCompositePrefixes?: boolean\n}\n\ntype BuildFilePathDataResult = {\n  sanitizedCollectionPrefix: string\n  sanitizedDocPrefix: string\n  sanitizedFilename: string\n  /**\n   * The full path to the file within the storage backend.\n   */\n  storageFilePath: string\n}\n\nexport function isStoragePathWithinCollectionPrefix({\n  collectionPrefix,\n  docPrefix,\n}: {\n  collectionPrefix?: string\n  docPrefix: string\n}): boolean {\n  const safeCollectionPrefix = sanitizePrefix(collectionPrefix || '')\n\n  return (\n    !safeCollectionPrefix ||\n    docPrefix === safeCollectionPrefix ||\n    docPrefix.startsWith(`${safeCollectionPrefix}/`)\n  )\n}\n\n/**\n * Resolves where a new upload must be stored, without needing a filename.\n *\n * In non-composite mode (useCompositePrefixes: false), docPrefix is treated as a complete prefix\n * when it is already within collectionPrefix and is otherwise nested beneath collectionPrefix.\n * In composite mode (useCompositePrefixes: true), the collection prefix is joined when the key is\n * built, so the persisted document prefix stays relative to it.\n *\n * Prefix-only callers (such as the upload prefix hooks) use this directly; use\n * {@link buildUploadStoragePathData} when a full object key is needed.\n */\nexport function buildUploadPrefix({\n  collectionPrefix,\n  docPrefix,\n  useCompositePrefixes = false,\n}: Omit<BuildFilePathDataArgs, 'filename'>): {\n  sanitizedCollectionPrefix: string\n  sanitizedDocPrefix: string\n  uploadPrefix: string\n} {\n  const safeCollectionPrefix = sanitizePrefix(collectionPrefix || '')\n  const safeDocPrefix = sanitizePrefix(docPrefix || '')\n  const uploadPrefix =\n    safeDocPrefix &&\n    !isStoragePathWithinCollectionPrefix({\n      collectionPrefix: safeCollectionPrefix,\n      docPrefix: safeDocPrefix,\n    })\n      ? path.posix.join(safeCollectionPrefix, safeDocPrefix)\n      : safeDocPrefix || safeCollectionPrefix\n\n  return {\n    sanitizedCollectionPrefix: safeCollectionPrefix,\n    sanitizedDocPrefix: !useCompositePrefixes && safeDocPrefix ? uploadPrefix : safeDocPrefix,\n    uploadPrefix,\n  }\n}\n\n/**\n * Resolves a new upload destination beneath the configured collection prefix.\n * Both prefixes are passed through {@link sanitizePrefix} so keys stay normalized.\n */\nexport function buildUploadStoragePathData({\n  collectionPrefix,\n  docPrefix,\n  filename,\n  useCompositePrefixes = false,\n}: BuildFilePathDataArgs): BuildFilePathDataResult {\n  const { sanitizedCollectionPrefix, sanitizedDocPrefix, uploadPrefix } = buildUploadPrefix({\n    collectionPrefix,\n    docPrefix,\n    useCompositePrefixes,\n  })\n  const safeFilename = sanitizeFilename(filename)\n\n  const storageFilePath = useCompositePrefixes\n    ? path.posix.join(sanitizedCollectionPrefix, sanitizedDocPrefix, safeFilename)\n    : path.posix.join(uploadPrefix, safeFilename)\n\n  return {\n    sanitizedCollectionPrefix,\n    sanitizedDocPrefix,\n    sanitizedFilename: safeFilename,\n    storageFilePath,\n  }\n}\n\n/**\n * Resolves the exact location represented by persisted upload metadata.\n * Non-composite document prefixes historically override the collection prefix;\n * keep that behavior for reads, URLs, and cleanup of pre-upgrade files.\n * New writes must use buildUploadStoragePathData instead.\n */\nexport function buildStoragePathData({\n  collectionPrefix,\n  docPrefix,\n  filename,\n  useCompositePrefixes = false,\n}: BuildFilePathDataArgs): BuildFilePathDataResult {\n  const sanitizedCollectionPrefix = sanitizePrefix(collectionPrefix || '')\n  const sanitizedDocPrefix = sanitizePrefix(docPrefix || '')\n  const sanitizedFilename = sanitizeFilename(filename)\n  const storageFilePath = useCompositePrefixes\n    ? path.posix.join(sanitizedCollectionPrefix, sanitizedDocPrefix, sanitizedFilename)\n    : path.posix.join(sanitizedDocPrefix || sanitizedCollectionPrefix, sanitizedFilename)\n\n  return {\n    sanitizedCollectionPrefix,\n    sanitizedDocPrefix,\n    sanitizedFilename,\n    storageFilePath,\n  }\n}\n"],"names":["path","sanitizeFilename","sanitizePrefix","isStoragePathWithinCollectionPrefix","collectionPrefix","docPrefix","safeCollectionPrefix","startsWith","buildUploadPrefix","useCompositePrefixes","safeDocPrefix","uploadPrefix","posix","join","sanitizedCollectionPrefix","sanitizedDocPrefix","buildUploadStoragePathData","filename","safeFilename","storageFilePath","sanitizedFilename","buildStoragePathData"],"mappings":"AAAA,OAAOA,UAAU,OAAM;AACvB,SAASC,gBAAgB,QAAQ,iBAAgB;AAEjD,SAASC,cAAc,QAAQ,sBAAqB;AAmBpD,OAAO,SAASC,oCAAoC,EAClDC,gBAAgB,EAChBC,SAAS,EAIV;IACC,MAAMC,uBAAuBJ,eAAeE,oBAAoB;IAEhE,OACE,CAACE,wBACDD,cAAcC,wBACdD,UAAUE,UAAU,CAAC,GAAGD,qBAAqB,CAAC,CAAC;AAEnD;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASE,kBAAkB,EAChCJ,gBAAgB,EAChBC,SAAS,EACTI,uBAAuB,KAAK,EACY;IAKxC,MAAMH,uBAAuBJ,eAAeE,oBAAoB;IAChE,MAAMM,gBAAgBR,eAAeG,aAAa;IAClD,MAAMM,eACJD,iBACA,CAACP,oCAAoC;QACnCC,kBAAkBE;QAClBD,WAAWK;IACb,KACIV,KAAKY,KAAK,CAACC,IAAI,CAACP,sBAAsBI,iBACtCA,iBAAiBJ;IAEvB,OAAO;QACLQ,2BAA2BR;QAC3BS,oBAAoB,CAACN,wBAAwBC,gBAAgBC,eAAeD;QAC5EC;IACF;AACF;AAEA;;;CAGC,GACD,OAAO,SAASK,2BAA2B,EACzCZ,gBAAgB,EAChBC,SAAS,EACTY,QAAQ,EACRR,uBAAuB,KAAK,EACN;IACtB,MAAM,EAAEK,yBAAyB,EAAEC,kBAAkB,EAAEJ,YAAY,EAAE,GAAGH,kBAAkB;QACxFJ;QACAC;QACAI;IACF;IACA,MAAMS,eAAejB,iBAAiBgB;IAEtC,MAAME,kBAAkBV,uBACpBT,KAAKY,KAAK,CAACC,IAAI,CAACC,2BAA2BC,oBAAoBG,gBAC/DlB,KAAKY,KAAK,CAACC,IAAI,CAACF,cAAcO;IAElC,OAAO;QACLJ;QACAC;QACAK,mBAAmBF;QACnBC;IACF;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASE,qBAAqB,EACnCjB,gBAAgB,EAChBC,SAAS,EACTY,QAAQ,EACRR,uBAAuB,KAAK,EACN;IACtB,MAAMK,4BAA4BZ,eAAeE,oBAAoB;IACrE,MAAMW,qBAAqBb,eAAeG,aAAa;IACvD,MAAMe,oBAAoBnB,iBAAiBgB;IAC3C,MAAME,kBAAkBV,uBACpBT,KAAKY,KAAK,CAACC,IAAI,CAACC,2BAA2BC,oBAAoBK,qBAC/DpB,KAAKY,KAAK,CAACC,IAAI,CAACE,sBAAsBD,2BAA2BM;IAErE,OAAO;QACLN;QACAC;QACAK;QACAD;IACF;AACF"}

package/dist/utilities/getFilePrefix.d.ts

@@ -1,20 +1,28 @@
-import type { CollectionConfig, PayloadRequest } from 'payload';
+import type { CollectionConfig, PayloadRequest, TypeWithID } from 'payload';
 /**
- * Resolves the file prefix from the highest-priority available source and
- * always returns a sanitized value.
+ * Resolves the folder a stored object lives under (semantic `prefix` plus `_objectKey`).
  *
- * Resolution order:
- * 1. `prefixQueryParam`
- * 2. `uploadReference.prefix`
- * 3. Stored document `prefix` from the database
- *
- * Resolved values are passed through `sanitizePrefix`.
+ * An already-authorized `doc` wins outright. Otherwise an `uploadReference` is used (its
+ * `prefix` re-contained with {@link buildUploadStoragePathData}, since it hasn't been verified against
+ * a signed receipt by every adapter). Otherwise the document is resolved with
+ * `overrideAccess: false`, any query-param prefix only narrows that lookup, and `_objectKey`
+ * is read from the resolved document via `showHiddenFields`.
  */
-export declare function getFilePrefix({ collection, filename, prefixQueryParam, req, uploadReference, }: {
+export declare function getFilePrefix({ collection, collectionPrefix, doc, filename, prefixQueryParam, req, uploadReference, useCompositePrefixes, }: {
     collection: CollectionConfig;
+    collectionPrefix?: string;
+    doc?: {
+        _objectKey?: string;
+        prefix?: string;
+    } & TypeWithID;
     filename: string;
+    /**
+     * Only narrows the access-controlled fallback lookup below; never trusted or
+     * returned directly. Prefer passing the access-checked document as `doc` instead.
+     */
     prefixQueryParam?: string;
     req: PayloadRequest;
     uploadReference?: unknown;
+    useCompositePrefixes?: boolean;
 }): Promise<string>;
 //# sourceMappingURL=getFilePrefix.d.ts.map

package/dist/utilities/getFilePrefix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getFilePrefix.d.ts","sourceRoot":"","sources":["../../src/utilities/getFilePrefix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAgB,MAAM,SAAS,CAAA;AAI7E;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CAAC,EAClC,UAAU,EACV,QAAQ,EACR,gBAAgB,EAChB,GAAG,EACH,eAAe,GAChB,EAAE;IACD,UAAU,EAAE,gBAAgB,CAAA;IAC5B,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,GAAG,EAAE,cAAc,CAAA;IACnB,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,GAAG,OAAO,CAAC,MAAM,CAAC,CAoClB"}
+{"version":3,"file":"getFilePrefix.d.ts","sourceRoot":"","sources":["../../src/utilities/getFilePrefix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAyB,UAAU,EAAE,MAAM,SAAS,CAAA;AAMlG;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,EAClC,UAAU,EACV,gBAAgB,EAChB,GAAG,EACH,QAAQ,EACR,gBAAgB,EAChB,GAAG,EACH,eAAe,EACf,oBAA4B,GAC7B,EAAE;IACD,UAAU,EAAE,gBAAgB,CAAA;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,GAAG,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,UAAU,CAAA;IAC3D,QAAQ,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,GAAG,EAAE,cAAc,CAAA;IACnB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B,GAAG,OAAO,CAAC,MAAM,CAAC,CAqElB"}

package/dist/utilities/getFilePrefix.js

@@ -1,46 +1,86 @@
+import { buildPrefixWithObjectKey } from './buildPrefixWithObjectKey.js';
+import { buildUploadStoragePathData } from './buildStoragePathData.js';
 import { sanitizePrefix } from './sanitizePrefix.js';
 /**
- * Resolves the file prefix from the highest-priority available source and
- * always returns a sanitized value.
+ * Resolves the folder a stored object lives under (semantic `prefix` plus `_objectKey`).
  *
- * Resolution order:
- * 1. `prefixQueryParam`
- * 2. `uploadReference.prefix`
- * 3. Stored document `prefix` from the database
- *
- * Resolved values are passed through `sanitizePrefix`.
- */ export async function getFilePrefix({ collection, filename, prefixQueryParam, req, uploadReference }) {
-    if (typeof prefixQueryParam === 'string') {
-        return sanitizePrefix(prefixQueryParam);
+ * An already-authorized `doc` wins outright. Otherwise an `uploadReference` is used (its
+ * `prefix` re-contained with {@link buildUploadStoragePathData}, since it hasn't been verified against
+ * a signed receipt by every adapter). Otherwise the document is resolved with
+ * `overrideAccess: false`, any query-param prefix only narrows that lookup, and `_objectKey`
+ * is read from the resolved document via `showHiddenFields`.
+ */ export async function getFilePrefix({ collection, collectionPrefix, doc, filename, prefixQueryParam, req, uploadReference, useCompositePrefixes = false }) {
+    // The serve path already loaded and authorized this document — trust it over any
+    // client-supplied upload reference or query prefix.
+    if (doc) {
+        return buildPrefixWithObjectKey({
+            objectKey: doc._objectKey,
+            prefix: doc.prefix
+        });
     }
-    // Prioritize the upload reference prefix if there is one.
+    // Upload instructions call handlers without a document yet. Re-contain the claimed
+    // prefix — it hasn't been verified against a signed receipt by every adapter.
     if (uploadReference && typeof uploadReference === 'object' && 'prefix' in uploadReference && typeof uploadReference.prefix === 'string') {
-        return sanitizePrefix(uploadReference.prefix);
+        const referenceObjectKey = '_objectKey' in uploadReference ? uploadReference._objectKey : undefined;
+        const containedPrefix = buildUploadStoragePathData({
+            collectionPrefix,
+            docPrefix: uploadReference.prefix,
+            filename,
+            useCompositePrefixes
+        }).sanitizedDocPrefix;
+        return buildPrefixWithObjectKey({
+            objectKey: referenceObjectKey,
+            prefix: containedPrefix
+        });
     }
-    const imageSizes = collection?.upload?.imageSizes || [];
+    // Reads without a query prefix or read-access constraints skip the endpoint's document lookup.
+    const variants = collection?.upload?.variants || [];
+    const filenameClause = {
+        or: [
+            {
+                filename: {
+                    equals: filename
+                }
+            },
+            ...variants.map((imageSize)=>({
+                    [`variants.${imageSize.name}.filename`]: {
+                        equals: filename
+                    }
+                }))
+        ]
+    };
+    // Only filter by prefix when the collection persists a `prefix` field (querying a missing field throws).
+    const hasPrefixField = collection.fields?.some((field)=>'name' in field && field.name === 'prefix');
+    const where = typeof prefixQueryParam === 'string' && hasPrefixField ? {
+        and: [
+            filenameClause,
+            {
+                prefix: {
+                    equals: sanitizePrefix(prefixQueryParam)
+                }
+            }
+        ]
+    } : filenameClause;
     const files = await req.payload.find({
         collection: collection.slug,
         depth: 0,
         draft: true,
         limit: 1,
+        overrideAccess: false,
         pagination: false,
-        where: {
-            or: [
-                {
-                    filename: {
-                        equals: filename
-                    }
-                },
-                ...imageSizes.map((imageSize)=>({
-                        [`sizes.${imageSize.name}.filename`]: {
-                            equals: filename
-                        }
-                    }))
-            ]
-        }
+        req,
+        select: {
+            _objectKey: true,
+            prefix: true
+        },
+        showHiddenFields: true,
+        where
+    });
+    const found = files?.docs?.[0];
+    return buildPrefixWithObjectKey({
+        objectKey: found?._objectKey,
+        prefix: found?.prefix
     });
-    const prefix = files?.docs?.[0]?.prefix;
-    return prefix ? sanitizePrefix(prefix) : '';
 }
 
 //# sourceMappingURL=getFilePrefix.js.map

package/dist/utilities/getFilePrefix.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/getFilePrefix.ts"],"sourcesContent":["import type { CollectionConfig, PayloadRequest, UploadConfig } from 'payload'\n\nimport { sanitizePrefix } from './sanitizePrefix.js'\n\n/**\n * Resolves the file prefix from the highest-priority available source and\n * always returns a sanitized value.\n *\n * Resolution order:\n * 1. `prefixQueryParam`\n * 2. `uploadReference.prefix`\n * 3. Stored document `prefix` from the database\n *\n * Resolved values are passed through `sanitizePrefix`.\n */\nexport async function getFilePrefix({\n  collection,\n  filename,\n  prefixQueryParam,\n  req,\n  uploadReference,\n}: {\n  collection: CollectionConfig\n  filename: string\n  prefixQueryParam?: string\n  req: PayloadRequest\n  uploadReference?: unknown\n}): Promise<string> {\n  if (typeof prefixQueryParam === 'string') {\n    return sanitizePrefix(prefixQueryParam)\n  }\n\n  // Prioritize the upload reference prefix if there is one.\n  if (\n    uploadReference &&\n    typeof uploadReference === 'object' &&\n    'prefix' in uploadReference &&\n    typeof uploadReference.prefix === 'string'\n  ) {\n    return sanitizePrefix(uploadReference.prefix)\n  }\n\n  const imageSizes = (collection?.upload as UploadConfig)?.imageSizes || []\n\n  const files = await req.payload.find({\n    collection: collection.slug,\n    depth: 0,\n    draft: true,\n    limit: 1,\n    pagination: false,\n    where: {\n      or: [\n        {\n          filename: { equals: filename },\n        },\n        ...imageSizes.map((imageSize) => ({\n          [`sizes.${imageSize.name}.filename`]: { equals: filename },\n        })),\n      ],\n    },\n  })\n  const prefix = files?.docs?.[0]?.prefix\n  return prefix ? sanitizePrefix(prefix as string) : ''\n}\n"],"names":["sanitizePrefix","getFilePrefix","collection","filename","prefixQueryParam","req","uploadReference","prefix","imageSizes","upload","files","payload","find","slug","depth","draft","limit","pagination","where","or","equals","map","imageSize","name","docs"],"mappings":"AAEA,SAASA,cAAc,QAAQ,sBAAqB;AAEpD;;;;;;;;;;CAUC,GACD,OAAO,eAAeC,cAAc,EAClCC,UAAU,EACVC,QAAQ,EACRC,gBAAgB,EAChBC,GAAG,EACHC,eAAe,EAOhB;IACC,IAAI,OAAOF,qBAAqB,UAAU;QACxC,OAAOJ,eAAeI;IACxB;IAEA,0DAA0D;IAC1D,IACEE,mBACA,OAAOA,oBAAoB,YAC3B,YAAYA,mBACZ,OAAOA,gBAAgBC,MAAM,KAAK,UAClC;QACA,OAAOP,eAAeM,gBAAgBC,MAAM;IAC9C;IAEA,MAAMC,aAAa,AAACN,YAAYO,QAAyBD,cAAc,EAAE;IAEzE,MAAME,QAAQ,MAAML,IAAIM,OAAO,CAACC,IAAI,CAAC;QACnCV,YAAYA,WAAWW,IAAI;QAC3BC,OAAO;QACPC,OAAO;QACPC,OAAO;QACPC,YAAY;QACZC,OAAO;YACLC,IAAI;gBACF;oBACEhB,UAAU;wBAAEiB,QAAQjB;oBAAS;gBAC/B;mBACGK,WAAWa,GAAG,CAAC,CAACC,YAAe,CAAA;wBAChC,CAAC,CAAC,MAAM,EAAEA,UAAUC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE;4BAAEH,QAAQjB;wBAAS;oBAC3D,CAAA;aACD;QACH;IACF;IACA,MAAMI,SAASG,OAAOc,MAAM,CAAC,EAAE,EAAEjB;IACjC,OAAOA,SAASP,eAAeO,UAAoB;AACrD"}
+{"version":3,"sources":["../../src/utilities/getFilePrefix.ts"],"sourcesContent":["import type { CollectionConfig, PayloadRequest, SanitizedUploadConfig, TypeWithID } from 'payload'\n\nimport { buildPrefixWithObjectKey } from './buildPrefixWithObjectKey.js'\nimport { buildUploadStoragePathData } from './buildStoragePathData.js'\nimport { sanitizePrefix } from './sanitizePrefix.js'\n\n/**\n * Resolves the folder a stored object lives under (semantic `prefix` plus `_objectKey`).\n *\n * An already-authorized `doc` wins outright. Otherwise an `uploadReference` is used (its\n * `prefix` re-contained with {@link buildUploadStoragePathData}, since it hasn't been verified against\n * a signed receipt by every adapter). Otherwise the document is resolved with\n * `overrideAccess: false`, any query-param prefix only narrows that lookup, and `_objectKey`\n * is read from the resolved document via `showHiddenFields`.\n */\nexport async function getFilePrefix({\n  collection,\n  collectionPrefix,\n  doc,\n  filename,\n  prefixQueryParam,\n  req,\n  uploadReference,\n  useCompositePrefixes = false,\n}: {\n  collection: CollectionConfig\n  collectionPrefix?: string\n  doc?: { _objectKey?: string; prefix?: string } & TypeWithID\n  filename: string\n  /**\n   * Only narrows the access-controlled fallback lookup below; never trusted or\n   * returned directly. Prefer passing the access-checked document as `doc` instead.\n   */\n  prefixQueryParam?: string\n  req: PayloadRequest\n  uploadReference?: unknown\n  useCompositePrefixes?: boolean\n}): Promise<string> {\n  // The serve path already loaded and authorized this document — trust it over any\n  // client-supplied upload reference or query prefix.\n  if (doc) {\n    return buildPrefixWithObjectKey({ objectKey: doc._objectKey, prefix: doc.prefix })\n  }\n\n  // Upload instructions call handlers without a document yet. Re-contain the claimed\n  // prefix — it hasn't been verified against a signed receipt by every adapter.\n  if (\n    uploadReference &&\n    typeof uploadReference === 'object' &&\n    'prefix' in uploadReference &&\n    typeof uploadReference.prefix === 'string'\n  ) {\n    const referenceObjectKey =\n      '_objectKey' in uploadReference\n        ? (uploadReference as { _objectKey?: string })._objectKey\n        : undefined\n    const containedPrefix = buildUploadStoragePathData({\n      collectionPrefix,\n      docPrefix: uploadReference.prefix,\n      filename,\n      useCompositePrefixes,\n    }).sanitizedDocPrefix\n    return buildPrefixWithObjectKey({ objectKey: referenceObjectKey, prefix: containedPrefix })\n  }\n\n  // Reads without a query prefix or read-access constraints skip the endpoint's document lookup.\n  const variants = (collection?.upload as SanitizedUploadConfig)?.variants || []\n\n  const filenameClause = {\n    or: [\n      {\n        filename: { equals: filename },\n      },\n      ...variants.map((imageSize) => ({\n        [`variants.${imageSize.name}.filename`]: { equals: filename },\n      })),\n    ],\n  }\n\n  // Only filter by prefix when the collection persists a `prefix` field (querying a missing field throws).\n  const hasPrefixField = collection.fields?.some(\n    (field) => 'name' in field && field.name === 'prefix',\n  )\n  const where =\n    typeof prefixQueryParam === 'string' && hasPrefixField\n      ? { and: [filenameClause, { prefix: { equals: sanitizePrefix(prefixQueryParam) } }] }\n      : filenameClause\n\n  const files = await req.payload.find({\n    collection: collection.slug,\n    depth: 0,\n    draft: true,\n    limit: 1,\n    overrideAccess: false,\n    pagination: false,\n    req,\n    select: {\n      _objectKey: true,\n      prefix: true,\n    },\n    showHiddenFields: true,\n    where,\n  })\n\n  const found = files?.docs?.[0] as { _objectKey?: string; prefix?: string } | undefined\n  return buildPrefixWithObjectKey({ objectKey: found?._objectKey, prefix: found?.prefix })\n}\n"],"names":["buildPrefixWithObjectKey","buildUploadStoragePathData","sanitizePrefix","getFilePrefix","collection","collectionPrefix","doc","filename","prefixQueryParam","req","uploadReference","useCompositePrefixes","objectKey","_objectKey","prefix","referenceObjectKey","undefined","containedPrefix","docPrefix","sanitizedDocPrefix","variants","upload","filenameClause","or","equals","map","imageSize","name","hasPrefixField","fields","some","field","where","and","files","payload","find","slug","depth","draft","limit","overrideAccess","pagination","select","showHiddenFields","found","docs"],"mappings":"AAEA,SAASA,wBAAwB,QAAQ,gCAA+B;AACxE,SAASC,0BAA0B,QAAQ,4BAA2B;AACtE,SAASC,cAAc,QAAQ,sBAAqB;AAEpD;;;;;;;;CAQC,GACD,OAAO,eAAeC,cAAc,EAClCC,UAAU,EACVC,gBAAgB,EAChBC,GAAG,EACHC,QAAQ,EACRC,gBAAgB,EAChBC,GAAG,EACHC,eAAe,EACfC,uBAAuB,KAAK,EAc7B;IACC,iFAAiF;IACjF,oDAAoD;IACpD,IAAIL,KAAK;QACP,OAAON,yBAAyB;YAAEY,WAAWN,IAAIO,UAAU;YAAEC,QAAQR,IAAIQ,MAAM;QAAC;IAClF;IAEA,mFAAmF;IACnF,8EAA8E;IAC9E,IACEJ,mBACA,OAAOA,oBAAoB,YAC3B,YAAYA,mBACZ,OAAOA,gBAAgBI,MAAM,KAAK,UAClC;QACA,MAAMC,qBACJ,gBAAgBL,kBACZ,AAACA,gBAA4CG,UAAU,GACvDG;QACN,MAAMC,kBAAkBhB,2BAA2B;YACjDI;YACAa,WAAWR,gBAAgBI,MAAM;YACjCP;YACAI;QACF,GAAGQ,kBAAkB;QACrB,OAAOnB,yBAAyB;YAAEY,WAAWG;YAAoBD,QAAQG;QAAgB;IAC3F;IAEA,+FAA+F;IAC/F,MAAMG,WAAW,AAAChB,YAAYiB,QAAkCD,YAAY,EAAE;IAE9E,MAAME,iBAAiB;QACrBC,IAAI;YACF;gBACEhB,UAAU;oBAAEiB,QAAQjB;gBAAS;YAC/B;eACGa,SAASK,GAAG,CAAC,CAACC,YAAe,CAAA;oBAC9B,CAAC,CAAC,SAAS,EAAEA,UAAUC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE;wBAAEH,QAAQjB;oBAAS;gBAC9D,CAAA;SACD;IACH;IAEA,yGAAyG;IACzG,MAAMqB,iBAAiBxB,WAAWyB,MAAM,EAAEC,KACxC,CAACC,QAAU,UAAUA,SAASA,MAAMJ,IAAI,KAAK;IAE/C,MAAMK,QACJ,OAAOxB,qBAAqB,YAAYoB,iBACpC;QAAEK,KAAK;YAACX;YAAgB;gBAAER,QAAQ;oBAAEU,QAAQtB,eAAeM;gBAAkB;YAAE;SAAE;IAAC,IAClFc;IAEN,MAAMY,QAAQ,MAAMzB,IAAI0B,OAAO,CAACC,IAAI,CAAC;QACnChC,YAAYA,WAAWiC,IAAI;QAC3BC,OAAO;QACPC,OAAO;QACPC,OAAO;QACPC,gBAAgB;QAChBC,YAAY;QACZjC;QACAkC,QAAQ;YACN9B,YAAY;YACZC,QAAQ;QACV;QACA8B,kBAAkB;QAClBZ;IACF;IAEA,MAAMa,QAAQX,OAAOY,MAAM,CAAC,EAAE;IAC9B,OAAO9C,yBAAyB;QAAEY,WAAWiC,OAAOhC;QAAYC,QAAQ+B,OAAO/B;IAAO;AACxF"}

package/dist/utilities/getIncomingFiles.js

@@ -16,8 +16,8 @@ export function getIncomingFiles({ data, req }) {
         files = [
             mainFile
         ];
-        if (data?.sizes) {
-            Object.entries(data.sizes).forEach(([key, resizedFileData])=>{
+        if (data?.variants) {
+            Object.entries(data.variants).forEach(([key, resizedFileData])=>{
                 if (payloadUploadSizes?.[key] && resizedFileData.mimeType) {
                     files = files.concat([
                         {

package/dist/utilities/getIncomingFiles.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/getIncomingFiles.ts"],"sourcesContent":["import type { FileData, PayloadRequest } from 'payload'\n\nimport type { File } from '../types.js'\n\ninterface CloudStorageContext {\n  file: PayloadRequest['file']\n  uploadSizes: PayloadRequest['payloadUploadSizes']\n}\n\nexport function getIncomingFiles({\n  data,\n  req,\n}: {\n  data: Partial<FileData>\n  req: PayloadRequest\n}): File[] {\n  // Fall back to context if req.file was cleared\n  const ctx = req.context?._payloadCloudStorage as CloudStorageContext | undefined\n  const file = req.file ?? ctx?.file\n  const payloadUploadSizes = req.payloadUploadSizes ?? ctx?.uploadSizes\n\n  let files: File[] = []\n\n  if (file && data.filename && data.mimeType) {\n    const mainFile: File = {\n      buffer: file.data,\n      filename: data.filename,\n      filesize: file.size,\n      mimeType: data.mimeType,\n      tempFilePath: file.tempFilePath,\n      uploadReference: file.uploadReference,\n    }\n\n    files = [mainFile]\n\n    if (data?.sizes) {\n      Object.entries(data.sizes).forEach(([key, resizedFileData]) => {\n        if (payloadUploadSizes?.[key] && resizedFileData.mimeType) {\n          files = files.concat([\n            {\n              buffer: payloadUploadSizes[key],\n              filename: `${resizedFileData.filename}`,\n              filesize: payloadUploadSizes[key].length,\n              mimeType: resizedFileData.mimeType,\n            },\n          ])\n        }\n      })\n    }\n  }\n\n  return files\n}\n"],"names":["getIncomingFiles","data","req","ctx","context","_payloadCloudStorage","file","payloadUploadSizes","uploadSizes","files","filename","mimeType","mainFile","buffer","filesize","size","tempFilePath","uploadReference","sizes","Object","entries","forEach","key","resizedFileData","concat","length"],"mappings":"AASA,OAAO,SAASA,iBAAiB,EAC/BC,IAAI,EACJC,GAAG,EAIJ;IACC,+CAA+C;IAC/C,MAAMC,MAAMD,IAAIE,OAAO,EAAEC;IACzB,MAAMC,OAAOJ,IAAII,IAAI,IAAIH,KAAKG;IAC9B,MAAMC,qBAAqBL,IAAIK,kBAAkB,IAAIJ,KAAKK;IAE1D,IAAIC,QAAgB,EAAE;IAEtB,IAAIH,QAAQL,KAAKS,QAAQ,IAAIT,KAAKU,QAAQ,EAAE;QAC1C,MAAMC,WAAiB;YACrBC,QAAQP,KAAKL,IAAI;YACjBS,UAAUT,KAAKS,QAAQ;YACvBI,UAAUR,KAAKS,IAAI;YACnBJ,UAAUV,KAAKU,QAAQ;YACvBK,cAAcV,KAAKU,YAAY;YAC/BC,iBAAiBX,KAAKW,eAAe;QACvC;QAEAR,QAAQ;YAACG;SAAS;QAElB,IAAIX,MAAMiB,OAAO;YACfC,OAAOC,OAAO,CAACnB,KAAKiB,KAAK,EAAEG,OAAO,CAAC,CAAC,CAACC,KAAKC,gBAAgB;gBACxD,IAAIhB,oBAAoB,CAACe,IAAI,IAAIC,gBAAgBZ,QAAQ,EAAE;oBACzDF,QAAQA,MAAMe,MAAM,CAAC;wBACnB;4BACEX,QAAQN,kBAAkB,CAACe,IAAI;4BAC/BZ,UAAU,GAAGa,gBAAgBb,QAAQ,EAAE;4BACvCI,UAAUP,kBAAkB,CAACe,IAAI,CAACG,MAAM;4BACxCd,UAAUY,gBAAgBZ,QAAQ;wBACpC;qBACD;gBACH;YACF;QACF;IACF;IAEA,OAAOF;AACT"}
+{"version":3,"sources":["../../src/utilities/getIncomingFiles.ts"],"sourcesContent":["import type { FileData, PayloadRequest } from 'payload'\n\nimport type { File } from '../types.js'\n\ninterface CloudStorageContext {\n  file: PayloadRequest['file']\n  uploadSizes: PayloadRequest['payloadUploadSizes']\n}\n\nexport function getIncomingFiles({\n  data,\n  req,\n}: {\n  data: Partial<FileData>\n  req: PayloadRequest\n}): File[] {\n  // Fall back to context if req.file was cleared\n  const ctx = req.context?._payloadCloudStorage as CloudStorageContext | undefined\n  const file = req.file ?? ctx?.file\n  const payloadUploadSizes = req.payloadUploadSizes ?? ctx?.uploadSizes\n\n  let files: File[] = []\n\n  if (file && data.filename && data.mimeType) {\n    const mainFile: File = {\n      buffer: file.data,\n      filename: data.filename,\n      filesize: file.size,\n      mimeType: data.mimeType,\n      tempFilePath: file.tempFilePath,\n      uploadReference: file.uploadReference,\n    }\n\n    files = [mainFile]\n\n    if (data?.variants) {\n      Object.entries(data.variants).forEach(([key, resizedFileData]) => {\n        if (payloadUploadSizes?.[key] && resizedFileData.mimeType) {\n          files = files.concat([\n            {\n              buffer: payloadUploadSizes[key],\n              filename: `${resizedFileData.filename}`,\n              filesize: payloadUploadSizes[key].length,\n              mimeType: resizedFileData.mimeType,\n            },\n          ])\n        }\n      })\n    }\n  }\n\n  return files\n}\n"],"names":["getIncomingFiles","data","req","ctx","context","_payloadCloudStorage","file","payloadUploadSizes","uploadSizes","files","filename","mimeType","mainFile","buffer","filesize","size","tempFilePath","uploadReference","variants","Object","entries","forEach","key","resizedFileData","concat","length"],"mappings":"AASA,OAAO,SAASA,iBAAiB,EAC/BC,IAAI,EACJC,GAAG,EAIJ;IACC,+CAA+C;IAC/C,MAAMC,MAAMD,IAAIE,OAAO,EAAEC;IACzB,MAAMC,OAAOJ,IAAII,IAAI,IAAIH,KAAKG;IAC9B,MAAMC,qBAAqBL,IAAIK,kBAAkB,IAAIJ,KAAKK;IAE1D,IAAIC,QAAgB,EAAE;IAEtB,IAAIH,QAAQL,KAAKS,QAAQ,IAAIT,KAAKU,QAAQ,EAAE;QAC1C,MAAMC,WAAiB;YACrBC,QAAQP,KAAKL,IAAI;YACjBS,UAAUT,KAAKS,QAAQ;YACvBI,UAAUR,KAAKS,IAAI;YACnBJ,UAAUV,KAAKU,QAAQ;YACvBK,cAAcV,KAAKU,YAAY;YAC/BC,iBAAiBX,KAAKW,eAAe;QACvC;QAEAR,QAAQ;YAACG;SAAS;QAElB,IAAIX,MAAMiB,UAAU;YAClBC,OAAOC,OAAO,CAACnB,KAAKiB,QAAQ,EAAEG,OAAO,CAAC,CAAC,CAACC,KAAKC,gBAAgB;gBAC3D,IAAIhB,oBAAoB,CAACe,IAAI,IAAIC,gBAAgBZ,QAAQ,EAAE;oBACzDF,QAAQA,MAAMe,MAAM,CAAC;wBACnB;4BACEX,QAAQN,kBAAkB,CAACe,IAAI;4BAC/BZ,UAAU,GAAGa,gBAAgBb,QAAQ,EAAE;4BACvCI,UAAUP,kBAAkB,CAACe,IAAI,CAACG,MAAM;4BACxCd,UAAUY,gBAAgBZ,QAAQ;wBACpC;qBACD;gBACH;YACF;QACF;IACF;IAEA,OAAOF;AACT"}

package/dist/utilities/resolveSignedURLKey.d.ts

@@ -1,4 +1,5 @@
 import type { PayloadRequest } from 'payload';
+import type { UploadReference } from '../types.js';
 type Args = {
     collectionPrefix?: string;
     collectionSlug: string;
@@ -12,13 +13,23 @@ type Args = {
  * the filename via {@link getSafeFileName} so a duplicate upload does not
  * overwrite an existing blob.
  *
+ * A unique per-upload segment is included in the storage key so each issued
+ * key is distinct. The stored `filename` stays clean and the semantic `prefix`
+ * stays exactly what the collection configured — the per-upload entropy is
+ * persisted separately in `_objectKey`.
+ *
  * The resolved `sanitizedFilename` is returned so the browser-side handler
  * can update the form via `updateFilename`.
+ *
+ * The semantic prefix is resolved with {@link buildUploadPrefix} and the final
+ * key with {@link buildUploadStoragePathData}, so the receipt only ever signs a key
+ * beneath the configured collection prefix.
  */
 export declare function resolveSignedURLKey({ collectionPrefix, collectionSlug, docPrefix, filename, req, useCompositePrefixes, }: Args): Promise<{
-    fileKey: string;
     sanitizedDocPrefix: string;
     sanitizedFilename: string;
+    storageFilePath: string;
+    uploadReference: UploadReference;
 }>;
 export {};
 //# sourceMappingURL=resolveSignedURLKey.d.ts.map

package/dist/utilities/resolveSignedURLKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveSignedURLKey.d.ts","sourceRoot":"","sources":["../../src/utilities/resolveSignedURLKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAM7C,KAAK,IAAI,GAAG;IACV,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B,CAAA;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,gBAAqB,EACrB,cAAc,EACd,SAAS,EACT,QAAQ,EACR,GAAG,EACH,oBAA4B,GAC7B,EAAE,IAAI;;;;GAgBN"}
+{"version":3,"file":"resolveSignedURLKey.d.ts","sourceRoot":"","sources":["../../src/utilities/resolveSignedURLKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAM7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAIlD,KAAK,IAAI,GAAG;IACV,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,gBAAqB,EACrB,cAAc,EACd,SAAS,EACT,QAAQ,EACR,GAAG,EACH,oBAA4B,GAC7B,EAAE,IAAI,GAAG,OAAO,CAAC;IAChB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,iBAAiB,EAAE,MAAM,CAAA;IACzB,eAAe,EAAE,MAAM,CAAA;IACvB,eAAe,EAAE,eAAe,CAAA;CACjC,CAAC,CAyCD"}

package/dist/utilities/resolveSignedURLKey.js

@@ -1,29 +1,63 @@
-import { getSafeFileName } from 'payload/internal';
-import { getFileKey } from './getFileKey.js';
+import { randomUUID } from 'node:crypto';
+import { createClientUploadReceipt, getSafeFileName } from 'payload/internal';
+import { getSanitizedUploadFilename } from 'payload/shared';
+import { buildUploadPrefix, buildUploadStoragePathData } from './buildStoragePathData.js';
 /**
  * Resolves the storage key for an upload-instructions request, deduping
  * the filename via {@link getSafeFileName} so a duplicate upload does not
  * overwrite an existing blob.
  *
+ * A unique per-upload segment is included in the storage key so each issued
+ * key is distinct. The stored `filename` stays clean and the semantic `prefix`
+ * stays exactly what the collection configured — the per-upload entropy is
+ * persisted separately in `_objectKey`.
+ *
  * The resolved `sanitizedFilename` is returned so the browser-side handler
  * can update the form via `updateFilename`.
+ *
+ * The semantic prefix is resolved with {@link buildUploadPrefix} and the final
+ * key with {@link buildUploadStoragePathData}, so the receipt only ever signs a key
+ * beneath the configured collection prefix.
  */ export async function resolveSignedURLKey({ collectionPrefix = '', collectionSlug, docPrefix, filename, req, useCompositePrefixes = false }) {
+    // Sanitize with the same helper generateFileData uses for the DB filename so the storage key
+    // and doc.filename stay in sync (#16694).
     const sanitizedFilename = await getSafeFileName({
         collectionSlug,
-        desiredFilename: filename,
-        prefix: docPrefix,
+        desiredFilename: getSanitizedUploadFilename(filename),
         req
     });
-    const { fileKey, sanitizedDocPrefix } = getFileKey({
+    const rawBaseDocPrefix = useCompositePrefixes ? docPrefix : docPrefix || collectionPrefix;
+    const { sanitizedDocPrefix } = buildUploadPrefix({
+        collectionPrefix,
+        docPrefix: rawBaseDocPrefix,
+        useCompositePrefixes
+    });
+    const _objectKey = randomUUID();
+    // Per-upload segment lives in the key; it is persisted in `_objectKey`, keeping `prefix` semantic.
+    const keyedDocPrefix = sanitizedDocPrefix ? `${sanitizedDocPrefix}/${_objectKey}` : _objectKey;
+    const { storageFilePath } = buildUploadStoragePathData({
         collectionPrefix,
-        docPrefix,
+        docPrefix: keyedDocPrefix,
         filename: sanitizedFilename,
         useCompositePrefixes
     });
+    const uploadReference = {
+        _objectKey,
+        prefix: sanitizedDocPrefix,
+        signedReceipt: createClientUploadReceipt({
+            _objectKey,
+            collectionSlug,
+            filename: sanitizedFilename,
+            filePrefix: sanitizedDocPrefix,
+            req,
+            storageFilePath
+        })
+    };
     return {
-        fileKey,
         sanitizedDocPrefix,
-        sanitizedFilename
+        sanitizedFilename,
+        storageFilePath,
+        uploadReference
     };
 }
 

package/dist/utilities/resolveSignedURLKey.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/resolveSignedURLKey.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\n\nimport { getSafeFileName } from 'payload/internal'\n\nimport { getFileKey } from './getFileKey.js'\n\ntype Args = {\n  collectionPrefix?: string\n  collectionSlug: string\n  docPrefix?: string\n  filename: string\n  req: PayloadRequest\n  useCompositePrefixes?: boolean\n}\n\n/**\n * Resolves the storage key for an upload-instructions request, deduping\n * the filename via {@link getSafeFileName} so a duplicate upload does not\n * overwrite an existing blob.\n *\n * The resolved `sanitizedFilename` is returned so the browser-side handler\n * can update the form via `updateFilename`.\n */\nexport async function resolveSignedURLKey({\n  collectionPrefix = '',\n  collectionSlug,\n  docPrefix,\n  filename,\n  req,\n  useCompositePrefixes = false,\n}: Args) {\n  const sanitizedFilename = await getSafeFileName({\n    collectionSlug,\n    desiredFilename: filename,\n    prefix: docPrefix,\n    req,\n  })\n\n  const { fileKey, sanitizedDocPrefix } = getFileKey({\n    collectionPrefix,\n    docPrefix,\n    filename: sanitizedFilename,\n    useCompositePrefixes,\n  })\n\n  return { fileKey, sanitizedDocPrefix, sanitizedFilename }\n}\n"],"names":["getSafeFileName","getFileKey","resolveSignedURLKey","collectionPrefix","collectionSlug","docPrefix","filename","req","useCompositePrefixes","sanitizedFilename","desiredFilename","prefix","fileKey","sanitizedDocPrefix"],"mappings":"AAEA,SAASA,eAAe,QAAQ,mBAAkB;AAElD,SAASC,UAAU,QAAQ,kBAAiB;AAW5C;;;;;;;CAOC,GACD,OAAO,eAAeC,oBAAoB,EACxCC,mBAAmB,EAAE,EACrBC,cAAc,EACdC,SAAS,EACTC,QAAQ,EACRC,GAAG,EACHC,uBAAuB,KAAK,EACvB;IACL,MAAMC,oBAAoB,MAAMT,gBAAgB;QAC9CI;QACAM,iBAAiBJ;QACjBK,QAAQN;QACRE;IACF;IAEA,MAAM,EAAEK,OAAO,EAAEC,kBAAkB,EAAE,GAAGZ,WAAW;QACjDE;QACAE;QACAC,UAAUG;QACVD;IACF;IAEA,OAAO;QAAEI;QAASC;QAAoBJ;IAAkB;AAC1D"}
+{"version":3,"sources":["../../src/utilities/resolveSignedURLKey.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\n\nimport { randomUUID } from 'node:crypto'\nimport { createClientUploadReceipt, getSafeFileName } from 'payload/internal'\nimport { getSanitizedUploadFilename } from 'payload/shared'\n\nimport type { UploadReference } from '../types.js'\n\nimport { buildUploadPrefix, buildUploadStoragePathData } from './buildStoragePathData.js'\n\ntype Args = {\n  collectionPrefix?: string\n  collectionSlug: string\n  docPrefix?: string\n  filename: string\n  req: PayloadRequest\n  useCompositePrefixes?: boolean\n}\n\n/**\n * Resolves the storage key for an upload-instructions request, deduping\n * the filename via {@link getSafeFileName} so a duplicate upload does not\n * overwrite an existing blob.\n *\n * A unique per-upload segment is included in the storage key so each issued\n * key is distinct. The stored `filename` stays clean and the semantic `prefix`\n * stays exactly what the collection configured — the per-upload entropy is\n * persisted separately in `_objectKey`.\n *\n * The resolved `sanitizedFilename` is returned so the browser-side handler\n * can update the form via `updateFilename`.\n *\n * The semantic prefix is resolved with {@link buildUploadPrefix} and the final\n * key with {@link buildUploadStoragePathData}, so the receipt only ever signs a key\n * beneath the configured collection prefix.\n */\nexport async function resolveSignedURLKey({\n  collectionPrefix = '',\n  collectionSlug,\n  docPrefix,\n  filename,\n  req,\n  useCompositePrefixes = false,\n}: Args): Promise<{\n  sanitizedDocPrefix: string\n  sanitizedFilename: string\n  storageFilePath: string\n  uploadReference: UploadReference\n}> {\n  // Sanitize with the same helper generateFileData uses for the DB filename so the storage key\n  // and doc.filename stay in sync (#16694).\n  const sanitizedFilename = await getSafeFileName({\n    collectionSlug,\n    desiredFilename: getSanitizedUploadFilename(filename),\n    req,\n  })\n\n  const rawBaseDocPrefix = useCompositePrefixes ? docPrefix : docPrefix || collectionPrefix\n  const { sanitizedDocPrefix } = buildUploadPrefix({\n    collectionPrefix,\n    docPrefix: rawBaseDocPrefix,\n    useCompositePrefixes,\n  })\n\n  const _objectKey = randomUUID()\n  // Per-upload segment lives in the key; it is persisted in `_objectKey`, keeping `prefix` semantic.\n  const keyedDocPrefix = sanitizedDocPrefix ? `${sanitizedDocPrefix}/${_objectKey}` : _objectKey\n\n  const { storageFilePath } = buildUploadStoragePathData({\n    collectionPrefix,\n    docPrefix: keyedDocPrefix,\n    filename: sanitizedFilename,\n    useCompositePrefixes,\n  })\n\n  const uploadReference = {\n    _objectKey,\n    prefix: sanitizedDocPrefix,\n    signedReceipt: createClientUploadReceipt({\n      _objectKey,\n      collectionSlug,\n      filename: sanitizedFilename,\n      filePrefix: sanitizedDocPrefix,\n      req,\n      storageFilePath,\n    }),\n  }\n\n  return { sanitizedDocPrefix, sanitizedFilename, storageFilePath, uploadReference }\n}\n"],"names":["randomUUID","createClientUploadReceipt","getSafeFileName","getSanitizedUploadFilename","buildUploadPrefix","buildUploadStoragePathData","resolveSignedURLKey","collectionPrefix","collectionSlug","docPrefix","filename","req","useCompositePrefixes","sanitizedFilename","desiredFilename","rawBaseDocPrefix","sanitizedDocPrefix","_objectKey","keyedDocPrefix","storageFilePath","uploadReference","prefix","signedReceipt","filePrefix"],"mappings":"AAEA,SAASA,UAAU,QAAQ,cAAa;AACxC,SAASC,yBAAyB,EAAEC,eAAe,QAAQ,mBAAkB;AAC7E,SAASC,0BAA0B,QAAQ,iBAAgB;AAI3D,SAASC,iBAAiB,EAAEC,0BAA0B,QAAQ,4BAA2B;AAWzF;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,eAAeC,oBAAoB,EACxCC,mBAAmB,EAAE,EACrBC,cAAc,EACdC,SAAS,EACTC,QAAQ,EACRC,GAAG,EACHC,uBAAuB,KAAK,EACvB;IAML,6FAA6F;IAC7F,0CAA0C;IAC1C,MAAMC,oBAAoB,MAAMX,gBAAgB;QAC9CM;QACAM,iBAAiBX,2BAA2BO;QAC5CC;IACF;IAEA,MAAMI,mBAAmBH,uBAAuBH,YAAYA,aAAaF;IACzE,MAAM,EAAES,kBAAkB,EAAE,GAAGZ,kBAAkB;QAC/CG;QACAE,WAAWM;QACXH;IACF;IAEA,MAAMK,aAAajB;IACnB,mGAAmG;IACnG,MAAMkB,iBAAiBF,qBAAqB,GAAGA,mBAAmB,CAAC,EAAEC,YAAY,GAAGA;IAEpF,MAAM,EAAEE,eAAe,EAAE,GAAGd,2BAA2B;QACrDE;QACAE,WAAWS;QACXR,UAAUG;QACVD;IACF;IAEA,MAAMQ,kBAAkB;QACtBH;QACAI,QAAQL;QACRM,eAAerB,0BAA0B;YACvCgB;YACAT;YACAE,UAAUG;YACVU,YAAYP;YACZL;YACAQ;QACF;IACF;IAEA,OAAO;QAAEH;QAAoBH;QAAmBM;QAAiBC;IAAgB;AACnF"}

package/dist/utilities/sanitizePrefix.d.ts

@@ -1,10 +1,2 @@
-/**
- * Normalizes a storage prefix for use in object keys and URLs.
- *
- * Decodes URI components once (so query-style `%2F` becomes `/`), rejects
- * values that still contain percent-encodings after decoding (e.g. `%252f`),
- * then normalizes slashes, drops `.` / `..` segments, strips leading slashes,
- * and removes control characters.
- */
-export declare function sanitizePrefix(prefix: string): string;
+export { sanitizeUploadPrefix as sanitizePrefix } from 'payload/shared';
 //# sourceMappingURL=sanitizePrefix.d.ts.map

package/dist/utilities/sanitizePrefix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sanitizePrefix.d.ts","sourceRoot":"","sources":["../../src/utilities/sanitizePrefix.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAwBrD"}
+{"version":3,"file":"sanitizePrefix.d.ts","sourceRoot":"","sources":["../../src/utilities/sanitizePrefix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,IAAI,cAAc,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/utilities/sanitizePrefix.js

@@ -1,23 +1,3 @@
-/**
- * Normalizes a storage prefix for use in object keys and URLs.
- *
- * Decodes URI components once (so query-style `%2F` becomes `/`), rejects
- * values that still contain percent-encodings after decoding (e.g. `%252f`),
- * then normalizes slashes, drops `.` / `..` segments, strips leading slashes,
- * and removes control characters.
- */ export function sanitizePrefix(prefix) {
-    let decodedPrefix;
-    try {
-        decodedPrefix = decodeURIComponent(prefix);
-    } catch  {
-        return '';
-    }
-    // Reject multi-encoded values (e.g. `%252f`) by allowing only a single decode pass.
-    if (/%[0-9a-f]{2}/i.test(decodedPrefix)) {
-        return '';
-    }
-    return decodedPrefix.replace(/\\/g, '/').split('/').filter((segment)=>segment !== '..' && segment !== '.').join('/').replace(/^\/+/, '')// eslint-disable-next-line no-control-regex
-    .replace(/[\x00-\x1f\x80-\x9f]/g, '');
-}
+export { sanitizeUploadPrefix as sanitizePrefix } from 'payload/shared';
 
 //# sourceMappingURL=sanitizePrefix.js.map

package/dist/utilities/sanitizePrefix.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/sanitizePrefix.ts"],"sourcesContent":["/**\n * Normalizes a storage prefix for use in object keys and URLs.\n *\n * Decodes URI components once (so query-style `%2F` becomes `/`), rejects\n * values that still contain percent-encodings after decoding (e.g. `%252f`),\n * then normalizes slashes, drops `.` / `..` segments, strips leading slashes,\n * and removes control characters.\n */\nexport function sanitizePrefix(prefix: string): string {\n  let decodedPrefix: string\n\n  try {\n    decodedPrefix = decodeURIComponent(prefix)\n  } catch {\n    return ''\n  }\n\n  // Reject multi-encoded values (e.g. `%252f`) by allowing only a single decode pass.\n  if (/%[0-9a-f]{2}/i.test(decodedPrefix)) {\n    return ''\n  }\n\n  return (\n    decodedPrefix\n      .replace(/\\\\/g, '/')\n      .split('/')\n      .filter((segment) => segment !== '..' && segment !== '.')\n      .join('/')\n      .replace(/^\\/+/, '')\n      // eslint-disable-next-line no-control-regex\n      .replace(/[\\x00-\\x1f\\x80-\\x9f]/g, '')\n  )\n}\n"],"names":["sanitizePrefix","prefix","decodedPrefix","decodeURIComponent","test","replace","split","filter","segment","join"],"mappings":"AAAA;;;;;;;CAOC,GACD,OAAO,SAASA,eAAeC,MAAc;IAC3C,IAAIC;IAEJ,IAAI;QACFA,gBAAgBC,mBAAmBF;IACrC,EAAE,OAAM;QACN,OAAO;IACT;IAEA,oFAAoF;IACpF,IAAI,gBAAgBG,IAAI,CAACF,gBAAgB;QACvC,OAAO;IACT;IAEA,OACEA,cACGG,OAAO,CAAC,OAAO,KACfC,KAAK,CAAC,KACNC,MAAM,CAAC,CAACC,UAAYA,YAAY,QAAQA,YAAY,KACpDC,IAAI,CAAC,KACLJ,OAAO,CAAC,QAAQ,GACjB,4CAA4C;KAC3CA,OAAO,CAAC,yBAAyB;AAExC"}
+{"version":3,"sources":["../../src/utilities/sanitizePrefix.ts"],"sourcesContent":["export { sanitizeUploadPrefix as sanitizePrefix } from 'payload/shared'\n"],"names":["sanitizeUploadPrefix","sanitizePrefix"],"mappings":"AAAA,SAASA,wBAAwBC,cAAc,QAAQ,iBAAgB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/plugin-cloud-storage",
-  "version": "4.0.0-internal.567a487",
+  "version": "4.0.0-internal.58473b9",
   "description": "The official cloud storage plugin for Payload CMS",
   "homepage": "https://payloadcms.com",
   "repository": {
@@ -51,18 +51,18 @@
   "dependencies": {
     "find-node-modules": "^2.1.3",
     "range-parser": "^1.2.1",
-    "@payloadcms/ui": "4.0.0-internal.567a487"
+    "@payloadcms/ui": "4.0.0-internal.58473b9"
   },
   "devDependencies": {
     "@types/find-node-modules": "^2.1.2",
-    "@types/react": "19.2.14",
-    "@types/react-dom": "19.2.3",
-    "payload": "4.0.0-internal.567a487"
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "payload": "4.0.0-internal.58473b9"
   },
   "peerDependencies": {
     "react": "^19.0.1 || ^19.1.2 || ^19.2.1",
     "react-dom": "^19.0.1 || ^19.1.2 || ^19.2.1",
-    "payload": "4.0.0-internal.567a487"
+    "payload": "4.0.0-internal.58473b9"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"

package/dist/admin/fields/getFields.d.ts

@@ -1,17 +0,0 @@
-import type { CollectionConfig, Field } from 'payload';
-interface Args {
-    /**
-     * When true, always insert the prefix field regardless of whether a prefix is configured.
-     */
-    alwaysInsertFields?: boolean;
-    collection: CollectionConfig;
-    prefix?: string;
-    /**
-     * When true, do not default the `prefix` field to the collection prefix; the
-     * document field holds only the document-level segment.
-     */
-    useCompositePrefixes?: boolean;
-}
-export declare const getFields: ({ alwaysInsertFields, collection, prefix, useCompositePrefixes, }: Args) => Field[];
-export {};
-//# sourceMappingURL=getFields.d.ts.map

package/dist/admin/fields/getFields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getFields.d.ts","sourceRoot":"","sources":["../../../src/admin/fields/getFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,KAAK,EAAyB,MAAM,SAAS,CAAA;AAI7E,UAAU,IAAI;IACZ;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,UAAU,EAAE,gBAAgB,CAAA;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;OAGG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,eAAO,MAAM,SAAS,sEAKnB,IAAI,KAAG,KAAK,EAsHd,CAAA"}