@opennextjs/cloudflare 1.0.4 → 1.2.0

package/dist/cli/build/patches/plugins/next-server.js

@@ -0,0 +1,110 @@
+/**
+ * Misc patches for `next-server.js`
+ *
+ * Note: we will probably need to revisit the patches when the Next adapter API lands
+ *
+ * - Inline `getBuildId` as it relies on `readFileSync` that is not supported by workerd
+ * - Inline the middleware manifest
+ * - Override the cache and composable cache handlers
+ */
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { getPackagePath } from "@opennextjs/aws/build/helper.js";
+import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+import { normalizePath } from "../../utils/index.js";
+export function patchNextServer(updater, buildOpts) {
+    return updater.updateContent("next-server", [
+        {
+            field: {
+                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
+                    escape: false,
+                }),
+                contentFilter: /getBuildId\(/,
+                callback: async ({ contents }) => {
+                    const { outputDir } = buildOpts;
+                    contents = patchCode(contents, buildIdRule);
+                    const manifestPath = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next/server/middleware-manifest.json");
+                    const manifest = existsSync(manifestPath)
+                        ? JSON.parse(await readFileSync(manifestPath, "utf-8"))
+                        : {};
+                    contents = patchCode(contents, createMiddlewareManifestRule(manifest));
+                    const outputPath = path.join(outputDir, "server-functions/default");
+                    const cacheHandler = path.join(outputPath, getPackagePath(buildOpts), "cache.cjs");
+                    contents = patchCode(contents, createCacheHandlerRule(cacheHandler));
+                    const composableCacheHandler = path.join(outputPath, getPackagePath(buildOpts), "composable-cache.cjs");
+                    contents = patchCode(contents, createComposableCacheHandlersRule(composableCacheHandler));
+                    return contents;
+                },
+            },
+        },
+    ]);
+}
+export const buildIdRule = `
+rule:
+  pattern:
+    selector: method_definition
+    context: "class { getBuildId($$$PARAMS) { $$$_ } }"
+fix: |-
+  getBuildId($$$PARAMS) {
+    return process.env.NEXT_BUILD_ID;
+  }
+`;
+export function createMiddlewareManifestRule(manifest) {
+    return `
+rule:
+  pattern:
+    selector: method_definition
+    context: "class { getMiddlewareManifest($$$PARAMS) { $$$_ } }"
+fix: |-
+  getMiddlewareManifest($$$PARAMS) {
+    return ${JSON.stringify(manifest)};
+  }
+`;
+}
+/**
+ * The cache handler used by Next.js is normally defined in the config file as a path. At runtime,
+ * Next.js would then do a dynamic require on a transformed version of the path to retrieve the
+ * cache handler and create a new instance of it.
+ *
+ * This is problematic in workerd due to the dynamic import of the file that is not known from
+ * build-time. Therefore, we have to manually override the default way that the cache handler is
+ * instantiated with a dynamic require that uses a string literal for the path.
+ */
+export function createCacheHandlerRule(handlerPath) {
+    return `
+rule:
+  pattern: "const { cacheHandler } = this.nextConfig;"
+  inside:
+    kind: method_definition
+    has:
+      field: name
+      regex: ^getIncrementalCache$
+    stopBy: end
+
+fix: |-
+  const cacheHandler = null;
+  CacheHandler = require('${normalizePath(handlerPath)}').default;
+`;
+}
+export function createComposableCacheHandlersRule(handlerPath) {
+    return `
+rule:
+  pattern: "const { cacheHandlers } = this.nextConfig.experimental;"
+  inside:
+    kind: method_definition
+    has:
+      field: name
+      regex: ^loadCustomCacheHandlers$
+    stopBy: end
+
+fix: |-
+  const cacheHandlers = null;
+  const handlersSymbol = Symbol.for('@next/cache-handlers');
+  const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
+  const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
+  globalThis[handlersMapSymbol] = new Map();
+  globalThis[handlersMapSymbol].set("default", require('${normalizePath(handlerPath)}').default);
+  globalThis[handlersSetSymbol] = new Set(globalThis[handlersMapSymbol].values());
+`;
+}

