@opennextjs/cloudflare 0.5.3 → 0.5.4

package/dist/api/cloudflare-context.d.ts

@@ -1,6 +1,9 @@
 declare global {
     interface CloudflareEnv {
         NEXT_CACHE_WORKERS_KV?: KVNamespace;
+        NEXT_CACHE_D1?: D1Database;
+        NEXT_CACHE_D1_TAGS_TABLE?: string;
+        NEXT_CACHE_D1_REVALIDATIONS_TABLE?: string;
         ASSETS?: Fetcher;
     }
 }

package/dist/api/cloudflare-context.js

@@ -38,11 +38,11 @@ function getCloudflareContextSync() {
     // can work during SSG since for SSG Next.js creates (jest) workers that don't get access to the
     // normal global state so we throw with a helpful error message.
     if (inSSG()) {
-        throw new Error(`\n\nERROR: \`getCloudflareContext\` has been called in a static route,` +
-            ` that is not allowed, this can be solved in different ways:\n\n` +
-            ` - call \`getCloudflareContext({async: true})\` to use the \`async\` mode\n` +
-            ` - avoid calling \`getCloudflareContext\` in the route\n` +
-            ` - make the route non static\n`);
+        throw new Error(`\n\nERROR: \`getCloudflareContext\` has been called in sync mode in either a static route or at the top level of a non-static one,` +
+            ` both cases are not allowed but can be solved by either:\n` +
+            `  - make sure that the call is not at the top level and that the route is not static\n` +
+            `  - call \`getCloudflareContext({async: true})\` to use the \`async\` mode\n` +
+            `  - avoid calling \`getCloudflareContext\` in the route\n`);
     }
     throw new Error(initOpenNextCloudflareForDevErrorMsg);
 }

package/dist/api/d1-tag-cache.d.ts

@@ -0,0 +1,35 @@
+import type { TagCache } from "@opennextjs/aws/types/overrides.js";
+/**
+ * An instance of the Tag Cache that uses a D1 binding (`NEXT_CACHE_D1`) as it's underlying data store.
+ *
+ * **Tag/path mappings table**
+ *
+ * Information about the relation between tags and paths is stored in a `tags` table that contains
+ * two columns; `tag`, and `path`. The table name can be configured with `NEXT_CACHE_D1_TAGS_TABLE`
+ * environment variable.
+ *
+ * This table should be populated using an SQL file that is generated during the build process.
+ *
+ * **Tag revalidations table**
+ *
+ * Revalidation times for tags are stored in a `revalidations` table that contains two columns; `tags`,
+ * and `revalidatedAt`. The table name can be configured with `NEXT_CACHE_D1_REVALIDATIONS_TABLE`
+ * environment variable.
+ */
+declare class D1TagCache implements TagCache {
+    readonly name = "d1-tag-cache";
+    getByPath(rawPath: string): Promise<string[]>;
+    getByTag(rawTag: string): Promise<string[]>;
+    getLastModified(path: string, lastModified?: number): Promise<number>;
+    writeTags(tags: {
+        tag: string;
+        path: string;
+        revalidatedAt?: number;
+    }[]): Promise<void>;
+    private getConfig;
+    protected removeBuildId(key: string): string;
+    protected getCacheKey(key: string): string;
+    protected getBuildId(): string;
+}
+declare const _default: D1TagCache;
+export default _default;

package/dist/api/d1-tag-cache.js

