vite-plugin-react-server 1.2.0-alpha.0 → 1.2.0

package/plugin/environments/resolveEnvironmentConfig.ts

@@ -0,0 +1,320 @@
+import type { UserConfig, BuildEnvironmentOptions } from "vite";
+import type { ResolvedUserOptions, AutoDiscoveredFiles } from "../types.js";
+import type { OutputOptions } from "rollup";
+import { join } from "node:path";
+import { createLogger } from "vite";
+import { getEnvValue, setEnvValue } from "../env/getEnvKey.js";
+import { DEFAULT_CONFIG } from "../config/defaults.js";
+
+
+// Cache for resolved environment configs to avoid recomputation
+const stashedEnvironmentConfig: Record<string, BuildEnvironmentOptions | null> = {};
+let originalConfig: UserConfig | null = null;
+
+
+
+// TODO: Use virtual module approach with this.fileName in transformer
+
+/**
+ * KEY DIFFERENCES FROM resolveUserConfig:
+ *
+ * 1. Uses BuildEnvironmentOptions type instead of UserConfig
+ * 2. Returns environment-specific configuration for Vite's Environment API
+ * 3. Must set preserveModules: true for preserveModulesRoot to work
+ * 4. Simplified input normalization (no moduleBase stripping in inputs)
+ * 5. Environment-specific output directories and settings
+ * 6. Uses Vite's natural module resolution and hashing
+ * 
+ * FUTURE ENHANCEMENTS:
+ * - Could support callback functions for entryFileNames, chunkFileNames, and assetFileNames
+ * - This would allow custom hash generation based on file content as discussed in
+ *   https://github.com/rollup/rollup/issues/5362
+ * - Would enable better cache busting and custom file naming strategies
+ */
+
+export type ResolveEnvironmentConfigProps = {
+  condition: "react-client" | "react-server";
+  config: UserConfig;
+  userOptions: ResolvedUserOptions;
+  autoDiscoveredFiles: AutoDiscoveredFiles;
+  ssr?: boolean;
+  forceResolve?: boolean;
+};
+
+export type ResolveEnvironmentConfigReturn =
+  | { type: "success"; environmentConfig: BuildEnvironmentOptions }
+  | { type: "error"; error: unknown };
+
+export type ResolveEnvironmentConfigFn = (
+  props: ResolveEnvironmentConfigProps
+) => ResolveEnvironmentConfigReturn;
+
+/**
+ * Resolve environment-specific configuration for the Environment API.
+ * This is a sophisticated version that follows the same patterns as resolveUserConfig
+ * but adapted for Vite's Environment API requirements.
+ */
+export const resolveEnvironmentConfig: ResolveEnvironmentConfigFn =
+  function _resolveEnvironmentConfig({
+    condition,
+    config,
+    userOptions,
+    autoDiscoveredFiles,
+    ssr = undefined,
+    forceResolve = false,
+  }) {
+    // Handle config changes and caching
+    if (!forceResolve && originalConfig == null) {
+      originalConfig = config;
+    } else if (originalConfig != null && config !== originalConfig) {
+      forceResolve = true;
+    }
+
+    // Determine SSR mode with fallbacks
+    ssr =
+      typeof ssr === "boolean"
+        ? ssr
+        : typeof config.build?.ssr === "boolean"
+        ? config.build?.ssr
+        : condition === "react-server"
+        ? true
+        : false;
+
+    if (condition === "react-server" && !ssr) {
+      const logger = config.customLogger ?? createLogger();
+      logger.warn(
+        "react-server build should be ssr, but it was manually set to false. This may not work as expected."
+      );
+    }
+
+    // Determine environment-specific directory
+    const envDir =
+      condition === "react-client" && ssr
+        ? userOptions.build.client
+        : condition === "react-client"
+        ? userOptions.build.static
+        : userOptions.build.server;
+    
+    const envId = `${envDir}${ssr ? "-ssr" : ""}`;
+
+    // Check cache first
+    if (stashedEnvironmentConfig[envId] && !forceResolve) {
+      return {
+        type: "success",
+        environmentConfig: stashedEnvironmentConfig[envId]!,
+      };
+    }
+
+    try {
+      // Get environment variables (env vars take precedence over config)
+      const vitePrefix = config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;
+      const primaryPrefix =
+        typeof vitePrefix === "string" ? vitePrefix : vitePrefix[0];
+      
+      const envBaseUrl = getEnvValue("BASE_URL", primaryPrefix);
+      const effectiveModuleBaseURL =
+        envBaseUrl != null && envBaseUrl !== ""
+          ? envBaseUrl
+          : userOptions.moduleBaseURL;
+
+      const envPublicOrigin = getEnvValue("PUBLIC_ORIGIN", primaryPrefix);
+      const effectivePublicOrigin =
+        envPublicOrigin != null ? envPublicOrigin : userOptions.publicOrigin;
+
+      // Set process.env values to ensure they're available for server-side code
+      if (!getEnvValue("BASE_URL", primaryPrefix)) {
+        setEnvValue("BASE_URL", effectiveModuleBaseURL, primaryPrefix);
+      }
+      if (!getEnvValue("PUBLIC_ORIGIN", primaryPrefix)) {
+        setEnvValue("PUBLIC_ORIGIN", effectivePublicOrigin, primaryPrefix);
+      }
+
+      // Determine inputs based on condition and SSR with better normalization
+      let inputs: Record<string, string>;
+      if (condition === "react-client") {
+        if (ssr) {
+          // For SSR builds, exclude HTML files and use only client inputs
+          inputs = Object.fromEntries(
+            Object.entries(autoDiscoveredFiles.clientInputs).filter(
+              ([, value]) => !value.endsWith(".html") && !value.endsWith(".htm")
+            )
+          );
+        } else {
+          // For static builds, use static inputs (which can include HTML)
+          inputs = autoDiscoveredFiles.staticInputs;
+        }
+      } else {
+        // For server builds, use server inputs (no HTML files)
+        inputs = autoDiscoveredFiles.serverInputs;
+      }
+
+      // Normalize inputs for this environment (following resolveUserConfig pattern)
+      const normalizedInputs = Object.fromEntries(
+        Object.entries(inputs).map(([key, value]) => [
+          key,
+          value.slice(Number(value.startsWith("/"))),
+        ])
+      );
+
+      // Handle user-defined output options (following resolveUserConfig pattern)
+      const userDefinedOutput = config.build?.rollupOptions?.output;
+      const hasOtherOutput =
+        Array.isArray(userDefinedOutput) && userDefinedOutput.length > 1;
+      const hasValidOutput = userDefinedOutput && !hasOtherOutput;
+      const hasObjectOutput =
+        userDefinedOutput &&
+        !hasOtherOutput &&
+        typeof userDefinedOutput === "object" &&
+        userDefinedOutput !== null;
+
+      const userDefinedAssetFileNames = hasObjectOutput
+        ? "assetFileNames" in userDefinedOutput
+          ? userDefinedOutput.assetFileNames
+          : undefined
+        : // find the other asset file names
+        hasOtherOutput
+        ? (userDefinedOutput.find((o) => o?.assetFileNames) as OutputOptions)
+            ?.assetFileNames
+        : undefined;
+
+      const userDefinedChunkFileNames = hasValidOutput
+        ? "chunkFileNames" in userDefinedOutput
+          ? userDefinedOutput.chunkFileNames
+          : undefined
+        : undefined;
+      const userDefinedEntryFileNames = hasValidOutput
+        ? "entryFileNames" in userDefinedOutput
+          ? userDefinedOutput.entryFileNames
+          : undefined
+        : undefined;
+
+      // Rollup's preserveModulesRoot works in reverse of what you'd expect:
+      // - When user wants preservation (true): pass undefined to Rollup (don't strip anything)
+      // - When user wants stripping (false): pass moduleBase to Rollup (strip this path)
+      const preserveModulesRootString =
+        userOptions.build.preserveModulesRoot === false
+          ? userOptions.moduleBase // Strip src/ from output paths
+          : undefined; // Keep src/ in output paths
+      
+
+      // Basic rollup options - the file naming will be handled by resolveUserConfig mapping
+      const rollupOptions = {
+        input: normalizedInputs,
+        output: {
+          format: "esm" as const,
+          exports: "named" as const,
+          preserveModules: true, // Required for preserveModulesRoot to work
+          preserveModulesRoot: preserveModulesRootString,
+          // Note: entryFileNames, chunkFileNames, assetFileNames will be overridden by createEnvironmentPlugin mapping
+          entryFileNames: userDefinedEntryFileNames,
+          chunkFileNames: userDefinedChunkFileNames,
+          assetFileNames: userDefinedAssetFileNames,
+        },
+      };
+
+      if (condition === "react-client") {
+        // Client environment configuration
+        const clientEnvironmentConfig: BuildEnvironmentOptions = {
+          outDir: join(userOptions.build.outDir, envDir),
+          assetsDir: userOptions.build.assetsDir,
+          emptyOutDir: config.build?.emptyOutDir ?? true,
+          copyPublicDir:
+            typeof config.build?.copyPublicDir === "boolean"
+              ? config.build?.copyPublicDir
+              : !ssr,
+          target: config.build?.target ?? "esnext",
+          minify: config.build?.minify ?? true,
+          manifest: config.build?.manifest ?? `.vite/manifest.json`,
+          ssrManifest: config.build?.ssrManifest ?? `.vite/ssr-manifest.json`,
+          ssrEmitAssets: config.build?.ssrEmitAssets ?? true,
+          cssCodeSplit:
+            typeof config.build?.cssCodeSplit === "boolean"
+              ? config.build?.cssCodeSplit
+              : true,
+          modulePreload: config.build?.modulePreload ?? false,
+          rollupOptions,
+        };
+
+        stashedEnvironmentConfig[envId] = clientEnvironmentConfig;
+        return {
+          type: "success",
+          environmentConfig: clientEnvironmentConfig,
+        };
+      } else {
+        // Server environment configuration
+        const serverBuildEnvironmentOptions: BuildEnvironmentOptions = {
+          outDir: join(userOptions.build.outDir, envDir),
+          assetsDir: userOptions.build.assetsDir,
+          emptyOutDir: config.build?.emptyOutDir ?? true,
+          copyPublicDir:
+            typeof config.build?.copyPublicDir === "boolean"
+              ? config.build?.copyPublicDir
+              : false,
+          target: config.build?.target ?? "esnext", // Use esnext for pure ESM - no helpers needed
+          minify: config.build?.minify ?? true,
+          manifest: config.build?.manifest ?? `.vite/manifest.json`,
+          ssrManifest: config.build?.ssrManifest ?? `.vite/ssr-manifest.json`,
+          ssrEmitAssets:
+            typeof config.build?.ssrEmitAssets === "boolean"
+              ? config.build?.ssrEmitAssets
+              : true,
+          cssCodeSplit:
+            typeof config.build?.cssCodeSplit === "boolean"
+              ? config.build?.cssCodeSplit
+              : true,
+          modulePreload: config.build?.modulePreload ?? false,
+          rollupOptions: {
+            ...config.build?.rollupOptions,
+            input: normalizedInputs,
+            output: {
+              format: "esm" as const,
+              exports: "named" as const,
+              preserveModules: true, // Required for preserveModulesRoot to work
+              preserveModulesRoot: preserveModulesRootString,
+              // Note: entryFileNames, chunkFileNames, assetFileNames will be overridden by createEnvironmentPlugin mapping
+              entryFileNames: userDefinedEntryFileNames,
+              chunkFileNames: userDefinedChunkFileNames,
+              assetFileNames: userDefinedAssetFileNames,
+            },
+            preserveEntrySignatures:
+              config.build?.rollupOptions?.preserveEntrySignatures ?? "strict",
+            external: config.build?.rollupOptions?.external ?? [
+              "react",
+              "react/jsx-runtime",
+              "react/jsx-dev-runtime",
+              "react-dom",
+              "react-server-dom-esm/server.node",
+            ],
+            context: "module",
+            plugins: [
+              ...(Array.isArray(config.build?.rollupOptions?.plugins)
+                ? config.build.rollupOptions.plugins
+                : config.build?.rollupOptions?.plugins
+                ? [config.build.rollupOptions.plugins]
+                : []),
+              {
+                name: "react-server-conditions",
+                buildStart() {
+                  // Ensure react-server condition is available during server builds
+                  if (condition === "react-server") {
+                   // process.env.NODE_OPTIONS = (process.env.NODE_OPTIONS || "") + " --conditions react-server";
+                  }
+                },
+              },
+            ],
+          },
+        };
+
+        stashedEnvironmentConfig[envId] = serverBuildEnvironmentOptions;
+        return {
+          type: "success",
+          environmentConfig: serverBuildEnvironmentOptions,
+        };
+      }
+    } catch (error) {
+      return {
+        type: "error",
+        error,
+      };
+    }
+  };

