vite-plugin-react-server 1.1.18 → 1.1.20

package/plugin/config/resolveOptions.ts

@@ -104,7 +104,7 @@ export const resolveOptions = <
     typeof options.moduleBasePath === "string"
       ? options.moduleBasePath
       : process.env.VITE_BASE_URL ?? DEFAULT_CONFIG.MODULE_BASE_PATH;
-
+  
   const moduleBaseURL =
     typeof options.moduleBaseURL === "string"
       ? options.moduleBaseURL
@@ -234,24 +234,23 @@ export const resolveOptions = <
   );
 
   const isServerFunctionCode = resolveAutoDiscoverMatcher(
-    options.autoDiscover?.isServerFunction,
+    options.autoDiscover?.isServerFunctionCode,
     options.autoDiscover?.serverDirective
       ? (code: string, moduleId?: string) =>
           code.match(options.autoDiscover?.serverDirective!) != null ||
           (moduleId && serverFunctions(moduleId)) ||
           false
-      : (code: string, moduleId?: string) =>
-          code.match(DEFAULT_CONFIG.AUTO_DISCOVER.serverDirective) != null ||
-          (moduleId && serverFunctions(moduleId)) ||
-          false
+      : DEFAULT_CONFIG.AUTO_DISCOVER.isServerFunctionCode
   );
 
   const isClientComponentCode = resolveAutoDiscoverMatcher(
-    options.autoDiscover?.isClientComponent,
+    options.autoDiscover?.isClientComponentCode,
     options.autoDiscover?.clientDirective
-      ? (code: string) =>
-          code.match(options.autoDiscover?.clientDirective!) != null
-      : DEFAULT_CONFIG.AUTO_DISCOVER.clientDirective
+      ? (code: string, moduleId?: string) =>
+          code.match(options.autoDiscover?.clientDirective!) != null ||
+          (moduleId && clientComponents(moduleId)) ||
+          false
+      : DEFAULT_CONFIG.AUTO_DISCOVER.isClientComponentCode
   );
 
   const hashOption =

package/plugin/helpers/handleServerAction.ts

@@ -0,0 +1,79 @@
+import type { Logger } from "vite";
+import { toError } from "../error/toError.js";
+import { PassThrough } from "node:stream";
+
+export interface ServerActionRequest {
+  id: string;
+  args: unknown[];
+}
+
+export interface ServerActionResponse {
+  type: "server-action-response";
+  returnValue: unknown;
+}
+
+/**
+ * Parses a server action request from the request body.
+ * Supports two formats:
+ * 1. Direct args array: [arg1, arg2, ...]
+ * 2. Object with id and args: { id: string, args: unknown[] }
+ */
+export function parseServerActionRequest(body: string, url?: string): ServerActionRequest {
+  const parsed = JSON.parse(body);
+  
+  if (Array.isArray(parsed)) {
+    // Format 1: Direct args array
+    return {
+      args: parsed,
+      id: url?.split("?")[0] ?? "",
+    };
+  } else if (parsed && typeof parsed === "object" && "id" in parsed) {
+    // Format 2: Object with id and args
+    return {
+      id: parsed.id,
+      args: parsed.args ?? [],
+    };
+  }
+  
+  throw new Error("Invalid server action request format");
+}
+
+/**
+ * Creates a server action response with the given result or error.
+ */
+export function createServerActionResponse(result?: unknown, error?: string): ServerActionResponse {
+  return {
+    type: "server-action-response",
+    returnValue: error 
+      ? { success: false, error }
+      : result
+  };
+}
+
+/**
+ * Handles errors in server action processing.
+ */
+export function handleServerActionError(error: unknown, res: any, logger: Logger) {
+  const err = toError(error);
+  logger.error(err.message + (err.stack ?? ""), { error: err });
+  res.statusCode = 500;
+  res.end(JSON.stringify(createServerActionResponse(undefined, err.message)));
+}
+
+/**
+ * Sets up common response headers for server actions.
+ */
+export function setupServerActionHeaders(res: any) {
+  res.setHeader("Content-Type", "text/x-component; charset=utf-8");
+  res.setHeader("Transfer-Encoding", "chunked");
+  res.setHeader("Connection", "keep-alive");
+}
+
+/**
+ * Creates a pass-through stream for server action responses.
+ */
+export function createServerActionStream(res: any): PassThrough {
+  const passThrough = new PassThrough();
+  passThrough.pipe(res);
+  return passThrough;
+} 

package/plugin/loader/handleExports.ts

