fix(rolldown): fix CJS require handling for nodeless worker builds

src/build/rolldown/config.ts

@@ -1,22 +1,39 @@
 import type { Nitro } from "nitro/types";
 import type { OutputOptions, RolldownOptions, RolldownPlugin } from "rolldown";
+import { esmExternalRequirePlugin } from "rolldown/plugins";
 import { baseBuildConfig } from "../config.ts";
 import { baseBuildPlugins } from "../plugins.ts";
 import { builtinModules } from "node:module";
 import { defu } from "defu";
 import { getChunkName, libChunkName, NODE_MODULES_RE } from "../chunks.ts";
+import { requireConditionResolver } from "./require-condition.ts";
 
 export const getRolldownConfig = async (nitro: Nitro): Promise<RolldownOptions> => {
   const base = baseBuildConfig(nitro);
+  const builtinExternals = [...builtinModules, ...builtinModules.map((m) => `node:${m}`)];
+  const plugins: RolldownPlugin[] = [
+    requireConditionResolver(nitro),
+    ...(!nitro.options.node
+      ? [
+          esmExternalRequirePlugin({
+            external: builtinExternals,
+            skipDuplicateCheck: true,
+          }) as RolldownPlugin,
+        ]
+      : []),
+    ...((await baseBuildPlugins(nitro, base)) as RolldownPlugin[]),
+  ];
 
   const tsc = nitro.options.typescript.tsConfig?.compilerOptions;
 
   let config: RolldownOptions = {
     platform: nitro.options.node ? "node" : "neutral",
     cwd: nitro.options.rootDir,
     input: nitro.options.entry,
-    external: [...base.env.external, ...builtinModules, ...builtinModules.map((m) => `node:${m}`)],
-    plugins: [...((await baseBuildPlugins(nitro, base)) as RolldownPlugin[])],
+    external: nitro.options.node
+      ? [...base.env.external, ...builtinExternals]
+      : [...base.env.external],
+    plugins,
     resolve: {
       alias: base.aliases,
       extensions: base.extensions,

src/build/rolldown/require-condition.ts

@@ -0,0 +1,64 @@
+import type { Nitro } from "nitro/types";
+import type { RolldownPlugin } from "rolldown";
+
+import { builtinModules } from "node:module";
+import { resolveModulePath } from "exsolve";
+import { isAbsolute } from "pathe";
+
+const RESOLVE_SKIP_RE = /^(?:[\0#~.]|[a-z0-9]{2,}:)|\?/;
+const BUILTIN_MODULE_SET = new Set([
+  ...builtinModules,
+  ...builtinModules.map((id) => `node:${id}`),
+]);
+
+export function getRequireConditionNames(exportConditions: string[]) {
+  return [
+    ...new Set([
+      "require",
+      ...exportConditions.filter((condition) => condition !== "import"),
+      "default",
+    ]),
+  ];
+}
+
+export function resolveRequireCallPath(options: {
+  id: string;
+  importer?: string;
+  rootDir: string;
+  conditionNames: string[];
+}) {
+  if (RESOLVE_SKIP_RE.test(options.id) || BUILTIN_MODULE_SET.has(options.id)) {
+    return;
+  }
+  return resolveModulePath(options.id, {
+    try: true,
+    from: options.importer && isAbsolute(options.importer) ? options.importer : options.rootDir,
+    conditions: options.conditionNames,
+  });
+}
+
+export function requireConditionResolver(nitro: Nitro): RolldownPlugin {
+  const conditionNames = getRequireConditionNames(nitro.options.exportConditions || []);
+
+  return {
+    name: "nitro:rolldown-require-conditions",
+    resolveId: {
+      order: "pre",
+      handler(source, importer, resolveOptions) {
+        if (resolveOptions.kind !== "require-call") {
+          return null;
+        }
+        const resolved = resolveRequireCallPath({
+          id: source,
+          importer,
+          rootDir: nitro.options.rootDir,
+          conditionNames,
+        });
+        if (!resolved) {
+          return null;
+        }
+        return { id: resolved };
+      },
+    },
+  };
+}

test/unit/rolldown-require-condition.test.ts

@@ -0,0 +1,60 @@
+import { afterAll, describe, expect, it } from "vitest";
+import { join } from "pathe";
+import { tmpdir } from "node:os";
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import {
+  getRequireConditionNames,
+  resolveRequireCallPath,
+} from "../../src/build/rolldown/require-condition.ts";
+
+describe("resolveRequireCallPath", () => {
+  const tmpDirs: string[] = [];
+
+  afterAll(async () => {
+    await Promise.all(tmpDirs.map((dir) => rm(dir, { recursive: true, force: true })));
+  });
+
+  it("prefers require condition for require-call package resolution", async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), "nitro-rolldown-require-condition-"));
+    tmpDirs.push(rootDir);
+
+    const pkgDir = join(rootDir, "node_modules/dual-entry");
+    await mkdir(join(pkgDir, "esm"), { recursive: true });
+    await mkdir(join(pkgDir, "cjs"), { recursive: true });
+    await writeFile(
+      join(pkgDir, "package.json"),
+      JSON.stringify(
+        {
+          name: "dual-entry",
+          version: "0.0.0",
+          exports: {
+            ".": {
+              import: "./esm/index.mjs",
+              require: "./cjs/index.cjs",
+              default: "./cjs/index.cjs",
+            },
+          },
+        },
+        null,
+        2
+      )
+    );
+    await writeFile(join(pkgDir, "esm/index.mjs"), "export default { entry: 'esm' };\n");
+    await writeFile(join(pkgDir, "cjs/index.cjs"), "module.exports = class DualEntry {};\n");
+
+    const resolved = resolveRequireCallPath({
+      id: "dual-entry",
+      rootDir,
+      conditionNames: getRequireConditionNames(["workerd", "import", "default"]),
+    });
+
+    expect(resolved?.replaceAll("\\", "/")).toMatch(/dual-entry\/cjs\/index\.cjs$/);
+  });
+
+  it("skips builtins and relative imports", () => {
+    const conditionNames = getRequireConditionNames(["workerd", "import", "default"]);
+    const rootDir = process.cwd();
+    expect(resolveRequireCallPath({ id: "events", rootDir, conditionNames })).toBeUndefined();
+    expect(resolveRequireCallPath({ id: "./local", rootDir, conditionNames })).toBeUndefined();
+  });
+});