package/dist/cli/build/patches/plugins/next-server.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/build/patches/plugins/next-server.spec.js

@@ -0,0 +1,429 @@
+import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { describe, expect, test } from "vitest";
+import { buildIdRule, createCacheHandlerRule, createComposableCacheHandlersRule, createMiddlewareManifestRule, } from "./next-server.js";
+describe("Next Server", () => {
+    const nextServerCode = `
+class NextNodeServer extends _baseserver.default {
+    constructor(options){
+        // Initialize super class
+        super(options);
+        this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
+    }
+    async handleUpgrade() {
+    // The web server does not support web sockets, it's only used for HMR in
+    // development.
+    }
+    loadEnvConfig({ dev, forceReload, silent }) {
+        (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
+            info: ()=>{},
+            error: ()=>{}
+        } : _log, forceReload);
+    }
+    async hasPage(pathname) {
+        var _this_nextConfig_i18n;
+        return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
+    }
+    getBuildId() {
+        const buildIdFile = (0, _path.join)(this.distDir, _constants.BUILD_ID_FILE);
+        try {
+            return _fs.default.readFileSync(buildIdFile, "utf8").trim();
+        } catch (err) {
+            if (err.code === "ENOENT") {
+                throw new Error(\`Could not find a production build in the '\${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id\`);
+            }
+            throw err;
+        }
+    }
+    getMiddlewareManifest() {
+        if (this.minimalMode) return null;
+        const manifest = require(this.middlewareManifestPath);
+        return manifest;
+    }
+    async loadCustomCacheHandlers() {
+        const { cacheHandlers } = this.nextConfig.experimental;
+        if (!cacheHandlers) return;
+        // If we've already initialized the cache handlers interface, don't do it
+        // again.
+        if (!(0, _handlers.initializeCacheHandlers)()) return;
+        for (const [kind, handler] of Object.entries(cacheHandlers)){
+            if (!handler) continue;
+            (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+        }
+    }
+    async getIncrementalCache({ requestHeaders, requestProtocol }) {
+        const dev = !!this.renderOpts.dev;
+        let CacheHandler;
+        const { cacheHandler } = this.nextConfig;
+        if (cacheHandler) {
+            CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+        }
+        await this.loadCustomCacheHandlers();
+        // incremental-cache is request specific
+        // although can have shared caches in module scope
+        // per-cache handler
+        return new _incrementalcache.IncrementalCache({
+            fs: this.getCacheFilesystem(),
+            dev,
+            requestHeaders,
+            requestProtocol,
+            allowedRevalidateHeaderKeys: this.nextConfig.experimental.allowedRevalidateHeaderKeys,
+            minimalMode: this.minimalMode,
+            serverDistDir: this.serverDistDir,
+            fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
+            maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+            flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
+            getPrerenderManifest: ()=>this.getPrerenderManifest(),
+            CurCacheHandler: CacheHandler
+        });
+    }
+    getEnabledDirectories(dev) {
+        const dir = dev ? this.dir : this.serverDistDir;
+        return {
+            app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
+            pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
+        };
+    }
+    // ...
+}`;
+    test("build ID", () => {
+        expect(patchCode(nextServerCode, buildIdRule)).toMatchInlineSnapshot(`
+        "class NextNodeServer extends _baseserver.default {
+            constructor(options){
+                // Initialize super class
+                super(options);
+                this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
+            }
+            async handleUpgrade() {
+            // The web server does not support web sockets, it's only used for HMR in
+            // development.
+            }
+            loadEnvConfig({ dev, forceReload, silent }) {
+                (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
+                    info: ()=>{},
+                    error: ()=>{}
+                } : _log, forceReload);
+            }
+            async hasPage(pathname) {
+                var _this_nextConfig_i18n;
+                return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
+            }
+            getBuildId() {
+          return process.env.NEXT_BUILD_ID;
+        }
+            getMiddlewareManifest() {
+                if (this.minimalMode) return null;
+                const manifest = require(this.middlewareManifestPath);
+                return manifest;
+            }
+            async loadCustomCacheHandlers() {
+                const { cacheHandlers } = this.nextConfig.experimental;
+                if (!cacheHandlers) return;
+                // If we've already initialized the cache handlers interface, don't do it
+                // again.
+                if (!(0, _handlers.initializeCacheHandlers)()) return;
+                for (const [kind, handler] of Object.entries(cacheHandlers)){
+                    if (!handler) continue;
+                    (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+                }
+            }
+            async getIncrementalCache({ requestHeaders, requestProtocol }) {
+                const dev = !!this.renderOpts.dev;
+                let CacheHandler;
+                const { cacheHandler } = this.nextConfig;
+                if (cacheHandler) {
+                    CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+                }
+                await this.loadCustomCacheHandlers();
+                // incremental-cache is request specific
+                // although can have shared caches in module scope
+                // per-cache handler
+                return new _incrementalcache.IncrementalCache({
+                    fs: this.getCacheFilesystem(),
+                    dev,
+                    requestHeaders,
+                    requestProtocol,
+                    allowedRevalidateHeaderKeys: this.nextConfig.experimental.allowedRevalidateHeaderKeys,
+                    minimalMode: this.minimalMode,
+                    serverDistDir: this.serverDistDir,
+                    fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
+                    maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+                    flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
+                    getPrerenderManifest: ()=>this.getPrerenderManifest(),
+                    CurCacheHandler: CacheHandler
+                });
+            }
+            getEnabledDirectories(dev) {
+                const dir = dev ? this.dir : this.serverDistDir;
+                return {
+                    app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
+                    pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
+                };
+            }
+            // ...
+        }"
+      `);
+    });
+    test("middleware manifest", () => {
+        expect(patchCode(nextServerCode, createMiddlewareManifestRule("manifest"))).toMatchInlineSnapshot(`
+      "class NextNodeServer extends _baseserver.default {
+          constructor(options){
+              // Initialize super class
+              super(options);
+              this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
+          }
+          async handleUpgrade() {
+          // The web server does not support web sockets, it's only used for HMR in
+          // development.
+          }
+          loadEnvConfig({ dev, forceReload, silent }) {
+              (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
+                  info: ()=>{},
+                  error: ()=>{}
+              } : _log, forceReload);
+          }
+          async hasPage(pathname) {
+              var _this_nextConfig_i18n;
+              return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
+          }
+          getBuildId() {
+              const buildIdFile = (0, _path.join)(this.distDir, _constants.BUILD_ID_FILE);
+              try {
+                  return _fs.default.readFileSync(buildIdFile, "utf8").trim();
+              } catch (err) {
+                  if (err.code === "ENOENT") {
+                      throw new Error(\`Could not find a production build in the '\${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id\`);
+                  }
+                  throw err;
+              }
+          }
+          getMiddlewareManifest() {
+        return "manifest";
+      }
+          async loadCustomCacheHandlers() {
+              const { cacheHandlers } = this.nextConfig.experimental;
+              if (!cacheHandlers) return;
+              // If we've already initialized the cache handlers interface, don't do it
+              // again.
+              if (!(0, _handlers.initializeCacheHandlers)()) return;
+              for (const [kind, handler] of Object.entries(cacheHandlers)){
+                  if (!handler) continue;
+                  (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+              }
+          }
+          async getIncrementalCache({ requestHeaders, requestProtocol }) {
+              const dev = !!this.renderOpts.dev;
+              let CacheHandler;
+              const { cacheHandler } = this.nextConfig;
+              if (cacheHandler) {
+                  CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+              }
+              await this.loadCustomCacheHandlers();
+              // incremental-cache is request specific
+              // although can have shared caches in module scope
+              // per-cache handler
+              return new _incrementalcache.IncrementalCache({
+                  fs: this.getCacheFilesystem(),
+                  dev,
+                  requestHeaders,
+                  requestProtocol,
+                  allowedRevalidateHeaderKeys: this.nextConfig.experimental.allowedRevalidateHeaderKeys,
+                  minimalMode: this.minimalMode,
+                  serverDistDir: this.serverDistDir,
+                  fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
+                  maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+                  flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
+                  getPrerenderManifest: ()=>this.getPrerenderManifest(),
+                  CurCacheHandler: CacheHandler
+              });
+          }
+          getEnabledDirectories(dev) {
+              const dir = dev ? this.dir : this.serverDistDir;
+              return {
+                  app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
+                  pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
+              };
+          }
+          // ...
+      }"
+    `);
+    });
+    test("cache handler", () => {
+        expect(patchCode(nextServerCode, createCacheHandlerRule("manifest"))).toMatchInlineSnapshot(`
+      "class NextNodeServer extends _baseserver.default {
+          constructor(options){
+              // Initialize super class
+              super(options);
+              this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
+          }
+          async handleUpgrade() {
+          // The web server does not support web sockets, it's only used for HMR in
+          // development.
+          }
+          loadEnvConfig({ dev, forceReload, silent }) {
+              (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
+                  info: ()=>{},
+                  error: ()=>{}
+              } : _log, forceReload);
+          }
+          async hasPage(pathname) {
+              var _this_nextConfig_i18n;
+              return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
+          }
+          getBuildId() {
+              const buildIdFile = (0, _path.join)(this.distDir, _constants.BUILD_ID_FILE);
+              try {
+                  return _fs.default.readFileSync(buildIdFile, "utf8").trim();
+              } catch (err) {
+                  if (err.code === "ENOENT") {
+                      throw new Error(\`Could not find a production build in the '\${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id\`);
+                  }
+                  throw err;
+              }
+          }
+          getMiddlewareManifest() {
+              if (this.minimalMode) return null;
+              const manifest = require(this.middlewareManifestPath);
+              return manifest;
+          }
+          async loadCustomCacheHandlers() {
+              const { cacheHandlers } = this.nextConfig.experimental;
+              if (!cacheHandlers) return;
+              // If we've already initialized the cache handlers interface, don't do it
+              // again.
+              if (!(0, _handlers.initializeCacheHandlers)()) return;
+              for (const [kind, handler] of Object.entries(cacheHandlers)){
+                  if (!handler) continue;
+                  (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+              }
+          }
+          async getIncrementalCache({ requestHeaders, requestProtocol }) {
+              const dev = !!this.renderOpts.dev;
+              let CacheHandler;
+              const cacheHandler = null;
+      CacheHandler = require('manifest').default;
+              if (cacheHandler) {
+                  CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+              }
+              await this.loadCustomCacheHandlers();
+              // incremental-cache is request specific
+              // although can have shared caches in module scope
+              // per-cache handler
+              return new _incrementalcache.IncrementalCache({
+                  fs: this.getCacheFilesystem(),
+                  dev,
+                  requestHeaders,
+                  requestProtocol,
+                  allowedRevalidateHeaderKeys: this.nextConfig.experimental.allowedRevalidateHeaderKeys,
+                  minimalMode: this.minimalMode,
+                  serverDistDir: this.serverDistDir,
+                  fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
+                  maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+                  flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
+                  getPrerenderManifest: ()=>this.getPrerenderManifest(),
+                  CurCacheHandler: CacheHandler
+              });
+          }
+          getEnabledDirectories(dev) {
+              const dir = dev ? this.dir : this.serverDistDir;
+              return {
+                  app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
+                  pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
+              };
+          }
+          // ...
+      }"
+    `);
+    });
+    test("composable cache handler", () => {
+        expect(patchCode(nextServerCode, createComposableCacheHandlersRule("manifest"))).toMatchInlineSnapshot(`
+      "class NextNodeServer extends _baseserver.default {
+          constructor(options){
+              // Initialize super class
+              super(options);
+              this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
+          }
+          async handleUpgrade() {
+          // The web server does not support web sockets, it's only used for HMR in
+          // development.
+          }
+          loadEnvConfig({ dev, forceReload, silent }) {
+              (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
+                  info: ()=>{},
+                  error: ()=>{}
+              } : _log, forceReload);
+          }
+          async hasPage(pathname) {
+              var _this_nextConfig_i18n;
+              return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
+          }
+          getBuildId() {
+              const buildIdFile = (0, _path.join)(this.distDir, _constants.BUILD_ID_FILE);
+              try {
+                  return _fs.default.readFileSync(buildIdFile, "utf8").trim();
+              } catch (err) {
+                  if (err.code === "ENOENT") {
+                      throw new Error(\`Could not find a production build in the '\${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id\`);
+                  }
+                  throw err;
+              }
+          }
+          getMiddlewareManifest() {
+              if (this.minimalMode) return null;
+              const manifest = require(this.middlewareManifestPath);
+              return manifest;
+          }
+          async loadCustomCacheHandlers() {
+              const cacheHandlers = null;
+      const handlersSymbol = Symbol.for('@next/cache-handlers');
+      const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
+      const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
+      globalThis[handlersMapSymbol] = new Map();
+      globalThis[handlersMapSymbol].set("default", require('manifest').default);
+      globalThis[handlersSetSymbol] = new Set(globalThis[handlersMapSymbol].values());
+              if (!cacheHandlers) return;
+              // If we've already initialized the cache handlers interface, don't do it
+              // again.
+              if (!(0, _handlers.initializeCacheHandlers)()) return;
+              for (const [kind, handler] of Object.entries(cacheHandlers)){
+                  if (!handler) continue;
+                  (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+              }
+          }
+          async getIncrementalCache({ requestHeaders, requestProtocol }) {
+              const dev = !!this.renderOpts.dev;
+              let CacheHandler;
+              const { cacheHandler } = this.nextConfig;
+              if (cacheHandler) {
+                  CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+              }
+              await this.loadCustomCacheHandlers();
+              // incremental-cache is request specific
+              // although can have shared caches in module scope
+              // per-cache handler
+              return new _incrementalcache.IncrementalCache({
+                  fs: this.getCacheFilesystem(),
+                  dev,
+                  requestHeaders,
+                  requestProtocol,
+                  allowedRevalidateHeaderKeys: this.nextConfig.experimental.allowedRevalidateHeaderKeys,
+                  minimalMode: this.minimalMode,
+                  serverDistDir: this.serverDistDir,
+                  fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
+                  maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+                  flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
+                  getPrerenderManifest: ()=>this.getPrerenderManifest(),
+                  CurCacheHandler: CacheHandler
+              });
+          }
+          getEnabledDirectories(dev) {
+              const dir = dev ? this.dir : this.serverDistDir;
+              return {
+                  app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
+                  pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
+              };
+          }
+          // ...
+      }"
+    `);
+    });
+});

