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

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

@@ -14,24 +14,13 @@ pnpm add @payloadcms/storage-azure
 
 - Configure the `collections` object to specify which collections should use the Azure Blob Storage adapter. The slug _must_ match one of your existing collection slugs.
 - 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 Azure.
 
-### Large client uploads (files over ~5GB)
+### Client uploads and CORS
 
-By default, client uploads (`clientUploads: true`) send each file in a single request, which Azure caps at ~5GB. To upload larger files, set `chunkLargeFiles: true`:
+Client uploads (`clientUploads: true`) use the Azure Blob SDK, which splits large files into blocks and therefore avoids the ~5GB limit of a single upload request. Because the SDK sends `x-ms-*` headers, the browser issues a CORS preflight, so your storage account's CORS rules must allow the `OPTIONS` and `PUT` methods **and** the required headers.
 
-```ts
-azureStorage({
-  // ...
-  clientUploads: {
-    chunkLargeFiles: true,
-  },
-})
-```
-
-This uploads through the Azure Blob SDK, which splits the file into blocks (`Put Block` + `Put Block List`) and raises the limit to Azure's block-blob maximum (~190TiB).
-
-Because the SDK sends additional `x-ms-*` headers, the browser issues a CORS preflight, so your storage account's CORS rules must allow the `OPTIONS` and `PUT` methods **and** those headers. Configure a CORS rule on the Blob service (Storage account → **Resource sharing (CORS)**):
+Configure a CORS rule on the Blob service (Storage account → **Resource sharing (CORS)**):
 
 | Field           | Value                                                    |
 | --------------- | -------------------------------------------------------- |
@@ -41,6 +30,8 @@ Because the SDK sends additional `x-ms-*` headers, the browser issues a CORS pre
 | Exposed headers | `*`                                                      |
 | Max age         | `3600`                                                   |
 
