vite-plugin-react-server 1.2.0-alpha.1 → 1.2.1

package/plugin/react-client/types.ts

@@ -0,0 +1,95 @@
+import type { ConfigEnv, Logger, Manifest, ResolvedConfig, ViteDevServer } from "vite";
+import type {
+  AutoDiscoveredFiles,
+  MessageHandler,
+  PanicThreshold,
+  ResolvedUserOptions,
+  SerializedUserOptions,
+} from "../../types.js";
+import type { MessageChannel, Worker } from "node:worker_threads";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type {
+  RscChunkOutputMessage,
+  RscWorkerOutputMessage,
+} from "../worker/rsc/types.js";
+import type { StreamHandlers } from "../worker/types.js";
+import type { PassThrough } from "node:stream";
+
+export type RestartWorkerFn = (props: {
+  server: ViteDevServer;
+  autoDiscoveredFiles: AutoDiscoveredFiles;
+  userOptions: SerializedUserOptions;
+  configEnv: ConfigEnv;
+  hmrChannel: MessageChannel;
+}) => Promise<Worker | null>;
+
+export type HandleWorkerServerActionFn = (
+  req: IncomingMessage,
+  res: ServerResponse,
+  worker: Worker,
+  logger: ViteDevServer["config"]["logger"]
+) => Promise<void>;
+
+export type CreateWorkerStreamFn = (props: {
+  route: string;
+  url: string;
+  projectRoot: string;
+  moduleBasePath: string;
+  moduleBaseURL: string;
+  moduleRootPath: string;
+  cssFiles: Map<string, any>;
+  globalCss: Map<string, any>;
+  manifest: any;
+  serverPipeableStreamOptions?: any;
+  clientPipeableStreamOptions?: any;
+  verbose?: boolean;
+  panicThreshold?: PanicThreshold;
+  logger?: any;
+  rscWorkerPath?: string;
+  onEvent?: (event: any) => void;
+  moduleBase: string;
+  HtmlComponent: any;
+  PageComponent: any;
+  RootComponent: any;
+  pageProps: any;
+  as: any;
+}) => {
+  abort: (reason?: unknown) => void;
+  pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+};
+
+
+// Removed GenerateWorkerStreamFn - using CreateWorkerStreamFn from helpers instead
+
+export type CreateMessageHandlerFn = (props: {
+  handlers: StreamHandlers;
+  logger: Logger;
+  verbose?: boolean;
+}) => (message: RscWorkerOutputMessage | undefined) => void;
+
+export type ConfigureWorkerRequestHandlerFn = (props: {
+  server: ViteDevServer;
+  autoDiscoveredFiles: AutoDiscoveredFiles;
+  userOptions: ResolvedUserOptions;
+  configEnv: ConfigEnv;
+  serverManifest: Manifest;
+  resolvedConfig: ResolvedConfig;
+  hmrChannel: MessageChannel;
+  onWorkerCreated?: (worker: Worker, restart?: () => Promise<void>) => void;
+}) => void;
+
+export type ConfigureRequestHandlerFn = (
+  req: IncomingMessage,
+  res: ServerResponse,
+  worker: Worker,
+  logger: ViteDevServer["config"]["logger"]
+) => Promise<void>;
+
+export type CleanupWorkerServerActionFn = (
+  passThrough: PassThrough,
+  worker: Worker,
+  messageHandler: MessageHandler<RscChunkOutputMessage>,
+  res: ServerResponse,
+  error?: unknown,
+  logger?: Logger
+) => void;

package/plugin/react-server/index.client.ts

@@ -0,0 +1 @@
+export { reactServerPlugin } from "./plugin.client.js";

package/plugin/react-server/index.server.ts

@@ -0,0 +1 @@
+export { reactServerPlugin } from "./plugin.server.js";

package/plugin/react-server/index.ts

@@ -1 +1,13 @@
-export { reactServerPlugin } from "./plugin.js";
+import type { VitePluginFn } from "../types.js";
+import { getCondition } from "../config/getCondition.js";
+import type { ConfigureReactServerFn, HandleServerActionFn } from "./types.js";
+
+const condition = getCondition("");
+const dir = new URL("./", import.meta.url).pathname.replace(/\/$/, "");
+
+export const { reactServerPlugin, handleServerAction, configureReactServer } =
+  (await import(`${dir}/index.${condition}.js`)) as {
+    reactServerPlugin: VitePluginFn;
+    handleServerAction: HandleServerActionFn;
+    configureReactServer: ConfigureReactServerFn;
+  };

package/plugin/react-server/plugin.client.ts

