@payloadcms/storage-vercel-blob 4.0.0-internal.bc5cf8c → 4.0.0-internal.bf4bcce

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018-2025 Payload CMS, Inc. <info@payloadcms.com>
+Copyright (c) 2018-2026 Payload CMS, LLC <info@payloadcms.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

package/README.md

@@ -15,7 +15,7 @@ pnpm add @payloadcms/storage-vercel-blob
 - Configure the `collections` object to specify which collections should use the Vercel Blob adapter. The slug _must_ match one of your existing collection slugs.
 - Ensure you have `BLOB_READ_WRITE_TOKEN` set in your Vercel environment variables. This is usually set by Vercel automatically after adding blob storage to your project.
 - When enabled, this package will automatically set `disableLocalStorage` to `true` for each collection.
-- When deploying to Vercel, server uploads are limited with 4.5MB. Set `clientUploads` to `true` to do uploads directly on the client.
+- When deploying to Vercel, server uploads are limited to 4.5MB. Set `clientUploads` to `true` to use upload instructions and send files directly to Vercel Blob.
 
 ```ts
 import { vercelBlobStorage } from '@payloadcms/storage-vercel-blob'
@@ -41,11 +41,13 @@ export default buildConfig({
 })
 ```
 
-| Option               | Description                                                          | Default                       |
-| -------------------- | -------------------------------------------------------------------- | ----------------------------- |
-| `enabled`            | Whether or not to enable the plugin                                  | `true`                        |
-| `collections`        | Collections to apply the Vercel Blob adapter to                      |                               |
-| `addRandomSuffix`    | Add a random suffix to the uploaded file name in Vercel Blob storage | `false`                       |
-| `cacheControlMaxAge` | Cache-Control max-age in seconds                                     | `365 * 24 * 60 * 60` (1 Year) |
-| `token`              | Vercel Blob storage read/write token                                 | `''`                          |
-| `clientUploads`      | Do uploads directly on the client to bypass limits on Vercel         |                               |
+| Option               | Description                                                                             | Default                       |
+| -------------------- | --------------------------------------------------------------------------------------- | ----------------------------- |
+| `enabled`            | Whether or not to enable the plugin                                                     | `true`                        |
+| `collections`        | Collections to apply the Vercel Blob adapter to                                         |                               |
+| `addRandomSuffix`    | Must be `false` or omitted; enabled adapters with configured collections reject `true`. | `false`                       |
+| `cacheControlMaxAge` | Cache-Control max-age in seconds                                                        | `365 * 24 * 60 * 60` (1 Year) |
+| `token`              | Vercel Blob storage read/write token                                                    | `''`                          |
+| `clientUploads`      | Upload directly to Vercel Blob instead of through Payload.                              |                               |
+
+Set `addRandomSuffix` to `false` or omit it. Payload requires exact storage paths for reads, rollback, and deletion, and already allocates unique `_objectKey` folders for managed uploads. Enabled adapters with configured collections reject `true` during initialization. Disabled adapters retain their existing behavior. Changing this option does not rename existing blobs; migrate any mismatched stored paths and saved metadata together.

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;AAO/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,CA+DvC"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,mBAAmB,EAGpB,MAAM,wCAAwC,CAAA;AAU/C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAA;AAS7E,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,CAoJvC"}

package/dist/adapter.js

