@opennextjs/cloudflare 0.4.6 → 0.4.8

package/dist/api/kv-cache.d.ts

@@ -0,0 +1,22 @@
+import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides";
+export declare const CACHE_ASSET_DIR = "cdn-cgi/_next_cache";
+export declare const STATUS_DELETED = 1;
+/**
+ * Open Next cache based on cloudflare KV and Assets.
+ *
+ * Note: The class is instantiated outside of the request context.
+ * The cloudflare context and process.env are not initialzed yet
+ * when the constructor is called.
+ */
+declare class Cache implements IncrementalCache {
+    readonly name = "cloudflare-kv";
+    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
+    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
+    delete(key: string): Promise<void>;
+    protected getKVKey(key: string, isFetch?: boolean): string;
+    protected getAssetUrl(key: string, isFetch?: boolean): string;
+    protected debug(...args: unknown[]): void;
+    protected getBuildId(): string;
+}
+declare const _default: Cache;
+export default _default;

package/dist/api/kv-cache.js

@@ -0,0 +1,123 @@
+import { IgnorableError, RecoverableError } from "@opennextjs/aws/utils/error.js";
+import { getCloudflareContext } from "./cloudflare-context.js";
+export const CACHE_ASSET_DIR = "cdn-cgi/_next_cache";
+export const STATUS_DELETED = 1;
+/**
+ * Open Next cache based on cloudflare KV and Assets.
+ *
+ * Note: The class is instantiated outside of the request context.
+ * The cloudflare context and process.env are not initialzed yet
+ * when the constructor is called.
+ */
+class Cache {
+    name = "cloudflare-kv";
+    async get(key, isFetch) {
+        const cfEnv = getCloudflareContext().env;
+        const kv = cfEnv.NEXT_CACHE_WORKERS_KV;
+        const assets = cfEnv.ASSETS;
+        if (!(kv || assets)) {
+            throw new IgnorableError(`No KVNamespace nor Fetcher`);
+        }
+        this.debug(`Get ${key}`);
+        try {
+            let entry = null;
+            if (kv) {
+                this.debug(`- From KV`);
+                const kvKey = this.getKVKey(key, isFetch);
+                entry = await kv.get(kvKey, "json");
+                if (entry?.status === STATUS_DELETED) {
+                    return null;
+                }
+            }
+            if (!entry && assets) {
+                this.debug(`- From Assets`);
+                const url = this.getAssetUrl(key, isFetch);
+                const response = await assets.fetch(url);
+                if (response.ok) {
+                    // TODO: consider populating KV with the asset value if faster.
+                    // This could be optional as KV writes are $$.
+                    // See https://github.com/opennextjs/opennextjs-cloudflare/pull/194#discussion_r1893166026
+                    entry = {
+                        value: await response.json(),
+                        // __BUILD_TIMESTAMP_MS__ is injected by ESBuild.
+                        lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
+                    };
+                }
+                if (!kv) {
+                    // The cache can not be updated when there is no KV
+                    // As we don't want to keep serving stale data for ever,
+                    // we pretend the entry is not in cache
+                    if (entry?.value &&
+                        "kind" in entry.value &&
+                        entry.value.kind === "FETCH" &&
+                        entry.value.data?.headers?.expires) {
+                        const expiresTime = new Date(entry.value.data.headers.expires).getTime();
+                        if (!isNaN(expiresTime) && expiresTime <= Date.now()) {
+                            this.debug(`found expired entry (expire time: ${entry.value.data.headers.expires})`);
+                            return null;
+                        }
+                    }
+                }
+            }
+            this.debug(entry ? `-> hit` : `-> miss`);
+            return { value: entry?.value, lastModified: entry?.lastModified };
+        }
+        catch {
+            throw new RecoverableError(`Failed to get cache [${key}]`);
+        }
+    }
+    async set(key, value, isFetch) {
+        const kv = getCloudflareContext().env.NEXT_CACHE_WORKERS_KV;
+        if (!kv) {
+            throw new IgnorableError(`No KVNamespace`);
+        }
+        this.debug(`Set ${key}`);
+        try {
+            const kvKey = this.getKVKey(key, isFetch);
+            // Note: We can not set a TTL as we might fallback to assets,
+            //       still removing old data (old BUILD_ID) could help avoiding
+            //       the cache growing too big.
+            await kv.put(kvKey, JSON.stringify({
+                value,
+                // Note: `Date.now()` returns the time of the last IO rather than the actual time.
+                //       See https://developers.cloudflare.com/workers/reference/security-model/
+                lastModified: Date.now(),
+            }));
+        }
+        catch {
+            throw new RecoverableError(`Failed to set cache [${key}]`);
+        }
+    }
+    async delete(key) {
+        const kv = getCloudflareContext().env.NEXT_CACHE_WORKERS_KV;
+        if (!kv) {
+            throw new IgnorableError(`No KVNamespace`);
+        }
+        this.debug(`Delete ${key}`);
+        try {
+            const kvKey = this.getKVKey(key, /* isFetch= */ false);
+            // Do not delete the key as we would then fallback to the assets.
+            await kv.put(kvKey, JSON.stringify({ status: STATUS_DELETED }));
+        }
+        catch {
+            throw new RecoverableError(`Failed to delete cache [${key}]`);
+        }
+    }
+    getKVKey(key, isFetch) {
+        return `${this.getBuildId()}/${key}.${isFetch ? "fetch" : "cache"}`;
+    }
+    getAssetUrl(key, isFetch) {
+        return isFetch
+            ? `http://assets.local/${CACHE_ASSET_DIR}/__fetch/${this.getBuildId()}/${key}`
+            : `http://assets.local/${CACHE_ASSET_DIR}/${this.getBuildId()}/${key}.cache`;
+    }
+    debug(...args) {
+        if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
+            console.log(`[Cache ${this.name}] `, ...args);
+        }
+    }
+    getBuildId() {
+        return process.env.NEXT_BUILD_ID ?? "no-build-id";
+    }
+}
+export default new Cache();

