fix(vite): proxy nitro/* imports from service environments (#4152)

Author: pi0

src/build/vite/env.ts

@@ -1,4 +1,4 @@
-import type { EnvironmentOptions, RollupCommonJSOptions } from "vite";
+import type { EnvironmentOptions, RollupCommonJSOptions, Plugin as VitePlugin } from "vite";
 import type { NitroPluginContext, ServiceConfig } from "./types.ts";
 
 import type { RunnerName } from "env-runner";
@@ -68,7 +68,10 @@ export function createServiceEnvironment(
   return {
     consumer: "server",
     build: {
-      rollupOptions: { input: { index: serviceConfig.entry } },
+      rollupOptions: {
+        input: { index: serviceConfig.entry },
+        external: [/^nitro(\/|$)/],
+      },
       minify: ctx.nitro!.options.minify,
       sourcemap: ctx.nitro!.options.sourcemap,
       outDir: join(ctx.nitro!.options.buildDir, "vite/services", name),
@@ -183,6 +186,49 @@ async function _loadRunner(ctx: NitroPluginContext, manager: RunnerManager) {
   await manager.reload(runner);
 }
 
+// Service environments (e.g. SSR) must not bundle their own copy of `nitro/*`
+// runtime modules. In dev, imports are proxied to the Nitro environment via
+// __VITE_ENVIRONMENT_RUNNER_IMPORT__. In prod, they are externalized (see createServiceEnvironment).
+const NITRO_PROXY_PREFIX = "\0nitro-env-proxy:";
+
+export function nitroServiceProxy(): VitePlugin {
+  return {
+    name: "nitro:service-proxy",
+    enforce: "pre",
+    applyToEnvironment: (env) => env.name !== "nitro" && env.config.consumer === "server",
+    apply: (_config, configEnv) => configEnv.command === "serve",
+
+    resolveId: {
+      filter: { id: /^nitro(\/|$)/ },
+      handler(id) {
+        if (id === "nitro" || id.startsWith("nitro/")) {
+          return { id: NITRO_PROXY_PREFIX + id, moduleSideEffects: false };
+        }
+      },
+    },
+
+    load: {
+      filter: { id: /^\0nitro-env-proxy:/ },
+      handler(id) {
+        if (!id.startsWith(NITRO_PROXY_PREFIX)) {
+          return;
+        }
+        const originalId = id.slice(NITRO_PROXY_PREFIX.length);
+        // __vite_ssr_exportAll__ is provided by the module runner execution context.
+        // It re-exports all enumerable own properties (except "default") from the source module.
+        return {
+          code: [
+            `const _mod = await globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__("nitro", ${JSON.stringify(originalId)});`,
+            `__vite_ssr_exportAll__(_mod);`,
+            `export default _mod.default;`,
+          ].join("\n"),
+          map: null,
+        };
+      },
+    },
+  };
+}
+
 // workerd-based runners (miniflare) cannot handle CJS externals via import(),
 // so all dependencies must be processed through Vite's transform pipeline.
 function _isWorkerdRunner(ctx: NitroPluginContext): boolean {

src/build/vite/plugin.ts

@@ -18,6 +18,7 @@ import {
   createNitroEnvironment,
   createServiceEnvironments,
   createServiceEnvironment,
+  nitroServiceProxy,
 } from "./env.ts";
 import { configureViteDevServer } from "./dev.ts";
 import { runtimeDir } from "nitro/meta";
@@ -50,6 +51,7 @@ export function nitro(pluginConfig: NitroPluginConfig = {}): VitePlugin[] {
     nitroMain(ctx),
     nitroPrepare(ctx),
     nitroService(ctx),
+    nitroServiceProxy(),
     nitroPreviewPlugin(ctx),
     pluginConfig.experimental?.vite?.assetsImport !== false &&
       assetsPlugin({

test/vite/app-fixture/api/storage.ts

@@ -0,0 +1,6 @@
+import { useStorage } from "nitro/storage";
+
+export default () => {
+  const storage = useStorage();
+  return storage.get("test:key");
+};

test/vite/app-fixture/app/entry-server.ts

@@ -0,0 +1,15 @@
+import { useStorage } from "nitro/storage";
+import { useRuntimeConfig } from "nitro/runtime-config";
+
+export default {
+  async fetch() {
+    const storage = useStorage();
+    const config = useRuntimeConfig();
+    await storage.set("test:key", "value-from-ssr");
+    const value = await storage.get("test:key");
+    return Response.json({
+      storage: value,
+      config: config.nitro?.envPrefix ?? "NITRO_",
+    });
+  },
+};

test/vite/app-fixture/vite.config.ts

@@ -0,0 +1,6 @@
+import { defineConfig } from "vite";
+import { nitro } from "nitro/vite";
+
+export default defineConfig({
+  plugins: [nitro({ serverDir: "./" })],
+});

test/vite/app.test.ts

@@ -0,0 +1,53 @@
+import { fileURLToPath } from "node:url";
+import type { ViteDevServer } from "vite";
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
+
+const { createServer } = (await import(
+  process.env.NITRO_VITE_PKG || "vite"
+)) as typeof import("vite");
+
+describe("vite:app", () => {
+  let server: ViteDevServer;
+  let serverURL: string;
+
+  const rootDir = fileURLToPath(new URL("./app-fixture", import.meta.url));
+
+  const originalCwd = process.cwd();
+
+  beforeAll(async () => {
+    process.chdir(rootDir);
+    server = await createServer({ root: rootDir });
+    await server.listen("0" as unknown as number);
+    const addr = server.httpServer?.address() as {
+      port: number;
+      address: string;
+      family: string;
+    };
+    serverURL = `http://${addr.family === "IPv6" ? `[${addr.address}]` : addr.address}:${addr.port}`;
+  }, 30_000);
+
+  afterAll(async () => {
+    await server?.close();
+    process.chdir(originalCwd);
+  });
+
+  test("SSR entry can use nitro/storage (shared with nitro env)", async () => {
+    const res = await fetch(serverURL);
+    const data = (await res.json()) as { storage: string; config: string };
+    expect(data.storage).toBe("value-from-ssr");
+  });
+
+  test("SSR entry can use nitro/runtime-config", async () => {
+    const res = await fetch(serverURL);
+    const data = (await res.json()) as { storage: string; config: string };
+    expect(data.config).toBe("NITRO_");
+  });
+
+  test("storage is shared between SSR and nitro environments", async () => {
+    // SSR entry writes to storage, API route reads it
+    await fetch(serverURL);
+    const res = await fetch(`${serverURL}/api/storage`);
+    const value = await res.text();
+    expect(value).toBe("value-from-ssr");
+  });
+});