+> If you previously configured CORS for the older single-`PUT` upload flow, broaden `Allowed headers` to include the `x-ms-*` headers when upgrading.
+
 ```ts
 import { azureStorage } from '@payloadcms/storage-azure'
 import { Media } from './collections/Media'
@@ -76,6 +67,6 @@ export default buildConfig({
 | `baseURL`              | Base URL for the Azure Blob storage account                                                                                                                                                                                                                               |             |
 | `connectionString`     | Azure Blob storage connection string                                                                                                                                                                                                                                      |             |
 | `containerName`        | Azure Blob storage container name                                                                                                                                                                                                                                         |             |
-| `clientUploads`        | Do uploads directly on the client to bypass limits on Vercel.                                                                                                                                                                                                             |             |
+| `clientUploads`        | Upload directly to Azure instead of through Payload.                                                                                                                                                                                                                      |             |
 
 > **Breaking change (private by default):** When `allowContainerCreate: true`, the plugin now creates containers with **private** access. Previously it created them with public `blob` access. If you relied on files being served directly from the anonymous Azure blob URL (typically alongside `disablePayloadAccessControl: true`), set `containerAccess: 'blob'` to restore the old behaviour. This only affects **newly created** containers — existing containers keep their current access level, so you must flip their ACL manually if needed.

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,KAAK,EACV,OAAO,EACP,mBAAmB,EAEpB,MAAM,wCAAwC,CAAA;AAQ/C,UAAU,sBAAsB;IAC9B,oBAAoB,EAAE,OAAO,CAAA;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,CAAC,EAAE,mBAAmB,CAAA;IACnC,aAAa,EAAE,MAAM,CAAA;IACrB,0BAA0B,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACtD,gBAAgB,EAAE,MAAM,eAAe,CAAA;IACvC,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,wBAAgB,kBAAkB,CAAC,EACjC,oBAAoB,EACpB,OAAO,EACP,aAAa,EACb,aAAa,EACb,0BAA0B,EAC1B,gBAAgB,EAChB,oBAA4B,GAC7B,EAAE,sBAAsB,GAAG,OAAO,CAiDlC"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,KAAK,EACV,OAAO,EACP,mBAAmB,EAGpB,MAAM,wCAAwC,CAAA;AAU/C,UAAU,sBAAsB;IAC9B,oBAAoB,EAAE,OAAO,CAAA;IAC7B,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,CAAC,EAAE,mBAAmB,CAAA;IACnC,aAAa,EAAE,MAAM,CAAA;IACrB,0BAA0B,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACtD,gBAAgB,EAAE,MAAM,eAAe,CAAA;IACvC,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,wBAAgB,kBAAkB,CAAC,EACjC,oBAAoB,EACpB,OAAO,EACP,aAAa,EACb,aAAa,EACb,0BAA0B,EAC1B,gBAAgB,EAChB,oBAA4B,GAC7B,EAAE,sBAAsB,GAAG,OAAO,CAmElC"}

package/dist/adapter.js

@@ -1,13 +1,25 @@
+import { copyAzureFile } from './copyFile.js';
 import { deleteFile } from './deleteFile.js';
+import { generateUploadInstructions } from './generateUploadInstructions.js';
 import { generateURL } from './generateURL.js';
 import { getFile } from './getFile.js';
-import { isAzureClientUploadAllowed } from './isClientUploadAllowed.js';
+import { isClientUploadAllowed } from './isClientUploadAllowed.js';
 import { uploadFile } from './uploadFile.js';
 export function createAzureAdapter({ allowContainerCreate, baseURL, clientUploads, containerName, createContainerIfNotExists, getStorageClient, useCompositePrefixes = false }) {
+    const deleteStoredFile = ({ storageFilePath })=>deleteFile({
+            client: getStorageClient(),
+            storageFilePath
+        });
     return ({ collection, prefix = '' })=>({
             name: 'azure',
-            clientUploads: isAzureClientUploadAllowed(collection) ? clientUploads : false,
-            requiresClientUploadReceipt: true,
+            supportsTempFiles: true,
+            copyFile: ({ from, req, to })=>copyAzureFile({
+                    client: getStorageClient(),
+                    from,
+                    req,
+                    to
+                }),
+            deleteFile: deleteStoredFile,
             generateURL: ({ filename, prefix: urlPrefix = '' })=>generateURL({
                     baseURL,
                     collectionPrefix: prefix,
@@ -16,10 +28,22 @@ export function createAzureAdapter({ allowContainerCreate, baseURL, clientUpload
                     prefix: urlPrefix,
                     useCompositePrefixes
                 }),
-            handleDelete: ({ storageFilePath })=>deleteFile({
-                    client: getStorageClient(),
-                    storageFilePath
+            uploadInstructions: {
+                adminHandler: {
+                    path: '@payloadcms/storage-azure/client#AzureClientUploadHandler'
+                },
+                enabled: Boolean(clientUploads) && isClientUploadAllowed(collection),
+                generate: generateUploadInstructions({
+                    access: typeof clientUploads === 'object' ? clientUploads.access : undefined,
+                    collectionPrefix: prefix,
+                    containerName,
+                    getStorageClient,
+                    useCompositePrefixes
                 }),
+                requiresUploadReceipt: true,
+                useInAdmin: true
+            },
+            handleDelete: deleteStoredFile,
             handleUpload: async ({ data, file, storageFilePath })=>{
                 await uploadFile({
                     buffer: file.buffer,
@@ -30,15 +54,16 @@ export function createAzureAdapter({ allowContainerCreate, baseURL, clientUpload
                 });
                 return data;
             },
-            staticHandler: (req, { doc, headers, params: { clientUploadContext, filename } })=>getFile({
+            staticHandler: (req, { doc, headers, params: { filename, operation, uploadReference } })=>getFile({
                     client: getStorageClient(),
-                    clientUploadContext,
                     collection,
                     collectionPrefix: prefix,
                     doc,
                     filename,
                     incomingHeaders: headers,
+                    operation,
                     req,
+                    uploadReference,
                     useCompositePrefixes
                 }),
             ...allowContainerCreate && {

package/dist/adapter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/adapter.ts"],"sourcesContent":["import type { ContainerClient } from '@azure/storage-blob'\nimport 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 { isAzureClientUploadAllowed } from './isClientUploadAllowed.js'\nimport { uploadFile } from './uploadFile.js'\n\ninterface CreateAzureAdapterArgs {\n  allowContainerCreate: boolean\n  baseURL: string\n  clientUploads?: ClientUploadsConfig\n  containerName: string\n  createContainerIfNotExists: () => Promise<void> | void\n  getStorageClient: () => ContainerClient\n  useCompositePrefixes?: boolean\n}\n\nexport function createAzureAdapter({\n  allowContainerCreate,\n  baseURL,\n  clientUploads,\n  containerName,\n  createContainerIfNotExists,\n  getStorageClient,\n  useCompositePrefixes = false,\n}: CreateAzureAdapterArgs): Adapter {\n  return ({ collection, prefix = '' }): GeneratedAdapter => ({\n    name: 'azure',\n    clientUploads: isAzureClientUploadAllowed(collection) ? clientUploads : false,\n    requiresClientUploadReceipt: true,\n\n    generateURL: ({ filename, prefix: urlPrefix = '' }) =>\n      generateURL({\n        baseURL,\n        collectionPrefix: prefix,\n        containerName,\n        filename,\n        prefix: urlPrefix,\n        useCompositePrefixes,\n      }),\n\n    handleDelete: ({ storageFilePath }) =>\n      deleteFile({\n        client: getStorageClient(),\n        storageFilePath,\n      }),\n\n    handleUpload: async ({ data, file, storageFilePath }) => {\n      await uploadFile({\n        buffer: file.buffer,\n        client: getStorageClient(),\n        mimeType: file.mimeType,\n        storageFilePath,\n        tempFilePath: file.tempFilePath,\n      })\n\n      return data\n    },\n\n    staticHandler: (req, { doc, headers, params: { clientUploadContext, filename } }) =>\n      getFile({\n        client: getStorageClient(),\n        clientUploadContext,\n        collection,\n        collectionPrefix: prefix,\n        doc,\n        filename,\n        incomingHeaders: headers,\n        req,\n        useCompositePrefixes,\n      }),\n\n    ...(allowContainerCreate && { onInit: createContainerIfNotExists }),\n  })\n}\n"],"names":["deleteFile","generateURL","getFile","isAzureClientUploadAllowed","uploadFile","createAzureAdapter","allowContainerCreate","baseURL","clientUploads","containerName","createContainerIfNotExists","getStorageClient","useCompositePrefixes","collection","prefix","name","requiresClientUploadReceipt","filename","urlPrefix","collectionPrefix","handleDelete","storageFilePath","client","handleUpload","data","file","buffer","mimeType","tempFilePath","staticHandler","req","doc","headers","params","clientUploadContext","incomingHeaders","onInit"],"mappings":"AAOA,SAASA,UAAU,QAAQ,kBAAiB;AAC5C,SAASC,WAAW,QAAQ,mBAAkB;AAC9C,SAASC,OAAO,QAAQ,eAAc;AACtC,SAASC,0BAA0B,QAAQ,6BAA4B;AACvE,SAASC,UAAU,QAAQ,kBAAiB;AAY5C,OAAO,SAASC,mBAAmB,EACjCC,oBAAoB,EACpBC,OAAO,EACPC,aAAa,EACbC,aAAa,EACbC,0BAA0B,EAC1BC,gBAAgB,EAChBC,uBAAuB,KAAK,EACL;IACvB,OAAO,CAAC,EAAEC,UAAU,EAAEC,SAAS,EAAE,EAAE,GAAwB,CAAA;YACzDC,MAAM;YACNP,eAAeL,2BAA2BU,cAAcL,gBAAgB;YACxEQ,6BAA6B;YAE7Bf,aAAa,CAAC,EAAEgB,QAAQ,EAAEH,QAAQI,YAAY,EAAE,EAAE,GAChDjB,YAAY;oBACVM;oBACAY,kBAAkBL;oBAClBL;oBACAQ;oBACAH,QAAQI;oBACRN;gBACF;YAEFQ,cAAc,CAAC,EAAEC,eAAe,EAAE,GAChCrB,WAAW;oBACTsB,QAAQX;oBACRU;gBACF;YAEFE,cAAc,OAAO,EAAEC,IAAI,EAAEC,IAAI,EAAEJ,eAAe,EAAE;gBAClD,MAAMjB,WAAW;oBACfsB,QAAQD,KAAKC,MAAM;oBACnBJ,QAAQX;oBACRgB,UAAUF,KAAKE,QAAQ;oBACvBN;oBACAO,cAAcH,KAAKG,YAAY;gBACjC;gBAEA,OAAOJ;YACT;YAEAK,eAAe,CAACC,KAAK,EAAEC,GAAG,EAAEC,OAAO,EAAEC,QAAQ,EAAEC,mBAAmB,EAAEjB,QAAQ,EAAE,EAAE,GAC9Ef,QAAQ;oBACNoB,QAAQX;oBACRuB;oBACArB;oBACAM,kBAAkBL;oBAClBiB;oBACAd;oBACAkB,iBAAiBH;oBACjBF;oBACAlB;gBACF;YAEF,GAAIN,wBAAwB;gBAAE8B,QAAQ1B;YAA2B,CAAC;QACpE,CAAA;AACF"}
+{"version":3,"sources":["../src/adapter.ts"],"sourcesContent":["import type { ContainerClient } from '@azure/storage-blob'\nimport type {\n  Adapter,\n  ClientUploadsConfig,\n  DeleteFile,\n  GeneratedAdapter,\n} from '@payloadcms/plugin-cloud-storage/types'\n\nimport { copyAzureFile } from './copyFile.js'\nimport { deleteFile } from './deleteFile.js'\nimport { generateUploadInstructions } from './generateUploadInstructions.js'\nimport { generateURL } from './generateURL.js'\nimport { getFile } from './getFile.js'\nimport { isClientUploadAllowed } from './isClientUploadAllowed.js'\nimport { uploadFile } from './uploadFile.js'\n\ninterface CreateAzureAdapterArgs {\n  allowContainerCreate: boolean\n  baseURL: string\n  clientUploads?: ClientUploadsConfig\n  containerName: string\n  createContainerIfNotExists: () => Promise<void> | void\n  getStorageClient: () => ContainerClient\n  useCompositePrefixes?: boolean\n}\n\nexport function createAzureAdapter({\n  allowContainerCreate,\n  baseURL,\n  clientUploads,\n  containerName,\n  createContainerIfNotExists,\n  getStorageClient,\n  useCompositePrefixes = false,\n}: CreateAzureAdapterArgs): Adapter {\n  const deleteStoredFile: DeleteFile = ({ storageFilePath }) =>\n    deleteFile({ client: getStorageClient(), storageFilePath })\n\n  return ({ collection, prefix = '' }): GeneratedAdapter => ({\n    name: 'azure',\n    supportsTempFiles: true,\n\n    copyFile: ({ from, req, to }) => copyAzureFile({ client: getStorageClient(), from, req, to }),\n    deleteFile: deleteStoredFile,\n\n    generateURL: ({ filename, prefix: urlPrefix = '' }) =>\n      generateURL({\n        baseURL,\n        collectionPrefix: prefix,\n        containerName,\n        filename,\n        prefix: urlPrefix,\n        useCompositePrefixes,\n      }),\n\n    uploadInstructions: {\n      adminHandler: {\n        path: '@payloadcms/storage-azure/client#AzureClientUploadHandler',\n      },\n      enabled: Boolean(clientUploads) && isClientUploadAllowed(collection),\n      generate: generateUploadInstructions({\n        access: typeof clientUploads === 'object' ? clientUploads.access : undefined,\n        collectionPrefix: prefix,\n        containerName,\n        getStorageClient,\n        useCompositePrefixes,\n      }),\n      requiresUploadReceipt: true,\n      useInAdmin: true,\n    },\n\n    handleDelete: deleteStoredFile,\n\n    handleUpload: async ({ data, file, storageFilePath }) => {\n      await uploadFile({\n        buffer: file.buffer,\n        client: getStorageClient(),\n        mimeType: file.mimeType,\n        storageFilePath,\n        tempFilePath: file.tempFilePath,\n      })\n\n      return data\n    },\n\n    staticHandler: (req, { doc, headers, params: { filename, operation, uploadReference } }) =>\n      getFile({\n        client: getStorageClient(),\n        collection,\n        collectionPrefix: prefix,\n        doc,\n        filename,\n        incomingHeaders: headers,\n        operation,\n        req,\n        uploadReference,\n        useCompositePrefixes,\n      }),\n\n    ...(allowContainerCreate && { onInit: createContainerIfNotExists }),\n  })\n}\n"],"names":["copyAzureFile","deleteFile","generateUploadInstructions","generateURL","getFile","isClientUploadAllowed","uploadFile","createAzureAdapter","allowContainerCreate","baseURL","clientUploads","containerName","createContainerIfNotExists","getStorageClient","useCompositePrefixes","deleteStoredFile","storageFilePath","client","collection","prefix","name","supportsTempFiles","copyFile","from","req","to","filename","urlPrefix","collectionPrefix","uploadInstructions","adminHandler","path","enabled","Boolean","generate","access","undefined","requiresUploadReceipt","useInAdmin","handleDelete","handleUpload","data","file","buffer","mimeType","tempFilePath","staticHandler","doc","headers","params","operation","uploadReference","incomingHeaders","onInit"],"mappings":"AAQA,SAASA,aAAa,QAAQ,gBAAe;AAC7C,SAASC,UAAU,QAAQ,kBAAiB;AAC5C,SAASC,0BAA0B,QAAQ,kCAAiC;AAC5E,SAASC,WAAW,QAAQ,mBAAkB;AAC9C,SAASC,OAAO,QAAQ,eAAc;AACtC,SAASC,qBAAqB,QAAQ,6BAA4B;AAClE,SAASC,UAAU,QAAQ,kBAAiB;AAY5C,OAAO,SAASC,mBAAmB,EACjCC,oBAAoB,EACpBC,OAAO,EACPC,aAAa,EACbC,aAAa,EACbC,0BAA0B,EAC1BC,gBAAgB,EAChBC,uBAAuB,KAAK,EACL;IACvB,MAAMC,mBAA+B,CAAC,EAAEC,eAAe,EAAE,GACvDf,WAAW;YAAEgB,QAAQJ;YAAoBG;QAAgB;IAE3D,OAAO,CAAC,EAAEE,UAAU,EAAEC,SAAS,EAAE,EAAE,GAAwB,CAAA;YACzDC,MAAM;YACNC,mBAAmB;YAEnBC,UAAU,CAAC,EAAEC,IAAI,EAAEC,GAAG,EAAEC,EAAE,EAAE,GAAKzB,cAAc;oBAAEiB,QAAQJ;oBAAoBU;oBAAMC;oBAAKC;gBAAG;YAC3FxB,YAAYc;YAEZZ,aAAa,CAAC,EAAEuB,QAAQ,EAAEP,QAAQQ,YAAY,EAAE,EAAE,GAChDxB,YAAY;oBACVM;oBACAmB,kBAAkBT;oBAClBR;oBACAe;oBACAP,QAAQQ;oBACRb;gBACF;YAEFe,oBAAoB;gBAClBC,cAAc;oBACZC,MAAM;gBACR;gBACAC,SAASC,QAAQvB,kBAAkBL,sBAAsBa;gBACzDgB,UAAUhC,2BAA2B;oBACnCiC,QAAQ,OAAOzB,kBAAkB,WAAWA,cAAcyB,MAAM,GAAGC;oBACnER,kBAAkBT;oBAClBR;oBACAE;oBACAC;gBACF;gBACAuB,uBAAuB;gBACvBC,YAAY;YACd;YAEAC,cAAcxB;YAEdyB,cAAc,OAAO,EAAEC,IAAI,EAAEC,IAAI,EAAE1B,eAAe,EAAE;gBAClD,MAAMV,WAAW;oBACfqC,QAAQD,KAAKC,MAAM;oBACnB1B,QAAQJ;oBACR+B,UAAUF,KAAKE,QAAQ;oBACvB5B;oBACA6B,cAAcH,KAAKG,YAAY;gBACjC;gBAEA,OAAOJ;YACT;YAEAK,eAAe,CAACtB,KAAK,EAAEuB,GAAG,EAAEC,OAAO,EAAEC,QAAQ,EAAEvB,QAAQ,EAAEwB,SAAS,EAAEC,eAAe,EAAE,EAAE,GACrF/C,QAAQ;oBACNa,QAAQJ;oBACRK;oBACAU,kBAAkBT;oBAClB4B;oBACArB;oBACA0B,iBAAiBJ;oBACjBE;oBACA1B;oBACA2B;oBACArC;gBACF;YAEF,GAAIN,wBAAwB;gBAAE6C,QAAQzC;YAA2B,CAAC;QACpE,CAAA;AACF"}

package/dist/client/AzureClientUploadHandler.d.ts

@@ -1,12 +1,8 @@
-export type AzureClientUploadHandlerExtra = {
-    chunkLargeFiles: boolean;
-};
-export declare const AzureClientUploadHandler: ({ children, collectionSlug, enabled, extra, prefix, serverHandlerPath, }: {
+export declare const AzureClientUploadHandler: ({ children, collectionSlug, endpointPath, prefix, props, }: {
     children: import("react").ReactNode;
-    collectionSlug: import("packages/payload/src/index.js").UploadCollectionSlug;
-    enabled?: boolean;
-    extra: AzureClientUploadHandlerExtra;
+    collectionSlug: import("payload").UploadCollectionSlug;
+    endpointPath?: `/${string}`;
     prefix?: string;
-    serverHandlerPath: `/${string}`;
+    props: Record<string, unknown>;
 }) => import("react").JSX.Element;
 //# sourceMappingURL=AzureClientUploadHandler.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AzureClientUploadHandler.d.ts","sourceRoot":"","sources":["../../src/client/AzureClientUploadHandler.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,eAAe,EAAE,OAAO,CAAA;CACzB,CAAA;AAED,eAAO,MAAM,wBAAwB;;;;;;;aAuBgI,OAAO,aAD1K,CAAA"}
+{"version":3,"file":"AzureClientUploadHandler.d.ts","sourceRoot":"","sources":["../../src/client/AzureClientUploadHandler.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,wBAAwB;;;;;;iCAGnC,CAAA"}

package/dist/client/AzureClientUploadHandler.js

@@ -2,18 +2,8 @@
 import { createClientUploadHandler } from '@payloadcms/plugin-cloud-storage/client';
 import { handleAzureUpload } from './handleAzureUpload.js';
 export const AzureClientUploadHandler = createClientUploadHandler({
-    handler: async ({ apiRoute, collectionSlug, docPrefix, extra: { chunkLargeFiles }, file, serverHandlerPath, serverURL, updateFilename })=>{
-        return handleAzureUpload({
-            apiRoute,
-            chunkLargeFiles,
-            collectionSlug,
-            docPrefix,
-            file,
-            serverHandlerPath,
-            serverURL,
-            updateFilename
-        });
-    }
+    name: 'uploadToAzure',
+    handler: handleAzureUpload
 });
 
 //# sourceMappingURL=AzureClientUploadHandler.js.map

package/dist/client/AzureClientUploadHandler.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/client/AzureClientUploadHandler.ts"],"sourcesContent":["'use client'\nimport { createClientUploadHandler } from '@payloadcms/plugin-cloud-storage/client'\n\nimport { handleAzureUpload } from './handleAzureUpload.js'\n\nexport type AzureClientUploadHandlerExtra = {\n  chunkLargeFiles: boolean\n}\n\nexport const AzureClientUploadHandler = createClientUploadHandler<AzureClientUploadHandlerExtra>({\n  handler: async ({\n    apiRoute,\n    collectionSlug,\n    docPrefix,\n    extra: { chunkLargeFiles },\n    file,\n    serverHandlerPath,\n    serverURL,\n    updateFilename,\n  }) => {\n    return handleAzureUpload({\n      apiRoute,\n      chunkLargeFiles,\n      collectionSlug,\n      docPrefix,\n      file,\n      serverHandlerPath,\n      serverURL,\n      updateFilename,\n    })\n  },\n})\n"],"names":["createClientUploadHandler","handleAzureUpload","AzureClientUploadHandler","handler","apiRoute","collectionSlug","docPrefix","extra","chunkLargeFiles","file","serverHandlerPath","serverURL","updateFilename"],"mappings":"AAAA;AACA,SAASA,yBAAyB,QAAQ,0CAAyC;AAEnF,SAASC,iBAAiB,QAAQ,yBAAwB;AAM1D,OAAO,MAAMC,2BAA2BF,0BAAyD;IAC/FG,SAAS,OAAO,EACdC,QAAQ,EACRC,cAAc,EACdC,SAAS,EACTC,OAAO,EAAEC,eAAe,EAAE,EAC1BC,IAAI,EACJC,iBAAiB,EACjBC,SAAS,EACTC,cAAc,EACf;QACC,OAAOX,kBAAkB;YACvBG;YACAI;YACAH;YACAC;YACAG;YACAC;YACAC;YACAC;QACF;IACF;AACF,GAAE"}
+{"version":3,"sources":["../../src/client/AzureClientUploadHandler.ts"],"sourcesContent":["'use client'\nimport { createClientUploadHandler } from '@payloadcms/plugin-cloud-storage/client'\n\nimport { handleAzureUpload } from './handleAzureUpload.js'\n\nexport const AzureClientUploadHandler = createClientUploadHandler({\n  name: 'uploadToAzure',\n  handler: handleAzureUpload,\n})\n"],"names":["createClientUploadHandler","handleAzureUpload","AzureClientUploadHandler","name","handler"],"mappings":"AAAA;AACA,SAASA,yBAAyB,QAAQ,0CAAyC;AAEnF,SAASC,iBAAiB,QAAQ,yBAAwB;AAE1D,OAAO,MAAMC,2BAA2BF,0BAA0B;IAChEG,MAAM;IACNC,SAASH;AACX,GAAE"}

package/dist/client/handleAzureUpload.d.ts

@@ -1,19 +1,7 @@
-import type { ClientUploadContext } from '@payloadcms/plugin-cloud-storage/types';
 type HandleAzureUploadArgs = {
-    apiRoute: string;
-    /**
-     * When true, upload through the Azure Blob SDK, which splits the file into
-     * blocks (Put Block + Put Block List) and lifts the ~5 GB single-request
-     * limit. When false, use the legacy single Put Blob request.
-     */
-    chunkLargeFiles: boolean;
-    collectionSlug: string;
-    docPrefix?: string;
+    data?: unknown;
     file: File;
-    serverHandlerPath: `/${string}`;
-    serverURL: string;
-    updateFilename: (value: string) => void;
 };
-export declare const handleAzureUpload: ({ apiRoute, chunkLargeFiles, collectionSlug, docPrefix, file, serverHandlerPath, serverURL, updateFilename, }: HandleAzureUploadArgs) => Promise<ClientUploadContext>;
+export declare const handleAzureUpload: ({ data, file }: HandleAzureUploadArgs) => Promise<void>;
 export {};
 //# sourceMappingURL=handleAzureUpload.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"handleAzureUpload.d.ts","sourceRoot":"","sources":["../../src/client/handleAzureUpload.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AASjF,KAAK,qBAAqB,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAA;IACxB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,IAAI,CAAA;IACV,iBAAiB,EAAE,IAAI,MAAM,EAAE,CAAA;IAC/B,SAAS,EAAE,MAAM,CAAA;IACjB,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,iBAAiB,kHAS3B,qBAAqB,KAAG,OAAO,CAAC,mBAAmB,CAiFrD,CAAA"}
+{"version":3,"file":"handleAzureUpload.d.ts","sourceRoot":"","sources":["../../src/client/handleAzureUpload.ts"],"names":[],"mappings":"AASA,KAAK,qBAAqB,GAAG;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,IAAI,EAAE,IAAI,CAAA;CACX,CAAA;AAED,eAAO,MAAM,iBAAiB,mBAA0B,qBAAqB,KAAG,OAAO,CAAC,IAAI,CAc3F,CAAA"}

package/dist/client/handleAzureUpload.js

@@ -1,67 +1,23 @@
 'use client';
-import { formatAdminURL } from 'payload/shared';
 // Balances upload parallelism against browser memory: `blockSize * concurrency`
-// bytes are buffered in flight (64 MiB * 4 = 256 MiB). Only used on the SDK path.
+// bytes are buffered in flight. The SDK uses a single Put Blob for small files
+// and switches to Put Block + Put Block List above its single-shot threshold,
+// lifting the ~5 GB single-request ceiling to Azure's block-blob maximum.
 const BLOCK_SIZE = 64 * 1024 * 1024;
 const CONCURRENCY = 4;
-export const handleAzureUpload = async ({ apiRoute, chunkLargeFiles, collectionSlug, docPrefix, file, serverHandlerPath, serverURL, updateFilename })=>{
-    const endpointRoute = formatAdminURL({
-        apiRoute,
-        path: serverHandlerPath,
-        serverURL
+export const handleAzureUpload = async ({ data, file })=>{
+    const { url } = data;
+    // Loaded on demand so @azure/storage-blob is only pulled into the client bundle
+    // when a client upload actually runs, rather than for every Azure adapter user.
+    const { BlockBlobClient } = await import('@azure/storage-blob');
+    const blockBlobClient = new BlockBlobClient(url);
+    await blockBlobClient.uploadData(file, {
+        blobHTTPHeaders: {
+            blobContentType: file.type
+        },
+        blockSize: BLOCK_SIZE,
+        concurrency: CONCURRENCY
     });
-    const response = await fetch(endpointRoute, {
-        body: JSON.stringify({
-            collectionSlug,
-            docPrefix,
-            filename: file.name,
-            mimeType: file.type
-        }),
-        credentials: 'include',
-        method: 'POST'
-    });
-    if (!response.ok) {
-        throw new Error('Failed to retrieve signed URL for Azure client upload');
-    }
-    const { clientUploadContext, filename: sanitizedFilename, url } = await response.json();
-    if (typeof clientUploadContext !== 'object' || clientUploadContext === null || !('prefix' in clientUploadContext) || typeof clientUploadContext.prefix !== 'string' || !('signedReceipt' in clientUploadContext) || typeof clientUploadContext.signedReceipt !== 'string') {
-        throw new Error('Invalid Azure client upload reference');
-    }
-    if (sanitizedFilename && sanitizedFilename !== file.name) {
-        updateFilename(sanitizedFilename);
-    }
-    if (chunkLargeFiles) {
-        // Loaded on demand so @azure/storage-blob is only pulled into the client bundle
-        // when a chunked client upload actually runs, rather than for every Azure user.
-        const { BlockBlobClient } = await import('@azure/storage-blob');
-        const blockBlobClient = new BlockBlobClient(url);
-        await blockBlobClient.uploadData(file, {
-            blobHTTPHeaders: {
-                blobContentType: file.type
-            },
-            blockSize: BLOCK_SIZE,
-            concurrency: CONCURRENCY
-        });
-    } else {
-        const upload = await fetch(url, {
-            body: file,
-            headers: {
-                'Content-Length': file.size.toString(),
-                'Content-Type': file.type,
-                // Required for azure
-                'x-ms-blob-type': 'BlockBlob'
-            },
-            method: 'PUT'
-        });
-        if (!upload.ok) {
-            throw new Error('Failed to upload file to Azure Blob Storage');
-        }
-    }
-    return {
-        prefix: clientUploadContext.prefix,
-        // Validated as a string above; re-typed to its branded receipt form for the return contract.
-        signedReceipt: clientUploadContext.signedReceipt
-    };
 };
 
 //# sourceMappingURL=handleAzureUpload.js.map

package/dist/client/handleAzureUpload.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/client/handleAzureUpload.ts"],"sourcesContent":["'use client'\nimport type { ClientUploadContext } from '@payloadcms/plugin-cloud-storage/types'\n\nimport { formatAdminURL } from 'payload/shared'\n\n// Balances upload parallelism against browser memory: `blockSize * concurrency`\n// bytes are buffered in flight (64 MiB * 4 = 256 MiB). Only used on the SDK path.\nconst BLOCK_SIZE = 64 * 1024 * 1024\nconst CONCURRENCY = 4\n\ntype HandleAzureUploadArgs = {\n  apiRoute: string\n  /**\n   * When true, upload through the Azure Blob SDK, which splits the file into\n   * blocks (Put Block + Put Block List) and lifts the ~5 GB single-request\n   * limit. When false, use the legacy single Put Blob request.\n   */\n  chunkLargeFiles: boolean\n  collectionSlug: string\n  docPrefix?: string\n  file: File\n  serverHandlerPath: `/${string}`\n  serverURL: string\n  updateFilename: (value: string) => void\n}\n\nexport const handleAzureUpload = async ({\n  apiRoute,\n  chunkLargeFiles,\n  collectionSlug,\n  docPrefix,\n  file,\n  serverHandlerPath,\n  serverURL,\n  updateFilename,\n}: HandleAzureUploadArgs): Promise<ClientUploadContext> => {\n  const endpointRoute = formatAdminURL({\n    apiRoute,\n    path: serverHandlerPath,\n    serverURL,\n  })\n\n  const response = await fetch(endpointRoute, {\n    body: JSON.stringify({\n      collectionSlug,\n      docPrefix,\n      filename: file.name,\n      mimeType: file.type,\n    }),\n    credentials: 'include',\n    method: 'POST',\n  })\n\n  if (!response.ok) {\n    throw new Error('Failed to retrieve signed URL for Azure client upload')\n  }\n\n  const {\n    clientUploadContext,\n    filename: sanitizedFilename,\n    url,\n  } = (await response.json()) as {\n    clientUploadContext?: unknown\n    filename?: string\n    url: string\n  }\n\n  if (\n    typeof clientUploadContext !== 'object' ||\n    clientUploadContext === null ||\n    !('prefix' in clientUploadContext) ||\n    typeof clientUploadContext.prefix !== 'string' ||\n    !('signedReceipt' in clientUploadContext) ||\n    typeof clientUploadContext.signedReceipt !== 'string'\n  ) {\n    throw new Error('Invalid Azure client upload reference')\n  }\n\n  if (sanitizedFilename && sanitizedFilename !== file.name) {\n    updateFilename(sanitizedFilename)\n  }\n\n  if (chunkLargeFiles) {\n    // Loaded on demand so @azure/storage-blob is only pulled into the client bundle\n    // when a chunked client upload actually runs, rather than for every Azure user.\n    const { BlockBlobClient } = await import('@azure/storage-blob')\n\n    const blockBlobClient = new BlockBlobClient(url)\n\n    await blockBlobClient.uploadData(file, {\n      blobHTTPHeaders: { blobContentType: file.type },\n      blockSize: BLOCK_SIZE,\n      concurrency: CONCURRENCY,\n    })\n  } else {\n    const upload = await fetch(url, {\n      body: file,\n      headers: {\n        'Content-Length': file.size.toString(),\n        'Content-Type': file.type,\n        // Required for azure\n        'x-ms-blob-type': 'BlockBlob',\n      },\n      method: 'PUT',\n    })\n\n    if (!upload.ok) {\n      throw new Error('Failed to upload file to Azure Blob Storage')\n    }\n  }\n\n  return {\n    prefix: clientUploadContext.prefix,\n    // Validated as a string above; re-typed to its branded receipt form for the return contract.\n    signedReceipt: clientUploadContext.signedReceipt as ClientUploadContext['signedReceipt'],\n  }\n}\n"],"names":["formatAdminURL","BLOCK_SIZE","CONCURRENCY","handleAzureUpload","apiRoute","chunkLargeFiles","collectionSlug","docPrefix","file","serverHandlerPath","serverURL","updateFilename","endpointRoute","path","response","fetch","body","JSON","stringify","filename","name","mimeType","type","credentials","method","ok","Error","clientUploadContext","sanitizedFilename","url","json","prefix","signedReceipt","BlockBlobClient","blockBlobClient","uploadData","blobHTTPHeaders","blobContentType","blockSize","concurrency","upload","headers","size","toString"],"mappings":"AAAA;AAGA,SAASA,cAAc,QAAQ,iBAAgB;AAE/C,gFAAgF;AAChF,kFAAkF;AAClF,MAAMC,aAAa,KAAK,OAAO;AAC/B,MAAMC,cAAc;AAkBpB,OAAO,MAAMC,oBAAoB,OAAO,EACtCC,QAAQ,EACRC,eAAe,EACfC,cAAc,EACdC,SAAS,EACTC,IAAI,EACJC,iBAAiB,EACjBC,SAAS,EACTC,cAAc,EACQ;IACtB,MAAMC,gBAAgBZ,eAAe;QACnCI;QACAS,MAAMJ;QACNC;IACF;IAEA,MAAMI,WAAW,MAAMC,MAAMH,eAAe;QAC1CI,MAAMC,KAAKC,SAAS,CAAC;YACnBZ;YACAC;YACAY,UAAUX,KAAKY,IAAI;YACnBC,UAAUb,KAAKc,IAAI;QACrB;QACAC,aAAa;QACbC,QAAQ;IACV;IAEA,IAAI,CAACV,SAASW,EAAE,EAAE;QAChB,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAM,EACJC,mBAAmB,EACnBR,UAAUS,iBAAiB,EAC3BC,GAAG,EACJ,GAAI,MAAMf,SAASgB,IAAI;IAMxB,IACE,OAAOH,wBAAwB,YAC/BA,wBAAwB,QACxB,CAAE,CAAA,YAAYA,mBAAkB,KAChC,OAAOA,oBAAoBI,MAAM,KAAK,YACtC,CAAE,CAAA,mBAAmBJ,mBAAkB,KACvC,OAAOA,oBAAoBK,aAAa,KAAK,UAC7C;QACA,MAAM,IAAIN,MAAM;IAClB;IAEA,IAAIE,qBAAqBA,sBAAsBpB,KAAKY,IAAI,EAAE;QACxDT,eAAeiB;IACjB;IAEA,IAAIvB,iBAAiB;QACnB,gFAAgF;QAChF,gFAAgF;QAChF,MAAM,EAAE4B,eAAe,EAAE,GAAG,MAAM,MAAM,CAAC;QAEzC,MAAMC,kBAAkB,IAAID,gBAAgBJ;QAE5C,MAAMK,gBAAgBC,UAAU,CAAC3B,MAAM;YACrC4B,iBAAiB;gBAAEC,iBAAiB7B,KAAKc,IAAI;YAAC;YAC9CgB,WAAWrC;YACXsC,aAAarC;QACf;IACF,OAAO;QACL,MAAMsC,SAAS,MAAMzB,MAAMc,KAAK;YAC9Bb,MAAMR;YACNiC,SAAS;gBACP,kBAAkBjC,KAAKkC,IAAI,CAACC,QAAQ;gBACpC,gBAAgBnC,KAAKc,IAAI;gBACzB,qBAAqB;gBACrB,kBAAkB;YACpB;YACAE,QAAQ;QACV;QAEA,IAAI,CAACgB,OAAOf,EAAE,EAAE;YACd,MAAM,IAAIC,MAAM;QAClB;IACF;IAEA,OAAO;QACLK,QAAQJ,oBAAoBI,MAAM;QAClC,6FAA6F;QAC7FC,eAAeL,oBAAoBK,aAAa;IAClD;AACF,EAAC"}
+{"version":3,"sources":["../../src/client/handleAzureUpload.ts"],"sourcesContent":["'use client'\n\n// Balances upload parallelism against browser memory: `blockSize * concurrency`\n// bytes are buffered in flight. The SDK uses a single Put Blob for small files\n// and switches to Put Block + Put Block List above its single-shot threshold,\n// lifting the ~5 GB single-request ceiling to Azure's block-blob maximum.\nconst BLOCK_SIZE = 64 * 1024 * 1024\nconst CONCURRENCY = 4\n\ntype HandleAzureUploadArgs = {\n  data?: unknown\n  file: File\n}\n\nexport const handleAzureUpload = async ({ data, file }: HandleAzureUploadArgs): Promise<void> => {\n  const { url } = data as { url: string }\n\n  // Loaded on demand so @azure/storage-blob is only pulled into the client bundle\n  // when a client upload actually runs, rather than for every Azure adapter user.\n  const { BlockBlobClient } = await import('@azure/storage-blob')\n\n  const blockBlobClient = new BlockBlobClient(url)\n\n  await blockBlobClient.uploadData(file, {\n    blobHTTPHeaders: { blobContentType: file.type },\n    blockSize: BLOCK_SIZE,\n    concurrency: CONCURRENCY,\n  })\n}\n"],"names":["BLOCK_SIZE","CONCURRENCY","handleAzureUpload","data","file","url","BlockBlobClient","blockBlobClient","uploadData","blobHTTPHeaders","blobContentType","type","blockSize","concurrency"],"mappings":"AAAA;AAEA,gFAAgF;AAChF,+EAA+E;AAC/E,8EAA8E;AAC9E,0EAA0E;AAC1E,MAAMA,aAAa,KAAK,OAAO;AAC/B,MAAMC,cAAc;AAOpB,OAAO,MAAMC,oBAAoB,OAAO,EAAEC,IAAI,EAAEC,IAAI,EAAyB;IAC3E,MAAM,EAAEC,GAAG,EAAE,GAAGF;IAEhB,gFAAgF;IAChF,gFAAgF;IAChF,MAAM,EAAEG,eAAe,EAAE,GAAG,MAAM,MAAM,CAAC;IAEzC,MAAMC,kBAAkB,IAAID,gBAAgBD;IAE5C,MAAME,gBAAgBC,UAAU,CAACJ,MAAM;QACrCK,iBAAiB;YAAEC,iBAAiBN,KAAKO,IAAI;QAAC;QAC9CC,WAAWZ;QACXa,aAAaZ;IACf;AACF,EAAC"}

package/dist/copyFile.d.ts

@@ -0,0 +1,11 @@
+import type { ContainerClient } from '@azure/storage-blob';
+import type { PayloadRequest } from 'payload';
+type Args = {
+    client: ContainerClient;
+    from: string;
+    req?: PayloadRequest;
+    to: string;
+};
+export declare const copyAzureFile: ({ client, from, req, to }: 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,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,KAAK,IAAI,GAAG;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,cAAc,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvF,eAAO,MAAM,aAAa,8BAAqC,IAAI,KAAG,OAAO,CAAC,IAAI,CAqDjF,CAAA"}

package/dist/copyFile.js

@@ -0,0 +1,52 @@
+export const copyAzureFile = async ({ client, from, req, to })=>{
+    if (from === to) {
+        throw new Error('Storage copy requires different source and destination keys');
+    }
+    const source = client.getBlockBlobClient(from);
+    const destination = client.getBlockBlobClient(to);
+    const properties = await source.getProperties();
+    const { tags } = await source.getTags();
+    const download = await source.download();
+    if (!download.readableStreamBody) {
+        throw new Error(`Azure storage source is not readable: ${from}`);
+    }
+    const uploaded = await destination.uploadStream(download.readableStreamBody, 4 * 1024 * 1024, 4, {
+        blobHTTPHeaders: {
+            blobCacheControl: properties.cacheControl,
+            blobContentDisposition: properties.contentDisposition,
+            blobContentEncoding: properties.contentEncoding,
+            blobContentLanguage: properties.contentLanguage,
+            blobContentType: properties.contentType
+        },
+        conditions: {
+            ifNoneMatch: '*'
+        },
+        metadata: properties.metadata,
+        tags
+    });
+    try {
+        const copied = await destination.getProperties();
+        if (copied.contentLength !== properties.contentLength) {
+            throw new Error(`Copied Azure object is not readable at its expected length: ${to}`);
+        }
+    } catch (err) {
+        try {
+            if (!uploaded.etag) {
+                throw new Error('Azure copy did not return an ETag for safe cleanup');
+            }
+            await destination.deleteIfExists({
+                conditions: {
+                    ifMatch: uploaded.etag
+                }
+            });
+        } catch (cleanupError) {
+            req?.payload.logger.error({
+                err: cleanupError,
+                msg: `Failed to remove unsuccessful Azure copy at ${client.containerName}/${to}`
+            });
+        }
+        throw err;
+    }
+};
+
+//# sourceMappingURL=copyFile.js.map

package/dist/copyFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/copyFile.ts"],"sourcesContent":["import type { ContainerClient } from '@azure/storage-blob'\nimport type { Readable } from 'node:stream'\nimport type { PayloadRequest } from 'payload'\n\ntype Args = { client: ContainerClient; from: string; req?: PayloadRequest; to: string }\n\nexport const copyAzureFile = async ({ client, from, req, to }: Args): Promise<void> => {\n  if (from === to) {\n    throw new Error('Storage copy requires different source and destination keys')\n  }\n\n  const source = client.getBlockBlobClient(from)\n  const destination = client.getBlockBlobClient(to)\n  const properties = await source.getProperties()\n  const { tags } = await source.getTags()\n  const download = await source.download()\n\n  if (!download.readableStreamBody) {\n    throw new Error(`Azure storage source is not readable: ${from}`)\n  }\n\n  const uploaded = await destination.uploadStream(\n    download.readableStreamBody as Readable,\n    4 * 1024 * 1024,\n    4,\n    {\n      blobHTTPHeaders: {\n        blobCacheControl: properties.cacheControl,\n        blobContentDisposition: properties.contentDisposition,\n        blobContentEncoding: properties.contentEncoding,\n        blobContentLanguage: properties.contentLanguage,\n        blobContentType: properties.contentType,\n      },\n      conditions: { ifNoneMatch: '*' },\n      metadata: properties.metadata,\n      tags,\n    },\n  )\n\n  try {\n    const copied = await destination.getProperties()\n\n    if (copied.contentLength !== properties.contentLength) {\n      throw new Error(`Copied Azure object is not readable at its expected length: ${to}`)\n    }\n  } catch (err) {\n    try {\n      if (!uploaded.etag) {\n        throw new Error('Azure copy did not return an ETag for safe cleanup')\n      }\n      await destination.deleteIfExists({ conditions: { ifMatch: uploaded.etag } })\n    } catch (cleanupError) {\n      req?.payload.logger.error({\n        err: cleanupError,\n        msg: `Failed to remove unsuccessful Azure copy at ${client.containerName}/${to}`,\n      })\n    }\n    throw err\n  }\n}\n"],"names":["copyAzureFile","client","from","req","to","Error","source","getBlockBlobClient","destination","properties","getProperties","tags","getTags","download","readableStreamBody","uploaded","uploadStream","blobHTTPHeaders","blobCacheControl","cacheControl","blobContentDisposition","contentDisposition","blobContentEncoding","contentEncoding","blobContentLanguage","contentLanguage","blobContentType","contentType","conditions","ifNoneMatch","metadata","copied","contentLength","err","etag","deleteIfExists","ifMatch","cleanupError","payload","logger","error","msg","containerName"],"mappings":"AAMA,OAAO,MAAMA,gBAAgB,OAAO,EAAEC,MAAM,EAAEC,IAAI,EAAEC,GAAG,EAAEC,EAAE,EAAQ;IACjE,IAAIF,SAASE,IAAI;QACf,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,SAASL,OAAOM,kBAAkB,CAACL;IACzC,MAAMM,cAAcP,OAAOM,kBAAkB,CAACH;IAC9C,MAAMK,aAAa,MAAMH,OAAOI,aAAa;IAC7C,MAAM,EAAEC,IAAI,EAAE,GAAG,MAAML,OAAOM,OAAO;IACrC,MAAMC,WAAW,MAAMP,OAAOO,QAAQ;IAEtC,IAAI,CAACA,SAASC,kBAAkB,EAAE;QAChC,MAAM,IAAIT,MAAM,CAAC,sCAAsC,EAAEH,MAAM;IACjE;IAEA,MAAMa,WAAW,MAAMP,YAAYQ,YAAY,CAC7CH,SAASC,kBAAkB,EAC3B,IAAI,OAAO,MACX,GACA;QACEG,iBAAiB;YACfC,kBAAkBT,WAAWU,YAAY;YACzCC,wBAAwBX,WAAWY,kBAAkB;YACrDC,qBAAqBb,WAAWc,eAAe;YAC/CC,qBAAqBf,WAAWgB,eAAe;YAC/CC,iBAAiBjB,WAAWkB,WAAW;QACzC;QACAC,YAAY;YAAEC,aAAa;QAAI;QAC/BC,UAAUrB,WAAWqB,QAAQ;QAC7BnB;IACF;IAGF,IAAI;QACF,MAAMoB,SAAS,MAAMvB,YAAYE,aAAa;QAE9C,IAAIqB,OAAOC,aAAa,KAAKvB,WAAWuB,aAAa,EAAE;YACrD,MAAM,IAAI3B,MAAM,CAAC,4DAA4D,EAAED,IAAI;QACrF;IACF,EAAE,OAAO6B,KAAK;QACZ,IAAI;YACF,IAAI,CAAClB,SAASmB,IAAI,EAAE;gBAClB,MAAM,IAAI7B,MAAM;YAClB;YACA,MAAMG,YAAY2B,cAAc,CAAC;gBAAEP,YAAY;oBAAEQ,SAASrB,SAASmB,IAAI;gBAAC;YAAE;QAC5E,EAAE,OAAOG,cAAc;YACrBlC,KAAKmC,QAAQC,OAAOC,MAAM;gBACxBP,KAAKI;gBACLI,KAAK,CAAC,4CAA4C,EAAExC,OAAOyC,aAAa,CAAC,CAAC,EAAEtC,IAAI;YAClF;QACF;QACA,MAAM6B;IACR;AACF,EAAC"}

package/dist/generateUploadInstructions.d.ts

@@ -0,0 +1,12 @@
+import type { ContainerClient } from '@azure/storage-blob';
+import type { GenerateUploadInstructions, UploadInstructionsAccess } from 'payload';
+interface Args {
+    access?: UploadInstructionsAccess;
+    collectionPrefix: string;
+    containerName: string;
+    getStorageClient: () => ContainerClient;
+    useCompositePrefixes?: boolean;
+}
+export declare const generateUploadInstructions: ({ access, collectionPrefix, containerName, getStorageClient, useCompositePrefixes, }: Args) => GenerateUploadInstructions;
+export {};
+//# sourceMappingURL=generateUploadInstructions.d.ts.map

package/dist/generateUploadInstructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateUploadInstructions.d.ts","sourceRoot":"","sources":["../src/generateUploadInstructions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAA8B,MAAM,qBAAqB,CAAA;AACtF,OAAO,KAAK,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AASnF,UAAU,IAAI;IACZ,MAAM,CAAC,EAAE,wBAAwB,CAAA;IACjC,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;IACrB,gBAAgB,EAAE,MAAM,eAAe,CAAA;IACvC,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED,eAAO,MAAM,0BAA0B,yFAMpC,IAAI,KAAG,0BA8DT,CAAA"}

package/dist/generateUploadInstructions.js

@@ -0,0 +1,57 @@
+import { BlobSASPermissions, generateBlobSASQueryParameters } from '@azure/storage-blob';
+import { resolveSignedURLKey } from '@payloadcms/plugin-cloud-storage/utilities';
+import { APIError, Forbidden } from 'payload';
+import { assertClientUploadAllowed } from 'payload/internal';
+import { isClientUploadAllowed } from './isClientUploadAllowed.js';
+export const generateUploadInstructions = ({ access, collectionPrefix, containerName, getStorageClient, useCompositePrefixes = false })=>{
+    return async ({ collectionSlug, docPrefix, filename, filesize, mimeType, overrideAccess, req })=>{
+        if (!overrideAccess && (access ? !await access({
+            collectionSlug,
+            req
+        }) : !req.user)) {
+            throw new Forbidden(req.t);
+        }
+        const collection = req.payload.collections[collectionSlug]?.config;
+        if (!isClientUploadAllowed(collection)) {
+            throw new APIError('Azure client uploads require allowRestrictedFileTypes to be enabled.', 400);
+        }
+        assertClientUploadAllowed({
+            collection,
+            filename,
+            mimeType
+        });
+        const { sanitizedFilename, storageFilePath, uploadReference } = await resolveSignedURLKey({
+            collectionPrefix,
+            collectionSlug,
+            docPrefix,
+            filename,
+            req,
+            useCompositePrefixes
+        });
+        const blobClient = getStorageClient().getBlobClient(storageFilePath);
+        const sasToken = generateBlobSASQueryParameters({
+            blobName: storageFilePath,
+            containerName,
+            contentType: mimeType,
+            expiresOn: new Date(Date.now() + 3 * 60 * 60 * 1000),
+            permissions: BlobSASPermissions.parse('c'),
+            startsOn: new Date(),
+            version: '2026-04-06'
+        }, getStorageClient().credential);
+        return {
+            name: 'uploadToAzure',
+            type: 'dispatch',
+            data: {
+                url: `${blobClient.url}?${sasToken.toString()}`
+            },
+            file: {
+                filename: sanitizedFilename,
+                mimeType,
+                size: filesize,
+                uploadReference
+            }
+        };
+    };
+};
+
+//# sourceMappingURL=generateUploadInstructions.js.map

package/dist/generateUploadInstructions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/generateUploadInstructions.ts"],"sourcesContent":["import type { ContainerClient, StorageSharedKeyCredential } from '@azure/storage-blob'\nimport type { GenerateUploadInstructions, UploadInstructionsAccess } from 'payload'\n\nimport { BlobSASPermissions, generateBlobSASQueryParameters } from '@azure/storage-blob'\nimport { resolveSignedURLKey } from '@payloadcms/plugin-cloud-storage/utilities'\nimport { APIError, Forbidden } from 'payload'\nimport { assertClientUploadAllowed } from 'payload/internal'\n\nimport { isClientUploadAllowed } from './isClientUploadAllowed.js'\n\ninterface Args {\n  access?: UploadInstructionsAccess\n  collectionPrefix: string\n  containerName: string\n  getStorageClient: () => ContainerClient\n  useCompositePrefixes?: boolean\n}\n\nexport const generateUploadInstructions = ({\n  access,\n  collectionPrefix,\n  containerName,\n  getStorageClient,\n  useCompositePrefixes = false,\n}: Args): GenerateUploadInstructions => {\n  return async ({\n    collectionSlug,\n    docPrefix,\n    filename,\n    filesize,\n    mimeType,\n    overrideAccess,\n    req,\n  }) => {\n    if (!overrideAccess && (access ? !(await access({ collectionSlug, req })) : !req.user)) {\n      throw new Forbidden(req.t)\n    }\n\n    const collection = req.payload.collections[collectionSlug]?.config\n    if (!isClientUploadAllowed(collection)) {\n      throw new APIError(\n        'Azure client uploads require allowRestrictedFileTypes to be enabled.',\n        400,\n      )\n    }\n\n    assertClientUploadAllowed({ collection, filename, mimeType })\n\n    const { sanitizedFilename, storageFilePath, uploadReference } = await resolveSignedURLKey({\n      collectionPrefix,\n      collectionSlug,\n      docPrefix,\n      filename,\n      req,\n      useCompositePrefixes,\n    })\n\n    const blobClient = getStorageClient().getBlobClient(storageFilePath)\n\n    const sasToken = generateBlobSASQueryParameters(\n      {\n        blobName: storageFilePath,\n        containerName,\n        contentType: mimeType,\n        expiresOn: new Date(Date.now() + 3 * 60 * 60 * 1000),\n        permissions: BlobSASPermissions.parse('c'),\n        startsOn: new Date(),\n        version: '2026-04-06',\n      },\n      getStorageClient().credential as StorageSharedKeyCredential,\n    )\n\n    return {\n      name: 'uploadToAzure',\n      type: 'dispatch',\n      data: {\n        url: `${blobClient.url}?${sasToken.toString()}`,\n      },\n      file: {\n        filename: sanitizedFilename,\n        mimeType,\n        size: filesize,\n        uploadReference,\n      },\n    }\n  }\n}\n"],"names":["BlobSASPermissions","generateBlobSASQueryParameters","resolveSignedURLKey","APIError","Forbidden","assertClientUploadAllowed","isClientUploadAllowed","generateUploadInstructions","access","collectionPrefix","containerName","getStorageClient","useCompositePrefixes","collectionSlug","docPrefix","filename","filesize","mimeType","overrideAccess","req","user","t","collection","payload","collections","config","sanitizedFilename","storageFilePath","uploadReference","blobClient","getBlobClient","sasToken","blobName","contentType","expiresOn","Date","now","permissions","parse","startsOn","version","credential","name","type","data","url","toString","file","size"],"mappings":"AAGA,SAASA,kBAAkB,EAAEC,8BAA8B,QAAQ,sBAAqB;AACxF,SAASC,mBAAmB,QAAQ,6CAA4C;AAChF,SAASC,QAAQ,EAAEC,SAAS,QAAQ,UAAS;AAC7C,SAASC,yBAAyB,QAAQ,mBAAkB;AAE5D,SAASC,qBAAqB,QAAQ,6BAA4B;AAUlE,OAAO,MAAMC,6BAA6B,CAAC,EACzCC,MAAM,EACNC,gBAAgB,EAChBC,aAAa,EACbC,gBAAgB,EAChBC,uBAAuB,KAAK,EACvB;IACL,OAAO,OAAO,EACZC,cAAc,EACdC,SAAS,EACTC,QAAQ,EACRC,QAAQ,EACRC,QAAQ,EACRC,cAAc,EACdC,GAAG,EACJ;QACC,IAAI,CAACD,kBAAmBV,CAAAA,SAAS,CAAE,MAAMA,OAAO;YAAEK;YAAgBM;QAAI,KAAM,CAACA,IAAIC,IAAI,AAAD,GAAI;YACtF,MAAM,IAAIhB,UAAUe,IAAIE,CAAC;QAC3B;QAEA,MAAMC,aAAaH,IAAII,OAAO,CAACC,WAAW,CAACX,eAAe,EAAEY;QAC5D,IAAI,CAACnB,sBAAsBgB,aAAa;YACtC,MAAM,IAAInB,SACR,wEACA;QAEJ;QAEAE,0BAA0B;YAAEiB;YAAYP;YAAUE;QAAS;QAE3D,MAAM,EAAES,iBAAiB,EAAEC,eAAe,EAAEC,eAAe,EAAE,GAAG,MAAM1B,oBAAoB;YACxFO;YACAI;YACAC;YACAC;YACAI;YACAP;QACF;QAEA,MAAMiB,aAAalB,mBAAmBmB,aAAa,CAACH;QAEpD,MAAMI,WAAW9B,+BACf;YACE+B,UAAUL;YACVjB;YACAuB,aAAahB;YACbiB,WAAW,IAAIC,KAAKA,KAAKC,GAAG,KAAK,IAAI,KAAK,KAAK;YAC/CC,aAAarC,mBAAmBsC,KAAK,CAAC;YACtCC,UAAU,IAAIJ;YACdK,SAAS;QACX,GACA7B,mBAAmB8B,UAAU;QAG/B,OAAO;YACLC,MAAM;YACNC,MAAM;YACNC,MAAM;gBACJC,KAAK,GAAGhB,WAAWgB,GAAG,CAAC,CAAC,EAAEd,SAASe,QAAQ,IAAI;YACjD;YACAC,MAAM;gBACJhC,UAAUW;gBACVT;gBACA+B,MAAMhC;gBACNY;YACF;QACF;IACF;AACF,EAAC"}

package/dist/getFile.d.ts

@@ -1,16 +1,17 @@
 import type { ContainerClient } from '@azure/storage-blob';
-import type { CollectionConfig, PayloadRequest, TypeWithID } from 'payload';
+import type { CollectionConfig, FileHandlerOperation, PayloadRequest, TypeWithID } from 'payload';
 interface GetFileArgs {
     client: ContainerClient;
-    clientUploadContext?: unknown;
     collection: CollectionConfig;
     collectionPrefix?: string;
     doc?: TypeWithID;
     filename: string;
     incomingHeaders?: Headers;
+    operation?: FileHandlerOperation;
     req: PayloadRequest;
+    uploadReference?: unknown;
     useCompositePrefixes?: boolean;
 }
-export declare function getFile({ client, clientUploadContext, collection, collectionPrefix, doc, filename, incomingHeaders, req, useCompositePrefixes, }: GetFileArgs): Promise<Response>;
+export declare function getFile({ client, collection, collectionPrefix, doc, filename, incomingHeaders, operation, req, uploadReference, useCompositePrefixes, }: GetFileArgs): Promise<Response>;
 export {};
 //# sourceMappingURL=getFile.d.ts.map

package/dist/getFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getFile.d.ts","sourceRoot":"","sources":["../src/getFile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA8B,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACtF,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAW3E,UAAU,WAAW;IACnB,MAAM,EAAE,eAAe,CAAA;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,UAAU,EAAE,gBAAgB,CAAA;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,GAAG,CAAC,EAAE,UAAU,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,GAAG,EAAE,cAAc,CAAA;IACnB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAgCD,wBAAsB,OAAO,CAAC,EAC5B,MAAM,EACN,mBAAmB,EACnB,UAAU,EACV,gBAAqB,EACrB,GAAG,EACH,QAAQ,EACR,eAAe,EACf,GAAG,EACH,oBAA4B,GAC7B,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAkHjC"}
+{"version":3,"file":"getFile.d.ts","sourceRoot":"","sources":["../src/getFile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA8B,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACtF,OAAO,KAAK,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAUjG,UAAU,WAAW;IACnB,MAAM,EAAE,eAAe,CAAA;IACvB,UAAU,EAAE,gBAAgB,CAAA;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,GAAG,CAAC,EAAE,UAAU,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,SAAS,CAAC,EAAE,oBAAoB,CAAA;IAChC,GAAG,EAAE,cAAc,CAAA;IACnB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAgCD,wBAAsB,OAAO,CAAC,EAC5B,MAAM,EACN,UAAU,EACV,gBAAqB,EACrB,GAAG,EACH,QAAQ,EACR,eAAe,EACf,SAAkB,EAClB,GAAG,EACH,eAAe,EACf,oBAA4B,GAC7B,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAsHjC"}