@payloadcms/storage-vercel-blob 4.0.0-canary.33 → 4.0.0-canary.34

package/dist/adapter.d.ts

@@ -1,13 +1,15 @@
 import type { Adapter, ClientUploadsConfig } from '@payloadcms/plugin-cloud-storage/types';
+import type { VercelBlobCollectionSource } from './authorizeFileOverwrite.js';
 interface CreateVercelBlobAdapterArgs {
     access: 'public';
     addRandomSuffix?: boolean;
     baseUrl: string;
     cacheControlMaxAge: number;
     clientUploads?: ClientUploadsConfig;
+    collectionSources: VercelBlobCollectionSource[];
     token: string;
     useCompositePrefixes?: boolean;
 }
-export declare function createVercelBlobAdapter({ access, addRandomSuffix, baseUrl, cacheControlMaxAge, clientUploads, token, useCompositePrefixes, }: CreateVercelBlobAdapterArgs): Adapter;
+export declare function createVercelBlobAdapter({ access, addRandomSuffix, baseUrl, cacheControlMaxAge, clientUploads, collectionSources, token, useCompositePrefixes, }: CreateVercelBlobAdapterArgs): Adapter;
 export {};
 //# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,mBAAmB,EAEpB,MAAM,wCAAwC,CAAA;AAW/C,UAAU,2BAA2B;IACnC,MAAM,EAAE,QAAQ,CAAA;IAChB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,kBAAkB,EAAE,MAAM,CAAA;IAC1B,aAAa,CAAC,EAAE,mBAAmB,CAAA;IACnC,KAAK,EAAE,MAAM,CAAA;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,wBAAgB,uBAAuB,CAAC,EACtC,MAAM,EACN,eAAe,EACf,OAAO,EACP,kBAAkB,EAClB,aAAa,EACb,KAAK,EACL,oBAA4B,GAC7B,EAAE,2BAA2B,GAAG,OAAO,CAwHvC"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,mBAAmB,EAEpB,MAAM,wCAAwC,CAAA;AAU/C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAA;AAQ7E,UAAU,2BAA2B;IACnC,MAAM,EAAE,QAAQ,CAAA;IAChB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,kBAAkB,EAAE,MAAM,CAAA;IAC1B,aAAa,CAAC,EAAE,mBAAmB,CAAA;IACnC,iBAAiB,EAAE,0BAA0B,EAAE,CAAA;IAC/C,KAAK,EAAE,MAAM,CAAA;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,wBAAgB,uBAAuB,CAAC,EACtC,MAAM,EACN,eAAe,EACf,OAAO,EACP,kBAAkB,EAClB,aAAa,EACb,iBAAiB,EACjB,KAAK,EACL,oBAA4B,GAC7B,EAAE,2BAA2B,GAAG,OAAO,CAgJvC"}

package/dist/adapter.js

@@ -1,11 +1,13 @@
-import { resolveSignedURLKey } from '@payloadcms/plugin-cloud-storage/utilities';
+import { buildUploadStoragePathData, resolveSignedURLKey } from '@payloadcms/plugin-cloud-storage/utilities';
 import { generateClientTokenFromReadWriteToken } from '@vercel/blob/client';
 import { Forbidden } from 'payload';
+import { assertClientUploadAllowed, createClientUploadReceipt } from 'payload/internal';
+import { authorizeClientOverwrite } from './authorizeFileOverwrite.js';
 import { deleteFile } from './deleteFile.js';
 import { generateURL } from './generateURL.js';
 import { getFile } from './getFile.js';
 import { uploadFile } from './uploadFile.js';