package/dist/api/kvCache.d.ts

@@ -1,22 +1,5 @@
-import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides";
-export declare const CACHE_ASSET_DIR = "cnd-cgi/_next_cache";
-export declare const STATUS_DELETED = 1;
+import cache from "./kv-cache.js";
 /**
- * Open Next cache based on cloudflare KV and Assets.
- *
- * Note: The class is instantiated outside of the request context.
- * The cloudflare context and process.env are not initialzed yet
- * when the constructor is called.
+ * @deprecated Please import from `kv-cache` instead of `kvCache`.
  */
-declare class Cache implements IncrementalCache {
-    readonly name = "cloudflare-kv";
-    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>>>;
-    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
-    delete(key: string): Promise<void>;
-    protected getKVKey(key: string, isFetch?: boolean): string;
-    protected getAssetUrl(key: string, isFetch?: boolean): string;
-    protected debug(...args: unknown[]): void;
-    protected getBuildId(): string;
-}
-declare const _default: Cache;
-export default _default;
+export default cache;

package/dist/api/kvCache.js

@@ -1,108 +1,5 @@
-import { IgnorableError, RecoverableError } from "@opennextjs/aws/utils/error.js";
-import { getCloudflareContext } from "./cloudflare-context.js";
-export const CACHE_ASSET_DIR = "cnd-cgi/_next_cache";
-export const STATUS_DELETED = 1;
+import cache from "./kv-cache.js";
 /**
- * Open Next cache based on cloudflare KV and Assets.
- *
- * Note: The class is instantiated outside of the request context.
- * The cloudflare context and process.env are not initialzed yet
- * when the constructor is called.
+ * @deprecated Please import from `kv-cache` instead of `kvCache`.
  */