@@ -1,11 +1,114 @@
+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 { copyVercelBlobFile } from './copyFile.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;
+    const deleteStoredFile = ({ storageFilePath })=>deleteFile({
+            baseUrl,
+            storageFilePath,
+            token
+        });
     return ({ collection, prefix = '' })=>({
             name: 'vercel-blob',
-            clientUploads,
+            copyFile: ({ from, req, to })=>copyVercelBlobFile({
+                    access,
+                    cacheControlMaxAge,
+                    from,
+                    req,
+                    to,
+                    token
+                }),
+            deleteFile: deleteStoredFile,
+            uploadInstructions: {
+                adminHandler: {
+                    path: '@payloadcms/storage-vercel-blob/client#VercelBlobClientUploadHandler'
+                },
+                enabled: Boolean(clientUploads),
+                generate: async ({ collectionSlug, docPrefix, filename, filesize, mimeType, overrideAccess, req })=>{
+                    if (!overrideAccess && (clientUploadsAccess ? !await clientUploadsAccess({
+                        collectionSlug,
+                        req
+                    }) : !req.user)) {
+                        throw new Forbidden(req.t);
+                    }
+                    assertClientUploadAllowed({
+                        collection,
+                        filename,
+                        mimeType
+                    });
+                    const requested = buildUploadStoragePathData({
+                        collectionPrefix: prefix,
+                        docPrefix,
+                        filename,
+                        useCompositePrefixes
+                    });
+                    const allowOverwrite = collection.versions ? false : 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,
+                        filename,
+                        req,
+                        useCompositePrefixes
+                    });
+                    return {
+                        name: 'uploadToVercelBlob',
+                        type: 'dispatch',
+                        data: {
+                            pathname: resolved.storageFilePath,
+                            token: await generateClientTokenFromReadWriteToken({
+                                addRandomSuffix: false,
+                                allowedContentTypes: mimeType ? [
+                                    mimeType
+                                ] : undefined,
+                                ...allowOverwrite && {
+                                    allowOverwrite: true
+                                },
+                                cacheControlMaxAge,
+                                maximumSizeInBytes: filesize,
+                                pathname: resolved.storageFilePath,
+                                token
+                            })
+                        },
+                        file: {
+                            filename: resolved.sanitizedFilename,
+                            mimeType,
+                            size: filesize,
+                            uploadReference: resolved.uploadReference
+                        }
+                    };
+                },
+                requiresUploadReceipt: true,
+                useInAdmin: true
+            },
             generateURL: ({ filename, prefix: urlPrefix = '' })=>generateURL({
                     baseUrl,
                     collectionPrefix: prefix,
@@ -13,43 +116,34 @@ export function createVercelBlobAdapter({ access, addRandomSuffix, baseUrl, cach
                     prefix: urlPrefix,
                     useCompositePrefixes
                 }),
-            handleDelete: ({ doc: { prefix: docPrefix = '' }, filename })=>deleteFile({
-                    baseUrl,
-                    collectionPrefix: prefix,
-                    docPrefix,
-                    filename,
-                    token,
-                    useCompositePrefixes
-                }),
-            handleUpload: async ({ data, file: { buffer, filename, mimeType } })=>{
+            handleDelete: deleteStoredFile,
+            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: { clientUploadContext, filename, prefix: prefixQueryParam } })=>getFile({
+            staticHandler: (req, { doc, headers, params: { filename, operation, uploadReference } })=>getFile({
                     baseUrl,
                     cacheControlMaxAge,
-                    clientUploadContext,
                     collection,
                     collectionPrefix: prefix,
+                    doc,
                     filename,
                     incomingHeaders: headers,
-                    prefixQueryParam,
+                    operation,
                     req,
                     token,
+                    uploadReference,
                     useCompositePrefixes
                 })
         });

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 { 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  return ({ collection, prefix = '' }): GeneratedAdapter => ({\n    name: 'vercel-blob',\n    clientUploads,\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: { clientUploadContext, filename, prefix: prefixQueryParam } },\n    ) =>\n      getFile({\n        baseUrl,\n        cacheControlMaxAge,\n        clientUploadContext,\n        collection,\n        collectionPrefix: prefix,\n        filename,\n        incomingHeaders: headers,\n        prefixQueryParam,\n        req,\n        token,\n        useCompositePrefixes,\n      }),\n  })\n}\n"],"names":["deleteFile","generateURL","getFile","uploadFile","createVercelBlobAdapter","access","addRandomSuffix","baseUrl","cacheControlMaxAge","clientUploads","token","useCompositePrefixes","collection","prefix","name","filename","urlPrefix","collectionPrefix","handleDelete","doc","docPrefix","handleUpload","data","file","buffer","mimeType","result","staticHandler","req","headers","params","clientUploadContext","prefixQueryParam","incomingHeaders"],"mappings":"AAMA,SAASA,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,OAAO,CAAC,EAAEC,UAAU,EAAEC,SAAS,EAAE,EAAE,GAAwB,CAAA;YACzDC,MAAM;YACNL;YAEAR,aAAa,CAAC,EAAEc,QAAQ,EAAEF,QAAQG,YAAY,EAAE,EAAE,GAChDf,YAAY;oBACVM;oBACAU,kBAAkBJ;oBAClBE;oBACAF,QAAQG;oBACRL;gBACF;YAEFO,cAAc,CAAC,EAAEC,KAAK,EAAEN,QAAQO,YAAY,EAAE,EAAE,EAAEL,QAAQ,EAAE,GAC1Df,WAAW;oBACTO;oBACAU,kBAAkBJ;oBAClBO;oBACAL;oBACAL;oBACAC;gBACF;YAEFU,cAAc,OAAO,EAAEC,IAAI,EAAEC,MAAM,EAAEC,MAAM,EAAET,QAAQ,EAAEU,QAAQ,EAAE,EAAE;gBACjE,MAAMC,SAAS,MAAMvB,WAAW;oBAC9BE;oBACAC;oBACAkB;oBACAhB;oBACAS,kBAAkBJ;oBAClBO,WAAWE,KAAKT,MAAM;oBACtBE;oBACAU;oBACAf;oBACAC;gBACF;gBAEA,IAAIe,OAAOX,QAAQ,EAAE;oBACnBO,KAAKP,QAAQ,GAAGW,OAAOX,QAAQ;gBACjC;gBAEA,OAAOO;YACT;YAEAK,eAAe,CACbC,KACA,EAAEC,OAAO,EAAEC,QAAQ,EAAEC,mBAAmB,EAAEhB,QAAQ,EAAEF,QAAQmB,gBAAgB,EAAE,EAAE,GAEhF9B,QAAQ;oBACNK;oBACAC;oBACAuB;oBACAnB;oBACAK,kBAAkBJ;oBAClBE;oBACAkB,iBAAiBJ;oBACjBG;oBACAJ;oBACAlB;oBACAC;gBACF;QACJ,CAAA;AACF"}
+{"version":3,"sources":["../src/adapter.ts"],"sourcesContent":["import type {\n  Adapter,\n  ClientUploadsConfig,\n  DeleteFile,\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 { copyVercelBlobFile } from './copyFile.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  const deleteStoredFile: DeleteFile = ({ storageFilePath }) =>\n    deleteFile({ baseUrl, storageFilePath, token })\n\n  return ({ collection, prefix = '' }): GeneratedAdapter => ({\n    name: 'vercel-blob',\n\n    copyFile: ({ from, req, to }) =>\n      copyVercelBlobFile({ access, cacheControlMaxAge, from, req, to, token }),\n    deleteFile: deleteStoredFile,\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 = collection.versions\n          ? false\n          : 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: deleteStoredFile,\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, operation, uploadReference } }) =>\n      getFile({\n        baseUrl,\n        cacheControlMaxAge,\n        collection,\n        collectionPrefix: prefix,\n        doc,\n        filename,\n        incomingHeaders: headers,\n        operation,\n        req,\n        token,\n        uploadReference,\n        useCompositePrefixes,\n      }),\n  })\n}\n"],"names":["buildUploadStoragePathData","resolveSignedURLKey","generateClientTokenFromReadWriteToken","Forbidden","assertClientUploadAllowed","createClientUploadReceipt","authorizeClientOverwrite","copyVercelBlobFile","deleteFile","generateURL","getFile","uploadFile","createVercelBlobAdapter","access","addRandomSuffix","baseUrl","cacheControlMaxAge","clientUploads","collectionSources","token","useCompositePrefixes","clientUploadsAccess","undefined","deleteStoredFile","storageFilePath","collection","prefix","name","copyFile","from","req","to","uploadInstructions","adminHandler","path","enabled","Boolean","generate","collectionSlug","docPrefix","filename","filesize","mimeType","overrideAccess","user","t","requested","collectionPrefix","allowOverwrite","versions","requestedCollectionSlug","requestedFilename","sanitizedFilename","requestedStorageFilePath","resolved","uploadReference","sanitizedDocPrefix","signedReceipt","filePrefix","type","data","pathname","allowedContentTypes","maximumSizeInBytes","file","size","requiresUploadReceipt","useInAdmin","urlPrefix","handleDelete","handleUpload","buffer","result","staticHandler","doc","headers","params","operation","incomingHeaders"],"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.variants || {}).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 variants = collection.config.upload && typeof collection.config.upload === 'object' ? collection.config.upload.variants || [] : [];
+    const filenameQueries = [
+        {
+            filename: {
+                equals: requestedFilename
+            }
+        },
+        ...variants.map(({ name })=>({
+                [`variants.${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.variants || {}).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 variants =\n    collection.config.upload && typeof collection.config.upload === 'object'\n      ? collection.config.upload.variants || []\n      : []\n  const filenameQueries: Where[] = [\n    { filename: { equals: requestedFilename } },\n    ...variants.map(({ name }) => ({\n      [`variants.${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","variants","map","size","filter","docPrefix","prefix","storageFilePath","findMatchingDocs","collectionSlug","req","requestedFilename","requestedStorageFilePath","collection","payload","collections","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/client/VercelBlobClientUploadHandler.d.ts

@@ -1,13 +1,8 @@
-export type VercelBlobClientUploadHandlerExtra = {
-    addRandomSuffix: boolean;
-    useCompositePrefixes: boolean;
-};
-export declare const VercelBlobClientUploadHandler: ({ children, collectionSlug, enabled, extra, prefix, serverHandlerPath, }: {
+export declare const VercelBlobClientUploadHandler: ({ children, collectionSlug, endpointPath, prefix, props, }: {
     children: import("react").ReactNode;
     collectionSlug: import("payload").UploadCollectionSlug;
-    enabled?: boolean;
-    extra: VercelBlobClientUploadHandlerExtra;
+    endpointPath?: `/${string}`;
     prefix?: string;
-    serverHandlerPath: `/${string}`;
+    props: Record<string, unknown>;
 }) => import("react").JSX.Element;
 //# sourceMappingURL=VercelBlobClientUploadHandler.d.ts.map

package/dist/client/VercelBlobClientUploadHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VercelBlobClientUploadHandler.d.ts","sourceRoot":"","sources":["../../src/client/VercelBlobClientUploadHandler.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,kCAAkC,GAAG;IAC/C,eAAe,EAAE,OAAO,CAAA;IACxB,oBAAoB,EAAE,OAAO,CAAA;CAC9B,CAAA;AASD,eAAO,MAAM,6BAA6B;;;;;;;iCAyCtC,CAAA"}
+{"version":3,"file":"VercelBlobClientUploadHandler.d.ts","sourceRoot":"","sources":["../../src/client/VercelBlobClientUploadHandler.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,6BAA6B;;;;;;iCAexC,CAAA"}

package/dist/client/VercelBlobClientUploadHandler.js

@@ -1,41 +1,18 @@
 'use client';
 import { createClientUploadHandler } from '@payloadcms/plugin-cloud-storage/client';
-import { getFileKey } from '@payloadcms/plugin-cloud-storage/utilities';
-import { upload } from '@vercel/blob/client';
-import { formatAdminURL } from 'payload/shared';
-/** Last path segment only (POSIX), for keys like `folder/sub/file.png`. */ function posixBasename(key) {
-    const normalized = key.replace(/^\/+/, '');
-    const lastSlash = normalized.lastIndexOf('/');
-    return lastSlash === -1 ? normalized : normalized.slice(lastSlash + 1);
-}
+import { put } from '@vercel/blob/client';
 export const VercelBlobClientUploadHandler = createClientUploadHandler({
-    handler: async ({ apiRoute, collectionSlug, docPrefix, extra: { addRandomSuffix, useCompositePrefixes = false }, file, prefix, serverHandlerPath, serverURL, updateFilename })=>{
-        const endpointRoute = formatAdminURL({
-            apiRoute,
-            path: serverHandlerPath,
-            serverURL
-        });
-        const { fileKey: pathname, sanitizedDocPrefix } = getFileKey({
-            collectionPrefix: prefix,
-            docPrefix,
-            filename: file.name,
-            useCompositePrefixes
-        });
-        // upload the file directly to Vercel Blob using the signed URL
-        const result = await upload(pathname, file, {
+    name: 'uploadToVercelBlob',
+    handler: async ({ data, file })=>{
+        const { pathname, token } = data;
+        const result = await put(pathname, file, {
             access: 'public',
-            clientPayload: collectionSlug,
             contentType: file.type,
-            handleUploadUrl: endpointRoute
+            token
         });
-        // Match server uploadFile: document `filename` is basename only; prefixes are separate.
-        if (addRandomSuffix) {
-            const pathname = result.pathname.replace(/^\/+/, '');
-            updateFilename(decodeURIComponent(posixBasename(pathname)));
+        if (decodeURIComponent(result.pathname) !== decodeURIComponent(pathname)) {
+            throw new Error('The uploaded file was stored at an unexpected location');
         }
-        return {
-            prefix: sanitizedDocPrefix
-        };
     }
 });
 

package/dist/client/VercelBlobClientUploadHandler.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/client/VercelBlobClientUploadHandler.ts"],"sourcesContent":["'use client'\nimport { createClientUploadHandler } from '@payloadcms/plugin-cloud-storage/client'\nimport { getFileKey } from '@payloadcms/plugin-cloud-storage/utilities'\nimport { upload } from '@vercel/blob/client'\nimport { formatAdminURL } from 'payload/shared'\n\nexport type VercelBlobClientUploadHandlerExtra = {\n  addRandomSuffix: boolean\n  useCompositePrefixes: boolean\n}\n\n/** Last path segment only (POSIX), for keys like `folder/sub/file.png`. */\nfunction posixBasename(key: string): string {\n  const normalized = key.replace(/^\\/+/, '')\n  const lastSlash = normalized.lastIndexOf('/')\n  return lastSlash === -1 ? normalized : normalized.slice(lastSlash + 1)\n}\n\nexport const VercelBlobClientUploadHandler =\n  createClientUploadHandler<VercelBlobClientUploadHandlerExtra>({\n    handler: async ({\n      apiRoute,\n      collectionSlug,\n      docPrefix,\n      extra: { addRandomSuffix, useCompositePrefixes = false },\n      file,\n      prefix,\n      serverHandlerPath,\n      serverURL,\n      updateFilename,\n    }) => {\n      const endpointRoute = formatAdminURL({\n        apiRoute,\n        path: serverHandlerPath,\n        serverURL,\n      })\n      const { fileKey: pathname, sanitizedDocPrefix } = getFileKey({\n        collectionPrefix: prefix,\n        docPrefix,\n        filename: file.name,\n        useCompositePrefixes,\n      })\n\n      // upload the file directly to Vercel Blob using the signed URL\n      const result = await upload(pathname, file, {\n        access: 'public',\n        clientPayload: collectionSlug,\n        contentType: file.type,\n        handleUploadUrl: endpointRoute,\n      })\n\n      // Match server uploadFile: document `filename` is basename only; prefixes are separate.\n      if (addRandomSuffix) {\n        const pathname = result.pathname.replace(/^\\/+/, '')\n        updateFilename(decodeURIComponent(posixBasename(pathname)))\n      }\n\n      return { prefix: sanitizedDocPrefix }\n    },\n  })\n"],"names":["createClientUploadHandler","getFileKey","upload","formatAdminURL","posixBasename","key","normalized","replace","lastSlash","lastIndexOf","slice","VercelBlobClientUploadHandler","handler","apiRoute","collectionSlug","docPrefix","extra","addRandomSuffix","useCompositePrefixes","file","prefix","serverHandlerPath","serverURL","updateFilename","endpointRoute","path","fileKey","pathname","sanitizedDocPrefix","collectionPrefix","filename","name","result","access","clientPayload","contentType","type","handleUploadUrl","decodeURIComponent"],"mappings":"AAAA;AACA,SAASA,yBAAyB,QAAQ,0CAAyC;AACnF,SAASC,UAAU,QAAQ,6CAA4C;AACvE,SAASC,MAAM,QAAQ,sBAAqB;AAC5C,SAASC,cAAc,QAAQ,iBAAgB;AAO/C,yEAAyE,GACzE,SAASC,cAAcC,GAAW;IAChC,MAAMC,aAAaD,IAAIE,OAAO,CAAC,QAAQ;IACvC,MAAMC,YAAYF,WAAWG,WAAW,CAAC;IACzC,OAAOD,cAAc,CAAC,IAAIF,aAAaA,WAAWI,KAAK,CAACF,YAAY;AACtE;AAEA,OAAO,MAAMG,gCACXX,0BAA8D;IAC5DY,SAAS,OAAO,EACdC,QAAQ,EACRC,cAAc,EACdC,SAAS,EACTC,OAAO,EAAEC,eAAe,EAAEC,uBAAuB,KAAK,EAAE,EACxDC,IAAI,EACJC,MAAM,EACNC,iBAAiB,EACjBC,SAAS,EACTC,cAAc,EACf;QACC,MAAMC,gBAAgBrB,eAAe;YACnCU;YACAY,MAAMJ;YACNC;QACF;QACA,MAAM,EAAEI,SAASC,QAAQ,EAAEC,kBAAkB,EAAE,GAAG3B,WAAW;YAC3D4B,kBAAkBT;YAClBL;YACAe,UAAUX,KAAKY,IAAI;YACnBb;QACF;QAEA,+DAA+D;QAC/D,MAAMc,SAAS,MAAM9B,OAAOyB,UAAUR,MAAM;YAC1Cc,QAAQ;YACRC,eAAepB;YACfqB,aAAahB,KAAKiB,IAAI;YACtBC,iBAAiBb;QACnB;QAEA,wFAAwF;QACxF,IAAIP,iBAAiB;YACnB,MAAMU,WAAWK,OAAOL,QAAQ,CAACpB,OAAO,CAAC,QAAQ;YACjDgB,eAAee,mBAAmBlC,cAAcuB;QAClD;QAEA,OAAO;YAAEP,QAAQQ;QAAmB;IACtC;AACF,GAAE"}
+{"version":3,"sources":["../../src/client/VercelBlobClientUploadHandler.ts"],"sourcesContent":["'use client'\nimport { createClientUploadHandler } from '@payloadcms/plugin-cloud-storage/client'\nimport { put } from '@vercel/blob/client'\n\nexport const VercelBlobClientUploadHandler = createClientUploadHandler({\n  name: 'uploadToVercelBlob',\n  handler: async ({ data, file }) => {\n    const { pathname, token } = data as { pathname: string; token: string }\n\n    const result = await put(pathname, file, {\n      access: 'public',\n      contentType: file.type,\n      token,\n    })\n\n    if (decodeURIComponent(result.pathname) !== decodeURIComponent(pathname)) {\n      throw new Error('The uploaded file was stored at an unexpected location')\n    }\n  },\n})\n"],"names":["createClientUploadHandler","put","VercelBlobClientUploadHandler","name","handler","data","file","pathname","token","result","access","contentType","type","decodeURIComponent","Error"],"mappings":"AAAA;AACA,SAASA,yBAAyB,QAAQ,0CAAyC;AACnF,SAASC,GAAG,QAAQ,sBAAqB;AAEzC,OAAO,MAAMC,gCAAgCF,0BAA0B;IACrEG,MAAM;IACNC,SAAS,OAAO,EAAEC,IAAI,EAAEC,IAAI,EAAE;QAC5B,MAAM,EAAEC,QAAQ,EAAEC,KAAK,EAAE,GAAGH;QAE5B,MAAMI,SAAS,MAAMR,IAAIM,UAAUD,MAAM;YACvCI,QAAQ;YACRC,aAAaL,KAAKM,IAAI;YACtBJ;QACF;QAEA,IAAIK,mBAAmBJ,OAAOF,QAAQ,MAAMM,mBAAmBN,WAAW;YACxE,MAAM,IAAIO,MAAM;QAClB;IACF;AACF,GAAE"}

package/dist/copyFile.d.ts

@@ -0,0 +1,12 @@
+import type { PayloadRequest } from 'payload';
+type Args = {
+    access: 'public';
+    cacheControlMaxAge: number;
+    from: string;
+    req?: PayloadRequest;
+    to: string;
+    token: string;
+};
+export declare const copyVercelBlobFile: ({ access, cacheControlMaxAge, from, req, to, token, }: Args) => Promise<void>;
+export {};
+//# sourceMappingURL=copyFile.d.ts.map

package/dist/copyFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"copyFile.d.ts","sourceRoot":"","sources":["../src/copyFile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7C,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,QAAQ,CAAA;IAChB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,cAAc,CAAA;IACpB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,kBAAkB,0DAO5B,IAAI,KAAG,OAAO,CAAC,IAAI,CA+ErB,CAAA"}

package/dist/copyFile.js

@@ -0,0 +1,86 @@
+import { BlobNotFoundError, copy, del, head, put } from '@vercel/blob';
+export const copyVercelBlobFile = async ({ access, cacheControlMaxAge, from, req, to, token })=>{
+    if (from === to) {
+        throw new Error('Storage copy requires different source and destination keys');
+    }
+    const source = await head(from, {
+        token
+    });
+    try {
+        await head(to, {
+            token
+        });
+        throw new Error(`Storage destination already exists: ${to}`);
+    } catch (err) {
+        if (!isBlobNotFound(err)) {
+            throw err;
+        }
+    }
+    const sourceMaxAge = /(?:^|,)\s*max-age=(\d+)/.exec(source.cacheControl);
+    let copied = await copy(from, to, {
+        access,
+        addRandomSuffix: false,
+        allowOverwrite: false,
+        cacheControlMaxAge: sourceMaxAge ? Number(sourceMaxAge[1]) : cacheControlMaxAge,
+        contentType: source.contentType,
+        token
+    });
+    try {
+        if (copied.pathname !== to) {
+            throw new Error(`Vercel Blob assigned an unexpected destination key: ${copied.pathname}`);
+        }
+        let destination = await head(to, {
+            token
+        });
+        if (destination.size !== source.size) {
+            await del(to, {
+                ifMatch: copied.etag,
+                token
+            });
+            // The first copy is gone; a rejected fallback must not delete another upload's object.
+            copied = undefined;
+            const sourceResponse = await fetch(source.url);
+            if (!sourceResponse.ok || !sourceResponse.body) {
+                throw new Error(`Vercel Blob source is not readable: ${from}`);
+            }
+            copied = await put(to, sourceResponse.body, {
+                access,
+                addRandomSuffix: false,
+                allowOverwrite: false,
+                cacheControlMaxAge: sourceMaxAge ? Number(sourceMaxAge[1]) : cacheControlMaxAge,
+                contentType: source.contentType,
+                token
+            });
+            if (copied.pathname !== to) {
+                throw new Error(`Vercel Blob assigned an unexpected destination key: ${copied.pathname}`);
+            }
+            destination = await head(to, {
+                token
+            });
+            if (destination.size !== source.size) {
+                throw new Error(`Copied Vercel Blob object is not readable at its expected length: ${to}`);
+            }
+        }
+    } catch (err) {
+        if (copied) {
+            try {
+                if (copied.pathname === from || !copied.etag) {
+                    throw new Error('Vercel Blob copy did not return a safe destination for cleanup');
+                }
+                await del(copied.pathname, {
+                    ifMatch: copied.etag,
+                    token
+                });
+            } catch (cleanupError) {
+                req?.payload.logger.error({
+                    err: cleanupError,
+                    msg: `Failed to remove unsuccessful Vercel Blob copy at ${copied.pathname}`
+                });
+            }
+        }
+        throw err;
+    }
+};
+const isBlobNotFound = (err)=>err instanceof BlobNotFoundError || err !== null && typeof err === 'object' && 'name' in err && err.name === 'BlobNotFoundError';
+
+//# sourceMappingURL=copyFile.js.map