@@ -0,0 +1,147 @@
+import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { RecoverableError } from "@opennextjs/aws/utils/error.js";
+import { getCloudflareContext } from "./cloudflare-context.js";
+/**
+ * An instance of the Tag Cache that uses a D1 binding (`NEXT_CACHE_D1`) as it's underlying data store.
+ *
+ * **Tag/path mappings table**
+ *
+ * Information about the relation between tags and paths is stored in a `tags` table that contains
+ * two columns; `tag`, and `path`. The table name can be configured with `NEXT_CACHE_D1_TAGS_TABLE`
+ * environment variable.
+ *
+ * This table should be populated using an SQL file that is generated during the build process.
+ *
+ * **Tag revalidations table**
+ *
+ * Revalidation times for tags are stored in a `revalidations` table that contains two columns; `tags`,
+ * and `revalidatedAt`. The table name can be configured with `NEXT_CACHE_D1_REVALIDATIONS_TABLE`
+ * environment variable.
+ */
+class D1TagCache {
+    name = "d1-tag-cache";
+    async getByPath(rawPath) {
+        const { isDisabled, db, tables } = this.getConfig();
+        if (isDisabled)
+            return [];
+        const path = this.getCacheKey(rawPath);
+        try {
+            const { success, results } = await db
+                .prepare(`SELECT tag FROM ${JSON.stringify(tables.tags)} WHERE path = ?`)
+                .bind(path)
+                .all();
+            if (!success)
+                throw new RecoverableError(`D1 select failed for ${path}`);
+            const tags = results?.map((item) => this.removeBuildId(item.tag));
+            debug("tags for path", path, tags);
+            return tags;
+        }
+        catch (e) {
+            error("Failed to get tags by path", e);
+            return [];
+        }
+    }
+    async getByTag(rawTag) {
+        const { isDisabled, db, tables } = this.getConfig();
+        if (isDisabled)
+            return [];
+        const tag = this.getCacheKey(rawTag);
+        try {
+            const { success, results } = await db
+                .prepare(`SELECT path FROM ${JSON.stringify(tables.tags)} WHERE tag = ?`)
+                .bind(tag)
+                .all();
+            if (!success)
+                throw new RecoverableError(`D1 select failed for ${tag}`);
+            const paths = results?.map((item) => this.removeBuildId(item.path));
+            debug("paths for tag", tag, paths);
+            return paths;
+        }
+        catch (e) {
+            error("Failed to get by tag", e);
+            return [];
+        }
+    }
+    async getLastModified(path, lastModified) {
+        const { isDisabled, db, tables } = this.getConfig();
+        if (isDisabled)
+            return lastModified ?? Date.now();
+        try {
+            const { success, results } = await db
+                .prepare(`SELECT ${JSON.stringify(tables.revalidations)}.tag FROM ${JSON.stringify(tables.revalidations)}
+            INNER JOIN ${JSON.stringify(tables.tags)} ON ${JSON.stringify(tables.revalidations)}.tag = ${JSON.stringify(tables.tags)}.tag
+            WHERE ${JSON.stringify(tables.tags)}.path = ? AND ${JSON.stringify(tables.revalidations)}.revalidatedAt > ?;`)
+                .bind(this.getCacheKey(path), lastModified ?? 0)
+                .all();
+            if (!success)
+                throw new RecoverableError(`D1 select failed for ${path} - ${lastModified ?? 0}`);
+            debug("revalidatedTags", results);
+            return results?.length > 0 ? -1 : (lastModified ?? Date.now());
+        }
+        catch (e) {
+            error("Failed to get revalidated tags", e);
+            return lastModified ?? Date.now();
+        }
+    }
+    async writeTags(tags) {
+        const { isDisabled, db, tables } = this.getConfig();
+        if (isDisabled || tags.length === 0)
+            return;
+        try {
+            const uniqueTags = new Set();
+            const results = await db.batch(tags
+                .map(({ tag, path, revalidatedAt }) => {
+                if (revalidatedAt === 1) {
+                    // new tag/path mapping from set
+                    return db
+                        .prepare(`INSERT INTO ${JSON.stringify(tables.tags)} (tag, path) VALUES (?, ?)`)
+                        .bind(this.getCacheKey(tag), this.getCacheKey(path));
+                }
+                if (!uniqueTags.has(tag) && revalidatedAt !== -1) {
+                    // tag was revalidated
+                    uniqueTags.add(tag);
+                    return db
+                        .prepare(`INSERT INTO ${JSON.stringify(tables.revalidations)} (tag, revalidatedAt) VALUES (?, ?)`)
+                        .bind(this.getCacheKey(tag), revalidatedAt ?? Date.now());
+                }
+            })
+                .filter((stmt) => !!stmt));
+            const failedResults = results.filter((res) => !res.success);
+            if (failedResults.length > 0) {
+                throw new RecoverableError(`${failedResults.length} tags failed to write`);
+            }
+        }
+        catch (e) {
+            error("Failed to batch write tags", e);
+        }
+    }
+    getConfig() {
+        const cfEnv = getCloudflareContext().env;
+        const db = cfEnv.NEXT_CACHE_D1;
+        if (!db)
+            debug("No D1 database found");
+        const isDisabled = !!globalThis.openNextConfig
+            .dangerous?.disableTagCache;
+        if (!db || isDisabled) {
+            return { isDisabled: true };
+        }
+        return {
+            isDisabled: false,
+            db,
+            tables: {
+                tags: cfEnv.NEXT_CACHE_D1_TAGS_TABLE ?? "tags",
+                revalidations: cfEnv.NEXT_CACHE_D1_REVALIDATIONS_TABLE ?? "revalidations",
+            },
+        };
+    }
+    removeBuildId(key) {
+        return key.replace(`${this.getBuildId()}/`, "");
+    }
+    getCacheKey(key) {
+        return `${this.getBuildId()}/${key}`.replaceAll("//", "/");
+    }
+    getBuildId() {
+        return process.env.NEXT_BUILD_ID ?? "no-build-id";
+    }
+}
+export default new D1TagCache();