-class Cache {
-    name = "cloudflare-kv";
-    async get(key, isFetch) {
-        const cfEnv = getCloudflareContext().env;
-        const kv = cfEnv.NEXT_CACHE_WORKERS_KV;
-        const assets = cfEnv.ASSETS;
-        if (!(kv || assets)) {
-            throw new IgnorableError(`No KVNamespace nor Fetcher`);
-        }
-        this.debug(`Get ${key}`);
-        try {
-            let entry = null;
-            if (kv) {
-                this.debug(`- From KV`);
-                const kvKey = this.getKVKey(key, isFetch);
-                entry = await kv.get(kvKey, "json");
-                if (entry?.status === STATUS_DELETED) {
-                    return {};
-                }
-            }
-            if (!entry && assets) {
-                this.debug(`- From Assets`);
-                const url = this.getAssetUrl(key, isFetch);
-                const response = await assets.fetch(url);
-                if (response.ok) {
-                    // TODO: consider populating KV with the asset value if faster.
-                    // This could be optional as KV writes are $$.
-                    // See https://github.com/opennextjs/opennextjs-cloudflare/pull/194#discussion_r1893166026
-                    entry = {
-                        value: await response.json(),
-                        // __BUILD_TIMESTAMP_MS__ is injected by ESBuild.
-                        lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
-                    };
-                }
-            }
-            this.debug(entry ? `-> hit` : `-> miss`);
-            return { value: entry?.value, lastModified: entry?.lastModified };
-        }
-        catch {
-            throw new RecoverableError(`Failed to get cache [${key}]`);
-        }
-    }
-    async set(key, value, isFetch) {
-        const kv = getCloudflareContext().env.NEXT_CACHE_WORKERS_KV;
-        if (!kv) {
-            throw new IgnorableError(`No KVNamespace`);
-        }
-        this.debug(`Set ${key}`);
-        try {
-            const kvKey = this.getKVKey(key, isFetch);
-            // Note: We can not set a TTL as we might fallback to assets,
-            //       still removing old data (old BUILD_ID) could help avoiding
-            //       the cache growing too big.
-            await kv.put(kvKey, JSON.stringify({
-                value,
-                // Note: `Date.now()` returns the time of the last IO rather than the actual time.
-                //       See https://developers.cloudflare.com/workers/reference/security-model/
-                lastModified: Date.now(),
-            }));
-        }
-        catch {
-            throw new RecoverableError(`Failed to set cache [${key}]`);
-        }
-    }
-    async delete(key) {
-        const kv = getCloudflareContext().env.NEXT_CACHE_WORKERS_KV;
-        if (!kv) {
-            throw new IgnorableError(`No KVNamespace`);
-        }
-        this.debug(`Delete ${key}`);
-        try {
-            const kvKey = this.getKVKey(key, /* isFetch= */ false);
-            // Do not delete the key as we would then fallback to the assets.
-            await kv.put(kvKey, JSON.stringify({ status: STATUS_DELETED }));
-        }
-        catch {
-            throw new RecoverableError(`Failed to delete cache [${key}]`);
-        }
-    }
-    getKVKey(key, isFetch) {
-        return `${this.getBuildId()}/${key}.${isFetch ? "fetch" : "cache"}`;
-    }
-    getAssetUrl(key, isFetch) {
-        return isFetch
-            ? `http://assets.local/${CACHE_ASSET_DIR}/__fetch/${this.getBuildId()}/${key}`
-            : `http://assets.local/${CACHE_ASSET_DIR}/${this.getBuildId()}/${key}.cache`;
-    }
-    debug(...args) {
-        if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
-            console.log(`[Cache ${this.name}] `, ...args);
-        }
-    }
-    getBuildId() {
-        return process.env.NEXT_BUILD_ID ?? "no-build-id";
-    }
-}
-export default new Cache();
+export default cache;

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

@@ -3,12 +3,15 @@ import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { getPackagePath } from "@opennextjs/aws/build/helper.js";
-import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
 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 { ContentUpdater } from "./patches/plugins/content-updater.js";
+import { patchLoadInstrumentation } from "./patches/plugins/load-instrumentation.js";
 import { handleOptionalDependencies } from "./patches/plugins/optional-deps.js";
 import { fixRequire } from "./patches/plugins/require.js";
+import { shimRequireHook } from "./patches/plugins/require-hook.js";
 import { inlineRequirePagePlugin } from "./patches/plugins/require-page.js";
 import { setWranglerExternal } from "./patches/plugins/wrangler-external.js";
 import { normalizePath, patchCodeWithValidations } from "./utils/index.js";
