@opennextjs/cloudflare 0.2.0 → 0.3.0

package/dist/cli/build/index.js

@@ -0,0 +1,123 @@
+import { cpSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { buildNextjsApp, setStandaloneBuildMode } from "@opennextjs/aws/build/buildNextApp.js";
+import { compileCache } from "@opennextjs/aws/build/compileCache.js";
+import { compileOpenNextConfig } from "@opennextjs/aws/build/compileConfig.js";
+import { createCacheAssets, createStaticAssets } from "@opennextjs/aws/build/createAssets.js";
+import { createMiddleware } from "@opennextjs/aws/build/createMiddleware.js";
+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 { containsDotNextDir, getConfig } from "../config.js";
+import { bundleServer } from "./bundle-server.js";
+import { compileEnvFiles } from "./open-next/compile-env-files.js";
+import { copyCacheAssets } from "./open-next/copyCacheAssets.js";
+import { createServerBundle } from "./open-next/createServerBundle.js";
+/**
+ * Builds the application in a format that can be passed to workerd
+ *
+ * It saves the output in a `.worker-next` directory
+ *
+ * @param projectOpts The options for the project
+ */
+export async function build(projectOpts) {
+    printHeader("Cloudflare build");
+    showWarningOnWindows();
+    const baseDir = projectOpts.sourceDir;
+    const require = createRequire(import.meta.url);
+    const openNextDistDir = dirname(require.resolve("@opennextjs/aws/index.js"));
+    const { config, buildDir } = await compileOpenNextConfig(baseDir);
+    ensureCloudflareConfig(config);
+    // Initialize options
+    const options = buildHelper.normalizeOptions(config, openNextDistDir, buildDir);
+    logger.setLevel(options.debug ? "debug" : "info");
+    // Do not minify the code so that we can apply string replacement patch.
+    // Note that wrangler will still minify the bundle.
+    options.minify = false;
+    // Pre-build validation
+    buildHelper.checkRunningInsideNextjsApp(options);
+    logger.info(`App directory: ${options.appPath}`);
+    buildHelper.printNextjsVersion(options);
+    buildHelper.printOpenNextVersion(options);
+    if (projectOpts.skipNextBuild) {
+        logger.warn("Skipping Next.js build");
+    }
+    else {
+        // Build the next app
+        printHeader("Building Next.js app");
+        setStandaloneBuildMode(options);
+        buildNextjsApp(options);
+    }
+    if (!containsDotNextDir(projectOpts.sourceDir)) {
+        throw new Error(`.next folder not found in ${projectOpts.sourceDir}`);
+    }
+    // Generate deployable bundle
+    printHeader("Generating bundle");
+    buildHelper.initOutputDir(options);
+    // Compile cache.ts
+    compileCache(options);
+    // Compile .env files
+    compileEnvFiles(options);
+    // Compile middleware
+    await createMiddleware(options, { forceOnlyBuildOnce: true });
+    createStaticAssets(options);
+    if (config.dangerous?.disableIncrementalCache !== true) {
+        createCacheAssets(options);
+        copyCacheAssets(options);
+    }
+    await createServerBundle(options);
+    // TODO: drop this copy.
+    // Copy the .next directory to the output directory so it can be mutated.
+    cpSync(join(projectOpts.sourceDir, ".next"), join(projectOpts.outputDir, ".next"), { recursive: true });
+    const projConfig = getConfig(projectOpts);
+    // TODO: rely on options only.
+    await bundleServer(projConfig, options);
+    logger.info("OpenNext build complete.");
+}
+/**
+ * Ensures open next is configured for cloudflare.
+ *
+ * @param config OpenNext configuration.
+ */
+function ensureCloudflareConfig(config) {
+    const requirements = {
+        dftUseCloudflareWrapper: config.default?.override?.wrapper === "cloudflare-node",
+        dftUseEdgeConverter: config.default?.override?.converter === "edge",
+        dftMaybeUseCache: config.default?.override?.incrementalCache === "dummy" ||
+            typeof config.default?.override?.incrementalCache === "function",
+        dftUseDummyTagCacheAndQueue: config.default?.override?.tagCache === "dummy" && config.default?.override?.queue === "dummy",
+        disableCacheInterception: config.dangerous?.enableCacheInterception !== true,
+        mwIsMiddlewareExternal: config.middleware?.external == true,
+        mwUseCloudflareWrapper: config.middleware?.override?.wrapper === "cloudflare-edge",
+        mwUseEdgeConverter: config.middleware?.override?.converter === "edge",
+        mwUseFetchProxy: config.middleware?.override?.proxyExternalRequest === "fetch",
+    };
+    if (Object.values(requirements).some((satisfied) => !satisfied)) {
+        throw new Error(`open-next.config.ts should contain:
+{
+  default: {
+    override: {
+      wrapper: "cloudflare-node",
+      converter: "edge",
+      incrementalCache: "dummy" | function,
+      tagCache: "dummy",
+      queue: "dummy",
+    },
+  },
+
+  middleware: {
+    external: true,
+    override: {
+      wrapper: "cloudflare-edge",
+      converter: "edge",
+      proxyExternalRequest: "fetch",
+    },
+  },
+
+  "dangerous": {
+    "enableCacheInterception": false
+  }
+}`);
+    }
+}

package/dist/cli/build/open-next/compile-env-files.d.ts

@@ -0,0 +1,5 @@
+import { BuildOptions } from "@opennextjs/aws/build/helper.js";
+/**
+ * Compiles the values extracted from the project's env files to the output directory for use in the worker.
+ */
+export declare function compileEnvFiles(options: BuildOptions): void;

package/dist/cli/build/open-next/compile-env-files.js

@@ -0,0 +1,9 @@
+import fs from "node:fs";
+import path from "node:path";
+import { extractProjectEnvVars } from "../utils/index.js";
+/**
+ * Compiles the values extracted from the project's env files to the output directory for use in the worker.
+ */
+export function compileEnvFiles(options) {
+    ["production", "development", "test"].forEach((mode) => fs.appendFileSync(path.join(options.outputDir, `.env.mjs`), `export const ${mode} = ${JSON.stringify(extractProjectEnvVars(mode, options))};\n`));
+}

package/dist/cli/build/open-next/copyCacheAssets.d.ts

@@ -0,0 +1,2 @@
+import * as buildHelper from "@opennextjs/aws/build/helper.js";
+export declare function copyCacheAssets(options: buildHelper.BuildOptions): void;

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

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

package/dist/cli/build/open-next/createServerBundle.d.ts

@@ -0,0 +1,2 @@
+import * as buildHelper from "@opennextjs/aws/build/helper.js";
+export declare function createServerBundle(options: buildHelper.BuildOptions): Promise<void>;

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

@@ -0,0 +1,216 @@
+// Copy-Edit of @opennextjs/aws packages/open-next/src/build/createServerBundle.ts
+// Adapted for cloudflare workers
+import fs from "node:fs";
+import path from "node:path";
+import { bundleNextServer } from "@opennextjs/aws/build/bundleNextServer.js";
+import { compileCache } from "@opennextjs/aws/build/compileCache.js";
+import { copyTracedFiles } from "@opennextjs/aws/build/copyTracedFiles.js";
+import { generateEdgeBundle } from "@opennextjs/aws/build/edge/createEdgeBundle.js";
+import * as buildHelper from "@opennextjs/aws/build/helper.js";
+import { installDependencies } from "@opennextjs/aws/build/installDeps.js";
+import logger from "@opennextjs/aws/logger.js";
+import { minifyAll } from "@opennextjs/aws/minimize-js.js";
+import { openNextEdgePlugins } from "@opennextjs/aws/plugins/edge.js";
+import { openNextReplacementPlugin } from "@opennextjs/aws/plugins/replacement.js";
+import { openNextResolvePlugin } from "@opennextjs/aws/plugins/resolve.js";
+export async function createServerBundle(options) {
+    const { config } = options;
+    const foundRoutes = new Set();
+    // Get all functions to build
+    const defaultFn = config.default;
+    const functions = Object.entries(config.functions ?? {});
+    // Recompile cache.ts as ESM if any function is using Deno runtime
+    if (defaultFn.runtime === "deno" || functions.some(([, fn]) => fn.runtime === "deno")) {
+        compileCache(options, "esm");
+    }
+    const promises = functions.map(async ([name, fnOptions]) => {
+        const routes = fnOptions.routes;
+        routes.forEach((route) => foundRoutes.add(route));
+        if (fnOptions.runtime === "edge") {
+            await generateEdgeBundle(name, options, fnOptions);
+        }
+        else {
+            await generateBundle(name, options, fnOptions);
+        }
+    });
+    //TODO: throw an error if not all edge runtime routes has been bundled in a separate function
+    // We build every other function than default before so we know which route there is left
+    await Promise.all(promises);
+    const remainingRoutes = new Set();
+    const { appBuildOutputPath, monorepoRoot } = options;
+    const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
+    // Find remaining routes
+    const serverPath = path.join(appBuildOutputPath, ".next", "standalone", packagePath, ".next", "server");
+    // Find app dir routes
+    if (fs.existsSync(path.join(serverPath, "app"))) {
+        const appPath = path.join(serverPath, "app");
+        buildHelper.traverseFiles(appPath, ({ relativePath }) => relativePath.endsWith("page.js") || relativePath.endsWith("route.js"), ({ relativePath }) => {
+            const route = `app/${relativePath.replace(/\.js$/, "")}`;
+            if (!foundRoutes.has(route)) {
+                remainingRoutes.add(route);
+            }
+        });
+    }
+    // Find pages dir routes
+    if (fs.existsSync(path.join(serverPath, "pages"))) {
+        const pagePath = path.join(serverPath, "pages");
+        buildHelper.traverseFiles(pagePath, ({ relativePath }) => relativePath.endsWith(".js"), ({ relativePath }) => {
+            const route = `pages/${relativePath.replace(/\.js$/, "")}`;
+            if (!foundRoutes.has(route)) {
+                remainingRoutes.add(route);
+            }
+        });
+    }
+    // Generate default function
+    await generateBundle("default", options, {
+        ...defaultFn,
+        // @ts-expect-error - Those string are RouteTemplate
+        routes: Array.from(remainingRoutes),
+        patterns: ["*"],
+    });
+}
+async function generateBundle(name, options, fnOptions) {
+    const { appPath, appBuildOutputPath, config, outputDir, monorepoRoot } = options;
+    logger.info(`Building server function: ${name}...`);
+    // Create output folder
+    const outputPath = path.join(outputDir, "server-functions", name);
+    // Resolve path to the Next.js app if inside the monorepo
+    // note: if user's app is inside a monorepo, standalone mode places
+    //       `node_modules` inside `.next/standalone`, and others inside
+    //       `.next/standalone/package/path` (ie. `.next`, `server.js`).
+    //       We need to output the handler file inside the package path.
+    const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
+    fs.mkdirSync(path.join(outputPath, packagePath), { recursive: true });
+    const ext = fnOptions.runtime === "deno" ? "mjs" : "cjs";
+    fs.copyFileSync(path.join(options.buildDir, `cache.${ext}`), path.join(outputPath, packagePath, "cache.cjs"));
+    if (fnOptions.runtime === "deno") {
+        addDenoJson(outputPath, packagePath);
+    }
+    // Bundle next server if necessary
+    const isBundled = fnOptions.experimentalBundledNextServer ?? false;
+    if (isBundled) {
+        await bundleNextServer(path.join(outputPath, packagePath), appPath, {
+            minify: options.minify,
+        });
+    }
+    // Copy middleware
+    if (!config.middleware?.external) {
+        fs.copyFileSync(path.join(options.buildDir, "middleware.mjs"), path.join(outputPath, packagePath, "middleware.mjs"));
+    }
+    // Copy open-next.config.mjs
+    buildHelper.copyOpenNextConfig(options.buildDir, path.join(outputPath, packagePath), true);
+    // Copy env files
+    buildHelper.copyEnvFile(appBuildOutputPath, packagePath, outputPath);
+    // Copy all necessary traced files
+    await copyTracedFiles(appBuildOutputPath, packagePath, outputPath, fnOptions.routes ?? ["app/page.tsx"], isBundled);
+    // Build Lambda code
+    // note: bundle in OpenNext package b/c the adapter relies on the
+    //       "serverless-http" package which is not a dependency in user's
+    //       Next.js app.
+    const disableNextPrebundledReact = buildHelper.compareSemver(options.nextVersion, "13.5.1") >= 0 ||
+        buildHelper.compareSemver(options.nextVersion, "13.4.1") <= 0;
+    const overrides = fnOptions.override ?? {};
+    const isBefore13413 = buildHelper.compareSemver(options.nextVersion, "13.4.13") <= 0;
+    const isAfter141 = buildHelper.compareSemver(options.nextVersion, "14.0.4") >= 0;
+    const disableRouting = isBefore13413 || config.middleware?.external;
+    const plugins = [
+        openNextReplacementPlugin({
+            name: `requestHandlerOverride ${name}`,
+            target: /core(\/|\\)requestHandler\.js/g,
+            deletes: [
+                ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
+                ...(disableRouting ? ["withRouting"] : []),
+            ],
+        }),
+        openNextReplacementPlugin({
+            name: `utilOverride ${name}`,
+            target: /core(\/|\\)util\.js/g,
+            deletes: [
+                ...(disableNextPrebundledReact ? ["requireHooks"] : []),
+                ...(disableRouting ? ["trustHostHeader"] : []),
+                ...(!isBefore13413 ? ["requestHandlerHost"] : []),
+                ...(isAfter141 ? ["experimentalIncrementalCacheHandler"] : ["stableIncrementalCache"]),
+            ],
+        }),
+        openNextResolvePlugin({
+            fnName: name,
+            overrides,
+        }),
+        openNextEdgePlugins({
+            nextDir: path.join(options.appBuildOutputPath, ".next"),
+            edgeFunctionHandlerPath: path.join(options.openNextDistDir, "core", "edgeFunctionHandler.js"),
+            isInCloudfare: true,
+        }),
+    ];
+    const outfileExt = fnOptions.runtime === "deno" ? "ts" : "mjs";
+    await buildHelper.esbuildAsync({
+        entryPoints: [path.join(options.openNextDistDir, "adapters", "server-adapter.js")],
+        outfile: path.join(outputPath, packagePath, `index.${outfileExt}`),
+        banner: {
+            js: [
+                `globalThis.monorepoPackagePath = "${packagePath}";`,
+                name === "default" ? "" : `globalThis.fnName = "${name}";`,
+            ].join(""),
+        },
+        plugins,
+        alias: {
+            ...(isBundled
+                ? {
+                    "next/dist/server/next-server.js": "./next-server.runtime.prod.js",
+                }
+                : {}),
+        },
+    }, options);
+    const isMonorepo = monorepoRoot !== appPath;
+    if (isMonorepo) {
+        addMonorepoEntrypoint(outputPath, packagePath);
+    }
+    installDependencies(outputPath, fnOptions.install);
+    if (fnOptions.minify) {
+        await minifyServerBundle(outputPath);
+    }
+    const shouldGenerateDocker = shouldGenerateDockerfile(fnOptions);
+    if (shouldGenerateDocker) {
+        fs.writeFileSync(path.join(outputPath, "Dockerfile"), typeof shouldGenerateDocker === "string"
+            ? shouldGenerateDocker
+            : `
+FROM node:18-alpine
+WORKDIR /app
+COPY . /app
+EXPOSE 3000
+CMD ["node", "index.mjs"]
+    `);
+    }
+}
+function shouldGenerateDockerfile(options) {
+    return options.override?.generateDockerfile ?? false;
+}
+// Add deno.json file to enable "bring your own node_modules" mode.
+// TODO: this won't be necessary in Deno 2. See https://github.com/denoland/deno/issues/23151
+function addDenoJson(outputPath, packagePath) {
+    const config = {
+        // Enable "bring your own node_modules" mode
+        // and allow `__proto__`
+        unstable: ["byonm", "fs", "unsafe-proto"],
+    };
+    fs.writeFileSync(path.join(outputPath, packagePath, "deno.json"), JSON.stringify(config, null, 2));
+}
+//TODO: check if this PR is still necessary https://github.com/opennextjs/opennextjs-aws/pull/341
+function addMonorepoEntrypoint(outputPath, packagePath) {
+    // Note: in the monorepo case, the handler file is output to
+    //       `.next/standalone/package/path/index.mjs`, but we want
+    //       the Lambda function to be able to find the handler at
+    //       the root of the bundle. We will create a dummy `index.mjs`
+    //       that re-exports the real handler.
+    // TOOD: use helper
+    // Always use posix path for import path
+    const packagePosixPath = packagePath.split(path.sep).join(path.posix.sep);
+    fs.writeFileSync(path.join(outputPath, "index.mjs"), `export * from "./${packagePosixPath}/index.mjs";`);
+}
+async function minifyServerBundle(outputDir) {
+    logger.info("Minimizing server function...");
+    await minifyAll(outputDir, {
+        compress_json: true,
+        mangle: true,
+    });
+}

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

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

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

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

package/dist/cli/build/patches/investigated/copy-package-cli-files.d.ts

@@ -0,0 +1,6 @@
+import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
+import { Config } from "../../../config.js";
+/**
+ * Copies the template files present in the cloudflare adapter package into the standalone node_modules folder
+ */
+export declare function copyPackageCliFiles(packageDistDir: string, config: Config, openNextConfig: BuildOptions): void;

package/dist/cli/build/patches/investigated/copy-package-cli-files.js

@@ -0,0 +1,12 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Copies the template files present in the cloudflare adapter package into the standalone node_modules folder
+ */
+export function copyPackageCliFiles(packageDistDir, config, openNextConfig) {
+    console.log("# copyPackageTemplateFiles");
+    const sourceDir = path.join(packageDistDir, "cli");
+    const destinationDir = path.join(config.paths.internal.package, "cli");
+    fs.cpSync(sourceDir, destinationDir, { recursive: true });
+    fs.copyFileSync(path.join(packageDistDir, "cli", "templates", "worker.js"), path.join(openNextConfig.outputDir, "worker.js"));
+}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,4 @@
+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/patch-cache.d.ts

@@ -0,0 +1,13 @@
+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, openNextOptions: BuildOptions): Promise<string>;