package/dist/cli/build/patches/plugins/open-next.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Removed unused `require.resolve` calls in Open Next.
+ */
+import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
+import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";
+export declare function patchResolveCache(updater: ContentUpdater, buildOpts: BuildOptions): Plugin;
+export declare const cacheHandlerRule = "\nrule:\n  pattern: var cacheHandlerPath = __require.resolve(\"./cache.cjs\");\nfix: |-\n  var cacheHandlerPath = \"\";\n";
+export declare const compositeCacheHandlerRule = "\nrule:\n  pattern: var composableCacheHandlerPath = __require.resolve(\"./composable-cache.cjs\");\nfix: |-\n  var composableCacheHandlerPath = \"\";\n";

package/dist/cli/build/patches/plugins/open-next.js

@@ -0,0 +1,39 @@
+/**
+ * Removed unused `require.resolve` calls in Open Next.
+ */
+import path from "node:path";
+import { getPackagePath } from "@opennextjs/aws/build/helper.js";
+import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+export function patchResolveCache(updater, buildOpts) {
+    const { outputDir } = buildOpts;
+    const packagePath = getPackagePath(buildOpts);
+    const outputPath = path.join(outputDir, "server-functions/default");
+    const indexPath = path.relative(buildOpts.appBuildOutputPath, path.join(outputPath, packagePath, `index.mjs`));
+    console.error({ index: indexPath });
+    return updater.updateContent("patch-resolve-cache", [
+        {
+            field: {
+                filter: getCrossPlatformPathRegex(indexPath),
+                contentFilter: /cacheHandlerPath/,
+                callback: async ({ contents }) => {
+                    contents = patchCode(contents, cacheHandlerRule);
+                    contents = patchCode(contents, compositeCacheHandlerRule);
+                    return contents;
+                },
+            },
+        },
+    ]);
+}
+export const cacheHandlerRule = `
+rule:
+  pattern: var cacheHandlerPath = __require.resolve("./cache.cjs");
+fix: |-
+  var cacheHandlerPath = "";
+`;
+export const compositeCacheHandlerRule = `
+rule:
+  pattern: var composableCacheHandlerPath = __require.resolve("./composable-cache.cjs");
+fix: |-
+  var composableCacheHandlerPath = "";
+`;