@@ -0,0 +1,54 @@
+import { performance } from "node:perf_hooks";
+
+import { resolveOptions } from "../config/resolveOptions.js";
+import type {
+  BuildTiming,
+  VitePluginFn,
+} from "../types.js";
+import { createDefaultModuleID } from "../config/createModuleID.js";
+import { assertNonReactServer } from "../config/getCondition.js";
+assertNonReactServer();
+
+export const reactServerPlugin: VitePluginFn =
+  function _reactServerPluginForClient(options) {
+    const timing: BuildTiming = {
+      start: performance.now(),
+    };
+
+
+    const resolvedOptions = resolveOptions(options);
+    if (resolvedOptions.type === "error") {
+      if (resolvedOptions.error != null) {
+        throw resolvedOptions.error;
+      }
+      throw new Error("Failed to resolve options");
+    }
+    let currentUserOptions = resolvedOptions.userOptions;
+    return {
+      name: "vite:plugin-react-server/rsc-worker-server",
+      enforce: "post",
+      api: {
+        meta: { timing },
+      },
+      applyToEnvironment(partialEnvironment) {
+        if (['server', 'client', 'ssr'].includes(partialEnvironment.name)) {
+          return true;
+        }
+        return false;
+      },
+      config(config, viteConfigEnv) {
+        // Set up moduleID function if not already set
+        if (typeof currentUserOptions.moduleID !== "function") {
+          currentUserOptions.moduleID = createDefaultModuleID(
+            currentUserOptions,
+            viteConfigEnv,
+            currentUserOptions.loader?.mode
+          );
+        }
+        
+        // The environment plugin handles auto-discovery and input configuration
+        // This plugin now focuses on server-specific functionality
+        return config; 
+      },
+  };
+};

package/plugin/react-server/plugin.server.ts

@@ -0,0 +1,27 @@
+import { performance } from "node:perf_hooks";
+import type {
+  BuildTiming,
+  VitePluginFn,
+} from "../types.js";
+import { assertReactServer } from "../config/getCondition.js";
+
+assertReactServer()
+
+export const reactServerPlugin: VitePluginFn = function _reactServerPlugin(
+  _options
+) {
+  const timing: BuildTiming = {
+    start: performance.now(),
+  };
+
+  return {
+    name: "vite:plugin-react-server/server",
+    enforce: "post",
+    api: {
+      meta: { timing },
+    },
+    configResolved(_resolvedConfig) {
+      timing.configResolved = performance.now();
+    },
+  };
+};

package/plugin/react-server/plugin.ts

@@ -1,185 +1,10 @@
-import { performance } from "node:perf_hooks";
-import {
-  type ResolvedConfig,
-  type UserConfig,
-  type ViteDevServer,
-  type Manifest,
-} from "vite";
-import { resolveOptions } from "../config/resolveOptions.js";
-import { resolveUserConfig } from "../config/resolveUserConfig.js";
-import type {
-  AutoDiscoveredFiles,
-  BuildTiming,
-  ReactStreamPluginFn,
-  ReactStreamPluginMeta,
-} from "../types.js";
-import { resolveAutoDiscover } from "../config/autoDiscover/resolveAutoDiscover.js";
-import { configureReactServer } from "./configureReactServer.js";
-import { configurePreviewServer } from "../react-static/configurePreviewServer.js";
-import { getBundleManifest } from "../helpers/getBundleManifest.js";
-import { createDefaultModuleID } from "../config/createModuleID.js";
+import type { VitePluginMainFn } from "../types.js";
+import { getCondition } from "../config/getCondition.js";
 
-let resolvedConfig: ResolvedConfig | null = null;
+const condition = getCondition("");
+const dir = new URL(".", import.meta.url)
+  .pathname;
 