@@ -36,12 +39,13 @@ export async function bundleServer(buildOpts) {
     const serverFiles = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next/required-server-files.json");
     const nextConfig = JSON.parse(fs.readFileSync(serverFiles, "utf-8")).config;
     console.log(`\x1b[35m⚙️ Bundling the OpenNext server...\n\x1b[0m`);
-    await patches.updateWebpackChunksFile(buildOpts);
+    await patchWebpackRuntime(buildOpts);
     patchVercelOgLibrary(buildOpts);
     const outputPath = path.join(outputDir, "server-functions", "default");
     const packagePath = getPackagePath(buildOpts);
     const openNextServer = path.join(outputPath, packagePath, `index.mjs`);
     const openNextServerBundle = path.join(outputPath, packagePath, `handler.mjs`);
+    const updater = new ContentUpdater();
     const result = await build({
         entryPoints: [openNextServer],
         bundle: true,
@@ -61,11 +65,14 @@ export async function bundleServer(buildOpts) {
         // - ESBuild `node` platform: https://esbuild.github.io/api/#platform
         conditions: [],
         plugins: [
-            createFixRequiresESBuildPlugin(buildOpts),
-            inlineRequirePagePlugin(buildOpts),
+            shimRequireHook(buildOpts),
+            inlineRequirePagePlugin(updater, buildOpts),
             setWranglerExternal(),
-            fixRequire(),
+            fixRequire(updater),
             handleOptionalDependencies(optionalDependencies),
+            patchLoadInstrumentation(updater),
+            // Apply updater updaters, must be the last plugin
+            updater.plugin,
         ],
         external: ["./middleware/handler.mjs"],
         alias: {
@@ -161,7 +168,6 @@ export async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
             (code) => patches.inlineMiddlewareManifestRequire(code, buildOpts),
         ],
         ["exception bubbling", patches.patchExceptionBubbling],
-        ["`loadInstrumentationModule` function", patches.patchLoadInstrumentationModule],
         [
             "`patchAsyncStorage` call",
             (code) => code
@@ -176,17 +182,6 @@ export async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
     ]);
     await writeFile(workerOutputFile, patchedCode);
 }
-function createFixRequiresESBuildPlugin(options) {
-    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: path.join(options.outputDir, "cloudflare-templates/shims/empty.js"),
-            }));
-        },
-    };
-}
 /**
  * Gets the path of the worker.js file generated by the build process
  *

package/dist/cli/build/open-next/copyCacheAssets.js

@@ -1,6 +1,6 @@
 import { cpSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { CACHE_ASSET_DIR } from "../../../api/kvCache.js";
+import { CACHE_ASSET_DIR } from "../../../api/kv-cache.js";
 export function copyCacheAssets(options) {
     const { outputDir } = options;
     const srcPath = join(outputDir, "cache");

package/dist/cli/build/patches/ast/webpack-runtime.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Inline dynamic requires in the webpack runtime.
+ *
+ * The webpack runtime has dynamic requires that would not be bundled by ESBuild:
+ *
+ *     installChunk(require("./chunks/" + __webpack_require__.u(chunkId)));
+ *
+ *  This patch unrolls the dynamic require for all the existing chunks:
+ *
+ *     switch (chunkId) {
+ *       case ID1: installChunk(require("./chunks/ID1"); break;
+ *       case ID2: installChunk(require("./chunks/ID2"); break;
+ *       // ...
+ *       case SELF_ID: installedChunks[chunkId] = 1; break;
+ *       default: throw new Error(`Unknown chunk ${chunkId}`);
+ *     }
+ */
+import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
+export declare function buildInlineChunksRule(chunks: number[]): string;
+/**
+ * Fixes the webpack-runtime.js file by removing its webpack dynamic requires.
+ */
+export declare function patchWebpackRuntime(buildOpts: BuildOptions): Promise<void>;

package/dist/cli/build/patches/ast/webpack-runtime.js