package/dist/cli/templates/init.js

@@ -108,5 +108,10 @@ function populateProcessEnv(url, env) {
             port: url.port,
         },
     });
+    /* We need to set this environment variable to make redirects work properly in preview mode.
+     * Next sets this in standalone mode during `startServer`. Without this the protocol would always be `https` here:
+     * https://github.com/vercel/next.js/blob/6b1e48080e896e0d44a05fe009cb79d2d3f91774/packages/next/src/server/app-render/action-handler.ts#L307-L316
+     */
+    process.env.__NEXT_PRIVATE_ORIGIN = url.origin;
 }
 /* eslint-enable no-var */

package/dist/cli/templates/shims/throw.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/cli/templates/shims/throw.js

@@ -0,0 +1,2 @@
+throw "OpenNext shim";
+export default {};

package/dist/cli/templates/worker.d.ts

@@ -1,5 +1,6 @@
 export { DOQueueHandler } from "./.build/durable-objects/queue.js";
 export { DOShardedTagCache } from "./.build/durable-objects/sharded-tag-cache.js";
+export { BucketCachePurge } from "./.build/durable-objects/bucket-cache-purge.js";
 declare const _default: {
     fetch(request: Request<unknown, IncomingRequestCfProperties<unknown>>, env: CloudflareEnv, ctx: ExecutionContext): Promise<any>;
 };