-export type ReactServerPluginFn = ReactStreamPluginFn<{
-  meta: ReactStreamPluginMeta;
-}>;
-
-export const reactServerPlugin: ReactServerPluginFn =
-  function _reactServerPlugin(options) {
-    const timing: BuildTiming = {
-      start: performance.now(),
-    };
-
-    let autoDiscoveredFiles: AutoDiscoveredFiles;
-    let serverManifest: Manifest = {};
-
-    const resolvedOptions = resolveOptions(options);
-    if (resolvedOptions.type === "error") {
-      throw resolvedOptions.error;
-    }
-    const userOptions = resolvedOptions.userOptions;
-
-    return {
-      name: "vite:react-stream-server",
-      enforce: "post",
-      api: {
-        meta: { timing },
-      },
-      configResolved(_resolvedConfig) {
-        resolvedConfig = _resolvedConfig;
-        if (
-          userOptions.projectRoot != resolvedConfig.root &&
-          typeof userOptions.projectRoot === "string" &&
-          userOptions.projectRoot !== ""
-        ) {
-          throw new Error(
-            "[RSC] Project root is not the current working directory, please set projectRoot in your config.\n" +
-              " projectRoot: " +
-              userOptions.projectRoot +
-              "\n" +
-              " resolvedConfig.root: " +
-              resolvedConfig.root
-          );
-        }
-        timing.configResolved = performance.now();
-      },
-
-      async configurePreviewServer(server) {
-        await configurePreviewServer({
-          server,
-          userOptions,
-        });
-      },
-      async configureServer(server: ViteDevServer) {
-        configureReactServer({
-          server,
-          autoDiscoveredFiles,
-          userOptions,
-          serverManifest,
-        });
-      },
-      async config(config, configEnv): Promise<UserConfig> {
-        // Create the proper moduleID function now that we have ConfigEnv
-        if (typeof userOptions.moduleID !== "function") {
-          userOptions.moduleID = createDefaultModuleID(
-            userOptions,
-            configEnv,
-            userOptions.loader?.mode
-          );
-        }
-
-        const autoDiscoverResult = await resolveAutoDiscover({
-          config,
-          configEnv,
-          userOptions,
-          condition: "react-server",
-        });
-        if (autoDiscoverResult.type === "error") {
-          throw autoDiscoverResult.error;
-        }
-        autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
-
-        const resolvedConfig = resolveUserConfig({
-          condition: "react-server",
-          config,
-          configEnv,
-          userOptions,
-          autoDiscoveredFiles,
-        });
-
-        if (resolvedConfig.type === "error") {
-          console.error(
-            "[react-server-plugin] Failed to resolve config:",
-            resolvedConfig.error
-          );
-          throw resolvedConfig.error;
-        }
-
-        return resolvedConfig.userConfig;
-      },
-      async writeBundle(options, bundle) {
-        if (userOptions.onEvent) {
-          userOptions.onEvent({
-            type: "build.writeBundle.server",
-            data: {
-              pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),
-              options,
-              bundle,
-            },
-          });
-        }
-      },
-      async buildStart() {
-        if (!timing.buildStart) {
-          timing.buildStart = performance.now();
-        } else if (userOptions.verbose) {
-          console.log("Build already started");
-        }
-      },
-      async generateBundle(_options, bundle) {
-        // Create manifest entries for each chunk
-        serverManifest = getBundleManifest<false>({
-          bundle,
-          normalizer: userOptions.normalizer,
-        });
-      },
-      async handleHotUpdate({ file, server, timestamp, ...ctx }) {
-        try {
-          // Invalidate the module in Vite's cache for both client and SSR
-          if (server.moduleGraph) {
-            const mod = server.moduleGraph.getModuleById(file);
-            if (mod) {
-              // Invalidate the parent module which will handle both client and SSR
-              server.moduleGraph.invalidateModule(
-                mod,
-                undefined,
-                timestamp,
-                true
-              );
-
-              // Force a reload of the module
-              const newMod = await server.moduleGraph.ensureEntryFromUrl(
-                file,
-                false
-              );
-              if (newMod) {
-                server.moduleGraph.invalidateModule(
-                  newMod,
-                  undefined,
-                  timestamp,
-                  true
-                );
-              }
-            }
-          }
-
-          // Let Vite handle the HMR update
-          return ctx.modules;
-        } catch (error) {
-          console.error("[react-server] HMR Error:", error);
-          return ctx.modules;
-        }
-      },
-    };
-  };
+export const { reactServerPlugin } = (await import(
+  `${dir}/plugin.${condition}.js`   
+)) as { reactServerPlugin: VitePluginMainFn };

package/plugin/react-server/types.ts

@@ -0,0 +1,24 @@
+import type { Manifest, ViteDevServer } from "vite";
+import type {
+  AutoDiscoveredFiles,
+  CreateHandlerOptions,
+  ResolvedUserOptions,
+} from "../types.js";
+import type { IncomingMessage, ServerResponse } from "http";
+
+export type HandleServerActionFn = (
+  req: IncomingMessage,
+  res: ServerResponse,
+  server: ViteDevServer,
+  handlerOptions: Pick<
+    CreateHandlerOptions,
+    "verbose" | "moduleBasePath" | "projectRoot" | "loader"
+  >
+) => Promise<void>;
+
+export type ConfigureReactServerFn = (options: {
+  server: ViteDevServer;
+  autoDiscoveredFiles: AutoDiscoveredFiles;
+  userOptions: ResolvedUserOptions;
+  serverManifest: Manifest;
+}) => void;