package/dist/cli/build/patches/investigated/patch-cache.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+/**
+ * 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 async function patchCache(code, openNextOptions) {
+    const { appBuildOutputPath, outputDir, monorepoRoot } = openNextOptions;
+    // TODO: switch to cache.mjs
+    const outputPath = path.join(outputDir, "server-functions", "default");
+    const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
+    const cacheFile = path.join(outputPath, packagePath, "cache.cjs");
+    return code.replace("const { cacheHandler } = this.nextConfig;", `const cacheHandler = null;
+CacheHandler = require('${cacheFile}').default;
+`);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * ESBuild does not support CJS format
+ * See https://github.com/evanw/esbuild/issues/1921 and linked issues
+ * Some of the solutions are based on `module.createRequire()` not implemented in workerd.
+ * James on Aug 29: `module.createRequire()` is planned.
+ */
+export declare function patchRequire(code: string): string;

package/dist/cli/build/patches/investigated/patch-require.js

@@ -0,0 +1,9 @@
+/**
+ * ESBuild does not support CJS format
+ * See https://github.com/evanw/esbuild/issues/1921 and linked issues
+ * Some of the solutions are based on `module.createRequire()` not implemented in workerd.
+ * James on Aug 29: `module.createRequire()` is planned.
+ */
+export function patchRequire(code) {
+    return code.replace(/__require\d?\(/g, "require(").replace(/__require\d?\./g, "require.");
+}

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-chunk-installation-identifiers.d.ts

@@ -0,0 +1,13 @@
+import * as ts from "ts-morph";
+/**
+ * Gets the names of the variables that in the unminified webpack runtime file are called `installedChunks` and `installChunk`.
+ *
+ * Variables example: https://github.com/webpack/webpack/blob/dae16ad11e/examples/module-worker/README.md?plain=1#L256-L282
+ *
+ * @param sourceFile the webpack runtime file parsed with ts-morph
+ * @returns an object containing the two variable names
+ */
+export declare function getChunkInstallationIdentifiers(sourceFile: ts.SourceFile): Promise<{
+    installedChunks: string;
+    installChunk: string;
+}>;

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-chunk-installation-identifiers.js

@@ -0,0 +1,82 @@
+import * as ts from "ts-morph";
+/**
+ * Gets the names of the variables that in the unminified webpack runtime file are called `installedChunks` and `installChunk`.
+ *
+ * Variables example: https://github.com/webpack/webpack/blob/dae16ad11e/examples/module-worker/README.md?plain=1#L256-L282
+ *
+ * @param sourceFile the webpack runtime file parsed with ts-morph
+ * @returns an object containing the two variable names
+ */
+export async function getChunkInstallationIdentifiers(sourceFile) {
+    const installChunkDeclaration = getInstallChunkDeclaration(sourceFile);
+    const installedChunksDeclaration = getInstalledChunksDeclaration(sourceFile, installChunkDeclaration);
+    return {
+        installChunk: installChunkDeclaration.getName(),
+        installedChunks: installedChunksDeclaration.getName(),
+    };
+}
+/**
+ * Gets the declaration for what in the unminified webpack runtime file is called `installChunk`(which is a function that registers the various chunks.
+ *
+ * `installChunk` example: https://github.com/webpack/webpack/blob/dae16ad11e/examples/module-worker/README.md?plain=1#L263-L282
+ *
+ * @param sourceFile the webpack runtime file parsed with ts-morph
+ * @returns the `installChunk` declaration
+ */
+function getInstallChunkDeclaration(sourceFile) {
+    const installChunkDeclaration = sourceFile
+        .getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration)
+        .find((declaration) => {
+        const arrowFunction = declaration.getInitializerIfKind(ts.SyntaxKind.ArrowFunction);
+        // we're looking for an arrow function
+        if (!arrowFunction)
+            return false;
+        const functionParameters = arrowFunction.getParameters();
+        // the arrow function we're looking for has a single parameter (the chunkId)
+        if (functionParameters.length !== 1)
+            return false;
+        const arrowFunctionBodyBlock = arrowFunction.getFirstChildByKind(ts.SyntaxKind.Block);
+        // the arrow function we're looking for has a block body
+        if (!arrowFunctionBodyBlock)
+            return false;
+        const statementKinds = arrowFunctionBodyBlock.getStatements().map((statement) => statement.getKind());
+        // the function we're looking for has 2 for loops (a standard one and a for-in one)
+        const forInStatements = statementKinds.filter((s) => s === ts.SyntaxKind.ForInStatement);
+        const forStatements = statementKinds.filter((s) => s === ts.SyntaxKind.ForStatement);
+        if (forInStatements.length !== 1 || forStatements.length !== 1)
+            return false;
+        // the function we're looking for accesses its parameter three times, and it
+        // accesses its `modules`, `ids` and `runtime` properties (in this order)
+        const parameterName = functionParameters[0].getText();
+        const functionParameterAccessedProperties = arrowFunctionBodyBlock
+            .getDescendantsOfKind(ts.SyntaxKind.PropertyAccessExpression)
+            .filter((propertyAccessExpression) => propertyAccessExpression.getExpression().getText() === parameterName)
+            .map((propertyAccessExpression) => propertyAccessExpression.getName());
+        if (functionParameterAccessedProperties.join(", ") !== "modules, ids, runtime")
+            return false;
+        return true;
+    });
+    if (!installChunkDeclaration) {
+        throw new Error("ERROR: unable to find the installChunk function declaration");
+    }
+    return installChunkDeclaration;
+}
+/**
+ * Gets the declaration for what in the unminified webpack runtime file is called `installedChunks` which is an object that holds the various registered chunks.
+ *
+ * `installedChunks` example: https://github.com/webpack/webpack/blob/dae16ad11e/examples/module-worker/README.md?plain=1#L256-L261
+ *
+ * @param sourceFile the webpack runtime file parsed with ts-morph
+ * @param installChunkDeclaration the declaration for the `installChunk` variable
+ * @returns the `installedChunks` declaration
+ */
+function getInstalledChunksDeclaration(sourceFile, installChunkDeclaration) {
+    const allVariableDeclarations = sourceFile.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration);
+    const installChunkDeclarationIdx = allVariableDeclarations.findIndex((declaration) => declaration === installChunkDeclaration);
+    // the installedChunks declaration comes right before the installChunk one
+    const installedChunksDeclaration = allVariableDeclarations[installChunkDeclarationIdx - 1];
+    if (!installedChunksDeclaration?.getInitializer()?.isKind(ts.SyntaxKind.ObjectLiteralExpression)) {
+        throw new Error("ERROR: unable to find the installedChunks declaration");
+    }
+    return installedChunksDeclaration;
+}

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-chunk-installation-identifiers.test.d.ts

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

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-chunk-installation-identifiers.test.js

