opennextjs-azure 0.1.3 → 0.2.0

package/dist/overrides/incrementalCache/azure-blob.js

@@ -1,6 +1,9 @@
-import { BlobServiceClient } from '@azure/storage-blob';
+import { BlobServiceClient, StorageSharedKeyCredential } from '@azure/storage-blob';
 import { getAzureConfig } from '../../config/index.js';
 
+const BLOB_RETRY_OPTIONS = {
+  retryOptions: { maxTries: 3, retryDelayInMs: 300, maxRetryDelayInMs: 2e3, tryTimeoutInMs: 1e4 }
+};
 class AzureBlobIncrementalCache {
   name = "azure-blob";
   containerClient;
@@ -9,27 +12,33 @@ class AzureBlobIncrementalCache {
     const connectionString = storage.connectionString;
     const accountName = storage.accountName;
     const accountKey = storage.accountKey;
+    const clientOptions = BLOB_RETRY_OPTIONS;
     if (connectionString) {
-      const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
+      const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString, clientOptions);
       this.containerClient = blobServiceClient.getContainerClient(storage.containerName || "nextjs-cache");
     } else if (accountName && accountKey) {
-      const blobServiceClient = new BlobServiceClient(`https://${accountName}.blob.core.windows.net`, {
-        accountName,
-        accountKey
-      });
+      const credential = new StorageSharedKeyCredential(accountName, accountKey);
+      const blobServiceClient = new BlobServiceClient(
+        `https://${accountName}.blob.core.windows.net`,
+        credential,
+        clientOptions
+      );
       this.containerClient = blobServiceClient.getContainerClient(storage.containerName || "nextjs-cache");
     }
   }
   /**
    * Builds the blob key path, mimicking S3 structure:
    * [prefix]/[__fetch]/[buildId]/[key].[extension]
+   *
+   * Keys must match the .open-next/cache layout the seeder uploads, so no
+   * container-name prefix and no leading slash.
    */
   buildBlobKey(key, cacheType = "cache") {
-    const { storage } = getAzureConfig();
     const { NEXT_BUILD_ID } = process.env;
-    const prefix = storage.containerName || "";
+    const prefix = process.env.AZURE_CACHE_KEY_PREFIX || "";
     const type = cacheType === "fetch" ? "__fetch" : "";
-    return [prefix, type, NEXT_BUILD_ID, cacheType === "fetch" ? key : `${key}.${cacheType}`].filter(Boolean).join("/");
+    const cleanKey = key.replace(/^\/+/, "");
+    return [prefix, type, NEXT_BUILD_ID, cacheType === "fetch" ? cleanKey : `${cleanKey}.${cacheType}`].filter(Boolean).join("/");
   }
   async get(key, cacheType) {
     try {
@@ -63,7 +72,7 @@ class AzureBlobIncrementalCache {
       const blobKey = this.buildBlobKey(key, cacheType);
       const blobClient = this.containerClient.getBlockBlobClient(blobKey);
       const content = JSON.stringify(value);
-      await blobClient.upload(content, content.length, {
+      await blobClient.upload(content, Buffer.byteLength(content), {
         blobHTTPHeaders: {
           blobContentType: "application/json"
         }
@@ -86,4 +95,4 @@ class AzureBlobIncrementalCache {
   }
 }
 
-export { AzureBlobIncrementalCache as default };
+export { BLOB_RETRY_OPTIONS, AzureBlobIncrementalCache as default };

package/dist/overrides/tagCache/azure-table.d.mts

@@ -16,11 +16,34 @@ declare class AzureTableTagCache implements OriginalTagCache {
     name: string;
     private tableClient;
     constructor();
+    /**
+     * Keys arrive from Next with a leading slash ("/isr") while seeded rows
+     * use posix-joined values ("<buildId>/isr") — strip it so both sides
+     * land on the same key, matching the blob cache's normalization.
+     */
     private buildKey;
+    /**
+     * Reverse-index partition key for a path. Every tag/path pair is written
+     * twice, (PK=tag, RK=path) and (PK=path#..., RK=tag), so getByPath and
+     * getLastModified are partition queries. Azure Tables' only index is
+     * PartitionKey+RowKey; a RowKey-only filter scans every partition, one
+     * round trip per 1,000 rows.
+     */
+    private buildPathKey;
+    private stripBuildId;
+    /** Escapes a value for interpolation into an OData filter string literal. */
+    private odataEscape;
     getByTag(tag: string): Promise<string[]>;
     getByPath(path: string): Promise<string[]>;
     getLastModified(path: string, lastModified?: number): Promise<number>;
     writeTags(tags: OriginalTagCacheWriteInput[]): Promise<void>;
 }
+/**
+ * Azure Table Storage forbids '/', '\', '#', '?' and control characters in
+ * PartitionKey/RowKey. Percent-encodes the forbidden set (plus '%' itself so
+ * decoding is unambiguous). Exported for the deploy-time table seeder.
+ */
+declare function encodeTableKey(part: string): string;
+declare function decodeTableKey(part: string): string;
 
-export { AzureTableTagCache as default };
+export { decodeTableKey, AzureTableTagCache as default, encodeTableKey };

package/dist/overrides/tagCache/azure-table.d.ts

@@ -16,11 +16,34 @@ declare class AzureTableTagCache implements OriginalTagCache {
     name: string;
     private tableClient;
     constructor();
+    /**
+     * Keys arrive from Next with a leading slash ("/isr") while seeded rows
+     * use posix-joined values ("<buildId>/isr") — strip it so both sides
+     * land on the same key, matching the blob cache's normalization.
+     */
     private buildKey;
+    /**
+     * Reverse-index partition key for a path. Every tag/path pair is written
+     * twice, (PK=tag, RK=path) and (PK=path#..., RK=tag), so getByPath and
+     * getLastModified are partition queries. Azure Tables' only index is
+     * PartitionKey+RowKey; a RowKey-only filter scans every partition, one
+     * round trip per 1,000 rows.
+     */
+    private buildPathKey;
+    private stripBuildId;
+    /** Escapes a value for interpolation into an OData filter string literal. */
+    private odataEscape;
     getByTag(tag: string): Promise<string[]>;
     getByPath(path: string): Promise<string[]>;
     getLastModified(path: string, lastModified?: number): Promise<number>;
     writeTags(tags: OriginalTagCacheWriteInput[]): Promise<void>;
 }
+/**
+ * Azure Table Storage forbids '/', '\', '#', '?' and control characters in
+ * PartitionKey/RowKey. Percent-encodes the forbidden set (plus '%' itself so
+ * decoding is unambiguous). Exported for the deploy-time table seeder.
+ */
+declare function encodeTableKey(part: string): string;
+declare function decodeTableKey(part: string): string;
 
-export { AzureTableTagCache as default };
+export { decodeTableKey, AzureTableTagCache as default, encodeTableKey };

package/dist/overrides/tagCache/azure-table.js

@@ -11,29 +11,59 @@ class AzureTableTagCache {
     const accountName = storage.accountName;
     const accountKey = storage.accountKey;
     const tableName = storage.tableName || "nextjstags";
+    const clientOptions = {
+      retryOptions: { maxRetries: 3, maxRetryDelayInMs: 2e3 }
+    };
     if (connectionString) {
-      this.tableClient = TableClient.fromConnectionString(connectionString, tableName);
+      this.tableClient = TableClient.fromConnectionString(connectionString, tableName, clientOptions);
     } else if (accountName && accountKey) {
       const credential = new AzureNamedKeyCredential(accountName, accountKey);
-      this.tableClient = new TableClient(`https://${accountName}.table.core.windows.net`, tableName, credential);
+      this.tableClient = new TableClient(
+        `https://${accountName}.table.core.windows.net`,
+        tableName,
+        credential,
+        clientOptions
+      );
     }
   }
+  /**
+   * Keys arrive from Next with a leading slash ("/isr") while seeded rows
+   * use posix-joined values ("<buildId>/isr") — strip it so both sides
+   * land on the same key, matching the blob cache's normalization.
+   */
   buildKey(key) {
     const { NEXT_BUILD_ID } = process.env;
-    return `${NEXT_BUILD_ID}/${key}`;
+    return encodeTableKey(`${NEXT_BUILD_ID}/${key.replace(/^\/+/, "")}`);
+  }
+  /**
+   * Reverse-index partition key for a path. Every tag/path pair is written
+   * twice, (PK=tag, RK=path) and (PK=path#..., RK=tag), so getByPath and
+   * getLastModified are partition queries. Azure Tables' only index is
+   * PartitionKey+RowKey; a RowKey-only filter scans every partition, one
+   * round trip per 1,000 rows.
+   */
+  buildPathKey(path) {
+    const { NEXT_BUILD_ID } = process.env;
+    return encodeTableKey(`path#${NEXT_BUILD_ID}/${path.replace(/^\/+/, "")}`);
+  }
+  stripBuildId(encodedKey) {
+    const { NEXT_BUILD_ID } = process.env;
+    return decodeTableKey(encodedKey).replace(`${NEXT_BUILD_ID}/`, "");
+  }
+  /** Escapes a value for interpolation into an OData filter string literal. */
+  odataEscape(value) {
+    return value.replace(/'/g, "''");
   }
   async getByTag(tag) {
     try {
       const queryKey = this.buildKey(tag);
       const entities = this.tableClient.listEntities({
-        queryOptions: { filter: `PartitionKey eq '${queryKey}'` }
+        queryOptions: { filter: `PartitionKey eq '${this.odataEscape(queryKey)}'` }
       });
       const paths = [];
       for await (const entity of entities) {
         if (entity.rowKey) {
-          const { NEXT_BUILD_ID } = process.env;
-          const path = entity.rowKey.toString().replace(`${NEXT_BUILD_ID}/`, "");
-          paths.push(path);
+          paths.push(this.stripBuildId(entity.rowKey.toString()));
         }
       }
       return paths;
@@ -45,16 +75,14 @@ class AzureTableTagCache {
   }
   async getByPath(path) {
     try {
-      const queryKey = this.buildKey(path);
+      const pathKey = this.buildPathKey(path);
       const entities = this.tableClient.listEntities({
-        queryOptions: { filter: `RowKey eq '${queryKey}'` }
+        queryOptions: { filter: `PartitionKey eq '${this.odataEscape(pathKey)}'` }
       });
       const tags = [];
       for await (const entity of entities) {
-        if (entity.partitionKey) {
-          const { NEXT_BUILD_ID: buildId } = process.env;
-          const tag = entity.partitionKey.toString().replace(`${buildId}/`, "");
-          tags.push(tag);
+        if (entity.rowKey) {
+          tags.push(this.stripBuildId(entity.rowKey.toString()));
         }
       }
       return tags;
@@ -66,10 +94,10 @@ class AzureTableTagCache {
   }
   async getLastModified(path, lastModified) {
     try {
-      const queryKey = this.buildKey(path);
+      const pathKey = this.buildPathKey(path);
       const entities = this.tableClient.listEntities({
         queryOptions: {
-          filter: `RowKey eq '${queryKey}' and RevalidatedAt gt ${lastModified ?? 0}L`
+          filter: `PartitionKey eq '${this.odataEscape(pathKey)}' and revalidatedAt gt ${Number(lastModified ?? 0).toFixed(1)}`
         }
       });
       for await (const entity of entities) {
@@ -85,20 +113,49 @@ class AzureTableTagCache {
     }
   }
   async writeTags(tags) {
-    try {
-      for (const { tag, path, revalidatedAt } of tags) {
-        const entity = {
-          partitionKey: this.buildKey(tag),
-          rowKey: this.buildKey(path),
-          revalidatedAt: revalidatedAt ?? Date.now()
-        };
-        await this.tableClient.upsertEntity(entity, "Merge");
-      }
-    } catch (error) {
-      process.stderr.write(`Failed to write tags to Azure Table: ${error}
+    const CONCURRENCY = 16;
+    const queue = [...tags];
+    const failures = [];
+    await Promise.all(
+      Array.from({ length: Math.min(CONCURRENCY, queue.length) }, async () => {
+        for (let pair = queue.shift(); pair; pair = queue.shift()) {
+          const { tag, path, revalidatedAt } = pair;
+          const stamp = revalidatedAt ?? Date.now();
+          try {
+            await this.tableClient.upsertEntity(
+              {
+                partitionKey: this.buildPathKey(path),
+                rowKey: this.buildKey(tag),
+                revalidatedAt: stamp
+              },
+              "Merge"
+            );
+            await this.tableClient.upsertEntity(
+              {
+                partitionKey: this.buildKey(tag),
+                rowKey: this.buildKey(path),
+                revalidatedAt: stamp
+              },
+              "Merge"
+            );
+          } catch (error) {
+            failures.push(error);
+          }
+        }
+      })
+    );
+    if (failures.length > 0) {
+      process.stderr.write(`Failed to write ${failures.length}/${tags.length} tag pairs to Azure Table: ${failures[0]}
 `);
+      throw failures[0];
     }
   }
 }
+function encodeTableKey(part) {
+  return part.replace(/[%/\\#?\u0000-\u001f\u007f-\u009f]/g, (c) => `%${c.charCodeAt(0).toString(16).padStart(2, "0")}`);
+}
+function decodeTableKey(part) {
+  return part.replace(/%([0-9a-f]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+}
 
-export { AzureTableTagCache as default };
+export { decodeTableKey, AzureTableTagCache as default, encodeTableKey };

package/infrastructure/main.bicep

@@ -136,6 +136,9 @@ resource appServicePlan 'Microsoft.Web/serverfarms@2023-01-01' = {
   kind: 'functionapp'
   properties: {
     reserved: true // Linux
+    // Elastic Premium defaults to a max of 1 worker when this is omitted,
+    // which pins the prod plan to a single instance. Y1 ignores it.
+    maximumElasticWorkerCount: environment == 'prod' ? 20 : 1
   }
 }
 
@@ -170,12 +173,10 @@ resource functionApp 'Microsoft.Web/sites@2023-01-01' = {
           value: 'node'
         }
         {
-          name: 'WEBSITE_NODE_DEFAULT_VERSION'
-          value: '~${nodeVersion}'
-        }
-        {
-          name: 'WEBSITE_RUN_FROM_PACKAGE'
-          value: '1'
+          // A second worker process buys resilience to GC stalls; SSR is
+          // single-threaded per worker. Memory-bounded on Y1 (1.5 GB).
+          name: 'FUNCTIONS_WORKER_PROCESS_COUNT'
+          value: '2'
         }
         {
           name: 'AzureWebJobsDisableHomepage'
@@ -223,6 +224,12 @@ resource functionApp 'Microsoft.Web/sites@2023-01-01' = {
       
       ftpsState: 'Disabled'
       minTlsVersion: '1.2'
+      // Always-ready SSR on Elastic Premium; both stay null on Y1.
+      // WEBSITE_RUN_FROM_PACKAGE is deliberately absent: '1' is unsupported
+      // on Linux Consumption, and the deploy step sets the blob-URL form
+      // that provisioning must not overwrite.
+      minimumElasticInstanceCount: environment == 'prod' ? 1 : null
+      preWarmedInstanceCount: environment == 'prod' ? 1 : null
       cors: {
         allowedOrigins: ['*']
       }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "opennextjs-azure",
-    "version": "0.1.3",
+    "version": "0.2.0",
     "description": "True serverless Next.js on Azure Functions with a Vercel-grade developer experience",
     "type": "module",
     "main": "./dist/index.js",
@@ -38,6 +38,14 @@
         "./overrides/queue/azure-queue.js": {
             "import": "./dist/overrides/queue/azure-queue.js",
             "types": "./dist/overrides/queue/azure-queue.d.ts"
+        },
+        "./adapters/wrappers/azure-queue-revalidate.js": {
+            "import": "./dist/adapters/wrappers/azure-queue-revalidate.js",
+            "types": "./dist/adapters/wrappers/azure-queue-revalidate.d.ts"
+        },
+        "./adapters/converters/azure-queue-revalidate.js": {
+            "import": "./dist/adapters/converters/azure-queue-revalidate.js",
+            "types": "./dist/adapters/converters/azure-queue-revalidate.d.ts"
         }
     },
     "files": [
@@ -49,9 +57,10 @@
         "dev": "unbuild --stub",
         "clean": "rimraf dist",
         "lint": "eslint src --ext .ts",
-        "test": "vitest",
+        "test": "vitest run",
         "typecheck": "tsc --noEmit",
-        "format": "prettier --write ."
+        "format": "prettier --write .",
+        "test:watch": "vitest"
     },
     "keywords": [
         "nextjs",
@@ -93,6 +102,6 @@
         "next": ">=13.4.0"
     },
     "engines": {
-        "node": ">=18.0.0"
+        "node": ">=20.0.0"
     }
 }

package/dist/adapters/image-optimization.d.mts

@@ -1,20 +0,0 @@
-import { InternalEvent, InternalResult } from '@opennextjs/aws/types/open-next.js';
-import { OpenNextHandler, OpenNextHandlerOptions } from '@opennextjs/aws/types/overrides.js';
-
-/**
- * Azure Image Optimization Handler
- *
- * Wraps OpenNext's default image optimization handler with Azure Blob caching.
- *
- * When AZURE_IMAGE_OPTIMIZATION_CACHE=true:
- *   - First request: Loads from "assets", processes, caches in "optimized-images", returns
- *   - Subsequent requests: Returns from "optimized-images" cache (no processing)
- *
- * When AZURE_IMAGE_OPTIMIZATION_CACHE=false:
- *   - Every request processes the image (no caching)
- */
-declare function createImageOptimizationHandler(): Promise<OpenNextHandler<InternalEvent, InternalResult>>;
-declare const handler: OpenNextHandler<InternalEvent, InternalResult>;
-declare function defaultHandler(event: InternalEvent, options?: OpenNextHandlerOptions): Promise<InternalResult>;
-
-export { createImageOptimizationHandler, defaultHandler, handler };

package/dist/adapters/image-optimization.d.ts

@@ -1,20 +0,0 @@
-import { InternalEvent, InternalResult } from '@opennextjs/aws/types/open-next.js';
-import { OpenNextHandler, OpenNextHandlerOptions } from '@opennextjs/aws/types/overrides.js';
-
-/**
- * Azure Image Optimization Handler
- *
- * Wraps OpenNext's default image optimization handler with Azure Blob caching.
- *
- * When AZURE_IMAGE_OPTIMIZATION_CACHE=true:
- *   - First request: Loads from "assets", processes, caches in "optimized-images", returns
- *   - Subsequent requests: Returns from "optimized-images" cache (no processing)
- *
- * When AZURE_IMAGE_OPTIMIZATION_CACHE=false:
- *   - Every request processes the image (no caching)
- */
-declare function createImageOptimizationHandler(): Promise<OpenNextHandler<InternalEvent, InternalResult>>;
-declare const handler: OpenNextHandler<InternalEvent, InternalResult>;
-declare function defaultHandler(event: InternalEvent, options?: OpenNextHandlerOptions): Promise<InternalResult>;
-
-export { createImageOptimizationHandler, defaultHandler, handler };

package/dist/adapters/image-optimization.js

@@ -1,11 +0,0 @@
-async function createImageOptimizationHandler() {
-  const { defaultHandler: defaultHandler2 } = await import('@opennextjs/aws/adapters/image-optimization-adapter.js');
-  const { createCachedImageOptimizationHandler } = await import('../overrides/imageOptimization/azure-cached.js');
-  return createCachedImageOptimizationHandler(defaultHandler2);
-}
-const handler = await createImageOptimizationHandler();
-async function defaultHandler(event, options) {
-  return handler(event, options);
-}
-
-export { createImageOptimizationHandler, defaultHandler, handler };

package/dist/overrides/imageOptimization/azure-cached.d.mts

@@ -1,6 +0,0 @@
-import { InternalEvent, InternalResult } from '@opennextjs/aws/types/open-next.js';
-import { OpenNextHandler } from '@opennextjs/aws/types/overrides.js';
-
-declare function createCachedImageOptimizationHandler(defaultHandler: OpenNextHandler<InternalEvent, InternalResult>): OpenNextHandler<InternalEvent, InternalResult>;
-
-export { createCachedImageOptimizationHandler };

package/dist/overrides/imageOptimization/azure-cached.d.ts

@@ -1,6 +0,0 @@
-import { InternalEvent, InternalResult } from '@opennextjs/aws/types/open-next.js';
-import { OpenNextHandler } from '@opennextjs/aws/types/overrides.js';
-
-declare function createCachedImageOptimizationHandler(defaultHandler: OpenNextHandler<InternalEvent, InternalResult>): OpenNextHandler<InternalEvent, InternalResult>;
-
-export { createCachedImageOptimizationHandler };

package/dist/overrides/imageOptimization/azure-cached.js

@@ -1,115 +0,0 @@
-import { createHash } from 'node:crypto';
-import { BlobServiceClient } from '@azure/storage-blob';
-import { ReadableStream } from 'node:stream/web';
-
-const { AZURE_STORAGE_CONNECTION_STRING, AZURE_STORAGE_ACCOUNT_NAME } = process.env;
-const CACHE_CONTAINER = "optimized-images";
-function getBlobClient(key) {
-  if (!AZURE_STORAGE_CONNECTION_STRING && !AZURE_STORAGE_ACCOUNT_NAME) {
-    throw new Error("Azure Storage connection string or account name must be defined");
-  }
-  const blobServiceClient = AZURE_STORAGE_CONNECTION_STRING ? BlobServiceClient.fromConnectionString(AZURE_STORAGE_CONNECTION_STRING) : new BlobServiceClient(`https://${AZURE_STORAGE_ACCOUNT_NAME}.blob.core.windows.net`);
-  const containerClient = blobServiceClient.getContainerClient(CACHE_CONTAINER);
-  return containerClient.getBlockBlobClient(key);
-}
-function computeCacheKey(event) {
-  const { query } = event;
-  const url = Array.isArray(query?.url) ? query.url[0] : query?.url || "";
-  const width = Array.isArray(query?.w) ? query.w[0] : query?.w || "0";
-  const quality = Array.isArray(query?.q) ? query.q[0] : query?.q || "75";
-  const hash = createHash("sha256").update(url).digest("hex").substring(0, 16);
-  return `${hash}/w${width}_q${quality}.cache`;
-}
-async function getCachedImage(cacheKey) {
-  try {
-    const blobClient = getBlobClient(cacheKey);
-    const exists = await blobClient.exists();
-    if (!exists) {
-      return null;
-    }
-    const downloadResponse = await blobClient.download();
-    const properties = await blobClient.getProperties();
-    if (!downloadResponse.readableStreamBody) {
-      return null;
-    }
-    const chunks = [];
-    for await (const chunk of downloadResponse.readableStreamBody) {
-      chunks.push(Buffer.from(chunk));
-    }
-    const buffer = Buffer.concat(chunks);
-    return {
-      type: "core",
-      statusCode: 200,
-      headers: {
-        "Content-Type": properties.contentType || "image/webp",
-        "Cache-Control": properties.cacheControl || "public,max-age=31536000,immutable",
-        Vary: "Accept"
-      },
-      body: new ReadableStream({
-        start(controller) {
-          controller.enqueue(buffer);
-          controller.close();
-        }
-      }),
-      isBase64Encoded: true
-    };
-  } catch (error) {
-    return null;
-  }
-}
-async function setCachedImage(cacheKey, result) {
-  try {
-    if (!result.body) {
-      return;
-    }
-    const chunks = [];
-    for await (const chunk of result.body) {
-      chunks.push(Buffer.from(chunk));
-    }
-    const buffer = Buffer.concat(chunks);
-    const blobClient = getBlobClient(cacheKey);
-    const contentTypeRaw = result.headers?.["Content-Type"] || result.headers?.["content-type"];
-    const contentType = Array.isArray(contentTypeRaw) ? contentTypeRaw[0] : contentTypeRaw || "image/webp";
-    const cacheControlRaw = result.headers?.["Cache-Control"] || result.headers?.["cache-control"];
-    const cacheControl = Array.isArray(cacheControlRaw) ? cacheControlRaw[0] : cacheControlRaw || "public,max-age=31536000,immutable";
-    await blobClient.upload(buffer, buffer.length, {
-      blobHTTPHeaders: {
-        blobContentType: contentType,
-        blobCacheControl: cacheControl
-      }
-    });
-  } catch (error) {
-    console.error("Failed to cache optimized image:", error);
-  }
-}
-function createCachedImageOptimizationHandler(defaultHandler) {
-  return async (event, options) => {
-    const cacheKey = computeCacheKey(event);
-    const cached = await getCachedImage(cacheKey);
-    if (cached) {
-      return cached;
-    }
-    const result = await defaultHandler(event, options);
-    if (result.statusCode === 200 && result.body) {
-      const chunks = [];
-      for await (const chunk of result.body) {
-        chunks.push(Buffer.from(chunk));
-      }
-      const buffer = Buffer.concat(chunks);
-      const resultWithBuffer = {
-        ...result,
-        body: new ReadableStream({
-          start(controller) {
-            controller.enqueue(buffer);
-            controller.close();
-          }
-        })
-      };
-      await setCachedImage(cacheKey, resultWithBuffer);
-      return resultWithBuffer;
-    }
-    return result;
-  };
-}
-
-export { createCachedImageOptimizationHandler };