package/dist/cli/templates/worker.js

@@ -6,6 +6,8 @@ import { handler as middlewareHandler } from "./middleware/handler.mjs";
 export { DOQueueHandler } from "./.build/durable-objects/queue.js";
 //@ts-expect-error: Will be resolved by wrangler build
 export { DOShardedTagCache } from "./.build/durable-objects/sharded-tag-cache.js";
+//@ts-expect-error: Will be resolved by wrangler build
+export { BucketCachePurge } from "./.build/durable-objects/bucket-cache-purge.js";
 export default {
     async fetch(request, env, ctx) {
         return runWithCloudflareRequestContext(request, env, ctx, async () => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.0.4",
+  "version": "1.2.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.6.2",
+    "@opennextjs/aws": "3.6.5",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",
     "ts-tqdm": "^0.8.6"
@@ -68,7 +68,7 @@
     "vitest": "^2.1.1"
   },
   "peerDependencies": {
-    "wrangler": "^4.14.0"
+    "wrangler": "^4.19.1"
   },
   "scripts": {
     "clean": "rimraf dist",

package/dist/cli/build/patches/investigated/patch-cache.d.ts

@@ -1,14 +0,0 @@
-import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
-/**
- * Sets up the OpenNext cache handler in a Next.js build.
- *
- * The cache handler used by Next.js is normally defined in the config file as a path. At runtime,
- * Next.js would then do a dynamic require on a transformed version of the path to retrieve the
- * cache handler and create a new instance of it.
- *
- * This is problematic in workerd due to the dynamic import of the file that is not known from
- * build-time. Therefore, we have to manually override the default way that the cache handler is
- * instantiated with a dynamic require that uses a string literal for the path.
- */
-export declare function patchCache(code: string, buildOpts: BuildOptions): Promise<string>;
-export declare function patchComposableCache(code: string, buildOpts: BuildOptions): Promise<string>;