@@ -0,0 +1,20 @@
+import { readFile } from "node:fs/promises";
+import { describe, expect, test } from "vitest";
+import { tsParseFile } from "../../../utils/index.js";
+import { getChunkInstallationIdentifiers } from "./get-chunk-installation-identifiers.js";
+describe("getChunkInstallationIdentifiers", () => {
+    test("gets chunk identifiers from unminified code", async () => {
+        const fileContent = await readFile(`${import.meta.dirname}/test-fixtures/unminified-webpacks-file.js`, "utf8");
+        const tsSourceFile = tsParseFile(fileContent);
+        const { installChunk, installedChunks } = await getChunkInstallationIdentifiers(tsSourceFile);
+        expect(installChunk).toEqual("installChunk");
+        expect(installedChunks).toEqual("installedChunks");
+    });
+    test("gets chunk identifiers from minified code", async () => {
+        const fileContent = await readFile(`${import.meta.dirname}/test-fixtures/minified-webpacks-file.js`, "utf8");
+        const tsSourceFile = tsParseFile(fileContent);
+        const { installChunk, installedChunks } = await getChunkInstallationIdentifiers(tsSourceFile);
+        expect(installChunk).toEqual("r");
+        expect(installedChunks).toEqual("e");
+    });
+});

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-file-content-with-updated-webpack-f-require-code.d.ts

@@ -0,0 +1,19 @@
+import * as ts from "ts-morph";
+/**
+ * Updates the function that in the unminified webpack runtime file appears as `__webpack_require__.f.require` which is a function that
+ * installs chunks by importing/requiring them at runtime.
+ *
+ * `__webpack_require__.f.require` example: https://github.com/webpack/webpack/blob/dae16ad11e/examples/module-worker/README.md?plain=1#L284-L304
+ *
+ * This function needs to be updated so that it requires chunks using the standard `require` function and not webpack's custom `require` logic
+ * which fails in the workerd runtime.
+ *
+ * @param sourceFile the webpack runtime file parsed with ts-morph (note: this gets side-effectfully updated)
+ * @param chunkInstallationIdentifiers the names of the `installedChunks` and `installChunk` variables
+ * @param chunks the identifiers of the chunks (found on the filesystem)
+ * @returns the content of the sourceFile but with the require function updated
+ */
+export declare function getFileContentWithUpdatedWebpackFRequireCode(sourceFile: ts.SourceFile, { installedChunks, installChunk }: {
+    installedChunks: string;
+    installChunk: string;
+}, chunks: string[]): Promise<string>;