@@ -1,5 +1,20 @@
-import type { Program } from "./types.js";
-import type { FunctionDeclaration, VariableDeclaration, VariableDeclarator } from "acorn";
+import type { Program, Node } from "./types.js";
+import type { 
+  FunctionDeclaration,  VariableDeclaration,
+  VariableDeclarator
+} from "acorn";
+
+export interface ExportInfo {
+  name: string;
+  localName?: string;
+  type: "function" | "variable" | "class" | "unknown" | "all";
+  node?: Node;
+  declaration?: string;
+  before?: string[];
+  after?: string[];
+  isAsync?: boolean;
+  loc?: { line: number; column: number };
+}
 
 /**
  * Collects and organizes export information from a module.
@@ -28,40 +43,31 @@ export function handleExports(
   imports: string[];
   declarations: string[];
   exportNames: string[];
-  exports: Map<
-    string,
-    {
-      type: "function" | "class" | "variable" | "default" | "all";
-      declaration?: string;
-      localName?: string;
-      before?: string[];
-      after?: string[];
-      isAsync?: boolean;
-      isServerAction?: boolean;
-    }
-  >;
+  exports: Map<string, ExportInfo>;
 } {
   const imports: string[] = [];
   const declarations: string[] = [];
   const exportNames: string[] = [];
-  // Track exports and their types
-  const exports = new Map<
-    string,
-    {
-      type: "function" | "class" | "variable" | "default" | "all";
-      declaration?: string;
-      localName?: string;
-      before?: string[];
-      after?: string[];
-      isAsync?: boolean;
-      isServerAction?: boolean;
-    }
-  >();
+  const exports = new Map<string, ExportInfo>();
 
   let lastEnd = 0;
   let currentBefore: string[] = [];
   let foundFirstExport = false;
 
+  // Helper function to get function type
+  function getFunctionType(node: Node): "function" | "variable" | "class" | "unknown" {
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      return "function";
+    }
+    if (node.type === "ClassDeclaration") {
+      return "class";
+    }
+    if (node.type === "VariableDeclaration") {
+      return "variable";
+    }
+    return "unknown";
+  }
+
   // First pass: collect all exports and code between them
   for (const node of program.body) {
     // Add any code before this node
@@ -85,9 +91,9 @@ export function handleExports(
             const importedName = spec.imported.type === "Identifier" ? spec.imported.name : "";
             if (localName && importedName) {
               exports.set(localName, {
+                name: localName,
                 type: "function",
                 localName,
-                isServerAction: true,
                 before: [...currentBefore],
               });
               exportNames.push(localName);
@@ -98,6 +104,7 @@ export function handleExports(
     } else if (node.type === "ExportAllDeclaration") {
       // For export * from './other', just add the * export
       exports.set("*", {
+        name: "*",
         type: "all",
         before: [...currentBefore],
       });
@@ -116,11 +123,11 @@ export function handleExports(
         ) {
           const name = node.declaration.id.name;
           exports.set(name, {
-            type: "function",
+            name,
+            type: getFunctionType(node.declaration),
             declaration: source.slice(node.declaration.start, node.declaration.end),
             before: [...currentBefore],
             isAsync: node.declaration.async,
-            isServerAction: isServerFunction === true,
           });
           exportNames.push(name);
           currentBefore = [];
@@ -130,7 +137,8 @@ export function handleExports(
         ) {
           const name = node.declaration.id.name;
           exports.set(name, {
-            type: "class",
+            name,
+            type: getFunctionType(node.declaration),
             declaration: source.slice(node.declaration.start, node.declaration.end),
             before: [...currentBefore],
           });
@@ -141,7 +149,7 @@ export function handleExports(
             if (decl.id && decl.id.type === "Identifier") {
               const name = decl.id.name;
               const init = decl.init;
-              const isFunction = init && (
+              const isFunction = init != null && (
                 init.type === "FunctionExpression" ||
                 init.type === "ArrowFunctionExpression"
               );
@@ -150,11 +158,11 @@ export function handleExports(
                 (init.type === "ArrowFunctionExpression" && init.async === true)
               );
               exports.set(name, {
+                name,
                 type: isFunction ? "function" : "variable",
                 declaration: source.slice(decl.start, decl.end),
                 before: [...currentBefore],
                 isAsync: isAsync || false,
-                isServerAction: isFunction  != null && isServerFunction === true,
               });
               exportNames.push(name);
               currentBefore = [];
@@ -177,12 +185,12 @@ export function handleExports(
 
               if (functionDecl) {
                 exports.set(exportedName, {
-                  type: "function",
+                  name: exportedName,
+                  type: getFunctionType(functionDecl),
                   localName,
                   declaration: source.slice(functionDecl.start, functionDecl.end),
                   before: [...currentBefore],
                   isAsync: functionDecl.async,
-                  isServerAction: isServerFunction === true,
                 });
                 exportNames.push(exportedName);
               } else {
@@ -208,17 +216,18 @@ export function handleExports(
                     const isAsync = decl.init.type === "FunctionExpression" ? decl.init.async :
                                   decl.init.type === "ArrowFunctionExpression" ? decl.init.async : false;
                     exports.set(exportedName, {
+                      name: exportedName,
                       type: "function",
                       localName,
                       declaration: source.slice(decl.start, decl.end),
                       before: [...currentBefore],
                       isAsync,
-                      isServerAction: isServerFunction === true,
                     });
                     exportNames.push(exportedName);
                   }
                 } else {
                   exports.set(exportedName, {
+                    name: exportedName,
                     type: "variable",
                     localName,
                     before: [...currentBefore],
@@ -233,14 +242,15 @@ export function handleExports(
     } else if (node.type === "ExportDefaultDeclaration") {
       if (node.declaration && node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
         exports.set("default", {
-          type: "default",
-          before: [...currentBefore],
+          name: "default",
+          type: getFunctionType(node.declaration),
           localName: node.declaration.id.name, // Capture the function name
-          isAsync: node.declaration.async
+          isAsync: node.declaration.async,
         });
       } else {
         exports.set("default", {
-          type: "default",
+          name: "default",
+          type: "unknown",
           before: [...currentBefore]
         });
       }

package/plugin/loader/transformModuleIfNeeded.ts

@@ -3,28 +3,63 @@ import { transformModuleWithPreservedFunctions } from "./transformModuleWithPres
 import { parse } from "./parse.js";
 import { DEFAULT_CONFIG } from "../config/defaults.js";
 
+// --- React RSC Directive Handling ---
+//
+// 1. 'use client' at file top:
+//    - Pass through code as-is (after removing directive).
+//    - Do not transform or register anything.
+//    - Required for React client features to work.
+//    - See: https://react.dev/reference/rsc/use-client
+//
+// 2. 'use server' at file top:
+//    - Register all exported async functions as server actions.
+//    - See: https://react.dev/reference/rsc/use-server
+//
+// 3. 'use server' at function top:
+//    - Register only that async function as a server action.
+//    - See: https://react.dev/reference/rsc/use-server
+//
+// 4. No directive:
+//    - Treat as a normal shared or server-only module.
+//    - No special registration or transformation.
+
 export function transformModuleIfNeeded(
   source: string,
   moduleId: string,
   isServerFunction: boolean | RegExpMatchArray | null = DEFAULT_CONFIG.AUTO_DISCOVER.isServerFunctionCode(source, moduleId),
-  isClientComponent: boolean | RegExpMatchArray | null = DEFAULT_CONFIG.AUTO_DISCOVER.isClientComponentCode(source),
+  isClientComponent: boolean | RegExpMatchArray | null = DEFAULT_CONFIG.AUTO_DISCOVER.isClientComponentCode(source, moduleId),
   isServerEnvironment = getCondition() === "react-server"
 ) {
   // Handle environment-specific cases
-  if (
-    (isServerEnvironment && !isServerFunction && !isClientComponent) ||
-    (!isServerEnvironment && isClientComponent)
-  ) {
-    return source
+  if (isServerEnvironment) {
+    // In server environment:
+    // - Server functions need transformation
+    // - Client components need transformation
+    // - Other modules can pass through
+    if (!isServerFunction && !isClientComponent) {
+      return source;
+    }
+  } else {
+    // In client environment:
+    // - Only client components should pass through
+    // - Server functions should be transformed
+    if (isClientComponent) {
+      return source;
+    }
   }
 
-  const result = transformModuleWithPreservedFunctions(
-    source,
-    moduleId,
-    parse(source),
-    isServerFunction,
-    isClientComponent
-  );
-
-  return result
+  try {
+    const result = transformModuleWithPreservedFunctions(
+      source,
+      moduleId,
+      parse(source),
+      isServerFunction,
+      isClientComponent
+    );
+    return result;
+  } catch (error) {
+    // Log the error and rethrow
+    console.error(`Error transforming module ${moduleId}:`, error);
+    throw error;
+  }
 }