@@ -0,0 +1,57 @@
+/**
+ * Inline dynamic requires in the webpack runtime.
+ *
+ * The webpack runtime has dynamic requires that would not be bundled by ESBuild:
+ *
+ *     installChunk(require("./chunks/" + __webpack_require__.u(chunkId)));
+ *
+ *  This patch unrolls the dynamic require for all the existing chunks:
+ *
+ *     switch (chunkId) {
+ *       case ID1: installChunk(require("./chunks/ID1"); break;
+ *       case ID2: installChunk(require("./chunks/ID2"); break;
+ *       // ...
+ *       case SELF_ID: installedChunks[chunkId] = 1; break;
+ *       default: throw new Error(`Unknown chunk ${chunkId}`);
+ *     }
+ */
+import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getPackagePath } from "@opennextjs/aws/build/helper.js";
+import { patchCode } from "./util.js";
+export function buildInlineChunksRule(chunks) {
+    return `
+rule:
+  pattern: ($CHUNK_ID, $_PROMISES) => { $$$ }
+  inside: {pattern: $_.$_.require = $$$_, stopBy: end}
+  all:
+    - has: {pattern: $INSTALL(require("./chunks/" + $$$)), stopBy: end}
+    - has: {pattern: $SELF_ID != $CHUNK_ID, stopBy: end}
+    - has: {pattern: "$INSTALLED_CHUNK[$CHUNK_ID] = 1", stopBy: end}
+fix: |
+  ($CHUNK_ID, _) => {
+    if (!$INSTALLED_CHUNK[$CHUNK_ID]) {
+      switch ($CHUNK_ID) {
+${chunks.map((chunk) => `         case ${chunk}: $INSTALL(require("./chunks/${chunk}.js")); break;`).join("\n")}
+         case $SELF_ID: $INSTALLED_CHUNK[$CHUNK_ID] = 1; break;
+         default: throw new Error(\`Unknown chunk \${$CHUNK_ID}\`);
+      }
+    }
+  }`;
+}
+/**
+ * Fixes the webpack-runtime.js file by removing its webpack dynamic requires.
+ */
+export async function patchWebpackRuntime(buildOpts) {
+    const { outputDir } = buildOpts;
+    const dotNextServerDir = join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next/server");
+    const runtimeFile = join(dotNextServerDir, "webpack-runtime.js");
+    const runtimeCode = readFileSync(runtimeFile, "utf-8");
+    // Look for all the chunks.
+    const chunks = readdirSync(join(dotNextServerDir, "chunks"))
+        .filter((chunk) => /^\d+\.js$/.test(chunk))
+        .map((chunk) => {
+        return Number(chunk.replace(/\.js$/, ""));
+    });
+    writeFileSync(runtimeFile, patchCode(runtimeCode, buildInlineChunksRule(chunks)));
+}

package/dist/cli/build/patches/ast/webpack-runtime.spec.js

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "vitest";
+import { patchCode } from "./util.js";
+import { buildInlineChunksRule } from "./webpack-runtime.js";
+describe("webpack runtime", () => {
+    test("patch runtime", () => {
+        const code = `
+        /******/ 		// require() chunk loading for javascript
+        /******/ 		__webpack_require__.f.require = (chunkId, promises) => {
+        /******/ 			// "1" is the signal for "already loaded"
+        /******/ 			if (!installedChunks[chunkId]) {
+        /******/ 				if (658 != chunkId) {
+        /******/ 					installChunk(require("./chunks/" + __webpack_require__.u(chunkId)));
+                    /******/
+                } else installedChunks[chunkId] = 1;
+                /******/
+            }
+            /******/
+        };
+    `;
+        expect(patchCode(code, buildInlineChunksRule([1, 2, 3]))).toMatchInlineSnapshot(`
+      "/******/ 		// require() chunk loading for javascript
+              /******/ 		__webpack_require__.f.require = (chunkId, _) => {
+        if (!installedChunks[chunkId]) {
+          switch (chunkId) {
+             case 1: installChunk(require("./chunks/1.js")); break;
+             case 2: installChunk(require("./chunks/2.js")); break;
+             case 3: installChunk(require("./chunks/3.js")); break;
+             case 658: installedChunks[chunkId] = 1; break;
+             default: throw new Error(\`Unknown chunk \${chunkId}\`);
+          }
+        }
+      }
+      ;
+          "
+    `);
+    });
+    test("patch minified runtime", () => {
+        const code = `
+    t.f.require=(o,n)=>{e[o]||(658!=o?r(require("./chunks/"+t.u(o))):e[o]=1)}
+    `;
+        expect(patchCode(code, buildInlineChunksRule([1, 2, 3]))).toMatchInlineSnapshot(`
+      "t.f.require=(o, _) => {
+        if (!e[o]) {
+          switch (o) {
+             case 1: r(require("./chunks/1.js")); break;
+             case 2: r(require("./chunks/2.js")); break;
+             case 3: r(require("./chunks/3.js")); break;
+             case 658: e[o] = 1; break;
+             default: throw new Error(\`Unknown chunk \${o}\`);
+          }
+        }
+      }
+
+          "
+    `);
+    });
+});

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

