fix(rsc): relax async function requirement for "use server" module directive (#754)

Author: hi-ogawa

packages/plugin-rsc/src/transforms/wrap-export.test.ts

@@ -2,13 +2,13 @@ import { parseAstAsync } from 'vite'
 import { describe, expect, test } from 'vitest'
 import { debugSourceMap } from './test-utils'
 import {
-  type TransformWrapExportFilter,
+  type TransformWrapExportOptions,
   transformWrapExport,
 } from './wrap-export'
 
 async function testTransform(
   input: string,
-  options?: { filter?: TransformWrapExportFilter },
+  options?: Omit<TransformWrapExportOptions, 'runtime'>,
 ) {
   const ast = await parseAstAsync(input)
   const { output } = transformWrapExport(input, ast, {
@@ -304,4 +304,55 @@ export default Page;
       "
     `)
   })
+
+  test('reject non async function', async () => {
+    // next.js's validataion isn't entirely consisten.
+    // for now we aim to make it at least as forgiving as next.js.
+
+    const accepted = [
+      `export async function f() {}`,
+      `export default async function f() {}`,
+      `export const fn = async function fn() {}`,
+      `export const fn = async () => {}`,
+      `export const fn = async () => {}, fn2 = x`,
+      `export const fn = x`,
+      `export const fn = x({ x: y })`,
+      `export const fn = x(async () => {})`,
+      `export default x`,
+      `const y = x; export { y }`,
+      `export const fn = x(() => {})`, // rejected by next.js
+    ]
+
+    const rejected = [
+      `export function f() {}`,
+      `export default function f() {}`,
+      `export const fn = function fn() {}`,
+      `export const fn = () => {}`,
+      `export const fn = x, fn2 = () => {}`,
+      `export class Cls {}`,
+    ]
+
+    async function toActual(input: string) {
+      try {
+        await testTransform(input, {
+          rejectNonAsyncFunction: true,
+        })
+        return [input, true]
+      } catch (e) {
+        return [input, e instanceof Error ? e.message : e]
+      }
+    }
+
+    const actual = [
+      ...(await Promise.all(accepted.map((e) => toActual(e)))),
+      ...(await Promise.all(rejected.map((e) => toActual(e)))),
+    ]
+
+    const expected = [
+      ...accepted.map((e) => [e, true]),
+      ...rejected.map((e) => [e, 'unsupported non async function']),
+    ]
+
+    expect(actual).toEqual(expected)
+  })
 })

packages/plugin-rsc/src/transforms/wrap-export.ts

@@ -14,15 +14,17 @@ export type TransformWrapExportFilter = (
   meta: ExportMeta,
 ) => boolean
 
+export type TransformWrapExportOptions = {
+  runtime: (value: string, name: string, meta: ExportMeta) => string
+  ignoreExportAllDeclaration?: boolean
+  rejectNonAsyncFunction?: boolean
+  filter?: TransformWrapExportFilter
+}
+
 export function transformWrapExport(
   input: string,
   ast: Program,
-  options: {
-    runtime: (value: string, name: string, meta: ExportMeta) => string
-    ignoreExportAllDeclaration?: boolean
-    rejectNonAsyncFunction?: boolean
-    filter?: TransformWrapExportFilter
-  },
+  options: TransformWrapExportOptions,
 ): {
   exportNames: string[]
   output: MagicString
@@ -81,8 +83,15 @@ export function transformWrapExport(
     )
   }
 
-  function validateNonAsyncFunction(node: Node, ok?: boolean) {
-    if (options.rejectNonAsyncFunction && !ok) {
+  function validateNonAsyncFunction(node: Node) {
+    if (!options.rejectNonAsyncFunction) return
+    if (
+      node.type === 'ClassDeclaration' ||
+      ((node.type === 'FunctionDeclaration' ||
+        node.type === 'FunctionExpression' ||
+        node.type === 'ArrowFunctionExpression') &&
+        !node.async)
+    ) {
       throw Object.assign(new Error(`unsupported non async function`), {
         pos: node.start,
       })
@@ -100,11 +109,7 @@ export function transformWrapExport(
           /**
            * export function foo() {}
            */
-          validateNonAsyncFunction(
-            node,
-            node.declaration.type === 'FunctionDeclaration' &&
-              node.declaration.async,
-          )
+          validateNonAsyncFunction(node.declaration)
           const name = node.declaration.id.name
           wrapSimple(node.start, node.declaration.start, [
             { name, meta: { isFunction: true, declName: name } },
@@ -113,14 +118,11 @@ export function transformWrapExport(
           /**
            * export const foo = 1, bar = 2
            */
-          validateNonAsyncFunction(
-            node,
-            node.declaration.declarations.every(
-              (decl) =>
-                decl.init?.type === 'ArrowFunctionExpression' &&
-                decl.init.async,
-            ),
-          )
+          for (const decl of node.declaration.declarations) {
+            if (decl.init) {
+              validateNonAsyncFunction(decl.init)
+            }
+          }
           if (node.declaration.kind === 'const') {
             output.update(
               node.declaration.start,
@@ -201,14 +203,7 @@ export function transformWrapExport(
      * export default () => {}
      */
     if (node.type === 'ExportDefaultDeclaration') {
-      validateNonAsyncFunction(
-        node,
-        // TODO: somehow identifier is allowed in next.js?
-        // (see packages/react-server/examples/next/app/actions/server/actions.ts)
-        node.declaration.type === 'Identifier' ||
-          (node.declaration.type === 'FunctionDeclaration' &&
-            node.declaration.async),
-      )
+      validateNonAsyncFunction(node.declaration as Node)
       let localName: string
       let isFunction = false
       let declName: string | undefined