-export function createVercelBlobAdapter({ access, addRandomSuffix, baseUrl, cacheControlMaxAge, clientUploads, token, useCompositePrefixes = false }) {
+export function createVercelBlobAdapter({ access, addRandomSuffix, baseUrl, cacheControlMaxAge, clientUploads, collectionSources, token, useCompositePrefixes = false }) {
     const clientUploadsAccess = typeof clientUploads === 'object' ? clientUploads.access : undefined;
     return ({ collection, prefix = '' })=>({
             name: 'vercel-blob',
@@ -21,7 +23,40 @@ export function createVercelBlobAdapter({ access, addRandomSuffix, baseUrl, cach
                     }) : !req.user)) {
                         throw new Forbidden(req.t);
                     }
-                    const resolved = await resolveSignedURLKey({
+                    assertClientUploadAllowed({
+                        collection,
+                        filename,
+                        mimeType
+                    });
+                    const requested = buildUploadStoragePathData({
+                        collectionPrefix: prefix,
+                        docPrefix,
+                        filename,
+                        useCompositePrefixes
+                    });
+                    const allowOverwrite = await authorizeClientOverwrite({
+                        collectionPrefix: prefix,
+                        collectionSources,
+                        overrideAccess,
+                        req,
+                        requestedCollectionSlug: collectionSlug,
+                        requestedFilename: requested.sanitizedFilename,
+                        requestedStorageFilePath: requested.storageFilePath
+                    });
+                    const resolved = allowOverwrite ? {
+                        ...requested,
+                        uploadReference: {
+                            prefix: requested.sanitizedDocPrefix,
+                            signedReceipt: createClientUploadReceipt({
+                                allowOverwrite: true,
+                                collectionSlug,
+                                filename: requested.sanitizedFilename,
+                                filePrefix: requested.sanitizedDocPrefix,
+                                req,
+                                storageFilePath: requested.storageFilePath
+                            })
+                        }
+                    } : await resolveSignedURLKey({
                         collectionPrefix: prefix,
                         collectionSlug,
                         docPrefix,
@@ -33,16 +68,18 @@ export function createVercelBlobAdapter({ access, addRandomSuffix, baseUrl, cach
                         name: 'uploadToVercelBlob',
                         type: 'dispatch',
                         data: {
-                            pathname: resolved.fileKey,
+                            pathname: resolved.storageFilePath,
                             token: await generateClientTokenFromReadWriteToken({
-                                addRandomSuffix,
+                                addRandomSuffix: false,
                                 allowedContentTypes: mimeType ? [
                                     mimeType
                                 ] : undefined,
-                                allowOverwrite: true,
+                                ...allowOverwrite && {
+                                    allowOverwrite: true
+                                },
                                 cacheControlMaxAge,
                                 maximumSizeInBytes: filesize,
-                                pathname: resolved.fileKey,
+                                pathname: resolved.storageFilePath,
                                 token
                             })
                         },
@@ -50,12 +87,11 @@ export function createVercelBlobAdapter({ access, addRandomSuffix, baseUrl, cach
                             filename: resolved.sanitizedFilename,
                             mimeType,
                             size: filesize,
-                            uploadReference: {
-                                prefix: resolved.sanitizedDocPrefix
-                            }
+                            uploadReference: resolved.uploadReference
                         }
                     };
                 },
+                requiresUploadReceipt: true,
                 useInAdmin: true
             },
             generateURL: ({ filename, prefix: urlPrefix = '' })=>generateURL({
@@ -65,40 +101,34 @@ export function createVercelBlobAdapter({ access, addRandomSuffix, baseUrl, cach
                     prefix: urlPrefix,
                     useCompositePrefixes
                 }),
-            handleDelete: ({ doc: { prefix: docPrefix = '' }, filename })=>deleteFile({
+            handleDelete: ({ storageFilePath })=>deleteFile({
                     baseUrl,
-                    collectionPrefix: prefix,
-                    docPrefix,
-                    filename,
-                    token,
-                    useCompositePrefixes
+                    storageFilePath,
+                    token
                 }),
-            handleUpload: async ({ data, file: { buffer, filename, mimeType } })=>{
+            handleUpload: async ({ data, file: { buffer, mimeType }, storageFilePath })=>{
                 const result = await uploadFile({
                     access,
                     addRandomSuffix,
                     buffer,
                     cacheControlMaxAge,
-                    collectionPrefix: prefix,
-                    docPrefix: data.prefix,
-                    filename,
                     mimeType,
-                    token,
-                    useCompositePrefixes
+                    storageFilePath,
+                    token
                 });
                 if (result.filename) {
                     data.filename = result.filename;
                 }
                 return data;
             },
-            staticHandler: (req, { headers, params: { filename, prefix: prefixQueryParam, uploadReference } })=>getFile({
+            staticHandler: (req, { doc, headers, params: { filename, uploadReference } })=>getFile({
                     baseUrl,
                     cacheControlMaxAge,
                     collection,
                     collectionPrefix: prefix,
+                    doc,
                     filename,
                     incomingHeaders: headers,
-                    prefixQueryParam,
                     req,
                     token,
                     uploadReference,

package/dist/adapter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/adapter.ts"],"sourcesContent":["import type {\n  Adapter,\n  ClientUploadsConfig,\n  GeneratedAdapter,\n} from '@payloadcms/plugin-cloud-storage/types'\n\nimport { resolveSignedURLKey } from '@payloadcms/plugin-cloud-storage/utilities'\nimport { generateClientTokenFromReadWriteToken } from '@vercel/blob/client'\nimport { Forbidden } from 'payload'\n\nimport { deleteFile } from './deleteFile.js'\nimport { generateURL } from './generateURL.js'\nimport { getFile } from './getFile.js'\nimport { uploadFile } from './uploadFile.js'\n\ninterface CreateVercelBlobAdapterArgs {\n  access: 'public'\n  addRandomSuffix?: boolean\n  baseUrl: string\n  cacheControlMaxAge: number\n  clientUploads?: ClientUploadsConfig\n  token: string\n  useCompositePrefixes?: boolean\n}\n\nexport function createVercelBlobAdapter({\n  access,\n  addRandomSuffix,\n  baseUrl,\n  cacheControlMaxAge,\n  clientUploads,\n  token,\n  useCompositePrefixes = false,\n}: CreateVercelBlobAdapterArgs): Adapter {\n  const clientUploadsAccess = typeof clientUploads === 'object' ? clientUploads.access : undefined\n\n  return ({ collection, prefix = '' }): GeneratedAdapter => ({\n    name: 'vercel-blob',\n\n    uploadInstructions: {\n      adminHandler: {\n        path: '@payloadcms/storage-vercel-blob/client#VercelBlobClientUploadHandler',\n      },\n      enabled: Boolean(clientUploads),\n      generate: async ({\n        collectionSlug,\n        docPrefix,\n        filename,\n        filesize,\n        mimeType,\n        overrideAccess,\n        req,\n      }) => {\n        if (\n          !overrideAccess &&\n          (clientUploadsAccess ? !(await clientUploadsAccess({ collectionSlug, req })) : !req.user)\n        ) {\n          throw new Forbidden(req.t)\n        }\n\n        const resolved = await resolveSignedURLKey({\n          collectionPrefix: prefix,\n          collectionSlug,\n          docPrefix,\n          filename,\n          req,\n          useCompositePrefixes,\n        })\n\n        return {\n          name: 'uploadToVercelBlob',\n          type: 'dispatch',\n          data: {\n            pathname: resolved.fileKey,\n            token: await generateClientTokenFromReadWriteToken({\n              addRandomSuffix,\n              allowedContentTypes: mimeType ? [mimeType] : undefined,\n              allowOverwrite: true,\n              cacheControlMaxAge,\n              maximumSizeInBytes: filesize,\n              pathname: resolved.fileKey,\n              token,\n            }),\n          },\n          file: {\n            filename: resolved.sanitizedFilename,\n            mimeType,\n            size: filesize,\n            uploadReference: { prefix: resolved.sanitizedDocPrefix },\n          },\n        }\n      },\n      useInAdmin: true,\n    },\n\n    generateURL: ({ filename, prefix: urlPrefix = '' }) =>\n      generateURL({\n        baseUrl,\n        collectionPrefix: prefix,\n        filename,\n        prefix: urlPrefix,\n        useCompositePrefixes,\n      }),\n\n    handleDelete: ({ doc: { prefix: docPrefix = '' }, filename }) =>\n      deleteFile({\n        baseUrl,\n        collectionPrefix: prefix,\n        docPrefix,\n        filename,\n        token,\n        useCompositePrefixes,\n      }),\n\n    handleUpload: async ({ data, file: { buffer, filename, mimeType } }) => {\n      const result = await uploadFile({\n        access,\n        addRandomSuffix,\n        buffer,\n        cacheControlMaxAge,\n        collectionPrefix: prefix,\n        docPrefix: data.prefix,\n        filename,\n        mimeType,\n        token,\n        useCompositePrefixes,\n      })\n\n      if (result.filename) {\n        data.filename = result.filename\n      }\n\n      return data\n    },\n\n    staticHandler: (\n      req,\n      { headers, params: { filename, prefix: prefixQueryParam, uploadReference } },\n    ) =>\n      getFile({\n        baseUrl,\n        cacheControlMaxAge,\n        collection,\n        collectionPrefix: prefix,\n        filename,\n        incomingHeaders: headers,\n        prefixQueryParam,\n        req,\n        token,\n        uploadReference,\n        useCompositePrefixes,\n      }),\n  })\n}\n"],"names":["resolveSignedURLKey","generateClientTokenFromReadWriteToken","Forbidden","deleteFile","generateURL","getFile","uploadFile","createVercelBlobAdapter","access","addRandomSuffix","baseUrl","cacheControlMaxAge","clientUploads","token","useCompositePrefixes","clientUploadsAccess","undefined","collection","prefix","name","uploadInstructions","adminHandler","path","enabled","Boolean","generate","collectionSlug","docPrefix","filename","filesize","mimeType","overrideAccess","req","user","t","resolved","collectionPrefix","type","data","pathname","fileKey","allowedContentTypes","allowOverwrite","maximumSizeInBytes","file","sanitizedFilename","size","uploadReference","sanitizedDocPrefix","useInAdmin","urlPrefix","handleDelete","doc","handleUpload","buffer","result","staticHandler","headers","params","prefixQueryParam","incomingHeaders"],"mappings":"AAMA,SAASA,mBAAmB,QAAQ,6CAA4C;AAChF,SAASC,qCAAqC,QAAQ,sBAAqB;AAC3E,SAASC,SAAS,QAAQ,UAAS;AAEnC,SAASC,UAAU,QAAQ,kBAAiB;AAC5C,SAASC,WAAW,QAAQ,mBAAkB;AAC9C,SAASC,OAAO,QAAQ,eAAc;AACtC,SAASC,UAAU,QAAQ,kBAAiB;AAY5C,OAAO,SAASC,wBAAwB,EACtCC,MAAM,EACNC,eAAe,EACfC,OAAO,EACPC,kBAAkB,EAClBC,aAAa,EACbC,KAAK,EACLC,uBAAuB,KAAK,EACA;IAC5B,MAAMC,sBAAsB,OAAOH,kBAAkB,WAAWA,cAAcJ,MAAM,GAAGQ;IAEvF,OAAO,CAAC,EAAEC,UAAU,EAAEC,SAAS,EAAE,EAAE,GAAwB,CAAA;YACzDC,MAAM;YAENC,oBAAoB;gBAClBC,cAAc;oBACZC,MAAM;gBACR;gBACAC,SAASC,QAAQZ;gBACjBa,UAAU,OAAO,EACfC,cAAc,EACdC,SAAS,EACTC,QAAQ,EACRC,QAAQ,EACRC,QAAQ,EACRC,cAAc,EACdC,GAAG,EACJ;oBACC,IACE,CAACD,kBACAhB,CAAAA,sBAAsB,CAAE,MAAMA,oBAAoB;wBAAEW;wBAAgBM;oBAAI,KAAM,CAACA,IAAIC,IAAI,AAAD,GACvF;wBACA,MAAM,IAAI/B,UAAU8B,IAAIE,CAAC;oBAC3B;oBAEA,MAAMC,WAAW,MAAMnC,oBAAoB;wBACzCoC,kBAAkBlB;wBAClBQ;wBACAC;wBACAC;wBACAI;wBACAlB;oBACF;oBAEA,OAAO;wBACLK,MAAM;wBACNkB,MAAM;wBACNC,MAAM;4BACJC,UAAUJ,SAASK,OAAO;4BAC1B3B,OAAO,MAAMZ,sCAAsC;gCACjDQ;gCACAgC,qBAAqBX,WAAW;oCAACA;iCAAS,GAAGd;gCAC7C0B,gBAAgB;gCAChB/B;gCACAgC,oBAAoBd;gCACpBU,UAAUJ,SAASK,OAAO;gCAC1B3B;4BACF;wBACF;wBACA+B,MAAM;4BACJhB,UAAUO,SAASU,iBAAiB;4BACpCf;4BACAgB,MAAMjB;4BACNkB,iBAAiB;gCAAE7B,QAAQiB,SAASa,kBAAkB;4BAAC;wBACzD;oBACF;gBACF;gBACAC,YAAY;YACd;YAEA7C,aAAa,CAAC,EAAEwB,QAAQ,EAAEV,QAAQgC,YAAY,EAAE,EAAE,GAChD9C,YAAY;oBACVM;oBACA0B,kBAAkBlB;oBAClBU;oBACAV,QAAQgC;oBACRpC;gBACF;YAEFqC,cAAc,CAAC,EAAEC,KAAK,EAAElC,QAAQS,YAAY,EAAE,EAAE,EAAEC,QAAQ,EAAE,GAC1DzB,WAAW;oBACTO;oBACA0B,kBAAkBlB;oBAClBS;oBACAC;oBACAf;oBACAC;gBACF;YAEFuC,cAAc,OAAO,EAAEf,IAAI,EAAEM,MAAM,EAAEU,MAAM,EAAE1B,QAAQ,EAAEE,QAAQ,EAAE,EAAE;gBACjE,MAAMyB,SAAS,MAAMjD,WAAW;oBAC9BE;oBACAC;oBACA6C;oBACA3C;oBACAyB,kBAAkBlB;oBAClBS,WAAWW,KAAKpB,MAAM;oBACtBU;oBACAE;oBACAjB;oBACAC;gBACF;gBAEA,IAAIyC,OAAO3B,QAAQ,EAAE;oBACnBU,KAAKV,QAAQ,GAAG2B,OAAO3B,QAAQ;gBACjC;gBAEA,OAAOU;YACT;YAEAkB,eAAe,CACbxB,KACA,EAAEyB,OAAO,EAAEC,QAAQ,EAAE9B,QAAQ,EAAEV,QAAQyC,gBAAgB,EAAEZ,eAAe,EAAE,EAAE,GAE5E1C,QAAQ;oBACNK;oBACAC;oBACAM;oBACAmB,kBAAkBlB;oBAClBU;oBACAgC,iBAAiBH;oBACjBE;oBACA3B;oBACAnB;oBACAkC;oBACAjC;gBACF;QACJ,CAAA;AACF"}
+{"version":3,"sources":["../src/adapter.ts"],"sourcesContent":["import type {\n  Adapter,\n  ClientUploadsConfig,\n  GeneratedAdapter,\n} from '@payloadcms/plugin-cloud-storage/types'\n\nimport {\n  buildUploadStoragePathData,\n  resolveSignedURLKey,\n} from '@payloadcms/plugin-cloud-storage/utilities'\nimport { generateClientTokenFromReadWriteToken } from '@vercel/blob/client'\nimport { Forbidden } from 'payload'\nimport { assertClientUploadAllowed, createClientUploadReceipt } from 'payload/internal'\n\nimport type { VercelBlobCollectionSource } from './authorizeFileOverwrite.js'\n\nimport { authorizeClientOverwrite } from './authorizeFileOverwrite.js'\nimport { deleteFile } from './deleteFile.js'\nimport { generateURL } from './generateURL.js'\nimport { getFile } from './getFile.js'\nimport { uploadFile } from './uploadFile.js'\n\ninterface CreateVercelBlobAdapterArgs {\n  access: 'public'\n  addRandomSuffix?: boolean\n  baseUrl: string\n  cacheControlMaxAge: number\n  clientUploads?: ClientUploadsConfig\n  collectionSources: VercelBlobCollectionSource[]\n  token: string\n  useCompositePrefixes?: boolean\n}\n\nexport function createVercelBlobAdapter({\n  access,\n  addRandomSuffix,\n  baseUrl,\n  cacheControlMaxAge,\n  clientUploads,\n  collectionSources,\n  token,\n  useCompositePrefixes = false,\n}: CreateVercelBlobAdapterArgs): Adapter {\n  const clientUploadsAccess = typeof clientUploads === 'object' ? clientUploads.access : undefined\n\n  return ({ collection, prefix = '' }): GeneratedAdapter => ({\n    name: 'vercel-blob',\n\n    uploadInstructions: {\n      adminHandler: {\n        path: '@payloadcms/storage-vercel-blob/client#VercelBlobClientUploadHandler',\n      },\n      enabled: Boolean(clientUploads),\n      generate: async ({\n        collectionSlug,\n        docPrefix,\n        filename,\n        filesize,\n        mimeType,\n        overrideAccess,\n        req,\n      }) => {\n        if (\n          !overrideAccess &&\n          (clientUploadsAccess ? !(await clientUploadsAccess({ collectionSlug, req })) : !req.user)\n        ) {\n          throw new Forbidden(req.t)\n        }\n\n        assertClientUploadAllowed({ collection, filename, mimeType })\n\n        const requested = buildUploadStoragePathData({\n          collectionPrefix: prefix,\n          docPrefix,\n          filename,\n          useCompositePrefixes,\n        })\n        const allowOverwrite = await authorizeClientOverwrite({\n          collectionPrefix: prefix,\n          collectionSources,\n          overrideAccess,\n          req,\n          requestedCollectionSlug: collectionSlug,\n          requestedFilename: requested.sanitizedFilename,\n          requestedStorageFilePath: requested.storageFilePath,\n        })\n        const resolved = allowOverwrite\n          ? {\n              ...requested,\n              uploadReference: {\n                prefix: requested.sanitizedDocPrefix,\n                signedReceipt: createClientUploadReceipt({\n                  allowOverwrite: true,\n                  collectionSlug,\n                  filename: requested.sanitizedFilename,\n                  filePrefix: requested.sanitizedDocPrefix,\n                  req,\n                  storageFilePath: requested.storageFilePath,\n                }),\n              },\n            }\n          : await resolveSignedURLKey({\n              collectionPrefix: prefix,\n              collectionSlug,\n              docPrefix,\n              filename,\n              req,\n              useCompositePrefixes,\n            })\n\n        return {\n          name: 'uploadToVercelBlob',\n          type: 'dispatch',\n          data: {\n            pathname: resolved.storageFilePath,\n            token: await generateClientTokenFromReadWriteToken({\n              addRandomSuffix: false,\n              allowedContentTypes: mimeType ? [mimeType] : undefined,\n              ...(allowOverwrite && { allowOverwrite: true }),\n              cacheControlMaxAge,\n              maximumSizeInBytes: filesize,\n              pathname: resolved.storageFilePath,\n              token,\n            }),\n          },\n          file: {\n            filename: resolved.sanitizedFilename,\n            mimeType,\n            size: filesize,\n            uploadReference: resolved.uploadReference,\n          },\n        }\n      },\n      requiresUploadReceipt: true,\n      useInAdmin: true,\n    },\n\n    generateURL: ({ filename, prefix: urlPrefix = '' }) =>\n      generateURL({\n        baseUrl,\n        collectionPrefix: prefix,\n        filename,\n        prefix: urlPrefix,\n        useCompositePrefixes,\n      }),\n\n    handleDelete: ({ storageFilePath }) =>\n      deleteFile({\n        baseUrl,\n        storageFilePath,\n        token,\n      }),\n\n    handleUpload: async ({ data, file: { buffer, mimeType }, storageFilePath }) => {\n      const result = await uploadFile({\n        access,\n        addRandomSuffix,\n        buffer,\n        cacheControlMaxAge,\n        mimeType,\n        storageFilePath,\n        token,\n      })\n\n      if (result.filename) {\n        data.filename = result.filename\n      }\n\n      return data\n    },\n\n    staticHandler: (req, { doc, headers, params: { filename, uploadReference } }) =>\n      getFile({\n        baseUrl,\n        cacheControlMaxAge,\n        collection,\n        collectionPrefix: prefix,\n        doc,\n        filename,\n        incomingHeaders: headers,\n        req,\n        token,\n        uploadReference,\n        useCompositePrefixes,\n      }),\n  })\n}\n"],"names":["buildUploadStoragePathData","resolveSignedURLKey","generateClientTokenFromReadWriteToken","Forbidden","assertClientUploadAllowed","createClientUploadReceipt","authorizeClientOverwrite","deleteFile","generateURL","getFile","uploadFile","createVercelBlobAdapter","access","addRandomSuffix","baseUrl","cacheControlMaxAge","clientUploads","collectionSources","token","useCompositePrefixes","clientUploadsAccess","undefined","collection","prefix","name","uploadInstructions","adminHandler","path","enabled","Boolean","generate","collectionSlug","docPrefix","filename","filesize","mimeType","overrideAccess","req","user","t","requested","collectionPrefix","allowOverwrite","requestedCollectionSlug","requestedFilename","sanitizedFilename","requestedStorageFilePath","storageFilePath","resolved","uploadReference","sanitizedDocPrefix","signedReceipt","filePrefix","type","data","pathname","allowedContentTypes","maximumSizeInBytes","file","size","requiresUploadReceipt","useInAdmin","urlPrefix","handleDelete","handleUpload","buffer","result","staticHandler","doc","headers","params","incomingHeaders"],"mappings":"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"}

package/dist/adapter.spec.js

@@ -0,0 +1,124 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(()=>({
+        generateClientToken: vi.fn(async ()=>'client-token'),
+        // Resolves the stored location of an owning document, so it matches the requested key.
+        buildStoragePathData: vi.fn(()=>({
+                storageFilePath: 'reference.png',
+                sanitizedCollectionPrefix: '',
+                sanitizedDocPrefix: '',
+                sanitizedFilename: 'reference.png'
+            })),
+        buildUploadStoragePathData: vi.fn(()=>({
+                storageFilePath: 'reference.png',
+                sanitizedCollectionPrefix: '',
+                sanitizedDocPrefix: '',
+                sanitizedFilename: 'reference.png'
+            })),
+        isStoragePathWithinCollectionPrefix: vi.fn(()=>true),
+        resolveSignedURLKey: vi.fn(async ()=>({
+                storageFilePath: 'reference-1.png',
+                sanitizedDocPrefix: '',
+                sanitizedFilename: 'reference-1.png',
+                uploadReference: {
+                    prefix: '',
+                    signedReceipt: 'upload-receipt'
+                }
+            }))
+    }));
+vi.mock('@payloadcms/plugin-cloud-storage/utilities', ()=>({
+        buildStoragePathData: mocks.buildStoragePathData,
+        buildUploadStoragePathData: mocks.buildUploadStoragePathData,
+        isStoragePathWithinCollectionPrefix: mocks.isStoragePathWithinCollectionPrefix,
+        resolveSignedURLKey: mocks.resolveSignedURLKey
+    }));
+vi.mock('@vercel/blob/client', ()=>({
+        generateClientTokenFromReadWriteToken: mocks.generateClientToken
+    }));
+import { createVercelBlobAdapter } from './adapter.js';
+const generateInstructions = async ({ hasOwner })=>{
+    const adapter = createVercelBlobAdapter({
+        access: 'public',
+        baseUrl: 'https://example.com',
+        cacheControlMaxAge: 60,
+        clientUploads: true,
+        collectionSources: [
+            {
+                collectionPrefix: '',
+                collectionSlug: 'media',
+                useCompositePrefixes: false
+            }
+        ],
+        token: 'read-write-token'
+    });
+    const generatedAdapter = adapter({
+        collection: {
+            slug: 'media'
+        },
+        prefix: ''
+    });
+    const req = {
+        payload: {
+            collections: {
+                media: {
+                    config: {
+                        access: {
+                            update: async ()=>true
+                        },
+                        upload: true
+                    }
+                }
+            },
+            find: vi.fn(async ()=>({
+                    docs: hasOwner ? [
+                        {
+                            filename: 'reference.png',
+                            id: 1
+                        }
+                    ] : []
+                })),
+            secret: 'secret'
+        },
+        t: vi.fn()
+    };
+    return generatedAdapter.uploadInstructions?.generate({
+        collectionSlug: 'media',
+        filename: 'reference.png',
+        filesize: 100,
+        mimeType: 'image/png',
+        overrideAccess: true,
+        req
+    });
+};
+describe('createVercelBlobAdapter', ()=>{
+    beforeEach(()=>{
+        vi.clearAllMocks();
+    });
+    it('should disable overwrite when no document owns the requested key', async ()=>{
+        const instructions = await generateInstructions({
+            hasOwner: false
+        });
+        const tokenOptions = mocks.generateClientToken.mock.calls[0][0];
+        expect(instructions).toMatchObject({
+            data: {
+                pathname: 'reference-1.png'
+            }
+        });
+        expect(tokenOptions).not.toHaveProperty('allowOverwrite');
+    });
+    it('should allow an authorized owner to update the requested key', async ()=>{
+        const instructions = await generateInstructions({
+            hasOwner: true
+        });
+        expect(instructions).toMatchObject({
+            data: {
+                pathname: 'reference.png'
+            }
+        });
+        expect(mocks.generateClientToken).toHaveBeenCalledWith(expect.objectContaining({
+            allowOverwrite: true,
+            pathname: 'reference.png'
+        }));
+    });
+});
+
+//# sourceMappingURL=adapter.spec.js.map

package/dist/adapter.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapter.spec.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\n\nimport { beforeEach, describe, expect, it, vi } from 'vitest'\n\nconst mocks = vi.hoisted(() => ({\n  generateClientToken: vi.fn(async () => 'client-token'),\n  // Resolves the stored location of an owning document, so it matches the requested key.\n  buildStoragePathData: vi.fn(() => ({\n    storageFilePath: 'reference.png',\n    sanitizedCollectionPrefix: '',\n    sanitizedDocPrefix: '',\n    sanitizedFilename: 'reference.png',\n  })),\n  buildUploadStoragePathData: vi.fn(() => ({\n    storageFilePath: 'reference.png',\n    sanitizedCollectionPrefix: '',\n    sanitizedDocPrefix: '',\n    sanitizedFilename: 'reference.png',\n  })),\n  isStoragePathWithinCollectionPrefix: vi.fn(() => true),\n  resolveSignedURLKey: vi.fn(async () => ({\n    storageFilePath: 'reference-1.png',\n    sanitizedDocPrefix: '',\n    sanitizedFilename: 'reference-1.png',\n    uploadReference: { prefix: '', signedReceipt: 'upload-receipt' },\n  })),\n}))\n\nvi.mock('@payloadcms/plugin-cloud-storage/utilities', () => ({\n  buildStoragePathData: mocks.buildStoragePathData,\n  buildUploadStoragePathData: mocks.buildUploadStoragePathData,\n  isStoragePathWithinCollectionPrefix: mocks.isStoragePathWithinCollectionPrefix,\n  resolveSignedURLKey: mocks.resolveSignedURLKey,\n}))\n\nvi.mock('@vercel/blob/client', () => ({\n  generateClientTokenFromReadWriteToken: mocks.generateClientToken,\n}))\n\nimport { createVercelBlobAdapter } from './adapter.js'\n\nconst generateInstructions = async ({ hasOwner }: { hasOwner: boolean }) => {\n  const adapter = createVercelBlobAdapter({\n    access: 'public',\n    baseUrl: 'https://example.com',\n    cacheControlMaxAge: 60,\n    clientUploads: true,\n    collectionSources: [\n      { collectionPrefix: '', collectionSlug: 'media', useCompositePrefixes: false },\n    ],\n    token: 'read-write-token',\n  })\n  const generatedAdapter = adapter({\n    collection: { slug: 'media' },\n    prefix: '',\n  } as never)\n  const req = {\n    payload: {\n      collections: {\n        media: { config: { access: { update: async () => true }, upload: true } },\n      },\n      find: vi.fn(async () => ({\n        docs: hasOwner ? [{ filename: 'reference.png', id: 1 }] : [],\n      })),\n      secret: 'secret',\n    },\n    t: vi.fn(),\n  } as unknown as PayloadRequest\n\n  return generatedAdapter.uploadInstructions?.generate({\n    collectionSlug: 'media',\n    filename: 'reference.png',\n    filesize: 100,\n    mimeType: 'image/png',\n    overrideAccess: true,\n    req,\n  })\n}\n\ndescribe('createVercelBlobAdapter', () => {\n  beforeEach(() => {\n    vi.clearAllMocks()\n  })\n\n  it('should disable overwrite when no document owns the requested key', async () => {\n    const instructions = await generateInstructions({ hasOwner: false })\n    const tokenOptions = mocks.generateClientToken.mock.calls[0]![0]\n\n    expect(instructions).toMatchObject({ data: { pathname: 'reference-1.png' } })\n    expect(tokenOptions).not.toHaveProperty('allowOverwrite')\n  })\n\n  it('should allow an authorized owner to update the requested key', async () => {\n    const instructions = await generateInstructions({ hasOwner: true })\n\n    expect(instructions).toMatchObject({ data: { pathname: 'reference.png' } })\n    expect(mocks.generateClientToken).toHaveBeenCalledWith(\n      expect.objectContaining({ allowOverwrite: true, pathname: 'reference.png' }),\n    )\n  })\n})\n"],"names":["beforeEach","describe","expect","it","vi","mocks","hoisted","generateClientToken","fn","buildStoragePathData","storageFilePath","sanitizedCollectionPrefix","sanitizedDocPrefix","sanitizedFilename","buildUploadStoragePathData","isStoragePathWithinCollectionPrefix","resolveSignedURLKey","uploadReference","prefix","signedReceipt","mock","generateClientTokenFromReadWriteToken","createVercelBlobAdapter","generateInstructions","hasOwner","adapter","access","baseUrl","cacheControlMaxAge","clientUploads","collectionSources","collectionPrefix","collectionSlug","useCompositePrefixes","token","generatedAdapter","collection","slug","req","payload","collections","media","config","update","upload","find","docs","filename","id","secret","t","uploadInstructions","generate","filesize","mimeType","overrideAccess","clearAllMocks","instructions","tokenOptions","calls","toMatchObject","data","pathname","not","toHaveProperty","toHaveBeenCalledWith","objectContaining","allowOverwrite"],"mappings":"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"}

package/dist/authorizeFileOverwrite.d.ts

@@ -0,0 +1,16 @@
+import type { PayloadRequest } from 'payload';
+export type VercelBlobCollectionSource = {
+    collectionPrefix: string;
+    collectionSlug: string;
+    useCompositePrefixes: boolean;
+};
+export declare function authorizeClientOverwrite({ collectionPrefix: collectionPrefixArg, collectionSources, overrideAccess, req, requestedCollectionSlug, requestedFilename, requestedStorageFilePath, }: {
+    collectionPrefix: string;
+    collectionSources: VercelBlobCollectionSource[];
+    overrideAccess?: boolean;
+    req: PayloadRequest;
+    requestedCollectionSlug: string;
+    requestedFilename: string;
+    requestedStorageFilePath: string;
+}): Promise<boolean>;
+//# sourceMappingURL=authorizeFileOverwrite.d.ts.map

package/dist/authorizeFileOverwrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorizeFileOverwrite.d.ts","sourceRoot":"","sources":["../src/authorizeFileOverwrite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,cAAc,EAAqB,MAAM,SAAS,CAAA;AAU1E,MAAM,MAAM,0BAA0B,GAAG;IACvC,gBAAgB,EAAE,MAAM,CAAA;IACxB,cAAc,EAAE,MAAM,CAAA;IACtB,oBAAoB,EAAE,OAAO,CAAA;CAC9B,CAAA;AAmHD,wBAAsB,wBAAwB,CAAC,EAC7C,gBAAgB,EAAE,mBAAmB,EACrC,iBAAiB,EACjB,cAAsB,EACtB,GAAG,EACH,uBAAuB,EACvB,iBAAiB,EACjB,wBAAwB,GACzB,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,iBAAiB,EAAE,0BAA0B,EAAE,CAAA;IAC/C,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,GAAG,EAAE,cAAc,CAAA;IACnB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,iBAAiB,EAAE,MAAM,CAAA;IACzB,wBAAwB,EAAE,MAAM,CAAA;CACjC,GAAG,OAAO,CAAC,OAAO,CAAC,CA8CnB"}

package/dist/authorizeFileOverwrite.js

@@ -0,0 +1,117 @@
+import { buildStoragePathData, isStoragePathWithinCollectionPrefix } from '@payloadcms/plugin-cloud-storage/utilities';
+import { combineQueries, executeAccess, Forbidden } from 'payload';
+function getDocumentFileKeys({ collectionPrefix, doc, useCompositePrefixes }) {
+    return [
+        doc.filename,
+        ...Object.values(doc.sizes || {}).map((size)=>size?.filename)
+    ].filter((filename)=>typeof filename === 'string').map((filename)=>buildStoragePathData({
+            collectionPrefix,
+            docPrefix: doc.prefix,
+            filename,
+            useCompositePrefixes
+        }).storageFilePath);
+}
+async function findMatchingDocs({ collectionPrefix, collectionSlug, req, requestedFilename, requestedStorageFilePath, useCompositePrefixes }) {
+    const collection = req.payload.collections[collectionSlug];
+    if (!collection) {
+        return [];
+    }
+    const imageSizes = collection.config.upload && typeof collection.config.upload === 'object' ? collection.config.upload.imageSizes || [] : [];
+    const filenameQueries = [
+        {
+            filename: {
+                equals: requestedFilename
+            }
+        },
+        ...imageSizes.map(({ name })=>({
+                [`sizes.${name}.filename`]: {
+                    equals: requestedFilename
+                }
+            }))
+    ];
+    const result = await req.payload.find({
+        collection: collectionSlug,
+        depth: 0,
+        draft: true,
+        overrideAccess: true,
+        pagination: false,
+        req,
+        where: {
+            or: filenameQueries
+        }
+    });
+    return result.docs.filter((doc)=>getDocumentFileKeys({
+            collectionPrefix,
+            doc,
+            useCompositePrefixes
+        }).includes(requestedStorageFilePath));
+}
+async function canUpdateDoc({ collectionSlug, doc, req }) {
+    const collection = req.payload.collections[collectionSlug];
+    if (!collection) {
+        return false;
+    }
+    const accessResult = await executeAccess({
+        id: doc.id,
+        slug: collectionSlug,
+        disableErrors: true,
+        req
+    }, collection.config.access.update);
+    if (typeof accessResult === 'boolean') {
+        return accessResult;
+    }
+    const result = await req.payload.find({
+        collection: collectionSlug,
+        depth: 0,
+        draft: true,
+        limit: 1,
+        overrideAccess: true,
+        pagination: false,
+        req,
+        where: combineQueries({
+            id: {
+                equals: doc.id
+            }
+        }, accessResult)
+    });
+    return result.docs.length === 1;
+}
+export async function authorizeClientOverwrite({ collectionPrefix: collectionPrefixArg, collectionSources, overrideAccess = false, req, requestedCollectionSlug, requestedFilename, requestedStorageFilePath }) {
+    if (!isStoragePathWithinCollectionPrefix({
+        collectionPrefix: collectionPrefixArg,
+        docPrefix: requestedStorageFilePath
+    })) {
+        throw new Forbidden(req.t);
+    }
+    const matchedDocs = (await Promise.all(collectionSources.map(async ({ collectionPrefix, collectionSlug, useCompositePrefixes })=>{
+        const docs = await findMatchingDocs({
+            collectionPrefix,
+            collectionSlug,
+            req,
+            requestedFilename,
+            requestedStorageFilePath,
+            useCompositePrefixes
+        });
+        return docs.map((doc)=>({
+                collectionSlug,
+                doc
+            }));
+    }))).flat();
+    if (matchedDocs.length === 0) {
+        return false;
+    }
+    const matchedDoc = matchedDocs[0];
+    if (matchedDocs.length !== 1 || matchedDoc.collectionSlug !== requestedCollectionSlug) {
+        throw new Forbidden(req.t);
+    }
+    if (!overrideAccess && !await canUpdateDoc({
+        collectionSlug: matchedDoc.collectionSlug,
+        doc: matchedDoc.doc,
+        req
+    })) {
+        throw new Forbidden(req.t);
+    }
+    return true;
+}
+
+//# sourceMappingURL=authorizeFileOverwrite.js.map

package/dist/authorizeFileOverwrite.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/authorizeFileOverwrite.ts"],"sourcesContent":["import type { FileData, PayloadRequest, TypeWithID, Where } from 'payload'\n\nimport {\n  buildStoragePathData,\n  isStoragePathWithinCollectionPrefix,\n} from '@payloadcms/plugin-cloud-storage/utilities'\nimport { combineQueries, executeAccess, Forbidden } from 'payload'\n\ntype OwnerDocument = { prefix?: string } & FileData & TypeWithID\n\nexport type VercelBlobCollectionSource = {\n  collectionPrefix: string\n  collectionSlug: string\n  useCompositePrefixes: boolean\n}\n\ntype Owner = {\n  collectionSlug: string\n  doc: OwnerDocument\n}\n\nfunction getDocumentFileKeys({\n  collectionPrefix,\n  doc,\n  useCompositePrefixes,\n}: {\n  collectionPrefix: string\n  doc: OwnerDocument\n  useCompositePrefixes: boolean\n}): string[] {\n  return [doc.filename, ...Object.values(doc.sizes || {}).map((size) => size?.filename)]\n    .filter((filename): filename is string => typeof filename === 'string')\n    .map(\n      (filename) =>\n        buildStoragePathData({\n          collectionPrefix,\n          docPrefix: doc.prefix,\n          filename,\n          useCompositePrefixes,\n        }).storageFilePath,\n    )\n}\n\nasync function findMatchingDocs({\n  collectionPrefix,\n  collectionSlug,\n  req,\n  requestedFilename,\n  requestedStorageFilePath,\n  useCompositePrefixes,\n}: {\n  collectionPrefix: string\n  collectionSlug: string\n  req: PayloadRequest\n  requestedFilename: string\n  requestedStorageFilePath: string\n  useCompositePrefixes: boolean\n}): Promise<OwnerDocument[]> {\n  const collection = req.payload.collections[collectionSlug]\n\n  if (!collection) {\n    return []\n  }\n\n  const imageSizes =\n    collection.config.upload && typeof collection.config.upload === 'object'\n      ? collection.config.upload.imageSizes || []\n      : []\n  const filenameQueries: Where[] = [\n    { filename: { equals: requestedFilename } },\n    ...imageSizes.map(({ name }) => ({\n      [`sizes.${name}.filename`]: { equals: requestedFilename },\n    })),\n  ]\n  const result = await req.payload.find({\n    collection: collectionSlug,\n    depth: 0,\n    draft: true,\n    overrideAccess: true,\n    pagination: false,\n    req,\n    where: { or: filenameQueries },\n  })\n\n  return (result.docs as OwnerDocument[]).filter((doc) =>\n    getDocumentFileKeys({ collectionPrefix, doc, useCompositePrefixes }).includes(\n      requestedStorageFilePath,\n    ),\n  )\n}\n\nasync function canUpdateDoc({\n  collectionSlug,\n  doc,\n  req,\n}: {\n  collectionSlug: string\n  doc: OwnerDocument\n  req: PayloadRequest\n}): Promise<boolean> {\n  const collection = req.payload.collections[collectionSlug]\n\n  if (!collection) {\n    return false\n  }\n\n  const accessResult = await executeAccess(\n    { id: doc.id, slug: collectionSlug, disableErrors: true, req },\n    collection.config.access.update,\n  )\n\n  if (typeof accessResult === 'boolean') {\n    return accessResult\n  }\n\n  const result = await req.payload.find({\n    collection: collectionSlug,\n    depth: 0,\n    draft: true,\n    limit: 1,\n    overrideAccess: true,\n    pagination: false,\n    req,\n    where: combineQueries({ id: { equals: doc.id } }, accessResult),\n  })\n\n  return result.docs.length === 1\n}\n\nexport async function authorizeClientOverwrite({\n  collectionPrefix: collectionPrefixArg,\n  collectionSources,\n  overrideAccess = false,\n  req,\n  requestedCollectionSlug,\n  requestedFilename,\n  requestedStorageFilePath,\n}: {\n  collectionPrefix: string\n  collectionSources: VercelBlobCollectionSource[]\n  overrideAccess?: boolean\n  req: PayloadRequest\n  requestedCollectionSlug: string\n  requestedFilename: string\n  requestedStorageFilePath: string\n}): Promise<boolean> {\n  if (\n    !isStoragePathWithinCollectionPrefix({\n      collectionPrefix: collectionPrefixArg,\n      docPrefix: requestedStorageFilePath,\n    })\n  ) {\n    throw new Forbidden(req.t)\n  }\n\n  const matchedDocs = (\n    await Promise.all(\n      collectionSources.map(\n        async ({ collectionPrefix, collectionSlug, useCompositePrefixes }): Promise<Owner[]> => {\n          const docs = await findMatchingDocs({\n            collectionPrefix,\n            collectionSlug,\n            req,\n            requestedFilename,\n            requestedStorageFilePath,\n            useCompositePrefixes,\n          })\n\n          return docs.map((doc) => ({ collectionSlug, doc }))\n        },\n      ),\n    )\n  ).flat()\n\n  if (matchedDocs.length === 0) {\n    return false\n  }\n\n  const matchedDoc = matchedDocs[0]!\n  if (matchedDocs.length !== 1 || matchedDoc.collectionSlug !== requestedCollectionSlug) {\n    throw new Forbidden(req.t)\n  }\n\n  if (\n    !overrideAccess &&\n    !(await canUpdateDoc({ collectionSlug: matchedDoc.collectionSlug, doc: matchedDoc.doc, req }))\n  ) {\n    throw new Forbidden(req.t)\n  }\n\n  return true\n}\n"],"names":["buildStoragePathData","isStoragePathWithinCollectionPrefix","combineQueries","executeAccess","Forbidden","getDocumentFileKeys","collectionPrefix","doc","useCompositePrefixes","filename","Object","values","sizes","map","size","filter","docPrefix","prefix","storageFilePath","findMatchingDocs","collectionSlug","req","requestedFilename","requestedStorageFilePath","collection","payload","collections","imageSizes","config","upload","filenameQueries","equals","name","result","find","depth","draft","overrideAccess","pagination","where","or","docs","includes","canUpdateDoc","accessResult","id","slug","disableErrors","access","update","limit","length","authorizeClientOverwrite","collectionPrefixArg","collectionSources","requestedCollectionSlug","t","matchedDocs","Promise","all","flat","matchedDoc"],"mappings":"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"}

package/dist/authorizeFileOverwrite.spec.js

@@ -0,0 +1,92 @@
+import { describe, expect, it, vi } from 'vitest';
+import { authorizeClientOverwrite } from './authorizeFileOverwrite.js';
+const owner = (id)=>({
+        filename: 'image.png',
+        id,
+        prefix: 'shared'
+    });
+const collectionSources = [
+    {
+        collectionPrefix: '',
+        collectionSlug: 'media',
+        useCompositePrefixes: false
+    },
+    {
+        collectionPrefix: '',
+        collectionSlug: 'protected',
+        useCompositePrefixes: false
+    }
+];
+const createRequest = ({ mediaOwner = true, protectedOwner = false } = {})=>({
+        payload: {
+            collections: {
+                media: {
+                    config: {
+                        access: {
+                            update: async ()=>true
+                        },
+                        upload: true
+                    }
+                },
+                protected: {
+                    config: {
+                        access: {
+                            update: async ()=>false
+                        },
+                        upload: true
+                    }
+                }
+            },
+            find: vi.fn(async ({ collection })=>({
+                    docs: collection === 'media' ? mediaOwner ? [
+                        owner(1)
+                    ] : [] : protectedOwner ? [
+                        owner(2)
+                    ] : []
+                }))
+        },
+        t: vi.fn()
+    });
+describe('authorizeClientOverwrite', ()=>{
+    it('allows an update when the requested collection is the only owner', async ()=>{
+        await expect(authorizeClientOverwrite({
+            collectionSources,
+            requestedStorageFilePath: 'shared/image.png',
+            requestedFilename: 'image.png',
+            req: createRequest(),
+            requestedCollectionSlug: 'media',
+            collectionPrefix: ''
+        })).resolves.toBe(true);
+    });
+    it('rejects an update when another collection owns the same key', async ()=>{
+        await expect(authorizeClientOverwrite({
+            collectionSources,
+            requestedStorageFilePath: 'shared/image.png',
+            requestedFilename: 'image.png',
+            req: createRequest({
+                mediaOwner: false,
+                protectedOwner: true
+            }),
+            requestedCollectionSlug: 'media',
+            collectionPrefix: ''
+        })).rejects.toMatchObject({
+            status: 403
+        });
+    });
+    it('rejects an update when multiple collections own the same key', async ()=>{
+        await expect(authorizeClientOverwrite({
+            collectionSources,
+            requestedStorageFilePath: 'shared/image.png',
+            requestedFilename: 'image.png',
+            req: createRequest({
+                protectedOwner: true
+            }),
+            requestedCollectionSlug: 'media',
+            collectionPrefix: ''
+        })).rejects.toMatchObject({
+            status: 403
+        });
+    });
+});
+
+//# sourceMappingURL=authorizeFileOverwrite.spec.js.map

package/dist/authorizeFileOverwrite.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/authorizeFileOverwrite.spec.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\n\nimport { describe, expect, it, vi } from 'vitest'\n\nimport { authorizeClientOverwrite } from './authorizeFileOverwrite.js'\n\nconst owner = (id: number) => ({ filename: 'image.png', id, prefix: 'shared' })\nconst collectionSources = [\n  { collectionPrefix: '', collectionSlug: 'media', useCompositePrefixes: false },\n  { collectionPrefix: '', collectionSlug: 'protected', useCompositePrefixes: false },\n]\n\nconst createRequest = ({\n  mediaOwner = true,\n  protectedOwner = false,\n}: {\n  mediaOwner?: boolean\n  protectedOwner?: boolean\n} = {}) =>\n  ({\n    payload: {\n      collections: {\n        media: {\n          config: { access: { update: async () => true }, upload: true },\n        },\n        protected: {\n          config: { access: { update: async () => false }, upload: true },\n        },\n      },\n      find: vi.fn(async ({ collection }: { collection: string }) => ({\n        docs:\n          collection === 'media'\n            ? mediaOwner\n              ? [owner(1)]\n              : []\n            : protectedOwner\n              ? [owner(2)]\n              : [],\n      })),\n    },\n    t: vi.fn(),\n  }) as unknown as PayloadRequest\n\ndescribe('authorizeClientOverwrite', () => {\n  it('allows an update when the requested collection is the only owner', async () => {\n    await expect(\n      authorizeClientOverwrite({\n        collectionSources,\n        requestedStorageFilePath: 'shared/image.png',\n        requestedFilename: 'image.png',\n        req: createRequest(),\n        requestedCollectionSlug: 'media',\n        collectionPrefix: '',\n      }),\n    ).resolves.toBe(true)\n  })\n\n  it('rejects an update when another collection owns the same key', async () => {\n    await expect(\n      authorizeClientOverwrite({\n        collectionSources,\n        requestedStorageFilePath: 'shared/image.png',\n        requestedFilename: 'image.png',\n        req: createRequest({ mediaOwner: false, protectedOwner: true }),\n        requestedCollectionSlug: 'media',\n        collectionPrefix: '',\n      }),\n    ).rejects.toMatchObject({ status: 403 })\n  })\n\n  it('rejects an update when multiple collections own the same key', async () => {\n    await expect(\n      authorizeClientOverwrite({\n        collectionSources,\n        requestedStorageFilePath: 'shared/image.png',\n        requestedFilename: 'image.png',\n        req: createRequest({ protectedOwner: true }),\n        requestedCollectionSlug: 'media',\n        collectionPrefix: '',\n      }),\n    ).rejects.toMatchObject({ status: 403 })\n  })\n})\n"],"names":["describe","expect","it","vi","authorizeClientOverwrite","owner","id","filename","prefix","collectionSources","collectionPrefix","collectionSlug","useCompositePrefixes","createRequest","mediaOwner","protectedOwner","payload","collections","media","config","access","update","upload","protected","find","fn","collection","docs","t","requestedStorageFilePath","requestedFilename","req","requestedCollectionSlug","resolves","toBe","rejects","toMatchObject","status"],"mappings":"AAEA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,EAAEC,EAAE,QAAQ,SAAQ;AAEjD,SAASC,wBAAwB,QAAQ,8BAA6B;AAEtE,MAAMC,QAAQ,CAACC,KAAgB,CAAA;QAAEC,UAAU;QAAaD;QAAIE,QAAQ;IAAS,CAAA;AAC7E,MAAMC,oBAAoB;IACxB;QAAEC,kBAAkB;QAAIC,gBAAgB;QAASC,sBAAsB;IAAM;IAC7E;QAAEF,kBAAkB;QAAIC,gBAAgB;QAAaC,sBAAsB;IAAM;CAClF;AAED,MAAMC,gBAAgB,CAAC,EACrBC,aAAa,IAAI,EACjBC,iBAAiB,KAAK,EAIvB,GAAG,CAAC,CAAC,GACH,CAAA;QACCC,SAAS;YACPC,aAAa;gBACXC,OAAO;oBACLC,QAAQ;wBAAEC,QAAQ;4BAAEC,QAAQ,UAAY;wBAAK;wBAAGC,QAAQ;oBAAK;gBAC/D;gBACAC,WAAW;oBACTJ,QAAQ;wBAAEC,QAAQ;4BAAEC,QAAQ,UAAY;wBAAM;wBAAGC,QAAQ;oBAAK;gBAChE;YACF;YACAE,MAAMrB,GAAGsB,EAAE,CAAC,OAAO,EAAEC,UAAU,EAA0B,GAAM,CAAA;oBAC7DC,MACED,eAAe,UACXZ,aACE;wBAACT,MAAM;qBAAG,GACV,EAAE,GACJU,iBACE;wBAACV,MAAM;qBAAG,GACV,EAAE;gBACZ,CAAA;QACF;QACAuB,GAAGzB,GAAGsB,EAAE;IACV,CAAA;AAEFzB,SAAS,4BAA4B;IACnCE,GAAG,oEAAoE;QACrE,MAAMD,OACJG,yBAAyB;YACvBK;YACAoB,0BAA0B;YAC1BC,mBAAmB;YACnBC,KAAKlB;YACLmB,yBAAyB;YACzBtB,kBAAkB;QACpB,IACAuB,QAAQ,CAACC,IAAI,CAAC;IAClB;IAEAhC,GAAG,+DAA+D;QAChE,MAAMD,OACJG,yBAAyB;YACvBK;YACAoB,0BAA0B;YAC1BC,mBAAmB;YACnBC,KAAKlB,cAAc;gBAAEC,YAAY;gBAAOC,gBAAgB;YAAK;YAC7DiB,yBAAyB;YACzBtB,kBAAkB;QACpB,IACAyB,OAAO,CAACC,aAAa,CAAC;YAAEC,QAAQ;QAAI;IACxC;IAEAnC,GAAG,gEAAgE;QACjE,MAAMD,OACJG,yBAAyB;YACvBK;YACAoB,0BAA0B;YAC1BC,mBAAmB;YACnBC,KAAKlB,cAAc;gBAAEE,gBAAgB;YAAK;YAC1CiB,yBAAyB;YACzBtB,kBAAkB;QACpB,IACAyB,OAAO,CAACC,aAAa,CAAC;YAAEC,QAAQ;QAAI;IACxC;AACF"}

package/dist/deleteFile.d.ts

@@ -1,11 +1,8 @@
 interface DeleteFileArgs {
     baseUrl: string;
-    collectionPrefix?: string;
-    docPrefix: string;
-    filename: string;
+    storageFilePath: string;
     token: string;
-    useCompositePrefixes?: boolean;
 }
-export declare function deleteFile({ baseUrl, collectionPrefix, docPrefix, filename, token, useCompositePrefixes, }: DeleteFileArgs): Promise<void>;
+export declare function deleteFile({ baseUrl, storageFilePath, token, }: DeleteFileArgs): Promise<void>;
 export {};
 //# sourceMappingURL=deleteFile.d.ts.map

package/dist/deleteFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deleteFile.d.ts","sourceRoot":"","sources":["../src/deleteFile.ts"],"names":[],"mappings":"AAIA,UAAU,cAAc;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,wBAAsB,UAAU,CAAC,EAC/B,OAAO,EACP,gBAAqB,EACrB,SAAS,EACT,QAAQ,EACR,KAAK,EACL,oBAA4B,GAC7B,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAUhC"}
+{"version":3,"file":"deleteFile.d.ts","sourceRoot":"","sources":["../src/deleteFile.ts"],"names":[],"mappings":"AAIA,UAAU,cAAc;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,MAAM,CAAA;IACvB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,wBAAsB,UAAU,CAAC,EAC/B,OAAO,EACP,eAAe,EACf,KAAK,GACN,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhC"}