@payloadcms/plugin-cloud-storage 3.91.0-internal.6e3dc85 → 4.0.0-beta.0

package/dist/utilities/buildStoragePathData.d.ts

@@ -5,12 +5,6 @@ type BuildFilePathDataArgs = {
     useCompositePrefixes?: boolean;
 };
 type BuildFilePathDataResult = {
-    /**
-     * @deprecated Use `storageFilePath` instead.
-     *
-     * The full path to the file within the storage backend.
-     */
-    fileKey: string;
     sanitizedCollectionPrefix: string;
     sanitizedDocPrefix: string;
     sanitizedFilename: string;

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

@@ -1 +1 @@
-{"version":3,"file":"buildStoragePathData.d.ts","sourceRoot":"","sources":["../../src/utilities/buildStoragePathData.ts"],"names":[],"mappings":"AAKA,KAAK,qBAAqB,GAAG;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC7B;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAA;IACf,yBAAyB,EAAE,MAAM,CAAA;IACjC,kBAAkB,EAAE,MAAM,CAAA;IAC1B,iBAAiB,EAAE,MAAM,CAAA;IACzB;;OAEG;IACH,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,wBAAgB,mCAAmC,CAAC,EAClD,gBAAgB,EAChB,SAAS,GACV,EAAE;IACD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,OAAO,CAQV;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,gBAAgB,EAChB,SAAS,EACT,oBAA4B,GAC7B,EAAE,IAAI,CAAC,qBAAqB,EAAE,UAAU,CAAC,GAAG;IAC3C,yBAAyB,EAAE,MAAM,CAAA;IACjC,kBAAkB,EAAE,MAAM,CAAA;IAC1B,YAAY,EAAE,MAAM,CAAA;CACrB,CAiBA;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,gBAAgB,EAChB,SAAS,EACT,QAAQ,EACR,oBAA4B,GAC7B,EAAE,qBAAqB,GAAG,uBAAuB,CAmBjD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,gBAAgB,EAChB,SAAS,EACT,QAAQ,EACR,oBAA4B,GAC7B,EAAE,qBAAqB,GAAG,uBAAuB,CAejD"}
+{"version":3,"file":"buildStoragePathData.d.ts","sourceRoot":"","sources":["../../src/utilities/buildStoragePathData.ts"],"names":[],"mappings":"AAKA,KAAK,qBAAqB,GAAG;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC7B,yBAAyB,EAAE,MAAM,CAAA;IACjC,kBAAkB,EAAE,MAAM,CAAA;IAC1B,iBAAiB,EAAE,MAAM,CAAA;IACzB;;OAEG;IACH,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,wBAAgB,mCAAmC,CAAC,EAClD,gBAAgB,EAChB,SAAS,GACV,EAAE;IACD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,OAAO,CAQV;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,gBAAgB,EAChB,SAAS,EACT,oBAA4B,GAC7B,EAAE,IAAI,CAAC,qBAAqB,EAAE,UAAU,CAAC,GAAG;IAC3C,yBAAyB,EAAE,MAAM,CAAA;IACjC,kBAAkB,EAAE,MAAM,CAAA;IAC1B,YAAY,EAAE,MAAM,CAAA;CACrB,CAiBA;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,gBAAgB,EAChB,SAAS,EACT,QAAQ,EACR,oBAA4B,GAC7B,EAAE,qBAAqB,GAAG,uBAAuB,CAkBjD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,gBAAgB,EAChB,SAAS,EACT,QAAQ,EACR,oBAA4B,GAC7B,EAAE,qBAAqB,GAAG,uBAAuB,CAcjD"}

package/dist/utilities/buildStoragePathData.js

@@ -40,7 +40,6 @@ export function isStoragePathWithinCollectionPrefix({ collectionPrefix, docPrefi
     const safeFilename = sanitizeFilename(filename);
     const storageFilePath = useCompositePrefixes ? path.posix.join(sanitizedCollectionPrefix, sanitizedDocPrefix, safeFilename) : path.posix.join(uploadPrefix, safeFilename);
     return {
-        fileKey: storageFilePath,
         sanitizedCollectionPrefix,
         sanitizedDocPrefix,
         sanitizedFilename: safeFilename,
@@ -58,7 +57,6 @@ export function isStoragePathWithinCollectionPrefix({ collectionPrefix, docPrefi
     const sanitizedFilename = sanitizeFilename(filename);
     const storageFilePath = useCompositePrefixes ? path.posix.join(sanitizedCollectionPrefix, sanitizedDocPrefix, sanitizedFilename) : path.posix.join(sanitizedDocPrefix || sanitizedCollectionPrefix, sanitizedFilename);
     return {
-        fileKey: storageFilePath,
         sanitizedCollectionPrefix,
         sanitizedDocPrefix,
         sanitizedFilename,

package/dist/utilities/buildStoragePathData.js.map

@@ -1 +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  /**\n   * @deprecated Use `storageFilePath` instead.\n   *\n   * The full path to the file within the storage backend.\n   */\n  fileKey: string\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    fileKey: storageFilePath,\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    fileKey: storageFilePath,\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","fileKey","sanitizedFilename","buildStoragePathData"],"mappings":"AAAA,OAAOA,UAAU,OAAM;AACvB,SAASC,gBAAgB,QAAQ,iBAAgB;AAEjD,SAASC,cAAc,QAAQ,sBAAqB;AAyBpD,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;QACLE,SAASD;QACTL;QACAC;QACAM,mBAAmBH;QACnBC;IACF;AACF;AAEA;;;;;CAKC,GACD,OAAO,SAASG,qBAAqB,EACnClB,gBAAgB,EAChBC,SAAS,EACTY,QAAQ,EACRR,uBAAuB,KAAK,EACN;IACtB,MAAMK,4BAA4BZ,eAAeE,oBAAoB;IACrE,MAAMW,qBAAqBb,eAAeG,aAAa;IACvD,MAAMgB,oBAAoBpB,iBAAiBgB;IAC3C,MAAME,kBAAkBV,uBACpBT,KAAKY,KAAK,CAACC,IAAI,CAACC,2BAA2BC,oBAAoBM,qBAC/DrB,KAAKY,KAAK,CAACC,IAAI,CAACE,sBAAsBD,2BAA2BO;IAErE,OAAO;QACLD,SAASD;QACTL;QACAC;QACAM;QACAF;IACF;AACF"}
+{"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/createFileOperations.d.ts

@@ -0,0 +1,13 @@
+import type { CollectionConfig, UploadConfig } from 'payload';
+import type { GeneratedAdapter, GenerateFileURL } from '../types.js';
+type Args = {
+    adapter: GeneratedAdapter;
+    collection: CollectionConfig;
+    collectionPrefix?: string;
+    disablePayloadAccessControl?: boolean;
+    generateFileURL?: GenerateFileURL;
+    useCompositePrefixes?: boolean;
+};
+export declare const createFileOperations: ({ adapter, collection, collectionPrefix, disablePayloadAccessControl, generateFileURL, useCompositePrefixes, }: Args) => NonNullable<UploadConfig['fileOperations']>;
+export {};
+//# sourceMappingURL=createFileOperations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createFileOperations.d.ts","sourceRoot":"","sources":["../../src/utilities/createFileOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAyB,YAAY,EAAE,MAAM,SAAS,CAAA;AAOpF,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AASpE,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,gBAAgB,CAAA;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,2BAA2B,CAAC,EAAE,OAAO,CAAA;IACrC,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B,CAAA;AAED,eAAO,MAAM,oBAAoB,mHAO9B,IAAI,KAAG,WAAW,CAAC,YAAY,CAAC,gBAAgB,CAAC,CA+OnD,CAAA"}

package/dist/utilities/createFileOperations.js

@@ -0,0 +1,258 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { deepCopyObjectSimple, generatePayloadFileURL } from 'payload';
+import { buildPrefixWithObjectKey } from './buildPrefixWithObjectKey.js';
+import { buildStoragePathData, buildUploadPrefix, buildUploadStoragePathData } from './buildStoragePathData.js';
+export const createFileOperations = ({ adapter, collection, collectionPrefix, disablePayloadAccessControl, generateFileURL, useCompositePrefixes })=>{
+    if (typeof adapter.deleteFile !== 'function') {
+        throw new Error(`Storage adapter "${adapter.name}" must implement deleteFile for collection "${collection.slug}".`);
+    }
+    return {
+        copy: async ({ from, req, to, trackStagedObject })=>{
+            await adapter.copyFile({
+                collection: req.payload.collections[collection.slug].config,
+                from,
+                req,
+                to
+            });
+            trackStagedObject({
+                key: to,
+                remove: async ()=>{
+                    await adapter.deleteFile({
+                        collection,
+                        req,
+                        storageFilePath: to
+                    });
+                }
+            });
+        },
+        delete: async ({ key, req })=>{
+            await adapter.deleteFile({
+                collection,
+                req,
+                storageFilePath: key
+            });
+        },
+        hasLegacyFile: async ({ doc, req })=>{
+            if (typeof doc.filename !== 'string' || typeof doc.url !== 'string') {
+                return false;
+            }
+            const docPrefix = typeof doc.prefix === 'string' ? doc.prefix : undefined;
+            const objectFolder = buildPrefixWithObjectKey({
+                objectKey: typeof doc._objectKey === 'string' ? doc._objectKey : undefined,
+                prefix: docPrefix
+            });
+            const expectedURL = async ({ filename, size })=>{
+                if (generateFileURL) {
+                    return generateFileURL({
+                        collection,
+                        filename,
+                        prefix: objectFolder,
+                        size
+                    });
+                }
+                if (disablePayloadAccessControl && adapter.generateURL) {
+                    return adapter.generateURL({
+                        collection,
+                        data: doc,
+                        filename,
+                        prefix: objectFolder
+                    });
+                }
+                return generatePayloadFileURL({
+                    collectionSlug: collection.slug,
+                    config: req.payload.config,
+                    filename,
+                    relative: true
+                });
+            };
+            if (!isSameFileLocation({
+                actual: doc.url,
+                expected: await expectedURL({
+                    filename: doc.filename
+                })
+            })) {
+                return false;
+            }
+            if (doc.variants && typeof doc.variants === 'object' && !Array.isArray(doc.variants)) {
+                for (const [sizeKey, size] of Object.entries(doc.variants)){
+                    if (size && typeof size === 'object' && 'filename' in size && typeof size.filename === 'string') {
+                        const imageSize = req.payload.collections[collection.slug]?.config.upload.variants?.find(({ name })=>name === sizeKey);
+                        if (!('url' in size) || typeof size.url !== 'string' || !isSameFileLocation({
+                            actual: size.url,
+                            expected: await expectedURL({
+                                filename: size.filename,
+                                size: imageSize
+                            })
+                        })) {
+                            return false;
+                        }
+                    }
+                }
+            }
+            return true;
+        },
+        resolveStorageKey: ({ _objectKey, filename, prefix })=>buildStoragePathData({
+                collectionPrefix,
+                docPrefix: buildPrefixWithObjectKey({
+                    objectKey: _objectKey,
+                    prefix
+                }),
+                filename,
+                useCompositePrefixes
+            }).storageFilePath,
+        ...adapter.moveFile && {
+            move: async ({ from, req, to, trackStagedObject })=>{
+                await adapter.moveFile({
+                    collection: req.payload.collections[collection.slug].config,
+                    from,
+                    req,
+                    to
+                });
+                trackStagedObject({
+                    key: to,
+                    remove: ()=>adapter.moveFile({
+                            collection: req.payload.collections[collection.slug].config,
+                            from: to,
+                            req,
+                            to: from
+                        })
+                });
+            }
+        },
+        stage: async ({ data, files, req, trackStagedObject })=>{
+            const uploadedNames = new Set();
+            const metadata = {};
+            const verifiedOriginal = req.context?._payloadVerifiedProviderOriginal;
+            for (const file of files){
+                const filename = path.basename(file.path);
+                const representations = [
+                    data
+                ];
+                if (data.original && typeof data.original === 'object') {
+                    representations.push(data.original);
+                }
+                if (data.variants && typeof data.variants === 'object') {
+                    representations.push(...Object.values(data.variants).filter((value)=>Boolean(value) && typeof value === 'object'));
+                }
+                const destinations = representations.filter((value)=>value.filename === filename);
+                // Provider-direct uploads already placed the source object at its verified location.
+                // A bounded content probe can still appear in files, but it is not a representation
+                // Payload should upload again.
+                if (!destinations.length && verifiedOriginal) {
+                    continue;
+                }
+                if (!destinations.length) {
+                    throw new Error(`No stored representation describes ${filename}`);
+                }
+                const prefixLocation = destinations.find((destination)=>typeof destination.prefix === 'string');
+                const objectKeyLocation = destinations.find((destination)=>typeof destination._objectKey === 'string');
+                const prefix = typeof prefixLocation?.prefix === 'string' ? prefixLocation.prefix : undefined;
+                const objectKey = typeof objectKeyLocation?._objectKey === 'string' ? objectKeyLocation._objectKey : undefined;
+                const prefixData = buildUploadPrefix({
+                    collectionPrefix,
+                    docPrefix: typeof prefix === 'string' ? prefix : undefined,
+                    useCompositePrefixes
+                });
+                const uploadPrefix = useCompositePrefixes ? prefixData.sanitizedDocPrefix : prefixData.uploadPrefix;
+                for (const destination of destinations){
+                    destination.prefix = uploadPrefix;
+                    destination._objectKey = objectKey;
+                }
+                const docPrefix = buildPrefixWithObjectKey({
+                    objectKey,
+                    prefix: uploadPrefix
+                });
+                const dataForUpload = {
+                    ...data,
+                    prefix: docPrefix
+                };
+                const storageFilePath = buildUploadStoragePathData({
+                    collectionPrefix,
+                    docPrefix,
+                    filename,
+                    useCompositePrefixes
+                }).storageFilePath;
+                if (uploadedNames.has(filename)) {
+                    throw new Error(`Duplicate managed cloud filename: ${filename}`);
+                }
+                uploadedNames.add(filename);
+                const buffer = 'buffer' in file ? file.buffer : adapter.supportsTempFiles ? Buffer.alloc(0) : await fs.readFile(file.sourcePath);
+                const uploadFile = {
+                    buffer,
+                    filename,
+                    filesize: 'buffer' in file ? file.buffer.length : (await fs.stat(file.sourcePath)).size,
+                    mimeType: getMimeType({
+                        data,
+                        filename
+                    }),
+                    ...'sourcePath' in file ? {
+                        tempFilePath: file.sourcePath
+                    } : {}
+                };
+                // A new object folder is allocated for every server upload, so an interrupted
+                // provider write can be removed without touching an earlier revision.
+                trackStagedObject({
+                    key: storageFilePath,
+                    remove: async ()=>{
+                        await adapter.deleteFile({
+                            collection,
+                            req,
+                            storageFilePath
+                        });
+                    }
+                });
+                const dataBeforeUpload = deepCopyObjectSimple(dataForUpload);
+                const result = await adapter.handleUpload({
+                    collection,
+                    data: dataForUpload,
+                    file: uploadFile,
+                    req,
+                    storageFilePath
+                });
+                if (result && typeof result === 'object') {
+                    // Adapters may return the entire input document, including fields made stale by this upload.
+                    for (const [key, value] of Object.entries(result)){
+                        if (!isDeepStrictEqual(value, dataBeforeUpload[key])) {
+                            metadata[key] = value;
+                        }
+                    }
+                }
+            }
+            delete metadata.prefix;
+            delete metadata._objectKey;
+            return {
+                metadata
+            };
+        }
+    };
+};
+const getMimeType = ({ data, filename })=>{
+    if (data.original && typeof data.original === 'object') {
+        const original = data.original;
+        if (original.filename === filename && original.mimeType) {
+            return original.mimeType;
+        }
+    }
+    if (data.variants && typeof data.variants === 'object') {
+        for (const size of Object.values(data.variants)){
+            const candidate = size;
+            if (candidate?.filename === filename && candidate.mimeType) {
+                return candidate.mimeType;
+            }
+        }
+    }
+    return typeof data.mimeType === 'string' ? data.mimeType : 'application/octet-stream';
+};
+/** Signed and time-limited URLs change their query on every generation, so only the location is compared. */ const isSameFileLocation = ({ actual, expected })=>typeof expected === 'string' && getFileLocation({
+        url: actual
+    }) === getFileLocation({
+        url: expected
+    });
+const getFileLocation = ({ url })=>{
+    const parsed = new URL(url, 'http://payload.local');
+    return url.startsWith('/') ? parsed.pathname : `${parsed.origin}${parsed.pathname}`;
+};
+
+//# sourceMappingURL=createFileOperations.js.map

package/dist/utilities/createFileOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/createFileOperations.ts"],"sourcesContent":["import type { CollectionConfig, ImageSize, JsonObject, UploadConfig } from 'payload'\n\nimport fs from 'node:fs/promises'\nimport path from 'node:path'\nimport { isDeepStrictEqual } from 'node:util'\nimport { deepCopyObjectSimple, generatePayloadFileURL } from 'payload'\n\nimport type { GeneratedAdapter, GenerateFileURL } from '../types.js'\n\nimport { buildPrefixWithObjectKey } from './buildPrefixWithObjectKey.js'\nimport {\n  buildStoragePathData,\n  buildUploadPrefix,\n  buildUploadStoragePathData,\n} from './buildStoragePathData.js'\n\ntype Args = {\n  adapter: GeneratedAdapter\n  collection: CollectionConfig\n  collectionPrefix?: string\n  disablePayloadAccessControl?: boolean\n  generateFileURL?: GenerateFileURL\n  useCompositePrefixes?: boolean\n}\n\nexport const createFileOperations = ({\n  adapter,\n  collection,\n  collectionPrefix,\n  disablePayloadAccessControl,\n  generateFileURL,\n  useCompositePrefixes,\n}: Args): NonNullable<UploadConfig['fileOperations']> => {\n  if (typeof adapter.deleteFile !== 'function') {\n    throw new Error(\n      `Storage adapter \"${adapter.name}\" must implement deleteFile for collection \"${collection.slug}\".`,\n    )\n  }\n\n  return {\n    copy: async ({ from, req, to, trackStagedObject }) => {\n      await adapter.copyFile({\n        collection: req.payload.collections[collection.slug]!.config,\n        from,\n        req,\n        to,\n      })\n      trackStagedObject({\n        key: to,\n        remove: async () => {\n          await adapter.deleteFile({\n            collection,\n            req,\n            storageFilePath: to,\n          })\n        },\n      })\n    },\n    delete: async ({ key, req }) => {\n      await adapter.deleteFile({\n        collection,\n        req,\n        storageFilePath: key,\n      })\n    },\n    hasLegacyFile: async ({ doc, req }) => {\n      if (typeof doc.filename !== 'string' || typeof doc.url !== 'string') {\n        return false\n      }\n\n      const docPrefix = typeof doc.prefix === 'string' ? doc.prefix : undefined\n      const objectFolder = buildPrefixWithObjectKey({\n        objectKey: typeof doc._objectKey === 'string' ? doc._objectKey : undefined,\n        prefix: docPrefix,\n      })\n      const expectedURL = async ({ filename, size }: { filename: string; size?: ImageSize }) => {\n        if (generateFileURL) {\n          return generateFileURL({ collection, filename, prefix: objectFolder, size })\n        }\n        if (disablePayloadAccessControl && adapter.generateURL) {\n          return adapter.generateURL({ collection, data: doc, filename, prefix: objectFolder })\n        }\n        return generatePayloadFileURL({\n          collectionSlug: collection.slug,\n          config: req.payload.config as unknown as Parameters<\n            typeof generatePayloadFileURL\n          >[0]['config'],\n          filename,\n          relative: true,\n        })\n      }\n      if (\n        !isSameFileLocation({\n          actual: doc.url,\n          expected: await expectedURL({ filename: doc.filename }),\n        })\n      ) {\n        return false\n      }\n      if (doc.variants && typeof doc.variants === 'object' && !Array.isArray(doc.variants)) {\n        for (const [sizeKey, size] of Object.entries(doc.variants)) {\n          if (\n            size &&\n            typeof size === 'object' &&\n            'filename' in size &&\n            typeof size.filename === 'string'\n          ) {\n            const imageSize = req.payload.collections[\n              collection.slug\n            ]?.config.upload.variants?.find(({ name }) => name === sizeKey)\n            if (\n              !('url' in size) ||\n              typeof size.url !== 'string' ||\n              !isSameFileLocation({\n                actual: size.url,\n                expected: await expectedURL({ filename: size.filename, size: imageSize }),\n              })\n            ) {\n              return false\n            }\n          }\n        }\n      }\n      return true\n    },\n    resolveStorageKey: ({ _objectKey, filename, prefix }) =>\n      buildStoragePathData({\n        collectionPrefix,\n        docPrefix: buildPrefixWithObjectKey({ objectKey: _objectKey, prefix }),\n        filename,\n        useCompositePrefixes,\n      }).storageFilePath,\n    ...(adapter.moveFile && {\n      move: async ({ from, req, to, trackStagedObject }) => {\n        await adapter.moveFile!({\n          collection: req.payload.collections[collection.slug]!.config,\n          from,\n          req,\n          to,\n        })\n        trackStagedObject({\n          key: to,\n          remove: () =>\n            adapter.moveFile!({\n              collection: req.payload.collections[collection.slug]!.config,\n              from: to,\n              req,\n              to: from,\n            }),\n        })\n      },\n    }),\n    stage: async ({ data, files, req, trackStagedObject }) => {\n      const uploadedNames = new Set<string>()\n      const metadata: Record<string, unknown> = {}\n      const verifiedOriginal = req.context?._payloadVerifiedProviderOriginal as\n        | { filename: string }\n        | undefined\n      for (const file of files) {\n        const filename = path.basename(file.path)\n        const representations: Record<string, unknown>[] = [data]\n        if (data.original && typeof data.original === 'object') {\n          representations.push(data.original as Record<string, unknown>)\n        }\n        if (data.variants && typeof data.variants === 'object') {\n          representations.push(\n            ...Object.values(data.variants).filter(\n              (value): value is Record<string, unknown> =>\n                Boolean(value) && typeof value === 'object',\n            ),\n          )\n        }\n        const destinations = representations.filter((value) => value.filename === filename)\n        // Provider-direct uploads already placed the source object at its verified location.\n        // A bounded content probe can still appear in files, but it is not a representation\n        // Payload should upload again.\n        if (!destinations.length && verifiedOriginal) {\n          continue\n        }\n        if (!destinations.length) {\n          throw new Error(`No stored representation describes ${filename}`)\n        }\n        const prefixLocation = destinations.find(\n          (destination) => typeof destination.prefix === 'string',\n        )\n        const objectKeyLocation = destinations.find(\n          (destination) => typeof destination._objectKey === 'string',\n        )\n        const prefix =\n          typeof prefixLocation?.prefix === 'string' ? prefixLocation.prefix : undefined\n        const objectKey =\n          typeof objectKeyLocation?._objectKey === 'string'\n            ? objectKeyLocation._objectKey\n            : undefined\n        const prefixData = buildUploadPrefix({\n          collectionPrefix,\n          docPrefix: typeof prefix === 'string' ? prefix : undefined,\n          useCompositePrefixes,\n        })\n        const uploadPrefix = useCompositePrefixes\n          ? prefixData.sanitizedDocPrefix\n          : prefixData.uploadPrefix\n        for (const destination of destinations) {\n          destination.prefix = uploadPrefix\n          destination._objectKey = objectKey\n        }\n        const docPrefix = buildPrefixWithObjectKey({ objectKey, prefix: uploadPrefix })\n        const dataForUpload = { ...data, prefix: docPrefix }\n        const storageFilePath = buildUploadStoragePathData({\n          collectionPrefix,\n          docPrefix,\n          filename,\n          useCompositePrefixes,\n        }).storageFilePath\n\n        if (uploadedNames.has(filename)) {\n          throw new Error(`Duplicate managed cloud filename: ${filename}`)\n        }\n\n        uploadedNames.add(filename)\n        const buffer =\n          'buffer' in file\n            ? file.buffer\n            : adapter.supportsTempFiles\n              ? Buffer.alloc(0)\n              : await fs.readFile(file.sourcePath)\n        const uploadFile = {\n          buffer,\n          filename,\n          filesize: 'buffer' in file ? file.buffer.length : (await fs.stat(file.sourcePath)).size,\n          mimeType: getMimeType({ data, filename }),\n          ...('sourcePath' in file ? { tempFilePath: file.sourcePath } : {}),\n        }\n\n        // A new object folder is allocated for every server upload, so an interrupted\n        // provider write can be removed without touching an earlier revision.\n        trackStagedObject({\n          key: storageFilePath,\n          remove: async () => {\n            await adapter.deleteFile({\n              collection,\n              req,\n              storageFilePath,\n            })\n          },\n        })\n\n        const dataBeforeUpload = deepCopyObjectSimple(dataForUpload as JsonObject)\n        const result = await adapter.handleUpload({\n          collection,\n          data: dataForUpload,\n          file: uploadFile,\n          req,\n          storageFilePath,\n        })\n\n        if (result && typeof result === 'object') {\n          // Adapters may return the entire input document, including fields made stale by this upload.\n          for (const [key, value] of Object.entries(result)) {\n            if (!isDeepStrictEqual(value, dataBeforeUpload[key])) {\n              metadata[key] = value\n            }\n          }\n        }\n      }\n\n      delete metadata.prefix\n      delete metadata._objectKey\n      return { metadata }\n    },\n  }\n}\n\nconst getMimeType = ({\n  data,\n  filename,\n}: {\n  data: Record<string, unknown>\n  filename: string\n}): string => {\n  if (data.original && typeof data.original === 'object') {\n    const original = data.original as { filename?: string; mimeType?: string }\n    if (original.filename === filename && original.mimeType) {\n      return original.mimeType\n    }\n  }\n  if (data.variants && typeof data.variants === 'object') {\n    for (const size of Object.values(data.variants)) {\n      const candidate = size as { filename?: string; mimeType?: string } | null\n      if (candidate?.filename === filename && candidate.mimeType) {\n        return candidate.mimeType\n      }\n    }\n  }\n  return typeof data.mimeType === 'string' ? data.mimeType : 'application/octet-stream'\n}\n\n/** Signed and time-limited URLs change their query on every generation, so only the location is compared. */\nconst isSameFileLocation = ({\n  actual,\n  expected,\n}: {\n  actual: string\n  expected: null | string | undefined\n}): boolean =>\n  typeof expected === 'string' &&\n  getFileLocation({ url: actual }) === getFileLocation({ url: expected })\n\nconst getFileLocation = ({ url }: { url: string }): string => {\n  const parsed = new URL(url, 'http://payload.local')\n\n  return url.startsWith('/') ? parsed.pathname : `${parsed.origin}${parsed.pathname}`\n}\n"],"names":["fs","path","isDeepStrictEqual","deepCopyObjectSimple","generatePayloadFileURL","buildPrefixWithObjectKey","buildStoragePathData","buildUploadPrefix","buildUploadStoragePathData","createFileOperations","adapter","collection","collectionPrefix","disablePayloadAccessControl","generateFileURL","useCompositePrefixes","deleteFile","Error","name","slug","copy","from","req","to","trackStagedObject","copyFile","payload","collections","config","key","remove","storageFilePath","delete","hasLegacyFile","doc","filename","url","docPrefix","prefix","undefined","objectFolder","objectKey","_objectKey","expectedURL","size","generateURL","data","collectionSlug","relative","isSameFileLocation","actual","expected","variants","Array","isArray","sizeKey","Object","entries","imageSize","upload","find","resolveStorageKey","moveFile","move","stage","files","uploadedNames","Set","metadata","verifiedOriginal","context","_payloadVerifiedProviderOriginal","file","basename","representations","original","push","values","filter","value","Boolean","destinations","length","prefixLocation","destination","objectKeyLocation","prefixData","uploadPrefix","sanitizedDocPrefix","dataForUpload","has","add","buffer","supportsTempFiles","Buffer","alloc","readFile","sourcePath","uploadFile","filesize","stat","mimeType","getMimeType","tempFilePath","dataBeforeUpload","result","handleUpload","candidate","getFileLocation","parsed","URL","startsWith","pathname","origin"],"mappings":"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"}

package/dist/utilities/getFilePrefix.d.ts

@@ -1,21 +1,17 @@
-import type { CollectionConfig, PayloadRequest, TypeWithID } from 'payload';
+import type { CollectionConfig, FileData, PayloadRequest, TypeWithID } from 'payload';
 /**
  * Resolves the folder a stored object lives under (semantic `prefix` plus `_objectKey`).
  *
- * An already-authorized `doc` wins outright. Otherwise a verified `clientUploadContext` is used
- * (its `prefix` re-contained with {@link buildUploadStoragePathData}, since it hasn't been verified against
+ * 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.
+ * `overrideAccess: false`, any query-param prefix only narrows that lookup, and `_objectKey`
+ * is read from the resolved document via `showHiddenFields`.
  */
-type GetFilePrefixArgs = {
-    clientUploadContext?: unknown;
+export declare function getFilePrefix({ collection, collectionPrefix, doc, filename, prefixQueryParam, req, uploadReference, useCompositePrefixes, }: {
     collection: CollectionConfig;
     collectionPrefix?: string;
-    doc?: {
-        _objectKey?: string;
-        prefix?: string;
-    } & TypeWithID;
+    doc?: Partial<FileData> & TypeWithID;
     filename: string;
     /**
      * Only narrows the access-controlled fallback lookup below; never trusted or
@@ -23,14 +19,7 @@ type GetFilePrefixArgs = {
      */
     prefixQueryParam?: string;
     req: PayloadRequest;
+    uploadReference?: unknown;
     useCompositePrefixes?: boolean;
-};
-export declare function getFilePrefix({ clientUploadContext, collection, collectionPrefix, doc, filename, prefixQueryParam, req, useCompositePrefixes, }: GetFilePrefixArgs): Promise<string>;
-/**
- * Serve-path helper: resolves the authorized folder with {@link getFilePrefix}, then returns the
- * full object key via {@link buildStoragePathData}. Read handlers use this so a key is never built from an
- * unresolved prefix.
- */
-export declare function getStorageFilePath(args: GetFilePrefixArgs): Promise<string>;
-export {};
+}): 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,EAAE,UAAU,EAAgB,MAAM,SAAS,CAAA;AAMzF;;;;;;;;GAQG;AAEH,KAAK,iBAAiB,GAAG;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,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,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B,CAAA;AACD,wBAAsB,aAAa,CAAC,EAClC,mBAAmB,EACnB,UAAU,EACV,gBAAgB,EAChB,GAAG,EACH,QAAQ,EACR,gBAAgB,EAChB,GAAG,EACH,oBAA4B,GAC7B,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAuErC;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CASjF"}
+{"version":3,"file":"getFilePrefix.d.ts","sourceRoot":"","sources":["../../src/utilities/getFilePrefix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,QAAQ,EACR,cAAc,EAEd,UAAU,EACX,MAAM,SAAS,CAAA;AAMhB;;;;;;;;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,OAAO,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAA;IACpC,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,CA2ElB"}

package/dist/utilities/getFilePrefix.js

@@ -1,32 +1,40 @@
 import { buildPrefixWithObjectKey } from './buildPrefixWithObjectKey.js';
-import { buildStoragePathData, buildUploadStoragePathData } from './buildStoragePathData.js';
+import { buildUploadStoragePathData } from './buildStoragePathData.js';
 import { sanitizePrefix } from './sanitizePrefix.js';
-export async function getFilePrefix({ clientUploadContext, collection, collectionPrefix, doc, filename, prefixQueryParam, req, useCompositePrefixes = false }) {
+/**
+ * Resolves the folder a stored object lives under (semantic `prefix` plus `_objectKey`).
+ *
+ * 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 context or query prefix.
+    // client-supplied upload reference or query prefix.
     if (doc) {
-        return buildPrefixWithObjectKey({
-            objectKey: doc._objectKey,
-            prefix: doc.prefix
+        return getRepresentationPrefix({
+            doc,
+            filename
         });
     }
-    // Client uploads call handlers without a document yet. Re-contain the claimed
+    // 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 (clientUploadContext && typeof clientUploadContext === 'object' && 'prefix' in clientUploadContext && typeof clientUploadContext.prefix === 'string') {
-        const contextObjectKey = '_objectKey' in clientUploadContext ? clientUploadContext._objectKey : undefined;
+    if (uploadReference && typeof uploadReference === 'object' && 'prefix' in uploadReference && typeof uploadReference.prefix === 'string') {
+        const referenceObjectKey = '_objectKey' in uploadReference ? uploadReference._objectKey : undefined;
         const containedPrefix = buildUploadStoragePathData({
             collectionPrefix,
-            docPrefix: clientUploadContext.prefix,
+            docPrefix: uploadReference.prefix,
             filename,
             useCompositePrefixes
         }).sanitizedDocPrefix;
         return buildPrefixWithObjectKey({
-            objectKey: contextObjectKey,
+            objectKey: referenceObjectKey,
             prefix: containedPrefix
         });
     }
     // Reads without a query prefix or read-access constraints skip the endpoint's document lookup.
-    const imageSizes = collection?.upload?.imageSizes || [];
+    const variants = collection?.upload?.variants || [];
     const filenameClause = {
         or: [
             {
@@ -34,8 +42,13 @@ export async function getFilePrefix({ clientUploadContext, collection, collectio
                     equals: filename
                 }
             },
-            ...imageSizes.map((imageSize)=>({
-                    [`sizes.${imageSize.name}.filename`]: {
+            {
+                'original.filename': {
+                    equals: filename
+                }
+            },
+            ...variants.map((imageSize)=>({
+                    [`variants.${imageSize.name}.filename`]: {
                         equals: filename
                     }
                 }))
@@ -63,28 +76,26 @@ export async function getFilePrefix({ clientUploadContext, collection, collectio
         req,
         select: {
             _objectKey: true,
-            prefix: true
+            filename: true,
+            original: true,
+            prefix: true,
+            variants: true
         },
+        showHiddenFields: true,
         where
     });
     const found = files?.docs?.[0];
+    return found ? getRepresentationPrefix({
+        doc: found,
+        filename
+    }) : '';
+}
+const getRepresentationPrefix = ({ doc, filename })=>{
+    const representation = doc.original?.filename === filename ? doc.original : Object.values(doc.variants ?? {}).find((variant)=>variant?.filename === filename) ?? doc;
     return buildPrefixWithObjectKey({
-        objectKey: found?._objectKey,
-        prefix: found?.prefix
+        objectKey: representation._objectKey ?? (!doc.original?.filename ? doc._objectKey : undefined),
+        prefix: representation.prefix ?? (!doc.original?.filename ? doc.prefix : undefined)
     });
-}
-/**
- * Serve-path helper: resolves the authorized folder with {@link getFilePrefix}, then returns the
- * full object key via {@link buildStoragePathData}. Read handlers use this so a key is never built from an
- * unresolved prefix.
- */ export async function getStorageFilePath(args) {
-    const docPrefix = await getFilePrefix(args);
-    return buildStoragePathData({
-        collectionPrefix: args.collectionPrefix,
-        docPrefix,
-        filename: args.filename,
-        useCompositePrefixes: args.useCompositePrefixes
-    }).storageFilePath;
-}
+};
 
 //# sourceMappingURL=getFilePrefix.js.map

package/dist/utilities/getFilePrefix.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/getFilePrefix.ts"],"sourcesContent":["import type { CollectionConfig, PayloadRequest, TypeWithID, UploadConfig } from 'payload'\n\nimport { buildPrefixWithObjectKey } from './buildPrefixWithObjectKey.js'\nimport { buildStoragePathData, 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 a verified `clientUploadContext` is used\n * (its `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` is\n * read from the resolved document.\n */\n\ntype GetFilePrefixArgs = {\n  clientUploadContext?: unknown\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  useCompositePrefixes?: boolean\n}\nexport async function getFilePrefix({\n  clientUploadContext,\n  collection,\n  collectionPrefix,\n  doc,\n  filename,\n  prefixQueryParam,\n  req,\n  useCompositePrefixes = false,\n}: GetFilePrefixArgs): Promise<string> {\n  // The serve path already loaded and authorized this document — trust it over any\n  // client-supplied upload context or query prefix.\n  if (doc) {\n    return buildPrefixWithObjectKey({ objectKey: doc._objectKey, prefix: doc.prefix })\n  }\n\n  // Client uploads 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    clientUploadContext &&\n    typeof clientUploadContext === 'object' &&\n    'prefix' in clientUploadContext &&\n    typeof clientUploadContext.prefix === 'string'\n  ) {\n    const contextObjectKey: string | undefined =\n      '_objectKey' in clientUploadContext\n        ? ((clientUploadContext as { _objectKey?: unknown })._objectKey as string)\n        : undefined\n    const containedPrefix = buildUploadStoragePathData({\n      collectionPrefix,\n      docPrefix: clientUploadContext.prefix,\n      filename,\n      useCompositePrefixes,\n    }).sanitizedDocPrefix\n    return buildPrefixWithObjectKey({\n      objectKey: contextObjectKey,\n      prefix: containedPrefix,\n    })\n  }\n\n  // Reads without a query prefix or read-access constraints skip the endpoint's document lookup.\n  const imageSizes = (collection?.upload as UploadConfig)?.imageSizes || []\n\n  const filenameClause = {\n    or: [\n      {\n        filename: { equals: filename },\n      },\n      ...imageSizes.map((imageSize) => ({\n        [`sizes.${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    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\n/**\n * Serve-path helper: resolves the authorized folder with {@link getFilePrefix}, then returns the\n * full object key via {@link buildStoragePathData}. Read handlers use this so a key is never built from an\n * unresolved prefix.\n */\nexport async function getStorageFilePath(args: GetFilePrefixArgs): Promise<string> {\n  const docPrefix = await getFilePrefix(args)\n\n  return buildStoragePathData({\n    collectionPrefix: args.collectionPrefix,\n    docPrefix,\n    filename: args.filename,\n    useCompositePrefixes: args.useCompositePrefixes,\n  }).storageFilePath\n}\n"],"names":["buildPrefixWithObjectKey","buildStoragePathData","buildUploadStoragePathData","sanitizePrefix","getFilePrefix","clientUploadContext","collection","collectionPrefix","doc","filename","prefixQueryParam","req","useCompositePrefixes","objectKey","_objectKey","prefix","contextObjectKey","undefined","containedPrefix","docPrefix","sanitizedDocPrefix","imageSizes","upload","filenameClause","or","equals","map","imageSize","name","hasPrefixField","fields","some","field","where","and","files","payload","find","slug","depth","draft","limit","overrideAccess","pagination","select","found","docs","getStorageFilePath","args","storageFilePath"],"mappings":"AAEA,SAASA,wBAAwB,QAAQ,gCAA+B;AACxE,SAASC,oBAAoB,EAAEC,0BAA0B,QAAQ,4BAA2B;AAC5F,SAASC,cAAc,QAAQ,sBAAqB;AA0BpD,OAAO,eAAeC,cAAc,EAClCC,mBAAmB,EACnBC,UAAU,EACVC,gBAAgB,EAChBC,GAAG,EACHC,QAAQ,EACRC,gBAAgB,EAChBC,GAAG,EACHC,uBAAuB,KAAK,EACV;IAClB,iFAAiF;IACjF,kDAAkD;IAClD,IAAIJ,KAAK;QACP,OAAOR,yBAAyB;YAAEa,WAAWL,IAAIM,UAAU;YAAEC,QAAQP,IAAIO,MAAM;QAAC;IAClF;IAEA,8EAA8E;IAC9E,8EAA8E;IAC9E,IACEV,uBACA,OAAOA,wBAAwB,YAC/B,YAAYA,uBACZ,OAAOA,oBAAoBU,MAAM,KAAK,UACtC;QACA,MAAMC,mBACJ,gBAAgBX,sBACX,AAACA,oBAAiDS,UAAU,GAC7DG;QACN,MAAMC,kBAAkBhB,2BAA2B;YACjDK;YACAY,WAAWd,oBAAoBU,MAAM;YACrCN;YACAG;QACF,GAAGQ,kBAAkB;QACrB,OAAOpB,yBAAyB;YAC9Ba,WAAWG;YACXD,QAAQG;QACV;IACF;IAEA,+FAA+F;IAC/F,MAAMG,aAAa,AAACf,YAAYgB,QAAyBD,cAAc,EAAE;IAEzE,MAAME,iBAAiB;QACrBC,IAAI;YACF;gBACEf,UAAU;oBAAEgB,QAAQhB;gBAAS;YAC/B;eACGY,WAAWK,GAAG,CAAC,CAACC,YAAe,CAAA;oBAChC,CAAC,CAAC,MAAM,EAAEA,UAAUC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE;wBAAEH,QAAQhB;oBAAS;gBAC3D,CAAA;SACD;IACH;IAEA,yGAAyG;IACzG,MAAMoB,iBAAiBvB,WAAWwB,MAAM,EAAEC,KACxC,CAACC,QAAU,UAAUA,SAASA,MAAMJ,IAAI,KAAK;IAE/C,MAAMK,QACJ,OAAOvB,qBAAqB,YAAYmB,iBACpC;QAAEK,KAAK;YAACX;YAAgB;gBAAER,QAAQ;oBAAEU,QAAQtB,eAAeO;gBAAkB;YAAE;SAAE;IAAC,IAClFa;IAEN,MAAMY,QAAQ,MAAMxB,IAAIyB,OAAO,CAACC,IAAI,CAAC;QACnC/B,YAAYA,WAAWgC,IAAI;QAC3BC,OAAO;QACPC,OAAO;QACPC,OAAO;QACPC,gBAAgB;QAChBC,YAAY;QACZhC;QACAiC,QAAQ;YACN9B,YAAY;YACZC,QAAQ;QACV;QACAkB;IACF;IAEA,MAAMY,QAAQV,OAAOW,MAAM,CAAC,EAAE;IAC9B,OAAO9C,yBAAyB;QAAEa,WAAWgC,OAAO/B;QAAYC,QAAQ8B,OAAO9B;IAAO;AACxF;AAEA;;;;CAIC,GACD,OAAO,eAAegC,mBAAmBC,IAAuB;IAC9D,MAAM7B,YAAY,MAAMf,cAAc4C;IAEtC,OAAO/C,qBAAqB;QAC1BM,kBAAkByC,KAAKzC,gBAAgB;QACvCY;QACAV,UAAUuC,KAAKvC,QAAQ;QACvBG,sBAAsBoC,KAAKpC,oBAAoB;IACjD,GAAGqC,eAAe;AACpB"}
+{"version":3,"sources":["../../src/utilities/getFilePrefix.ts"],"sourcesContent":["import type {\n  CollectionConfig,\n  FileData,\n  PayloadRequest,\n  SanitizedUploadConfig,\n  TypeWithID,\n} 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?: Partial<FileData> & 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 getRepresentationPrefix({ doc, filename })\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      { 'original.filename': { equals: filename } },\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      filename: true,\n      original: true,\n      prefix: true,\n      variants: true,\n    },\n    showHiddenFields: true,\n    where,\n  })\n\n  const found = files?.docs?.[0] as\n    | ({ _objectKey?: string; prefix?: string } & Partial<FileData>)\n    | undefined\n  return found ? getRepresentationPrefix({ doc: found, filename }) : ''\n}\n\nconst getRepresentationPrefix = ({\n  doc,\n  filename,\n}: {\n  doc: Partial<FileData>\n  filename: string\n}): string => {\n  const representation =\n    doc.original?.filename === filename\n      ? doc.original\n      : (Object.values(doc.variants ?? {}).find((variant) => variant?.filename === filename) ?? doc)\n  return buildPrefixWithObjectKey({\n    objectKey: representation._objectKey ?? (!doc.original?.filename ? doc._objectKey : undefined),\n    prefix: representation.prefix ?? (!doc.original?.filename ? doc.prefix : undefined),\n  })\n}\n"],"names":["buildPrefixWithObjectKey","buildUploadStoragePathData","sanitizePrefix","getFilePrefix","collection","collectionPrefix","doc","filename","prefixQueryParam","req","uploadReference","useCompositePrefixes","getRepresentationPrefix","prefix","referenceObjectKey","_objectKey","undefined","containedPrefix","docPrefix","sanitizedDocPrefix","objectKey","variants","upload","filenameClause","or","equals","map","imageSize","name","hasPrefixField","fields","some","field","where","and","files","payload","find","slug","depth","draft","limit","overrideAccess","pagination","select","original","showHiddenFields","found","docs","representation","Object","values","variant"],"mappings":"AAQA,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,OAAOM,wBAAwB;YAAEN;YAAKC;QAAS;IACjD;IAEA,mFAAmF;IACnF,8EAA8E;IAC9E,IACEG,mBACA,OAAOA,oBAAoB,YAC3B,YAAYA,mBACZ,OAAOA,gBAAgBG,MAAM,KAAK,UAClC;QACA,MAAMC,qBACJ,gBAAgBJ,kBACZ,AAACA,gBAA4CK,UAAU,GACvDC;QACN,MAAMC,kBAAkBhB,2BAA2B;YACjDI;YACAa,WAAWR,gBAAgBG,MAAM;YACjCN;YACAI;QACF,GAAGQ,kBAAkB;QACrB,OAAOnB,yBAAyB;YAAEoB,WAAWN;YAAoBD,QAAQI;QAAgB;IAC3F;IAEA,+FAA+F;IAC/F,MAAMI,WAAW,AAACjB,YAAYkB,QAAkCD,YAAY,EAAE;IAE9E,MAAME,iBAAiB;QACrBC,IAAI;YACF;gBACEjB,UAAU;oBAAEkB,QAAQlB;gBAAS;YAC/B;YACA;gBAAE,qBAAqB;oBAAEkB,QAAQlB;gBAAS;YAAE;eACzCc,SAASK,GAAG,CAAC,CAACC,YAAe,CAAA;oBAC9B,CAAC,CAAC,SAAS,EAAEA,UAAUC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE;wBAAEH,QAAQlB;oBAAS;gBAC9D,CAAA;SACD;IACH;IAEA,yGAAyG;IACzG,MAAMsB,iBAAiBzB,WAAW0B,MAAM,EAAEC,KACxC,CAACC,QAAU,UAAUA,SAASA,MAAMJ,IAAI,KAAK;IAE/C,MAAMK,QACJ,OAAOzB,qBAAqB,YAAYqB,iBACpC;QAAEK,KAAK;YAACX;YAAgB;gBAAEV,QAAQ;oBAAEY,QAAQvB,eAAeM;gBAAkB;YAAE;SAAE;IAAC,IAClFe;IAEN,MAAMY,QAAQ,MAAM1B,IAAI2B,OAAO,CAACC,IAAI,CAAC;QACnCjC,YAAYA,WAAWkC,IAAI;QAC3BC,OAAO;QACPC,OAAO;QACPC,OAAO;QACPC,gBAAgB;QAChBC,YAAY;QACZlC;QACAmC,QAAQ;YACN7B,YAAY;YACZR,UAAU;YACVsC,UAAU;YACVhC,QAAQ;YACRQ,UAAU;QACZ;QACAyB,kBAAkB;QAClBb;IACF;IAEA,MAAMc,QAAQZ,OAAOa,MAAM,CAAC,EAAE;IAG9B,OAAOD,QAAQnC,wBAAwB;QAAEN,KAAKyC;QAAOxC;IAAS,KAAK;AACrE;AAEA,MAAMK,0BAA0B,CAAC,EAC/BN,GAAG,EACHC,QAAQ,EAIT;IACC,MAAM0C,iBACJ3C,IAAIuC,QAAQ,EAAEtC,aAAaA,WACvBD,IAAIuC,QAAQ,GACXK,OAAOC,MAAM,CAAC7C,IAAIe,QAAQ,IAAI,CAAC,GAAGgB,IAAI,CAAC,CAACe,UAAYA,SAAS7C,aAAaA,aAAaD;IAC9F,OAAON,yBAAyB;QAC9BoB,WAAW6B,eAAelC,UAAU,IAAK,CAAA,CAACT,IAAIuC,QAAQ,EAAEtC,WAAWD,IAAIS,UAAU,GAAGC,SAAQ;QAC5FH,QAAQoC,eAAepC,MAAM,IAAK,CAAA,CAACP,IAAIuC,QAAQ,EAAEtC,WAAWD,IAAIO,MAAM,GAAGG,SAAQ;IACnF;AACF"}

package/dist/utilities/getIncomingFiles.js

@@ -7,17 +7,17 @@ export function getIncomingFiles({ data, req }) {
     if (file && data.filename && data.mimeType) {
         const mainFile = {
             buffer: file.data,
-            clientUploadContext: file.clientUploadContext,
             filename: data.filename,
             filesize: file.size,
             mimeType: data.mimeType,
-            tempFilePath: file.tempFilePath
+            tempFilePath: file.tempFilePath,
+            uploadReference: file.uploadReference
         };
         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([
                         {