@opennextjs/cloudflare 1.9.2 → 1.10.0

package/dist/api/cloudflare-context.js

@@ -143,6 +143,10 @@ async function getCloudflareContextFromWrangler(options) {
     const environment = options?.environment ?? process.env.NEXT_DEV_WRANGLER_ENV;
     const { env, cf, ctx } = await getPlatformProxy({
         ...options,
+        // The `env` passed to the fetch handler does not contain variables from `.env*` files.
+        // because we invoke wrangler with `CLOUDFLARE_LOAD_DEV_VARS_FROM_DOT_ENV`=`"false"`.
+        // Initializing `envFiles` with an empty list is the equivalent for this API call.
+        envFiles: [],
         environment,
     });
     return {

package/dist/cli/build/patches/plugins/require-hook.js

@@ -1,12 +1,13 @@
 import { join } from "node:path";
 import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
 export function shimRequireHook(options) {
+    const emptyShimPath = join(options.outputDir, "cloudflare-templates/shims/empty.js");
     return {
         name: "replaceRelative",
         setup(build) {
             // Note: we (empty) shim require-hook modules as they generate problematic code that uses requires
             build.onResolve({ filter: getCrossPlatformPathRegex(String.raw `^\./require-hook$`, { escape: false }) }, () => ({
-                path: join(options.outputDir, "cloudflare-templates/shims/empty.js"),
+                path: emptyShimPath,
             }));
         },
     };

package/dist/cli/build/utils/extract-project-env-vars.js

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { parse } from "@dotenvx/dotenvx";
 function readEnvFile(filePath) {
     if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
-        return parse(fs.readFileSync(filePath).toString());
+        return parse(fs.readFileSync(filePath, "utf-8"));
     }
 }
 /**

package/dist/cli/commands/deploy.js

@@ -12,21 +12,18 @@ import { getNormalizedOptions, printHeaders, readWranglerConfig, retrieveCompile
 export async function deployCommand(args) {
     printHeaders("deploy");
     const { config } = await retrieveCompiledConfig();
-    const options = getNormalizedOptions(config);
+    const buildOpts = getNormalizedOptions(config);
     const wranglerConfig = readWranglerConfig(args);
-    const envVars = await getEnvFromPlatformProxy({
-        configPath: args.wranglerConfigPath,
-        environment: args.env,
-    });
-    const deploymentMapping = await getDeploymentMapping(options, config, envVars);
-    await populateCache(options, config, wranglerConfig, {
+    const envVars = await getEnvFromPlatformProxy(config, buildOpts);
+    await populateCache(buildOpts, config, wranglerConfig, {
         target: "remote",
         environment: args.env,
         wranglerConfigPath: args.wranglerConfigPath,
         cacheChunkSize: args.cacheChunkSize,
         shouldUsePreviewId: false,
-    });
-    runWrangler(options, [
+    }, envVars);
+    const deploymentMapping = await getDeploymentMapping(buildOpts, config, envVars);
+    runWrangler(buildOpts, [
         "deploy",
         ...args.wranglerArgs,
         ...(deploymentMapping

package/dist/cli/commands/helpers.d.ts

@@ -1,12 +1,36 @@
+import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
 import { type GetPlatformProxyOptions } from "wrangler";
 export type WorkerEnvVar = Record<keyof CloudflareEnv, string | undefined>;
 /**
- * Return the string env vars from the worker.
+ * Returns the env vars to use by the CLI.
+ *
+ * The environments variables are returned from a combination of `process.env`, wrangler config, and `.env*` files.
+ *
+ * Recommended usage on CI:
+ *
+ * - Add you secrets to `process.env` (i.e. `CF_ACCOUNT_ID`)
+ * - Add public values to the wrangler config `wrangler.jsonc` (i.e. `R2_CACHE_PREFIX_ENV_NAME`)
+ *
+ * Note: `.dev.vars*` and `.env*` should not be checked in.
+ *
+ * Recommended usage for local dev:
+ *
+ * - Add you secrets to either a `.dev.vars*` or `.env*` file (i.e. `CF_ACCOUNT_ID`)
+ * - Add public values to the wrangler config `wrangler.jsonc` (i.e. `R2_CACHE_PREFIX_ENV_NAME`)
+ *
+ * Note: `.env*` files are also used by `next dev` while `.dev.var*` files are only loaded by `wrangler`.
+ *
+ * Loading details:
+ *
+ * 1. The variables are first initialized from `process.env`
+ * 2. They are then augmented/replaced with variables from the wrangler config (`wrangler.jsonc` and `.dev.vars*`)
+ * 3. They are then augmented with variables from `.env*` files (existing values are not replaced).
  *
  * @param options Options to pass to `getPlatformProxy`, i.e. to set the environment
+ * @param buildOpts Open Next build options
  * @returns the env vars
  */
-export declare function getEnvFromPlatformProxy(options: GetPlatformProxyOptions): Promise<WorkerEnvVar>;
+export declare function getEnvFromPlatformProxy(options: GetPlatformProxyOptions, buildOpts: BuildOptions): Promise<WorkerEnvVar>;
 /**
  * Escape shell metacharacters.
  *

package/dist/cli/commands/helpers.js

@@ -1,19 +1,63 @@
 import { getPlatformProxy } from "wrangler";
+import { extractProjectEnvVars } from "../build/utils/extract-project-env-vars.js";
 /**
- * Return the string env vars from the worker.
+ * Returns the env vars to use by the CLI.
+ *
+ * The environments variables are returned from a combination of `process.env`, wrangler config, and `.env*` files.
+ *
+ * Recommended usage on CI:
+ *
+ * - Add you secrets to `process.env` (i.e. `CF_ACCOUNT_ID`)
+ * - Add public values to the wrangler config `wrangler.jsonc` (i.e. `R2_CACHE_PREFIX_ENV_NAME`)
+ *
+ * Note: `.dev.vars*` and `.env*` should not be checked in.
+ *
+ * Recommended usage for local dev:
+ *
+ * - Add you secrets to either a `.dev.vars*` or `.env*` file (i.e. `CF_ACCOUNT_ID`)
+ * - Add public values to the wrangler config `wrangler.jsonc` (i.e. `R2_CACHE_PREFIX_ENV_NAME`)
+ *
+ * Note: `.env*` files are also used by `next dev` while `.dev.var*` files are only loaded by `wrangler`.
+ *
+ * Loading details:
+ *
+ * 1. The variables are first initialized from `process.env`
+ * 2. They are then augmented/replaced with variables from the wrangler config (`wrangler.jsonc` and `.dev.vars*`)
+ * 3. They are then augmented with variables from `.env*` files (existing values are not replaced).
  *
  * @param options Options to pass to `getPlatformProxy`, i.e. to set the environment
+ * @param buildOpts Open Next build options
  * @returns the env vars
  */
-export async function getEnvFromPlatformProxy(options) {
-    const envVars = {};
-    const proxy = await getPlatformProxy(options);
+export async function getEnvFromPlatformProxy(options, buildOpts) {
+    // 1. Start from `process.env`
+    const envVars = process.env;
+    // 2. Apply vars from workers `env`
+    const proxy = await getPlatformProxy({
+        ...options,
+        // Next.js uses a different mechanism to load `.env*` files from wrangler.
+        // We prevent wrangler for loading the files and handle that in `getEnvFromPlatformProxy`.
+        envFiles: [],
+    });
     Object.entries(proxy.env).forEach(([key, value]) => {
         if (typeof value === "string") {
+            // filter out bindings by only considering string values
             envVars[key] = value;
         }
     });
     await proxy.dispose();
+    // 3. Apply new vars from `.env*` files
+    let mode = "production";
+    if (envVars.NEXTJS_ENV === "development") {
+        mode = "development";
+    }
+    else if (envVars.NEXTJS_ENV === "test") {
+        mode = "test";
+    }
+    const dotEnvVars = extractProjectEnvVars(mode, buildOpts);
+    for (const varName in dotEnvVars) {
+        envVars[varName] ??= dotEnvVars[varName];
+    }
     return envVars;
 }
 /**

package/dist/cli/commands/populate-cache.d.ts

@@ -3,6 +3,8 @@ import type { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
 import type { Unstable_Config as WranglerConfig } from "wrangler";
 import type yargs from "yargs";
 import type { WranglerTarget } from "../utils/run-wrangler.js";
+import { type WorkerEnvVar } from "./helpers.js";
+export declare function populateCache(buildOpts: BuildOptions, config: OpenNextConfig, wranglerConfig: WranglerConfig, populateCacheOptions: PopulateCacheOptions, envVars: WorkerEnvVar): Promise<void>;
 export type CacheAsset = {
     isFetch: boolean;
     fullPath: string;
@@ -34,7 +36,6 @@ type PopulateCacheOptions = {
      */
     shouldUsePreviewId: boolean;
 };
-export declare function populateCache(options: BuildOptions, config: OpenNextConfig, wranglerConfig: WranglerConfig, populateCacheOptions: PopulateCacheOptions): Promise<void>;
 /**
  * Add the `populateCache` command to yargs configuration, with nested commands for `local` and `remote`.
  *

package/dist/cli/commands/populate-cache.js

@@ -12,6 +12,58 @@ import { normalizePath } from "../build/utils/normalize-path.js";
 import { runWrangler } from "../utils/run-wrangler.js";
 import { getEnvFromPlatformProxy, quoteShellMeta } from "./helpers.js";
 import { getNormalizedOptions, printHeaders, readWranglerConfig, retrieveCompiledConfig, withWranglerOptions, withWranglerPassthroughArgs, } from "./utils.js";
+/**
+ * Implementation of the `opennextjs-cloudflare populateCache` command.
+ *
+ * @param args
+ */
+async function populateCacheCommand(target, args) {
+    printHeaders(`populate cache - ${target}`);
+    const { config } = await retrieveCompiledConfig();
+    const buildOpts = getNormalizedOptions(config);
+    const wranglerConfig = readWranglerConfig(args);
+    const envVars = await getEnvFromPlatformProxy(config, buildOpts);
+    await populateCache(buildOpts, config, wranglerConfig, {
+        target,
+        environment: args.env,
+        wranglerConfigPath: args.wranglerConfigPath,
+        cacheChunkSize: args.cacheChunkSize,
+        shouldUsePreviewId: false,
+    }, envVars);
+}
+export async function populateCache(buildOpts, config, wranglerConfig, populateCacheOptions, envVars) {
+    const { incrementalCache, tagCache } = config.default.override ?? {};
+    if (!existsSync(buildOpts.outputDir)) {
+        logger.error("Unable to populate cache: Open Next build not found");
+        process.exit(1);
+    }
+    if (!config.dangerous?.disableIncrementalCache && incrementalCache) {
+        const name = await resolveCacheName(incrementalCache);
+        switch (name) {
+            case R2_CACHE_NAME:
+                await populateR2IncrementalCache(buildOpts, wranglerConfig, populateCacheOptions, envVars);
+                break;
+            case KV_CACHE_NAME:
+                await populateKVIncrementalCache(buildOpts, wranglerConfig, populateCacheOptions, envVars);
+                break;
+            case STATIC_ASSETS_CACHE_NAME:
+                populateStaticAssetsIncrementalCache(buildOpts);
+                break;
+            default:
+                logger.info("Incremental cache does not need populating");
+        }
+    }
+    if (!config.dangerous?.disableTagCache && !config.dangerous?.disableIncrementalCache && tagCache) {
+        const name = await resolveCacheName(tagCache);
+        switch (name) {
+            case D1_TAG_NAME:
+                populateD1TagCache(buildOpts, wranglerConfig, populateCacheOptions);
+                break;
+            default:
+                logger.info("Tag cache does not need populating");
+        }
+    }
+}
 async function resolveCacheName(value) {
     return typeof value === "function" ? (await value()).name : value;
 }
@@ -51,7 +103,7 @@ export function getCacheAssets(opts) {
     }
     return assets;
 }
-async function populateR2IncrementalCache(options, config, populateCacheOptions) {
+async function populateR2IncrementalCache(buildOpts, config, populateCacheOptions, envVars) {
     logger.info("\nPopulating R2 incremental cache...");
     const binding = config.r2_buckets.find(({ binding }) => binding === R2_CACHE_BINDING_NAME);
     if (!binding) {
@@ -61,16 +113,15 @@ async function populateR2IncrementalCache(options, config, populateCacheOptions)
     if (!bucket) {
         throw new Error(`R2 binding ${JSON.stringify(R2_CACHE_BINDING_NAME)} should have a 'bucket_name'`);
     }
-    const envVars = await getEnvFromPlatformProxy(populateCacheOptions);
     const prefix = envVars[R2_CACHE_PREFIX_ENV_NAME];
-    const assets = getCacheAssets(options);
+    const assets = getCacheAssets(buildOpts);
     for (const { fullPath, key, buildId, isFetch } of tqdm(assets)) {
         const cacheKey = computeCacheKey(key, {
             prefix,
             buildId,
             cacheType: isFetch ? "fetch" : "cache",
         });
-        runWrangler(options, [
+        runWrangler(buildOpts, [
             "r2 object put",
             quoteShellMeta(normalizePath(path.join(bucket, cacheKey))),
             `--file ${quoteShellMeta(fullPath)}`,
@@ -85,20 +136,19 @@ async function populateR2IncrementalCache(options, config, populateCacheOptions)
     }
     logger.info(`Successfully populated cache with ${assets.length} assets`);
 }
-async function populateKVIncrementalCache(options, config, populateCacheOptions) {
+async function populateKVIncrementalCache(buildOpts, config, populateCacheOptions, envVars) {
     logger.info("\nPopulating KV incremental cache...");
     const binding = config.kv_namespaces.find(({ binding }) => binding === KV_CACHE_BINDING_NAME);
     if (!binding) {
         throw new Error(`No KV binding ${JSON.stringify(KV_CACHE_BINDING_NAME)} found!`);
     }
-    const envVars = await getEnvFromPlatformProxy(populateCacheOptions);
     const prefix = envVars[KV_CACHE_PREFIX_ENV_NAME];
-    const assets = getCacheAssets(options);
+    const assets = getCacheAssets(buildOpts);
     const chunkSize = Math.max(1, populateCacheOptions.cacheChunkSize ?? 25);
     const totalChunks = Math.ceil(assets.length / chunkSize);
     logger.info(`Inserting ${assets.length} assets to KV in chunks of ${chunkSize}`);
     for (const i of tqdm(Array.from({ length: totalChunks }, (_, i) => i))) {
-        const chunkPath = path.join(options.outputDir, "cloudflare", `cache-chunk-${i}.json`);
+        const chunkPath = path.join(buildOpts.outputDir, "cloudflare", `cache-chunk-${i}.json`);
         const kvMapping = assets
             .slice(i * chunkSize, (i + 1) * chunkSize)
             .map(({ fullPath, key, buildId, isFetch }) => ({
@@ -110,7 +160,7 @@ async function populateKVIncrementalCache(options, config, populateCacheOptions)
             value: readFileSync(fullPath, "utf8"),
         }));
         writeFileSync(chunkPath, JSON.stringify(kvMapping));
-        runWrangler(options, [
+        runWrangler(buildOpts, [
             "kv bulk put",
             quoteShellMeta(chunkPath),
             `--binding ${KV_CACHE_BINDING_NAME}`,
@@ -125,13 +175,13 @@ async function populateKVIncrementalCache(options, config, populateCacheOptions)
     }
     logger.info(`Successfully populated cache with ${assets.length} assets`);
 }
-function populateD1TagCache(options, config, populateCacheOptions) {
+function populateD1TagCache(buildOpts, config, populateCacheOptions) {
     logger.info("\nCreating D1 table if necessary...");
     const binding = config.d1_databases.find(({ binding }) => binding === D1_TAG_BINDING_NAME);
     if (!binding) {
         throw new Error(`No D1 binding ${JSON.stringify(D1_TAG_BINDING_NAME)} found!`);
     }
-    runWrangler(options, [
+    runWrangler(buildOpts, [
         "d1 execute",
         D1_TAG_BINDING_NAME,
         `--command "CREATE TABLE IF NOT EXISTS revalidations (tag TEXT NOT NULL, revalidatedAt INTEGER NOT NULL, UNIQUE(tag) ON CONFLICT REPLACE);"`,
@@ -149,57 +199,6 @@ function populateStaticAssetsIncrementalCache(options) {
     cpSync(path.join(options.outputDir, "cache"), path.join(options.outputDir, "assets", STATIC_ASSETS_CACHE_DIR), { recursive: true });
     logger.info(`Successfully populated static assets cache`);
 }
-export async function populateCache(options, config, wranglerConfig, populateCacheOptions) {
-    const { incrementalCache, tagCache } = config.default.override ?? {};
-    if (!existsSync(options.outputDir)) {
-        logger.error("Unable to populate cache: Open Next build not found");
-        process.exit(1);
-    }
-    if (!config.dangerous?.disableIncrementalCache && incrementalCache) {
-        const name = await resolveCacheName(incrementalCache);
-        switch (name) {
-            case R2_CACHE_NAME:
-                await populateR2IncrementalCache(options, wranglerConfig, populateCacheOptions);
-                break;
-            case KV_CACHE_NAME:
-                await populateKVIncrementalCache(options, wranglerConfig, populateCacheOptions);
-                break;
-            case STATIC_ASSETS_CACHE_NAME:
-                populateStaticAssetsIncrementalCache(options);
-                break;
-            default:
-                logger.info("Incremental cache does not need populating");
-        }
-    }
-    if (!config.dangerous?.disableTagCache && !config.dangerous?.disableIncrementalCache && tagCache) {
-        const name = await resolveCacheName(tagCache);
-        switch (name) {
-            case D1_TAG_NAME:
-                populateD1TagCache(options, wranglerConfig, populateCacheOptions);
-                break;
-            default:
-                logger.info("Tag cache does not need populating");
-        }
-    }
-}
-/**
- * Implementation of the `opennextjs-cloudflare populateCache` command.
- *
- * @param args
- */
-async function populateCacheCommand(target, args) {
-    printHeaders(`populate cache - ${target}`);
-    const { config } = await retrieveCompiledConfig();
-    const options = getNormalizedOptions(config);
-    const wranglerConfig = readWranglerConfig(args);
-    await populateCache(options, config, wranglerConfig, {
-        target,
-        environment: args.env,
-        wranglerConfigPath: args.wranglerConfigPath,
-        cacheChunkSize: args.cacheChunkSize,
-        shouldUsePreviewId: false,
-    });
-}
 /**
  * Add the `populateCache` command to yargs configuration, with nested commands for `local` and `remote`.
  *

package/dist/cli/commands/preview.js

@@ -1,4 +1,5 @@
 import { runWrangler } from "../utils/run-wrangler.js";
+import { getEnvFromPlatformProxy } from "./helpers.js";
 import { populateCache, withPopulateCacheOptions } from "./populate-cache.js";
 import { getNormalizedOptions, printHeaders, readWranglerConfig, retrieveCompiledConfig, withWranglerPassthroughArgs, } from "./utils.js";
 /**
@@ -9,16 +10,17 @@ import { getNormalizedOptions, printHeaders, readWranglerConfig, retrieveCompile
 export async function previewCommand(args) {
     printHeaders("preview");
     const { config } = await retrieveCompiledConfig();
-    const options = getNormalizedOptions(config);
+    const buildOpts = getNormalizedOptions(config);
     const wranglerConfig = readWranglerConfig(args);
-    await populateCache(options, config, wranglerConfig, {
+    const envVars = await getEnvFromPlatformProxy(config, buildOpts);
+    await populateCache(buildOpts, config, wranglerConfig, {
         target: args.remote ? "remote" : "local",
         environment: args.env,
         wranglerConfigPath: args.wranglerConfigPath,
         cacheChunkSize: args.cacheChunkSize,
         shouldUsePreviewId: args.remote,
-    });
-    runWrangler(options, ["dev", ...args.wranglerArgs], { logging: "all" });
+    }, envVars);
+    runWrangler(buildOpts, ["dev", ...args.wranglerArgs], { logging: "all" });
 }
 /**
  * Add the `preview` command to yargs configuration.

package/dist/cli/commands/skew-protection.d.ts

@@ -26,12 +26,12 @@ import type { WorkerEnvVar } from "./helpers.js";
 /**
  * Compute the deployment mapping for a deployment.
  *
- * @param options Build options
+ * @param buildOpts Build options
  * @param config OpenNext config
  * @param workerEnvVars Worker Environment variables (taken from the wrangler config files)
  * @returns Deployment mapping or undefined
  */
-export declare function getDeploymentMapping(options: BuildOptions, config: OpenNextConfig, workerEnvVars: WorkerEnvVar): Promise<Record<string, string> | undefined>;
+export declare function getDeploymentMapping(buildOpts: BuildOptions, config: OpenNextConfig, workerEnvVars: WorkerEnvVar): Promise<Record<string, string> | undefined>;
 /**
  * Update an existing deployment mapping:
  * - Replace the "current" version with the latest deployed version

package/dist/cli/commands/skew-protection.js

@@ -34,12 +34,12 @@ const MS_PER_DAY = 24 * 3600 * 1000;
 /**
  * Compute the deployment mapping for a deployment.
  *
- * @param options Build options
+ * @param buildOpts Build options
  * @param config OpenNext config
  * @param workerEnvVars Worker Environment variables (taken from the wrangler config files)
  * @returns Deployment mapping or undefined
  */
-export async function getDeploymentMapping(options, config, workerEnvVars) {
+export async function getDeploymentMapping(buildOpts, config, workerEnvVars) {
     if (config.cloudflare?.skewProtection?.enabled !== true) {
         return undefined;
     }
@@ -47,7 +47,7 @@ export async function getDeploymentMapping(options, config, workerEnvVars) {
     // system environment variables to take precedence over the variables defined
     // in the wrangler config files
     const envVars = { ...workerEnvVars, ...process.env };
-    const nextConfig = loadConfig(path.join(options.appBuildOutputPath, ".next"));
+    const nextConfig = loadConfig(path.join(buildOpts.appBuildOutputPath, ".next"));
     const deploymentId = nextConfig.deploymentId;
     if (!deploymentId) {
         logger.error("Deployment ID should be set in the Next config when skew protection is enabled");

package/dist/cli/commands/upload.js

@@ -12,21 +12,21 @@ import { getNormalizedOptions, printHeaders, readWranglerConfig, retrieveCompile
 export async function uploadCommand(args) {
     printHeaders("upload");
     const { config } = await retrieveCompiledConfig();
-    const options = getNormalizedOptions(config);
+    const buildOpts = getNormalizedOptions(config);
     const wranglerConfig = readWranglerConfig(args);
     const envVars = await getEnvFromPlatformProxy({
         configPath: args.wranglerConfigPath,
         environment: args.env,
-    });
-    const deploymentMapping = await getDeploymentMapping(options, config, envVars);
-    await populateCache(options, config, wranglerConfig, {
+    }, buildOpts);
+    const deploymentMapping = await getDeploymentMapping(buildOpts, config, envVars);
+    await populateCache(buildOpts, config, wranglerConfig, {
         target: "remote",
         environment: args.env,
         wranglerConfigPath: args.wranglerConfigPath,
         cacheChunkSize: args.cacheChunkSize,
         shouldUsePreviewId: false,
-    });
-    runWrangler(options, [
+    }, envVars);
+    runWrangler(buildOpts, [
         "versions upload",
         ...args.wranglerArgs,
         ...(deploymentMapping

package/dist/cli/templates/images.js

@@ -1,3 +1,4 @@
+let NEXT_IMAGE_REGEXP;
 /**
  * Fetches an images.
  *
@@ -11,17 +12,15 @@ export async function fetchImage(fetcher, imageUrl, ctx) {
     }
     // Local
     if (imageUrl.startsWith("/")) {
-        let pathname;
-        let url;
-        try {
-            // We only need pathname and search
-            url = new URL(imageUrl, "http://n");
-            pathname = decodeURIComponent(url.pathname);
-        }
-        catch {
+        // @ts-expect-error TS2339 Missing types for URL.parse
+        const url = URL.parse(imageUrl, "http://n");
+        if (url == null) {
             return getUrlErrorResponse();
         }
-        if (/\/_next\/image($|\/)/.test(pathname)) {
+        // This method will never throw because URL parser will handle invalid input.
+        const pathname = decodeURIComponent(url.pathname);
+        NEXT_IMAGE_REGEXP ??= /\/_next\/image($|\/)/;
+        if (NEXT_IMAGE_REGEXP.test(pathname)) {
             return getUrlErrorResponse();
         }
         // If localPatterns are not defined all local images are allowed.

package/dist/cli/templates/skew-protection.js

@@ -3,6 +3,7 @@ import process from "node:process";
 export const DEPLOYMENT_MAPPING_ENV_NAME = "CF_DEPLOYMENT_MAPPING";
 /** Version used for the latest worker */
 export const CURRENT_VERSION_ID = "current";
+let deploymentMapping;
 /**
  * Routes the request to the requested deployment.
  *
@@ -36,14 +37,14 @@ export function maybeGetSkewProtectionResponse(request) {
             // The request does not specify a deployment id or it is the current deployment id
             return undefined;
         }
-        const mapping = process.env[DEPLOYMENT_MAPPING_ENV_NAME]
+        deploymentMapping ??= process.env[DEPLOYMENT_MAPPING_ENV_NAME]
             ? JSON.parse(process.env[DEPLOYMENT_MAPPING_ENV_NAME])
             : {};
-        if (!(requestDeploymentId in mapping)) {
+        if (!(requestDeploymentId in deploymentMapping)) {
             // Unknown deployment id, serve the current version
             return undefined;
         }
-        const version = mapping[requestDeploymentId];
+        const version = deploymentMapping[requestDeploymentId];
         if (!version || version === CURRENT_VERSION_ID) {
             return undefined;
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.9.2",
+  "version": "1.10.0",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -43,7 +43,7 @@
   "homepage": "https://github.com/opennextjs/opennextjs-cloudflare",
   "dependencies": {
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "3.8.1",
+    "@opennextjs/aws": "3.8.2",
     "cloudflare": "^4.4.1",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",