@@ -1,4 +1,3 @@
 export * from "./copy-package-cli-files.js";
 export * from "./patch-cache.js";
 export * from "./patch-require.js";
-export * from "./update-webpack-chunks-file/index.js";

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

@@ -1,4 +1,3 @@
 export * from "./copy-package-cli-files.js";
 export * from "./patch-cache.js";
 export * from "./patch-require.js";
-export * from "./update-webpack-chunks-file/index.js";

package/dist/cli/build/patches/plugins/content-updater.d.ts

@@ -0,0 +1,34 @@
+/**
+ * ESBuild stops calling `onLoad` hooks after the first hook returns an updated content.
+ *
+ * The updater allows multiple plugins to update the content.
+ */
+import { type OnLoadOptions, type Plugin, type PluginBuild } from "esbuild";
+export type Callback = (args: {
+    contents: string;
+    path: string;
+}) => string | undefined | Promise<string | undefined>;
+export type Updater = OnLoadOptions & {
+    callback: Callback;
+};
+export declare class ContentUpdater {
+    updaters: Map<string, Updater>;
+    /**
+     * Register a callback to update the file content.
+     *
+     * The callbacks are called in order of registration.
+     *
+     * @param name The name of the plugin (must be unique).
+     * @param options Same options as the `onLoad` hook to restrict updates.
+     * @param callback The callback updating the content.
+     * @returns A noop ESBuild plugin.
+     */
+    updateContent(name: string, options: OnLoadOptions, callback: Callback): Plugin;
+    /**
+     * Returns an ESBuild plugin applying the registered updates.
+     */
+    get plugin(): {
+        name: string;
+        setup: (build: PluginBuild) => Promise<void>;
+    };
+}

package/dist/cli/build/patches/plugins/content-updater.js

@@ -0,0 +1,52 @@
+/**
+ * ESBuild stops calling `onLoad` hooks after the first hook returns an updated content.
+ *
+ * The updater allows multiple plugins to update the content.
+ */
+import { readFile } from "node:fs/promises";
+export class ContentUpdater {
+    updaters = new Map();
+    /**
+     * Register a callback to update the file content.
+     *
+     * The callbacks are called in order of registration.
+     *
+     * @param name The name of the plugin (must be unique).
+     * @param options Same options as the `onLoad` hook to restrict updates.
+     * @param callback The callback updating the content.
+     * @returns A noop ESBuild plugin.
+     */
+    updateContent(name, options, callback) {
+        if (this.updaters.has(name)) {
+            throw new Error(`Plugin "${name}" already registered`);
+        }
+        this.updaters.set(name, { ...options, callback });
+        return {
+            name,
+            setup() { },
+        };
+    }
+    /**
+     * Returns an ESBuild plugin applying the registered updates.
+     */
+    get plugin() {
+        return {
+            name: "aggregate-on-load",
+            setup: async (build) => {
+                build.onLoad({ filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/ }, async (args) => {
+                    let contents = await readFile(args.path, "utf-8");
+                    for (const { filter, namespace, callback } of this.updaters.values()) {
+                        if (namespace !== undefined && args.namespace !== namespace) {
+                            continue;
+                        }
+                        if (!filter.test(args.path)) {
+                            continue;
+                        }
+                        contents = (await callback({ contents, path: args.path })) ?? contents;
+                    }
+                    return { contents };
+                });
+            },
+        };
+    }
+}

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

@@ -0,0 +1,6 @@
+/**
+ * `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

@@ -0,0 +1,20 @@
+/**
+ * `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)$/ }, ({ contents }) => {
+        if (/async loadInstrumentationModule\(/.test(contents)) {
+            return patchCode(contents, instrumentationRule);
+        }
+    });
+}