package/plugin/react-static/collectHtmlContent.ts

@@ -0,0 +1,131 @@
+/**
+ * collectHtmlContent.client.ts
+ *
+ * PURPOSE: Collects HTML stream with metrics
+ *
+ * This module:
+ * 1. Takes an HTML stream and collects it
+ * 2. Tracks metrics (chunks, bytes, duration)
+ * 3. Returns buffered content and metrics
+ * 4. Does NOT create HTML streams - that's the caller's responsibility
+ * 5. Does NOT write files - that's the caller's responsibility
+ */
+
+import { Transform } from "node:stream";
+import { createStreamMetrics } from "../metrics/createStreamMetrics.js";
+import type { CollectHtmlContentFn } from "./types.js";
+
+export const collectHtmlContent: CollectHtmlContentFn =
+  async function _collectHtmlContent(html, handlerOptions) {
+    const metrics = createStreamMetrics();
+    const startTime = performance.now();
+    const htmlBuffer: Buffer[] = [];
+
+    if (handlerOptions.verbose) {
+      handlerOptions.logger.info(
+        `[collectHtmlContent.client] Starting HTML collection for route: ${handlerOptions.route}`
+      );
+    }
+
+    try {
+      // Create a transform stream to collect HTML content and track metrics
+      const metricsTransform = new Transform({
+        transform(chunk, encoding, callback) {
+          const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding as BufferEncoding);
+          htmlBuffer.push(buffer);
+          metrics.chunks++;
+          metrics.bytes += buffer.length;
+          
+          if (handlerOptions.verbose) {
+            handlerOptions.logger.info(
+              `[collectHtmlContent.client] HTML chunk ${metrics.chunks}, bytes: ${buffer.length}, total: ${metrics.bytes}`
+            );
+          }
+          
+          callback(null, chunk);
+        },
+        flush(callback) {
+          metrics.duration = performance.now() - startTime;
+          if (handlerOptions.verbose) {
+            handlerOptions.logger.info(
+              `[collectHtmlContent.client] HTML collection completed: ${metrics.bytes} bytes in ${metrics.duration}ms`
+            );
+          }
+          callback();
+        }
+      });
+
+      // Create a PassThrough stream to consume the transform
+      const { PassThrough } = await import("node:stream");
+      const consumer = new PassThrough();
+      
+      // Pipe HTML stream through metrics tracking to consumer
+      html.pipe(metricsTransform).pipe(consumer);
+
+      // Wait for stream to complete with timeout
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          if (handlerOptions.verbose) {
+            handlerOptions.logger.info(
+              `[collectHtmlContent.client] Stream timeout reached, forcing completion`
+            );
+          }
+          resolve();
+        }, 15000); // 15 second timeout for HTML content collection
+
+        consumer.on("end", () => {
+          if (handlerOptions.verbose) {
+            handlerOptions.logger.info(
+              `[collectHtmlContent.client] Stream ended with ${metrics.bytes} bytes`
+            );
+          }
+          clearTimeout(timeout);
+          resolve();
+        });
+
+        consumer.on("error", (error) => {
+          if (handlerOptions.verbose) {
+            handlerOptions.logger.info(
+              `[collectHtmlContent.client] Stream error: ${error}`
+            );
+          }
+          clearTimeout(timeout);
+          reject(error);
+        });
+      });
+
+      // Create a readable stream from the buffered content that can be piped multiple times
+      const { Readable } = await import("node:stream");
+      const readableStream = new Readable({
+        read() {
+          // Push all buffered content
+          for (const chunk of htmlBuffer) {
+            this.push(chunk);
+          }
+          this.push(null); // End the stream
+        }
+      });
+
+      // Return buffered content and metrics - file writing is caller's responsibility
+      return {
+        pipe: readableStream.pipe.bind(readableStream),
+        abort: (reason?: unknown) => {
+          html.abort(reason);
+          readableStream.destroy(reason as Error);
+        },
+        metrics,
+        // Include buffered content for reuse
+        bufferedContent: htmlBuffer,
+      };
+
+    } catch (error) {
+      if (handlerOptions.verbose) {
+        handlerOptions.logger.info(`[collectHtmlContent.client] Error: ${error}`);
+      }
+      html.abort(new Error("HTML Stream aborted"));
+      if (error != null) {
+        throw error;
+      }
+      throw new Error("Failed to collect HTML content");
+    }
+  };