package/plugin/error/assertPanic.ts

@@ -0,0 +1,9 @@
+import { isPanic } from "./shouldPanic.js";
+
+export function assertPanic<T>(
+  error: T
+): asserts error is NonNullable<T> {
+  if (isPanic(error)) {
+    throw error;
+  }
+}

package/plugin/error/handleError.ts

@@ -0,0 +1,63 @@
+import { createLogger } from "vite";
+import { toError } from "./toError.js";
+import { getNodeEnv } from "../config/getNodeEnv.js";
+import { logError } from "./logError.js";
+import { PANIC_SYMBOL } from "./shouldPanic.js";
+import type { HandleErrorFn } from "./types.js";
+
+let errRepeat = 0;
+let lastError: Error | null = null;
+/**
+ * Simplified error handling function that:
+ * - Formats and logs errors
+ * - Handles panic thresholds
+ * - Returns error to throw or null to continue
+ */
+export const handleError: HandleErrorFn = function _handleError(
+  options
+): Error | null {
+  const {
+    error,
+    errorInfo,
+    logger = createLogger(),
+    mode = getNodeEnv(),
+    panicThreshold = "none",
+    critical = false,
+    log = false,
+  } = options;
+  // Handle React error info if present
+  if (errorInfo != null) {
+    const errInfo = new Error(`Digest: ${(errorInfo as any).digest ?? 'unknown'}`);
+    errInfo.stack = errorInfo.componentStack ?? undefined;
+    errInfo.name = "ErrorInfo";
+    if (log) logError(errInfo, logger, mode);
+  }
+
+  const err = toError(error, errorInfo ?? undefined);
+
+  // Simple panic threshold logic
+  if (panicThreshold === "all_errors" || (critical && panicThreshold === "critical_errors")) {
+    // Mark error for panic and return it to be thrown
+    (err as any)[PANIC_SYMBOL] = true;
+    return err;
+  }
+
+  if (log) {
+    if (
+      lastError?.message === (error as Error)?.message &&
+      lastError?.stack === (error as Error)?.stack
+    ) {
+      errRepeat++;
+      const repeatedFrom = new Error("Error repeated", { cause: err });
+      repeatedFrom.stack = err.stack;
+      logger.error(`${err.message} (${errRepeat})`, { error: repeatedFrom });
+    } else {
+      errRepeat = 0;
+      lastError = error as Error;
+      logError(err, logger, mode);
+    }
+  }
+
+  // For "none" or non-critical errors, continue processing
+  return null;
+};