package/dist/cli/build/build.js

@@ -9,6 +9,7 @@ import * as buildHelper from "@opennextjs/aws/build/helper.js";
 import { printHeader, showWarningOnWindows } from "@opennextjs/aws/build/utils.js";
 import logger from "@opennextjs/aws/logger.js";
 import { bundleServer } from "./bundle-server.js";
+import { compileCacheAssetsManifestSqlFile } from "./open-next/compile-cache-assets-manifest.js";
 import { compileEnvFiles } from "./open-next/compile-env-files.js";
 import { copyCacheAssets } from "./open-next/copyCacheAssets.js";
 import { createServerBundle } from "./open-next/createServerBundle.js";
@@ -64,8 +65,11 @@ export async function build(projectOpts) {
     await createMiddleware(options, { forceOnlyBuildOnce: true });
     createStaticAssets(options);
     if (config.dangerous?.disableIncrementalCache !== true) {
-        createCacheAssets(options);
+        const { useTagCache, metaFiles } = createCacheAssets(options);
         copyCacheAssets(options);
+        if (useTagCache) {
+            compileCacheAssetsManifestSqlFile(options, metaFiles);
+        }
     }
     await createServerBundle(options);
     await bundleServer(options);

package/dist/cli/build/bundle-server.js

@@ -7,13 +7,15 @@ import { build } from "esbuild";
 import { patchVercelOgLibrary } from "./patches/ast/patch-vercel-og-library.js";
 import { patchWebpackRuntime } from "./patches/ast/webpack-runtime.js";
 import * as patches from "./patches/index.js";
+import { inlineBuildId } from "./patches/plugins/build-id.js";
 import { ContentUpdater } from "./patches/plugins/content-updater.js";
 import { inlineEvalManifest } from "./patches/plugins/eval-manifest.js";
 import { patchFetchCacheSetMissingWaitUntil } from "./patches/plugins/fetch-cache-wait-until.js";
 import { inlineFindDir } from "./patches/plugins/find-dir.js";
-import { patchLoadInstrumentation } from "./patches/plugins/load-instrumentation.js";
+import { patchInstrumentation } from "./patches/plugins/instrumentation.js";
 import { inlineLoadManifest } from "./patches/plugins/load-manifest.js";
 import { handleOptionalDependencies } from "./patches/plugins/optional-deps.js";
+import { patchDepdDeprecations } from "./patches/plugins/patch-depd-deprecations.js";
 import { fixRequire } from "./patches/plugins/require.js";
 import { shimRequireHook } from "./patches/plugins/require-hook.js";
 import { inlineRequirePage } from "./patches/plugins/require-page.js";
@@ -74,11 +76,13 @@ export async function bundleServer(buildOpts) {
             setWranglerExternal(),
             fixRequire(updater),
             handleOptionalDependencies(optionalDependencies),
-            patchLoadInstrumentation(updater),
+            patchInstrumentation(updater, buildOpts),
             patchFetchCacheSetMissingWaitUntil(updater),
             inlineEvalManifest(updater, buildOpts),
             inlineFindDir(updater, buildOpts),
             inlineLoadManifest(updater, buildOpts),
+            inlineBuildId(updater),
+            patchDepdDeprecations(updater),
             // Apply updater updaters, must be the last plugin
             updater.plugin,
         ],
@@ -166,13 +170,11 @@ export async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
     const code = await readFile(workerOutputFile, "utf8");
     const patchedCode = await patchCodeWithValidations(code, [
         ["require", patches.patchRequire],
-        ["`buildId` function", (code) => patches.patchBuildId(code, buildOpts)],
         ["cacheHandler", (code) => patches.patchCache(code, buildOpts)],
         [
             "'require(this.middlewareManifestPath)'",
             (code) => patches.inlineMiddlewareManifestRequire(code, buildOpts),
         ],
-        ["exception bubbling", patches.patchExceptionBubbling],
         [
             "`patchAsyncStorage` call",
             (code) => code

package/dist/cli/build/open-next/compile-cache-assets-manifest.d.ts

@@ -0,0 +1,6 @@
+import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
+import type { TagCacheMetaFile } from "@opennextjs/aws/types/cache.js";
+/**
+ * Generates SQL statements that can be used to initialise the cache assets manifest in an SQL data store.
+ */
+export declare function compileCacheAssetsManifestSqlFile(options: BuildOptions, metaFiles: TagCacheMetaFile[]): void;

package/dist/cli/build/open-next/compile-cache-assets-manifest.js

@@ -0,0 +1,17 @@
+import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+/**
+ * Generates SQL statements that can be used to initialise the cache assets manifest in an SQL data store.
+ */
+export function compileCacheAssetsManifestSqlFile(options, metaFiles) {
+    const outputPath = path.join(options.outputDir, "cloudflare/cache-assets-manifest.sql");
+    const tagsTable = process.env.NEXT_CACHE_D1_TAGS_TABLE || "tags";
+    const revalidationsTable = process.env.NEXT_CACHE_D1_REVALIDATIONS_TABLE || "revalidations";
+    mkdirSync(path.dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, `CREATE TABLE IF NOT EXISTS ${JSON.stringify(tagsTable)} (tag TEXT NOT NULL, path TEXT NOT NULL, UNIQUE(tag, path) ON CONFLICT REPLACE);
+     CREATE TABLE IF NOT EXISTS ${JSON.stringify(revalidationsTable)} (tag TEXT NOT NULL, revalidatedAt INTEGER NOT NULL, UNIQUE(tag) ON CONFLICT REPLACE);\n`);
+    const values = metaFiles.map(({ tag, path }) => `(${JSON.stringify(tag.S)}, ${JSON.stringify(path.S)})`);
+    if (values.length) {
+        appendFileSync(outputPath, `INSERT INTO ${JSON.stringify(tagsTable)} (tag, path) VALUES ${values.join(", ")};`);
+    }
+}

package/dist/cli/build/patches/index.d.ts

@@ -1,2 +1,2 @@
 export * from "./investigated/index.js";
-export * from "./to-investigate/index.js";
+export * from "./to-investigate/inline-middleware-manifest.js";

package/dist/cli/build/patches/index.js

@@ -1,2 +1,2 @@
 export * from "./investigated/index.js";
-export * from "./to-investigate/index.js";
+export * from "./to-investigate/inline-middleware-manifest.js";

package/dist/cli/build/patches/plugins/build-id.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Inline `getBuildId` as it relies on `readFileSync` that is not supported by workerd.
+ */
+import type { ContentUpdater } from "./content-updater.js";
+export declare function inlineBuildId(updater: ContentUpdater): import("esbuild").Plugin;
+export declare const rule = "\nrule:\n  kind: method_definition\n  has:\n    field: name\n    regex: ^getBuildId$\nfix: |-\n  getBuildId() {\n    return process.env.NEXT_BUILD_ID;\n  }\n";

package/dist/cli/build/patches/plugins/build-id.js

@@ -0,0 +1,22 @@
+/**
+ * Inline `getBuildId` as it relies on `readFileSync` that is not supported by workerd.
+ */
+import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+import { patchCode } from "../ast/util.js";
+export function inlineBuildId(updater) {
+    return updater.updateContent("inline-build-id", {
+        filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, { escape: false }),
+        contentFilter: /getBuildId\(/,
+    }, async ({ contents }) => patchCode(contents, rule));
+}
+export const rule = `
+rule:
+  kind: method_definition
+  has:
+    field: name
+    regex: ^getBuildId$
+fix: |-
+  getBuildId() {
+    return process.env.NEXT_BUILD_ID;
+  }
+`;

package/dist/cli/build/patches/plugins/build-id.spec.js

@@ -0,0 +1,82 @@
+import { describe, expect, test } from "vitest";
+import { patchCode } from "../ast/util.js";
+import { rule } from "./build-id.js";
+describe("getBuildId", () => {
+    test("patch", () => {
+        const code = `
+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;
+        }
+    }
+    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
+        };
+    }
+    // ...
+}`;
+        expect(patchCode(code, rule)).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;
+      }
+          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/find-dir.d.ts

@@ -1,6 +1,5 @@
 /**
- * Inline `evalManifest` as it relies on `readFileSync` and `runInNewContext`
- * that are not supported by workerd.
+ * Inline `findDir` as it relies on `existsSync` which is not supported by workerd.
  */
 import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
 import type { ContentUpdater } from "./content-updater.js";

package/dist/cli/build/patches/plugins/find-dir.js

@@ -1,6 +1,5 @@
 /**
- * Inline `evalManifest` as it relies on `readFileSync` and `runInNewContext`
- * that are not supported by workerd.
+ * Inline `findDir` as it relies on `existsSync` which is not supported by workerd.
  */
 import { existsSync } from "node:fs";
 import { join } from "node:path";

package/dist/cli/build/patches/plugins/instrumentation.d.ts

@@ -0,0 +1,8 @@
+import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
+import type { ContentUpdater } from "./content-updater.js";
+export declare function patchInstrumentation(updater: ContentUpdater, buildOpts: BuildOptions): {
+    name: string;
+    setup(): void;
+};
+export declare function getNext15Rule(builtInstrumentationPath: string | null): string;
+export declare function getNext14Rule(builtInstrumentationPath: string | null): string;

package/dist/cli/build/patches/plugins/instrumentation.js

@@ -0,0 +1,62 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getPackagePath } from "@opennextjs/aws/build/helper.js";
+import { patchCode } from "../ast/util.js";
+export function patchInstrumentation(updater, buildOpts) {
+    const builtInstrumentationPath = getBuiltInstrumentationPath(buildOpts);
+    updater.updateContent("patch-instrumentation-next15", { filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/, contentFilter: /async loadInstrumentationModule\(/ }, async ({ contents }) => patchCode(contents, getNext15Rule(builtInstrumentationPath)));
+    updater.updateContent("patch-instrumentation-next14", { filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/, contentFilter: /async prepareImpl\(/ }, async ({ contents }) => patchCode(contents, getNext14Rule(builtInstrumentationPath)));
+    return {
+        name: "patch-instrumentation",
+        setup() { },
+    };
+}
+export function getNext15Rule(builtInstrumentationPath) {
+    return `
+    rule:
+      kind: method_definition
+      all:
+        - has: {field: name, regex: ^loadInstrumentationModule$}
+        - has: {pattern: dynamicRequire, stopBy: end}
+
+    fix:
+      async loadInstrumentationModule() {
+        this.instrumentation = ${builtInstrumentationPath ? `require('${builtInstrumentationPath}')` : "null"};
+        return this.instrumentation;
+      }
+  `;
+}
+export function getNext14Rule(builtInstrumentationPath) {
+    return `
+    rule:
+      kind: method_definition
+      any:
+        - has: { field: name, regex: ^prepareImpl$, pattern: $NAME }
+      all:
+        - has: { pattern: dynamicRequire, stopBy: end }
+        - has: { pattern: $_.INSTRUMENTATION_HOOK_FILENAME, stopBy: end }
+    fix: |-
+        async $NAME() {
+          await super.prepareImpl();
+          const instrumentationHook = ${builtInstrumentationPath ? `require('${builtInstrumentationPath}')` : "{}"};
+          await (instrumentationHook.register == null ? void 0 : instrumentationHook.register.call(instrumentationHook));
+        }
+  `;
+}
+/**
+ * Gets the instrumentation.js file that the Next.js build process generates when an
+ * instrumentation hook is provided in the app's source
+ *
+ * @param buildOpts the open-next build options
+ * @returns the path to instrumentation.js, or null if it doesn't exist
+ */
+function getBuiltInstrumentationPath(buildOpts) {
+    const { outputDir } = buildOpts;
+    const maybeBuiltInstrumentationPath = join(outputDir, "server-functions/default", getPackagePath(buildOpts), `.next/server/${INSTRUMENTATION_HOOK_FILENAME}.js`);
+    return existsSync(maybeBuiltInstrumentationPath) ? maybeBuiltInstrumentationPath : null;
+}
+/**
+ * Pattern to detect instrumentation hooks file
+ * (taken from Next.js source: https://github.com/vercel/next.js/blob/1d5820563/packages/next/src/lib/constants.ts#L46-L47)
+ */
+const INSTRUMENTATION_HOOK_FILENAME = "instrumentation";

package/dist/cli/build/patches/plugins/instrumentation.spec.d.ts

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

package/dist/cli/build/patches/plugins/instrumentation.spec.js

@@ -0,0 +1,91 @@
+import { describe, expect, test } from "vitest";
+import { patchCode } from "../ast/util.js";
+import { getNext14Rule, getNext15Rule } from "./instrumentation.js";
+describe("LoadInstrumentationModule (Next15)", () => {
+    const code = `
+      export default class NextNodeServer extends BaseServer {
+        protected async loadInstrumentationModule() {
+          if (!this.serverOptions.dev) {
+            try {
+              this.instrumentation = await dynamicRequire(
+                resolve(
+                  this.serverOptions.dir || '.',
+                  this.serverOptions.conf.distDir!,
+                  'server',
+                  INSTRUMENTATION_HOOK_FILENAME
+                )
+              )
+            } catch (err: any) {
+              if (err.code !== 'MODULE_NOT_FOUND') {
+                throw new Error(
+                  'An error occurred while loading the instrumentation hook',
+                  { cause: err }
+                )
+              }
+            }
+          }
+          return this.instrumentation
+        }
+      }
+    `;
+    test("patch when an instrumentation file is not present", async () => {
+        expect(patchCode(code, getNext15Rule(null))).toMatchInlineSnapshot(`
+        "export default class NextNodeServer extends BaseServer {
+                async loadInstrumentationModule() { this.instrumentation = null; return this.instrumentation; }
+              }
+            "
+      `);
+    });
+    test("patch when an instrumentation file is present", async () => {
+        expect(patchCode(code, getNext15Rule("/_file_exists_/instrumentation.js"))).toMatchInlineSnapshot(`
+        "export default class NextNodeServer extends BaseServer {
+                async loadInstrumentationModule() { this.instrumentation = require('/_file_exists_/instrumentation.js'); return this.instrumentation; }
+              }
+            "
+      `);
+    });
+});
+describe("prepareImpl (Next14)", () => {
+    const code = `
+      export default class NextNodeServer extends BaseServer {
+          async prepareImpl() {
+            await super.prepareImpl();
+            if (!this.serverOptions.dev && this.nextConfig.experimental.instrumentationHook) {
+              try {
+                const instrumentationHook = await dynamicRequire((0, _path.resolve)(this.serverOptions.dir || ".", this.serverOptions.conf.distDir, "server", _constants1.INSTRUMENTATION_HOOK_FILENAME));
+                await (instrumentationHook.register == null ? void 0 : instrumentationHook.register.call(instrumentationHook));
+              } catch (err2) {
+                if (err2.code !== "MODULE_NOT_FOUND") {
+                  err2.message = \`An error occurred while loading instrumentation hook: \${err2.message}\`;
+                  throw err2;
+                }
+              }
+            }
+          }
+      }
+    `;
+    test("patch when an instrumentation file is not present", async () => {
+        expect(patchCode(code, getNext14Rule(null))).toMatchInlineSnapshot(`
+      "export default class NextNodeServer extends BaseServer {
+                async prepareImpl() {
+        await super.prepareImpl();
+        const instrumentationHook = {};
+        await (instrumentationHook.register == null ? void 0 : instrumentationHook.register.call(instrumentationHook));
+      }
+            }
+          "
+    `);
+    });
+    test("patch when an instrumentation file is present", async () => {
+        expect(patchCode(code, getNext14Rule("/_file_exists_/instrumentation.js"))).toMatchInlineSnapshot(`
+      "export default class NextNodeServer extends BaseServer {
+                async prepareImpl() {
+        await super.prepareImpl();
+        const instrumentationHook = require('/_file_exists_/instrumentation.js');
+        await (instrumentationHook.register == null ? void 0 : instrumentationHook.register.call(instrumentationHook));
+      }
+            }
+          "
+    `);
+    });
+});

package/dist/cli/build/patches/plugins/load-manifest.d.ts

@@ -1,5 +1,5 @@
 /**
- * Inline `loadManifest` as it relies on `readFileSync`that is not supported by workerd.
+ * Inline `loadManifest` as it relies on `readFileSync` that is not supported by workerd.
  */
 import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
 import type { ContentUpdater } from "./content-updater.js";

package/dist/cli/build/patches/plugins/load-manifest.js

@@ -1,5 +1,5 @@
 /**
- * Inline `loadManifest` as it relies on `readFileSync`that is not supported by workerd.
+ * Inline `loadManifest` as it relies on `readFileSync` that is not supported by workerd.
  */
 import { readFile } from "node:fs/promises";
 import { join, relative } from "node:path";

package/dist/cli/build/patches/plugins/patch-depd-deprecations.d.ts

@@ -0,0 +1,9 @@
+import type { ContentUpdater } from "./content-updater.js";
+/**
+ * Some dependencies of Next.js use depd to deprecate some of their functions, depd uses `eval` to generate
+ * a deprecated version of such functions, this causes `eval` warnings in the terminal even if these functions
+ * are never called, this function fixes that by patching the depd `wrapfunction` function so that it still
+ * retains the same type of behavior but without using `eval`
+ */
+export declare function patchDepdDeprecations(updater: ContentUpdater): import("esbuild").Plugin;
+export declare const rule = "\nrule:\n  kind: function_declaration\n  pattern: function wrapfunction($FN, $MESSAGE) { $$$ }\n  all:\n    - has:\n        kind: variable_declarator\n        stopBy: end\n        has:\n          field: name\n          pattern: deprecatedfn\n    - has:\n        kind: call_expression\n        stopBy: end\n        has:\n          kind: identifier\n          pattern: eval\nfix:\n  function wrapfunction($FN, $MESSAGE) {\n    if(typeof $FN !== 'function') throw new Error(\"argument fn must be a function\");\n    return function deprecated_$FN(...args) {\n      console.warn($MESSAGE);\n      return $FN(...args);\n    }\n  }\n";

package/dist/cli/build/patches/plugins/patch-depd-deprecations.js

@@ -0,0 +1,36 @@
+import { patchCode } from "../ast/util.js";
+/**
+ * Some dependencies of Next.js use depd to deprecate some of their functions, depd uses `eval` to generate
+ * a deprecated version of such functions, this causes `eval` warnings in the terminal even if these functions
+ * are never called, this function fixes that by patching the depd `wrapfunction` function so that it still
+ * retains the same type of behavior but without using `eval`
+ */
+export function patchDepdDeprecations(updater) {
+    return updater.updateContent("patch-depd-deprecations", { filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/, contentFilter: /argument fn must be a function/ }, ({ contents }) => patchCode(contents, rule));
+}
+export const rule = `
+rule:
+  kind: function_declaration
+  pattern: function wrapfunction($FN, $MESSAGE) { $$$ }
+  all:
+    - has:
+        kind: variable_declarator
+        stopBy: end
+        has:
+          field: name
+          pattern: deprecatedfn
+    - has:
+        kind: call_expression
+        stopBy: end
+        has:
+          kind: identifier
+          pattern: eval
+fix:
+  function wrapfunction($FN, $MESSAGE) {
+    if(typeof $FN !== 'function') throw new Error("argument fn must be a function");
+    return function deprecated_$FN(...args) {
+      console.warn($MESSAGE);
+      return $FN(...args);
+    }
+  }
+`;

package/dist/cli/build/patches/plugins/patch-depd-deprecations.spec.d.ts

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

package/dist/cli/build/patches/plugins/patch-depd-deprecations.spec.js

@@ -0,0 +1,29 @@
+import { describe, expect, test } from "vitest";
+import { patchCode } from "../ast/util.js";
+import { rule } from "./patch-depd-deprecations.js";
+describe("patchDepdDeprecations", () => {
+    test("patch", () => {
+        const code = `
+      function prepareObjectStackTrace(e,t){
+        return t
+      }
+      function wrapfunction(fn,message){
+        if(typeof fn!=="function"){
+          throw new TypeError("argument fn must be a function")
+        }
+        var args=createArgumentsString(fn.length);
+        var deprecate=this;
+        var stack=getStack();
+        var site=callSiteLocation(stack[1]);
+        site.name=fn.name;
+        var deprecatedfn=eval("(function ("+args+") {\\n"+'"use strict"\\n'+"log.call(deprecate, message, site)\\n"+"return fn.apply(this, arguments)\\n"+"})");
+        return deprecatedfn;
+      }`;
+        expect(patchCode(code, rule)).toMatchInlineSnapshot(`
+      "function prepareObjectStackTrace(e,t){
+              return t
+            }
+            function wrapfunction(fn, message) { if(typeof fn !== 'function') throw new Error("argument fn must be a function"); return function deprecated_fn(...args) { console.warn(message); return fn(...args); } }"
+    `);
+    });
+});

package/dist/cli/build/utils/ensure-cf-config.js

@@ -10,7 +10,8 @@ export function ensureCloudflareConfig(config) {
         dftUseEdgeConverter: config.default?.override?.converter === "edge",
         dftMaybeUseCache: config.default?.override?.incrementalCache === "dummy" ||
             typeof config.default?.override?.incrementalCache === "function",
-        dftUseDummyTagCache: config.default?.override?.tagCache === "dummy",
+        dftMaybeUseTagCache: config.default?.override?.tagCache === "dummy" ||
+            typeof config.default?.override?.incrementalCache === "function",
         dftMaybeUseQueue: config.default?.override?.queue === "dummy" ||
             config.default?.override?.queue === "direct" ||
             typeof config.default?.override?.queue === "function",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -63,7 +63,7 @@
   "dependencies": {
     "@ast-grep/napi": "^0.34.1",
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "https://pkg.pr.new/@opennextjs/aws@733",
+    "@opennextjs/aws": "https://pkg.pr.new/@opennextjs/aws@748",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",
     "yaml": "^2.7.0"

package/dist/cli/build/patches/plugins/load-instrumentation.d.ts

@@ -1,6 +0,0 @@
-/**
- * `loadInstrumentationModule` uses a dynamic require which is not supported.
- */
-import type { ContentUpdater } from "./content-updater.js";
-export declare const instrumentationRule = "\nrule:\n  kind: method_definition\n  all:\n    - has: {field: name, regex: ^loadInstrumentationModule$}\n    - has: {pattern: dynamicRequire, stopBy: end}\n\nfix: async loadInstrumentationModule() { }\n";
-export declare function patchLoadInstrumentation(updater: ContentUpdater): import("esbuild").Plugin;

package/dist/cli/build/patches/plugins/load-instrumentation.js

@@ -1,16 +0,0 @@
-/**
- * `loadInstrumentationModule` uses a dynamic require which is not supported.
- */
-import { patchCode } from "../ast/util.js";
-export const instrumentationRule = `
-rule:
-  kind: method_definition
-  all:
-    - has: {field: name, regex: ^loadInstrumentationModule$}
-    - has: {pattern: dynamicRequire, stopBy: end}
-
-fix: async loadInstrumentationModule() { }
-`;
-export function patchLoadInstrumentation(updater) {
-    return updater.updateContent("patch-load-instrumentation", { filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/, contentFilter: /async loadInstrumentationModule\(/ }, ({ contents }) => patchCode(contents, instrumentationRule));
-}

package/dist/cli/build/patches/plugins/load-instrumentation.spec.js

@@ -1,45 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { patchCode } from "../ast/util.js";
-import { instrumentationRule } from "./load-instrumentation.js";
-describe("LoadInstrumentationModule", () => {
-    test("patch", () => {
-        const code = `
-export default class NextNodeServer extends BaseServer<
-  Options,
-  NodeNextRequest,
-  NodeNextResponse
-> {
-  protected async loadInstrumentationModule() {
-    if (!this.serverOptions.dev) {
-      try {
-        this.instrumentation = await dynamicRequire(
-          resolve(
-            this.serverOptions.dir || '.',
-            this.serverOptions.conf.distDir!,
-            'server',
-            INSTRUMENTATION_HOOK_FILENAME
-          )
-        )
-      } catch (err: any) {
-        if (err.code !== 'MODULE_NOT_FOUND') {
-          throw new Error(
-            'An error occurred while loading the instrumentation hook',
-            { cause: err }
-          )
-        }
-      }
-    }
-    return this.instrumentation
-  }
-}`;
-        expect(patchCode(code, instrumentationRule)).toMatchInlineSnapshot(`
-      "export default class NextNodeServer extends BaseServer<
-        Options,
-        NodeNextRequest,
-        NodeNextResponse
-      > {
-        async loadInstrumentationModule() { }
-      }"
-    `);
-    });
-});

package/dist/cli/build/patches/to-investigate/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./inline-middleware-manifest-require.js";
-export * from "./patch-exception-bubbling.js";
-export * from "./patch-read-file.js";

package/dist/cli/build/patches/to-investigate/index.js

@@ -1,3 +0,0 @@
-export * from "./inline-middleware-manifest-require.js";
-export * from "./patch-exception-bubbling.js";
-export * from "./patch-read-file.js";

package/dist/cli/build/patches/to-investigate/patch-exception-bubbling.d.ts

@@ -1,7 +0,0 @@
-/**
- * When using SSG and `dynamicParams = false`, Next.js throws a NoFallbackError. This error is
- * bubbled up by default in Node.js servers, however this causes issues in the workerd with
- * the current response handling and streaming implementation we have, and leads to hanging
- * promises.
- */
-export declare function patchExceptionBubbling(code: string): string;

package/dist/cli/build/patches/to-investigate/patch-exception-bubbling.js

@@ -1,17 +0,0 @@
-/**
- * When using SSG and `dynamicParams = false`, Next.js throws a NoFallbackError. This error is
- * bubbled up by default in Node.js servers, however this causes issues in the workerd with
- * the current response handling and streaming implementation we have, and leads to hanging
- * promises.
- */
-export function patchExceptionBubbling(code) {
-    // The code before had: `query._nextBubbleNoFallback = '1'`, that has ben refactored to
-    // `addRequestMeta(req, 'bubbleNoFallback', true)` in https://github.com/vercel/next.js/pull/74100
-    // we need to support both for backward compatibility, that's why we have the following if statement
-    if (code.includes("_nextBubbleNoFallback")) {
-        return code.replace('_nextBubbleNoFallback = "1"', "_nextBubbleNoFallback = undefined");
-    }
-    // The Next.js transpiled code contains something like `(0, _requestmeta.addRequestMeta)(req, "bubbleNoFallback", true);`
-    // and we want to update it to `(0, _requestmeta.addRequestMeta)(req, "bubbleNoFallback", false);`
-    return code.replace(/\((.*?.addRequestMeta\)\(.*?,\s+"bubbleNoFallback"),\s+true\)/, "($1, false)");
-}

package/dist/cli/build/patches/to-investigate/patch-read-file.d.ts

@@ -1,2 +0,0 @@
-import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
-export declare function patchBuildId(code: string, buildOpts: BuildOptions): string;

package/dist/cli/build/patches/to-investigate/patch-read-file.js

@@ -1,7 +0,0 @@
-import { getBuildId } from "@opennextjs/aws/build/helper.js";
-export function patchBuildId(code, buildOpts) {
-    // The Next code gets the buildId from the filesystem so we hardcode the value at build time.
-    return code.replace("getBuildId() {", `getBuildId() {
-      return ${JSON.stringify(getBuildId(buildOpts))};
-    `);
-}