package/plugin/error/index.ts

@@ -1,3 +1,6 @@
 export { toError } from "./toError.js";
 export { logError } from "./logError.js";
-export { enhanceError, createContextualError } from "./enhanceError.js";
+export { enhanceError, createContextualError } from "./enhanceError.js";
+export { handleError } from "./handleError.js";
+export { shouldPanic, PANIC_SYMBOL, isPanic } from "./shouldPanic.js";
+export { assertPanic } from "./assertPanic.js";

package/plugin/error/logError.ts

@@ -1,45 +1,69 @@
-import type { Logger } from "vite";
-import { toError } from "./toError.js";
-import { getNodeEnv } from "../getNodeEnv.js";
+import { createLogger, type Logger } from "vite";
+import { getNodeEnv } from "../config/getNodeEnv.js";
+/**
+ * Simple error logging function focused purely on logging errors
+ * without any deduplication or complex formatting logic
+ */
+export function logError(
+  err: Error,
+  logger: Logger | Console = createLogger(),
+  mode: "development" | "production" | "test" = getNodeEnv()
+) {
+  // when a proper logger is provided
+  if (logger == null || typeof logger.error !== "function") {
+    logger = console;
+  }
+  const errorOptions = {
+    error: err,
+    clear: mode === "development",
+    timestamp: mode !== "test",
+  };
 
-export function logError(error: unknown, logger: Logger | Console = console) {
-    const err = toError(error);
-    if (getNodeEnv() !== "production") {
-      if (
-        err.stack &&
-        err.message.length > 0 &&
-        err.stack.includes(err.message)
-      ) {
-        logger.error(err.stack);
-      } else if (err.stack && err.stack.length > 0 && err.message.length > 0) {
-        logger.error(err.message + "\n" + err.stack, {
-          error: err,
-        });
-      } else if (err.stack && err.stack.length > 0) {
-        logger.error(err.stack, {
-          error: err,
-        });
-      } else if (err.message.length > 0) {
-        logger.error(err.message, {
-          error: err,
-        });
-      } else {
-        logger.error("Unknown error", {
-          error: err,
-        });
-      }
-    } else if(typeof err.message === "string") {
-      logger.error(err.message);
-    } else if(typeof err.message === "object" && err.message !== null && "message" in err.message) {
-      logger.error(err.message);
+  // Simple error logging based on mode
+  if (mode !== "production") {
+    if (
+      err.stack &&
+      (err.message?.length ?? 0) > 0 &&
+      err.stack.includes(err.message)
+    ) {
+      logger.error(err.stack, errorOptions);
+    } else if ((err.stack?.length ?? 0) > 0 && (err.message?.length ?? 0) > 0) {
+      logger.error(err.message + "\n" + err.stack, errorOptions);
+    } else if ((err.stack?.length ?? 0) > 0 && typeof err.stack === "string") {
+      logger.error(err.stack, errorOptions);
+    } else if ((err.message?.length ?? 0) > 0) {
+      logger.error(err.message, errorOptions);
+    } else {
+      logger.error("Unknown error", errorOptions);
+    }
+  } else {
+    // Production mode - simplified logging
+    if (typeof err.message === "string") {
+      logger.error(err.message, errorOptions);
+    } else if (
+      typeof err.message === "object" &&
+      err.message !== null &&
+      "message" in err.message
+    ) {
+      logger.error(err.message, errorOptions);
     } else if (err.stack) {
-      logger.error(err.stack);
-    } else if (err != null && typeof err === "object" && 'reason' in err && typeof err.reason === "string") {
-      logger.error(err.reason);
-    } else if (err != null && typeof err === "object" && 'error' in err && typeof err.error === "string") {
-      logger.error(err.error);
+      logger.error(err.stack, errorOptions);
+    } else if (
+      err != null &&
+      typeof err === "object" &&
+      "reason" in err &&
+      typeof err.reason === "string"
+    ) {
+      logger.error(err.reason, errorOptions);
+    } else if (
+      err != null &&
+      typeof err === "object" &&
+      "error" in err &&
+      typeof err.error === "string"
+    ) {
+      logger.error(err.error, errorOptions);
     } else {
-      logger.error(JSON.stringify(err));
+      logger.error(JSON.stringify(err), errorOptions);
     }
   }
-  
+}

package/plugin/error/panicThresholdHandler.ts

@@ -0,0 +1,52 @@
+/**
+ * Centralized panic threshold handling logic
+ * 
+ * This module provides a single place to handle panic threshold decisions
+ * instead of scattering the logic across multiple files.
+ */
+
+import { shouldPanic, isPanic } from "./shouldPanic.js";
+import type { PanicThreshold } from "../types.js";
+
+export interface PanicThresholdOptions {
+  panicThreshold: PanicThreshold;
+  critical?: boolean;
+  logger?: any;
+  context?: string;
+}
+
+/**
+ * Determines if an error should cause a panic based on panic threshold settings
+ */
+export function shouldCausePanic(
+  error: unknown,
+  options: PanicThresholdOptions
+): boolean {
+  return shouldPanic(error, options.panicThreshold, options.critical);
+}
+
+/**
+ * Handles an error based on panic threshold settings
+ * Returns the error if it should cause a panic, null otherwise
+ */
+export function handlePanicThreshold(
+  error: unknown,
+  options: PanicThresholdOptions
+): Error | null {
+  if (shouldCausePanic(error, options)) {
+    // Mark error for panic and return it to be thrown
+    const err = error instanceof Error ? error : new Error(String(error));
+    (err as any)[Symbol.for('vite-plugin-react-server.panic')] = true;
+    return err;
+  }
+  return null;
+}
+
+/**
+ * Checks if an error is already marked as a panic error
+ */
+export function isPanicError(error: unknown): boolean {
+  return isPanic(error);
+}
+
+

package/plugin/error/serializeError.ts

@@ -1,15 +1,26 @@
+import { PANIC_SYMBOL } from "./shouldPanic.js";
+
 export function serializeError(error: unknown): {
-  message: string;
+  message?: string;
   stack?: string | undefined;
-  name: string;
+  name?: string;
+  environment?: string;
   cause?: unknown;
+  breadcrumbs?: string[];
+  [PANIC_SYMBOL]?: boolean;
 } {
   if (error instanceof Error) {
-  return {
-    message: error.message,
-      stack: error.stack,
-      name: error.name,
-      cause: error.cause,
+    const { message, stack, name, cause, ...rest } = error;
+    return {
+      message: message,
+      stack: stack,
+      name: name,
+      cause: cause,
+      breadcrumbs:
+        (error as Error & { breadcrumbs: string[] })["breadcrumbs"] ?? [],
+      [PANIC_SYMBOL]:
+        (error as Error & { PANIC_SYMBOL: boolean })["PANIC_SYMBOL"] ?? false,
+      ...rest,
     };
   }
   if (typeof error === "string") {
@@ -17,18 +28,32 @@ export function serializeError(error: unknown): {
       message: error,
       stack: undefined,
       name: "Unknown React Stream Error",
+      breadcrumbs: [],
+      [PANIC_SYMBOL]: false,
     };
   }
   if (typeof error === "object" && error !== null) {
+    const {
+      message = "Unknown React Stream Error",
+      stack,
+      name,
+      cause,
+      ...rest
+    } = error as Error;
     return {
-      message: "Unknown React Stream Error",
-      stack: undefined,
-      name: "Unknown React Stream Error",
+      message: message,
+      stack: stack,
+      name: name,
+      breadcrumbs: [],
+      [PANIC_SYMBOL]: false,
+      ...rest,
     };
   }
   return {
     message: "Unknown React Stream Error",
     stack: undefined,
     name: "Unknown React Stream Error",
+    breadcrumbs: [],
+    [PANIC_SYMBOL]: false,
   };
-}
+}

package/plugin/error/serializeErrorInfo.ts

@@ -0,0 +1,17 @@
+export function serializeErrorInfo(errorInfo: unknown): null | {
+  componentStack?: string | undefined;
+  digest?: string | undefined;
+} {
+  if(errorInfo == null || typeof errorInfo !== "object") {
+    return null;
+  }
+  const { componentStack, digest, ...rest } = errorInfo as {
+    componentStack?: string;
+    digest?: string;
+  };
+  return {
+    componentStack: componentStack,
+    digest: digest,
+    ...rest,
+  };
+}