{
205 | 'use server'
206 | console.log(props)
207 | }} />
208 | }
209 | ```
210 |
211 | ⬇️
212 |
213 | ```tsx
214 | import { registerServerReference } from 'react-server-dom-webpack/server'
215 |
216 | export const App = (props) => {
217 | return
218 | }
219 |
220 | export const __prefix__action_1 = registerServerReference(async (bound) => {
221 | 'use server'
222 | const [props] = bound
223 | console.log(props)
224 | }, 'file_id', '__prefix__action_1')
225 | ```
226 |
227 | ## LICENSE
228 |
229 | MIT
230 |
--------------------------------------------------------------------------------
/build.rs:
--------------------------------------------------------------------------------
1 | extern crate napi_build;
2 |
3 | fn main() {
4 | napi_build::setup();
5 | }
6 |
--------------------------------------------------------------------------------
/index.d.ts:
--------------------------------------------------------------------------------
1 | /* auto-generated by NAPI-RS */
2 | /* eslint-disable */
3 | export interface Comment {
4 | start: number
5 | end: number
6 | text: string
7 | }
8 |
9 | export const enum FileType {
10 | Client = 'Client',
11 | Server = 'Server',
12 | Isomorphic = 'Isomorphic'
13 | }
14 |
15 | export interface ModuleImports {
16 | name: string
17 | }
18 |
19 | export function reactServerAction(filePath: string, actionExportPrefix: string, isServerLayer: boolean): Promise
20 |
21 | export const enum RSCError {
22 | CannotUseBothClientAndServer = 0,
23 | ServerActionMustBeAsync = 1
24 | }
25 |
26 | /**
27 | *
28 | * Validate a file is a valid Server file or Client File
29 | *
30 | * @param code: string - the code to validate
31 | *
32 | * @param file_path: string - the path to the file
33 | *
34 | * @param is_server_layer: boolean - if the file is in the server layer, enable this in server side rendering
35 | */
36 | export function validate(code: string, filePath: string, isServerLayer: boolean): ValidateResult
37 |
38 | export interface ValidateResult {
39 | fileType: FileType
40 | isServerAction: boolean
41 | error?: RSCError
42 | imports: Array
43 | }
44 |
45 |
--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | // prettier-ignore
2 | /* eslint-disable */
3 | /* auto-generated by NAPI-RS */
4 |
5 | const { readFileSync } = require('fs')
6 |
7 | let nativeBinding = null
8 | const loadErrors = []
9 |
10 | const isMusl = () => {
11 | let musl = false
12 | if (process.platform === 'linux') {
13 | musl = isMuslFromFilesystem()
14 | if (musl === null) {
15 | musl = isMuslFromReport()
16 | }
17 | if (musl === null) {
18 | musl = isMuslFromChildProcess()
19 | }
20 | }
21 | return musl
22 | }
23 |
24 | const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
25 |
26 | const isMuslFromFilesystem = () => {
27 | try {
28 | return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
29 | } catch {
30 | return null
31 | }
32 | }
33 |
34 | const isMuslFromReport = () => {
35 | const report = typeof process.report.getReport === 'function' ? process.report.getReport() : null
36 | if (!report) {
37 | return null
38 | }
39 | if (report.header && report.header.glibcVersionRuntime) {
40 | return false
41 | }
42 | if (Array.isArray(report.sharedObjects)) {
43 | if (report.sharedObjects.some(isFileMusl)) {
44 | return true
45 | }
46 | }
47 | return false
48 | }
49 |
50 | const isMuslFromChildProcess = () => {
51 | try {
52 | return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
53 | } catch (e) {
54 | // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
55 | return false
56 | }
57 | }
58 |
59 | function requireNative() {
60 | if (process.platform === 'android') {
61 | if (process.arch === 'arm64') {
62 | try {
63 | return require('./react-server-action.android-arm64.node')
64 | } catch (e) {
65 | loadErrors.push(e)
66 | }
67 | try {
68 | return require('react-server-action-android-arm64')
69 | } catch (e) {
70 | loadErrors.push(e)
71 | }
72 |
73 | } else if (process.arch === 'arm') {
74 | try {
75 | return require('./react-server-action.android-arm-eabi.node')
76 | } catch (e) {
77 | loadErrors.push(e)
78 | }
79 | try {
80 | return require('react-server-action-android-arm-eabi')
81 | } catch (e) {
82 | loadErrors.push(e)
83 | }
84 |
85 | } else {
86 | loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
87 | }
88 | } else if (process.platform === 'win32') {
89 | if (process.arch === 'x64') {
90 | try {
91 | return require('./react-server-action.win32-x64-msvc.node')
92 | } catch (e) {
93 | loadErrors.push(e)
94 | }
95 | try {
96 | return require('react-server-action-win32-x64-msvc')
97 | } catch (e) {
98 | loadErrors.push(e)
99 | }
100 |
101 | } else if (process.arch === 'ia32') {
102 | try {
103 | return require('./react-server-action.win32-ia32-msvc.node')
104 | } catch (e) {
105 | loadErrors.push(e)
106 | }
107 | try {
108 | return require('react-server-action-win32-ia32-msvc')
109 | } catch (e) {
110 | loadErrors.push(e)
111 | }
112 |
113 | } else if (process.arch === 'arm64') {
114 | try {
115 | return require('./react-server-action.win32-arm64-msvc.node')
116 | } catch (e) {
117 | loadErrors.push(e)
118 | }
119 | try {
120 | return require('react-server-action-win32-arm64-msvc')
121 | } catch (e) {
122 | loadErrors.push(e)
123 | }
124 |
125 | } else {
126 | loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
127 | }
128 | } else if (process.platform === 'darwin') {
129 | try {
130 | return require('./react-server-action.darwin-universal.node')
131 | } catch (e) {
132 | loadErrors.push(e)
133 | }
134 | try {
135 | return require('react-server-action-darwin-universal')
136 | } catch (e) {
137 | loadErrors.push(e)
138 | }
139 |
140 | if (process.arch === 'x64') {
141 | try {
142 | return require('./react-server-action.darwin-x64.node')
143 | } catch (e) {
144 | loadErrors.push(e)
145 | }
146 | try {
147 | return require('react-server-action-darwin-x64')
148 | } catch (e) {
149 | loadErrors.push(e)
150 | }
151 |
152 | } else if (process.arch === 'arm64') {
153 | try {
154 | return require('./react-server-action.darwin-arm64.node')
155 | } catch (e) {
156 | loadErrors.push(e)
157 | }
158 | try {
159 | return require('react-server-action-darwin-arm64')
160 | } catch (e) {
161 | loadErrors.push(e)
162 | }
163 |
164 | } else {
165 | loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
166 | }
167 | } else if (process.platform === 'freebsd') {
168 | if (process.arch === 'x64') {
169 | try {
170 | return require('./react-server-action.freebsd-x64.node')
171 | } catch (e) {
172 | loadErrors.push(e)
173 | }
174 | try {
175 | return require('react-server-action-freebsd-x64')
176 | } catch (e) {
177 | loadErrors.push(e)
178 | }
179 |
180 | } else if (process.arch === 'arm64') {
181 | try {
182 | return require('./react-server-action.freebsd-arm64.node')
183 | } catch (e) {
184 | loadErrors.push(e)
185 | }
186 | try {
187 | return require('react-server-action-freebsd-arm64')
188 | } catch (e) {
189 | loadErrors.push(e)
190 | }
191 |
192 | } else {
193 | loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
194 | }
195 | } else if (process.platform === 'linux') {
196 | if (process.arch === 'x64') {
197 | if (isMusl()) {
198 | try {
199 | return require('./react-server-action.linux-x64-musl.node')
200 | } catch (e) {
201 | loadErrors.push(e)
202 | }
203 | try {
204 | return require('react-server-action-linux-x64-musl')
205 | } catch (e) {
206 | loadErrors.push(e)
207 | }
208 |
209 | } else {
210 | try {
211 | return require('./react-server-action.linux-x64-gnu.node')
212 | } catch (e) {
213 | loadErrors.push(e)
214 | }
215 | try {
216 | return require('react-server-action-linux-x64-gnu')
217 | } catch (e) {
218 | loadErrors.push(e)
219 | }
220 |
221 | }
222 | } else if (process.arch === 'arm64') {
223 | if (isMusl()) {
224 | try {
225 | return require('./react-server-action.linux-arm64-musl.node')
226 | } catch (e) {
227 | loadErrors.push(e)
228 | }
229 | try {
230 | return require('react-server-action-linux-arm64-musl')
231 | } catch (e) {
232 | loadErrors.push(e)
233 | }
234 |
235 | } else {
236 | try {
237 | return require('./react-server-action.linux-arm64-gnu.node')
238 | } catch (e) {
239 | loadErrors.push(e)
240 | }
241 | try {
242 | return require('react-server-action-linux-arm64-gnu')
243 | } catch (e) {
244 | loadErrors.push(e)
245 | }
246 |
247 | }
248 | } else if (process.arch === 'arm') {
249 | if (isMusl()) {
250 | try {
251 | return require('./react-server-action.linux-arm-musleabihf.node')
252 | } catch (e) {
253 | loadErrors.push(e)
254 | }
255 | try {
256 | return require('react-server-action-linux-arm-musleabihf')
257 | } catch (e) {
258 | loadErrors.push(e)
259 | }
260 |
261 | } else {
262 | try {
263 | return require('./react-server-action.linux-arm-gnueabihf.node')
264 | } catch (e) {
265 | loadErrors.push(e)
266 | }
267 | try {
268 | return require('react-server-action-linux-arm-gnueabihf')
269 | } catch (e) {
270 | loadErrors.push(e)
271 | }
272 |
273 | }
274 | } else if (process.arch === 'riscv64') {
275 | if (isMusl()) {
276 | try {
277 | return require('./react-server-action.linux-riscv64-musl.node')
278 | } catch (e) {
279 | loadErrors.push(e)
280 | }
281 | try {
282 | return require('react-server-action-linux-riscv64-musl')
283 | } catch (e) {
284 | loadErrors.push(e)
285 | }
286 |
287 | } else {
288 | try {
289 | return require('./react-server-action.linux-riscv64-gnu.node')
290 | } catch (e) {
291 | loadErrors.push(e)
292 | }
293 | try {
294 | return require('react-server-action-linux-riscv64-gnu')
295 | } catch (e) {
296 | loadErrors.push(e)
297 | }
298 |
299 | }
300 | } else if (process.arch === 'ppc64') {
301 | try {
302 | return require('./react-server-action.linux-ppc64-gnu.node')
303 | } catch (e) {
304 | loadErrors.push(e)
305 | }
306 | try {
307 | return require('react-server-action-linux-ppc64-gnu')
308 | } catch (e) {
309 | loadErrors.push(e)
310 | }
311 |
312 | } else if (process.arch === 's390x') {
313 | try {
314 | return require('./react-server-action.linux-s390x-gnu.node')
315 | } catch (e) {
316 | loadErrors.push(e)
317 | }
318 | try {
319 | return require('react-server-action-linux-s390x-gnu')
320 | } catch (e) {
321 | loadErrors.push(e)
322 | }
323 |
324 | } else {
325 | loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
326 | }
327 | } else {
328 | loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
329 | }
330 | }
331 |
332 | nativeBinding = requireNative()
333 |
334 | if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
335 | try {
336 | nativeBinding = require('./react-server-action.wasi.cjs')
337 | } catch (err) {
338 | if (process.env.NAPI_RS_FORCE_WASI) {
339 | console.error(err)
340 | }
341 | }
342 | if (!nativeBinding) {
343 | try {
344 | nativeBinding = require('react-server-action-wasm32-wasi')
345 | } catch (err) {
346 | if (process.env.NAPI_RS_FORCE_WASI) {
347 | console.error(err)
348 | }
349 | }
350 | }
351 | }
352 |
353 | if (!nativeBinding) {
354 | if (loadErrors.length > 0) {
355 | // TODO Link to documentation with potential fixes
356 | // - The package owner could build/publish bindings for this arch
357 | // - The user may need to bundle the correct files
358 | // - The user may need to re-install node_modules to get new packages
359 | throw new Error('Failed to load native binding', { cause: loadErrors })
360 | }
361 | throw new Error(`Failed to load native binding`)
362 | }
363 |
364 | module.exports.FileType = nativeBinding.FileType
365 | module.exports.reactServerAction = nativeBinding.reactServerAction
366 | module.exports.RSCError = nativeBinding.RSCError
367 | module.exports.validate = nativeBinding.validate
368 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "react-server-action",
3 | "version": "0.2.15",
4 | "main": "index.js",
5 | "types": "index.d.ts",
6 | "files": [
7 | "index.js",
8 | "index.d.ts",
9 | "esm.mjs",
10 | "register.mjs",
11 | "browser.js"
12 | ],
13 | "napi": {
14 | "binaryName": "react-server-action",
15 | "packageName": "react-server-action",
16 | "targets": [
17 | "x86_64-apple-darwin",
18 | "aarch64-apple-darwin",
19 | "x86_64-pc-windows-msvc",
20 | "x86_64-unknown-linux-gnu",
21 | "aarch64-linux-android",
22 | "aarch64-unknown-linux-gnu",
23 | "aarch64-unknown-linux-musl",
24 | "aarch64-pc-windows-msvc",
25 | "armv7-unknown-linux-gnueabihf",
26 | "x86_64-unknown-linux-musl",
27 | "i686-pc-windows-msvc",
28 | "armv7-linux-androideabi"
29 | ]
30 | },
31 | "license": "MIT",
32 | "devDependencies": {
33 | "@napi-rs/cli": "^3.0.0-alpha.55",
34 | "@taplo/cli": "^0.7.0",
35 | "ava": "^6.1.3",
36 | "benny": "^3.7.1",
37 | "chalk": "^5.3.0",
38 | "emnapi": "^1.1.1",
39 | "husky": "^9.0.11",
40 | "lint-staged": "^15.2.2",
41 | "oxlint": "^0.5.1",
42 | "prettier": "^3.3.2",
43 | "tsx": "^4.16.2",
44 | "typescript": "^5.5.2"
45 | },
46 | "lint-staged": {
47 | "*.@(js|ts|tsx)": [
48 | "eslint --fix"
49 | ],
50 | "*.@(js|ts|tsx|yml|yaml|md|json)": [
51 | "prettier --write"
52 | ],
53 | "*.toml": [
54 | "taplo format"
55 | ]
56 | },
57 | "ava": {
58 | "require": [
59 | "tsx"
60 | ],
61 | "extensions": [
62 | "ts"
63 | ],
64 | "timeout": "2m",
65 | "workerThreads": false,
66 | "environmentVariables": {
67 | "TS_NODE_PROJECT": "./tsconfig.json"
68 | }
69 | },
70 | "prettier": {
71 | "printWidth": 120,
72 | "semi": false,
73 | "trailingComma": "all",
74 | "singleQuote": true,
75 | "arrowParens": "always"
76 | },
77 | "scripts": {
78 | "artifacts": "napi artifacts",
79 | "build": "napi build --platform --release",
80 | "build:debug": "napi build --platform",
81 | "test": "ava ./tests",
82 | "universal": "napi universal",
83 | "version": "napi version"
84 | },
85 | "packageManager": "pnpm@9.4.0",
86 | "repository": {
87 | "url": "https://github.com/himself65/react-server"
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/rustfmt.toml:
--------------------------------------------------------------------------------
1 | tab_spaces = 2
2 |
--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
1 | #![deny(clippy::all)]
2 |
3 | #[macro_use]
4 | extern crate napi_derive;
5 | mod transform;
6 |
7 | pub use transform::{
8 | validate,
9 | react_server_action
10 | };
11 |
--------------------------------------------------------------------------------
/src/transform/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod validate;
2 | pub mod react_server_action;
3 |
--------------------------------------------------------------------------------
/src/transform/react_server_action.rs:
--------------------------------------------------------------------------------
1 | use std::cell::Cell;
2 | use std::path::Path;
3 | use napi::{Error, Status};
4 | use oxc_allocator::{Allocator, Box, Vec};
5 | use oxc_ast::ast;
6 | use oxc_ast::visit::{walk_mut};
7 | use oxc_ast::{AstBuilder, VisitMut};
8 | use oxc_semantic::{Semantic, SemanticBuilder};
9 | use oxc_parser::Parser;
10 | use oxc_codegen::CodeGenerator;
11 | use oxc_span::{Atom, SourceType};
12 | use sha1::{Digest, Sha1};
13 | use hex::encode;
14 | use oxc_syntax::scope::{ScopeFlags};
15 | use tokio::fs;
16 | use crate::validate::{validate_string, ValidateResult};
17 |
18 | #[napi]
19 | pub async fn react_server_action(
20 | file_path: String,
21 | action_export_prefix: String,
22 | is_server_layer: bool,
23 | ) -> napi::Result {
24 | let path = Path::new(&file_path);
25 | let source_text = String::from_utf8(
26 | fs::read(path)
27 | .await
28 | .map_err(|e| Error::new(Status::Unknown, format!("Failed to read file: {}", e)))?
29 | ).unwrap();
30 | Ok(react_server_action_impl(source_text, file_path.as_str(), action_export_prefix, is_server_layer))
31 | }
32 |
33 | fn react_server_action_impl(
34 | source_text: String,
35 | action_export_prefix: &str,
36 | file_path: String,
37 | is_server_layer: bool,
38 | ) -> String {
39 | let path = Path::new(&file_path);
40 | let source_type = SourceType::from_path(path).unwrap();
41 | let valid_ret = validate_string(&source_text, source_type, is_server_layer).unwrap();
42 |
43 | let allocator = Allocator::default();
44 | let ret = Parser::new(&allocator, &source_text, source_type).parse();
45 | let mut program = ret.program;
46 | let ast = AstBuilder::new(&allocator);
47 | let sem_ret = SemanticBuilder::new(&source_text, source_type)
48 | .with_check_syntax_error(true)
49 | .with_trivias(ret.trivias).build(
50 | ast.copy(&&program),
51 | );
52 |
53 | let mut rsc = ReactServerAction {
54 | file_name: &file_path,
55 | action_export_prefix,
56 | is_server_layer,
57 | rsc_count: 0,
58 | allocator: &allocator,
59 | validate_result: valid_ret,
60 | allow_emit_export: true,
61 | semantic: sem_ret.semantic,
62 | ast,
63 | names: vec![],
64 | comments: vec![],
65 | new_stat: vec![],
66 | };
67 |
68 | rsc.visit_program(&mut program);
69 |
70 | for stat in rsc.new_stat {
71 | program.body.push(stat);
72 | }
73 |
74 | CodeGenerator::new().build(&program).source_text
75 | }
76 |
77 | #[napi(object)]
78 | #[derive(Debug)]
79 | struct Comment {
80 | pub start: u32,
81 | pub end: u32,
82 | pub text: String,
83 | }
84 |
85 | struct ReactServerAction<'ast> {
86 | file_name: &'ast String,
87 |
88 | action_export_prefix: &'ast str,
89 |
90 | is_server_layer: bool,
91 |
92 | validate_result: ValidateResult,
93 |
94 | allow_emit_export: bool,
95 |
96 | rsc_count: u32,
97 | names: std::vec::Vec,
98 |
99 | new_stat: std::vec::Vec>,
100 |
101 | ast: AstBuilder<'ast>,
102 | semantic: Semantic<'ast>,
103 |
104 | allocator: &'ast Allocator,
105 | comments: std::vec::Vec,
106 | }
107 |
108 | impl<'ast> ReactServerAction<'ast> {
109 | // slightly different logic with next.js
110 | // next.js uses sha1(file_name#export_name) as id, and store function into a global map,
111 | // but we use id = sha1('file_name')#sha1('start')
112 | // then we can use jump table Map> in the JS side.
113 | fn generate_action_id(
114 | &self,
115 | file_name: &str,
116 | start: u32,
117 | ) -> (&'ast str, &'ast str) {
118 | let mut hasher = Sha1::new();
119 | hasher.update(file_name.as_bytes());
120 | let file_name_result = hasher.finalize();
121 | let mut hasher = Sha1::new();
122 | hasher.update(start.to_string().as_bytes());
123 | let fn_id_result = hasher.finalize();
124 |
125 | (
126 | oxc_allocator::String::from_str_in(
127 | encode(file_name_result).as_str(),
128 | self.allocator,
129 | ).into_bump_str(),
130 | oxc_allocator::String::from_str_in(
131 | encode(fn_id_result).as_str(),
132 | self.allocator,
133 | ).into_bump_str()
134 | )
135 | }
136 | }
137 |
138 | impl<'ast> ReactServerAction<'ast> {
139 | fn generate_register_call(
140 | &self,
141 | func_name: &'ast str,
142 | arguments: Vec<'ast, ast::Argument<'ast>>,
143 | ) -> ast::Expression<'ast> {
144 | ast::Expression::CallExpression(
145 | Box::new_in(
146 | ast::CallExpression {
147 | span: Default::default(),
148 | callee: ast::Expression::Identifier(
149 | Box::new_in(
150 | ast::IdentifierReference {
151 | span: Default::default(),
152 | name: Atom::from(func_name),
153 | reference_id: Cell::new(None),
154 | reference_flag: Default::default(),
155 | },
156 | self.allocator,
157 | )
158 | ),
159 | arguments,
160 | optional: false,
161 | type_parameters: None,
162 | },
163 | self.allocator,
164 | )
165 | )
166 | }
167 |
168 | fn get_export_id(
169 | &self,
170 | export_id: &'ast str,
171 | ) -> &'ast str {
172 | oxc_allocator::String::from_str_in(
173 | format!("{}{}", self.action_export_prefix, export_id).as_str(),
174 | self.allocator,
175 | ).into_bump_str()
176 | }
177 |
178 | /// const fn_name = createServerReference(id, callServerRSC)
179 | /// callServerRSC is a global variable
180 | fn generate_rsc_reference_call(
181 | &mut self,
182 | fn_name: &'ast str,
183 | id: &'ast str,
184 | ) -> ast::Declaration<'ast> {
185 | let mut arguments = Vec::new_in(self.allocator);
186 | arguments.push(
187 | ast::Argument::StringLiteral(
188 | Box::new_in(
189 | ast::StringLiteral {
190 | span: Default::default(),
191 | value: Atom::from(id),
192 | },
193 | self.allocator,
194 | )
195 | ));
196 | arguments.push(
197 | ast::Argument::Identifier(
198 | Box::new_in(
199 | ast::IdentifierReference {
200 | span: Default::default(),
201 | name: Atom::from("callServerRSC"),
202 | reference_id: Cell::new(None),
203 | reference_flag: Default::default(),
204 | },
205 | self.allocator,
206 | )
207 | ),
208 | );
209 | let mut declarations = Vec::new_in(self.allocator);
210 |
211 | declarations.push(
212 | ast::VariableDeclarator {
213 | span: Default::default(),
214 | kind: ast::VariableDeclarationKind::Const,
215 | id: ast::BindingPattern {
216 | kind: ast::BindingPatternKind::BindingIdentifier(
217 | Box::new_in(
218 | ast::BindingIdentifier {
219 | span: Default::default(),
220 | name: Atom::from(fn_name),
221 | symbol_id: Cell::new(None),
222 | },
223 | self.allocator,
224 | )
225 | ),
226 | type_annotation: None,
227 | optional: false,
228 | },
229 | init: Some(
230 | ast::Expression::CallExpression(
231 | Box::new_in(
232 | ast::CallExpression {
233 | span: Default::default(),
234 | callee: ast::Expression::Identifier(
235 | Box::new_in(
236 | ast::IdentifierReference {
237 | span: Default::default(),
238 | name: Atom::from("registerServerReference"),
239 | reference_id: Cell::new(None),
240 | reference_flag: Default::default(),
241 | },
242 | self.allocator,
243 | )
244 | ),
245 | arguments,
246 | optional: false,
247 | type_parameters: None,
248 | },
249 | self.allocator,
250 | )
251 | )
252 | ),
253 | definite: false,
254 | }
255 | );
256 |
257 | ast::Declaration::VariableDeclaration(
258 | Box::new_in(
259 | ast::VariableDeclaration {
260 | span: Default::default(),
261 | kind: ast::VariableDeclarationKind::Const,
262 | declarations,
263 | declare: false,
264 | },
265 | self.allocator,
266 | )
267 | )
268 | }
269 |
270 | /// For server side
271 | /// emit `export const $PREFIX$id = registerServerReference(original_func_id, fileId, actionId)`
272 | /// For client side
273 | /// emit `export const name = registerClientReference(error, fileId, actionId)`
274 | fn emit_rsc_export(
275 | &mut self,
276 | fn_name: &'ast str,
277 | file_id: &'ast str,
278 | export_id: &'ast str,
279 | ) {
280 | let mut arguments: Vec = Vec::new_in(self.allocator);
281 |
282 | if self.validate_result.is_client() && self.is_server_layer {
283 | // func_name = invalid_rsc_call
284 | arguments.push(
285 | ast::Argument::Identifier(
286 | Box::new_in(
287 | ast::IdentifierReference {
288 | span: Default::default(),
289 | name: Atom::from("invalid_rsc_call"),
290 | reference_id: Cell::new(None),
291 | reference_flag: Default::default(),
292 | },
293 | self.allocator,
294 | )
295 | )
296 | );
297 | } else {
298 | // func_name
299 | arguments.push(
300 | ast::Argument::Identifier(
301 | Box::new_in(
302 | ast::IdentifierReference {
303 | span: Default::default(),
304 | name: Atom::from(fn_name),
305 | reference_id: Cell::new(None),
306 | reference_flag: Default::default(),
307 | },
308 | self.allocator,
309 | )
310 | )
311 | );
312 | }
313 | // file_id
314 | arguments.push(
315 | ast::Argument::StringLiteral(
316 | Box::new_in(
317 | ast::StringLiteral {
318 | span: Default::default(),
319 | value: Atom::from(file_id),
320 | },
321 | self.allocator,
322 | )
323 | )
324 | );
325 | // export_id
326 | arguments.push(
327 | ast::Argument::StringLiteral(
328 | Box::new_in(
329 | ast::StringLiteral {
330 | span: Default::default(),
331 | value: Atom::from(export_id),
332 | },
333 | self.allocator,
334 | )
335 | )
336 | );
337 |
338 | let mut var = Vec::new_in(self.allocator);
339 | let export_id: &str = match self.validate_result.is_client() {
340 | true => fn_name,
341 | false => self.get_export_id(export_id)
342 | };
343 | self.names.push(String::from(export_id));
344 |
345 | var.push(
346 | ast::VariableDeclarator {
347 | span: Default::default(),
348 | kind: ast::VariableDeclarationKind::Const,
349 | id: ast::BindingPattern {
350 | kind: ast::BindingPatternKind::BindingIdentifier(
351 | Box::new_in(
352 | ast::BindingIdentifier {
353 | span: Default::default(),
354 | name: Atom::from(export_id),
355 | symbol_id: Cell::new(None),
356 | },
357 | self.allocator,
358 | )
359 | ),
360 | type_annotation: None,
361 | optional: false,
362 | },
363 | init: Some(
364 | self.generate_register_call(
365 | match self.validate_result.is_client() {
366 | true => "registerClientReference",
367 | false => "registerServerReference",
368 | },
369 | arguments,
370 | )
371 | ),
372 | definite: false,
373 | }
374 | );
375 |
376 | // export const ...
377 | self.new_stat.push(
378 | ast::Statement::ExportNamedDeclaration(
379 | Box::new_in(
380 | ast::ExportNamedDeclaration {
381 | span: Default::default(),
382 | declaration: Some(
383 | ast::Declaration::VariableDeclaration(
384 | Box::new_in(
385 | ast::VariableDeclaration {
386 | span: Default::default(),
387 | kind: ast::VariableDeclarationKind::Const,
388 | declarations: var,
389 | declare: false,
390 | }, self.allocator,
391 | )
392 | )
393 | ),
394 | specifiers: Vec::new_in(self.allocator),
395 | source: None,
396 | export_kind: ast::ImportOrExportKind::Value,
397 | with_clause: None,
398 | }, self.allocator)
399 | )
400 | );
401 | }
402 |
403 | /// emit `export const SERVER_ACTION_ID = registerServerReference(original_func with impl, fileId, actionId)`
404 | ///
405 | /// Return the SERVER_ACTION_ID string
406 | fn emit_anonymous_rsc_export(
407 | &mut self,
408 | original_func: &ast::Function<'ast>,
409 | ) -> &'ast str {
410 | let mut var = Vec::new_in(self.allocator);
411 | let (file_id, fn_id) = self.generate_action_id(self.file_name.as_str(), original_func.span.start);
412 | self.rsc_count += 1;
413 | let mut arguments = Vec::new_in(self.allocator);
414 |
415 | let func: Box> = Box::new_in(
416 | ast::Function::new(
417 | original_func.r#type,
418 | original_func.span,
419 | self.ast.copy(&original_func.id),
420 | original_func.generator,
421 | original_func.r#async,
422 | original_func.declare,
423 | self.ast.copy(&original_func.this_param),
424 | self.ast.copy(&original_func.params),
425 | self.ast.copy(&original_func.body),
426 | self.ast.copy(&original_func.type_parameters),
427 | self.ast.copy(&original_func.return_type),
428 | ),
429 | self.allocator,
430 | );
431 | // original function
432 | arguments.push(
433 | ast::Argument::FunctionExpression(
434 | func
435 | )
436 | );
437 | // file_id
438 | arguments.push(
439 | ast::Argument::StringLiteral(
440 | Box::new_in(
441 | ast::StringLiteral {
442 | span: Default::default(),
443 | value: Atom::from(file_id),
444 | },
445 | self.allocator,
446 | )
447 | )
448 | );
449 | // export_id
450 | arguments.push(
451 | ast::Argument::StringLiteral(
452 | Box::new_in(
453 | ast::StringLiteral {
454 | span: Default::default(),
455 | value: Atom::from(fn_id),
456 | },
457 | self.allocator,
458 | )
459 | )
460 | );
461 |
462 | let export_id = self.get_export_id(fn_id);
463 |
464 | var.push(
465 | ast::VariableDeclarator {
466 | span: Default::default(),
467 | kind: ast::VariableDeclarationKind::Const,
468 | id: ast::BindingPattern {
469 | kind: ast::BindingPatternKind::BindingIdentifier(
470 | Box::new_in(
471 | ast::BindingIdentifier {
472 | span: Default::default(),
473 | name: Atom::from(export_id),
474 | symbol_id: Cell::new(None),
475 | },
476 | self.allocator,
477 | )
478 | ),
479 | type_annotation: None,
480 | optional: false,
481 | },
482 | init: Some(
483 | self.generate_register_call("registerServerReference", arguments)
484 | ),
485 | definite: false,
486 | }
487 | );
488 | // export const SERVER_ACTION_ID = registerServerReference(func, fileId, actionId);
489 | self.new_stat.push(
490 | ast::Statement::ExportNamedDeclaration(
491 | Box::new_in(
492 | ast::ExportNamedDeclaration {
493 | span: Default::default(),
494 | declaration: Some(
495 | ast::Declaration::VariableDeclaration(
496 | Box::new_in(
497 | ast::VariableDeclaration {
498 | span: Default::default(),
499 | kind: ast::VariableDeclarationKind::Const,
500 | declarations: var,
501 | declare: false,
502 | }, self.allocator,
503 | )
504 | )
505 | ),
506 | specifiers: Vec::new_in(self.allocator),
507 | source: None,
508 | export_kind: ast::ImportOrExportKind::Value,
509 | with_clause: None,
510 | }, self.allocator,
511 | )
512 | )
513 | );
514 | return export_id;
515 | }
516 |
517 | fn is_server_action(
518 | &mut self,
519 | func: &ast::Function<'ast>,
520 | ) -> bool {
521 | let mut has_use_server = false;
522 | for stmt in &func.body {
523 | for d in &stmt.directives {
524 | if &d.expression.value == "use server" {
525 | has_use_server = true;
526 | }
527 | }
528 | }
529 |
530 |
531 | if !self.is_server_layer {
532 | // client side
533 | func.r#async && has_use_server
534 | } else {
535 | // server side
536 | func.r#async && (self.is_server_layer || has_use_server)
537 | }
538 | }
539 |
540 | fn try_add_function_as_rsc(
541 | &mut self,
542 | func: &mut ast::Function<'ast>,
543 | file_id: &'ast str,
544 | export_id: &'ast str,
545 | ) {
546 | let fn_name = match &func.id {
547 | Some(id) => Some(id.name.as_str()),
548 | None => None,
549 | };
550 | let is_server_action = self.is_server_action(func);
551 | if self.is_server_layer {
552 | if self.validate_result.is_client() {
553 | // do nothing here
554 | } else if is_server_action {
555 | // convert to `registerServerReference(fn, file_id, export_id);`
556 | if !func.r#async {
557 | return self.comments.push(Comment {
558 | start: func.span.start,
559 | end: func.span.end,
560 | text: "Server actions must be async.".to_string(),
561 | });
562 | // throw error;
563 | }
564 | match fn_name {
565 | Some(fn_name) => {
566 | if self.allow_emit_export {
567 | self.emit_rsc_export(fn_name, file_id, export_id);
568 | }
569 | }
570 | None => {
571 | // if this function doesn't have a function name, we should not convert it
572 | }
573 | }
574 | } else {
575 | // convert to `registerClientReference(() => {
576 | // throw new Error();
577 | // }, file_id, export_id);`
578 | // handle it in visit_declaration
579 | }
580 | } else {
581 | // convert to `createServerReference(id, callServerRSC);`
582 | // could not handle here, because Function cannot be converted to CallExpression at this point
583 | // handle it in visit_declaration
584 | }
585 | }
586 | }
587 |
588 | /// Case 1: server import client -> registerClientReference
589 | /// Case 2: server import server -> registerServerReference
590 | /// Case 3: client import server -> createServerReference
591 | /// Case 4: client import client -> as-is
592 | impl<'ast> VisitMut<'ast> for ReactServerAction<'ast> {
593 | fn visit_variable_declarator(&mut self, declarator: &mut ast::VariableDeclarator<'ast>) {
594 | if let Some(expr) = declarator.init.as_mut() {
595 | match expr {
596 | ast::Expression::ArrowFunctionExpression(arrow_func) => {
597 | let arrow_func: Box> = Box::new_in(
598 | ast::ArrowFunctionExpression::new(
599 | arrow_func.span,
600 | arrow_func.expression,
601 | arrow_func.r#async,
602 | self.ast.copy(&arrow_func.params),
603 | self.ast.copy(&arrow_func.body),
604 | self.ast.copy(&arrow_func.type_parameters),
605 | self.ast.copy(&arrow_func.return_type),
606 | ),
607 | self.allocator,
608 | );
609 | let mut arguments: Vec> = Vec::new_in(self.allocator);
610 | arguments.push(
611 | ast::Argument::ArrowFunctionExpression(
612 | arrow_func
613 | )
614 | );
615 | declarator.init = Some(self.generate_register_call("registerServerReference", arguments));
616 | walk_mut::walk_variable_declarator_mut(self, declarator);
617 | return;
618 | }
619 | ast::Expression::FunctionExpression(func) => {
620 | match func.scope_id.get() {
621 | Some(scope_id) => {
622 | let bindings = self.semantic.scopes().get_bindings(
623 | scope_id
624 | );
625 | for (name, symbol_id) in bindings.iter() {
626 | println!("name: {}, symbol_id: {:?}", name, symbol_id);
627 | // todo
628 | }
629 | }
630 | None => {
631 | // no scope, no need to bind vars
632 | }
633 | }
634 |
635 | let export_id = self.emit_anonymous_rsc_export(func);
636 | declarator.init = Some(ast::Expression::Identifier(
637 | Box::new_in(
638 | ast::IdentifierReference {
639 | span: Default::default(),
640 | name: Atom::from(export_id),
641 | reference_id: Cell::new(None),
642 | reference_flag: Default::default(),
643 | },
644 | self.allocator,
645 | )
646 | ));
647 | }
648 | ast::Expression::ObjectExpression(expr) => {
649 | for kind in expr.properties.iter_mut() {
650 | match kind {
651 | ast::ObjectPropertyKind::ObjectProperty(item) => {
652 | match &item.value {
653 | ast::Expression::FunctionExpression(func) => {
654 | let export_id = self.emit_anonymous_rsc_export(func);
655 | item.value = ast::Expression::Identifier(
656 | Box::new_in(
657 | ast::IdentifierReference {
658 | span: Default::default(),
659 | name: Atom::from(export_id),
660 | reference_id: Cell::new(None),
661 | reference_flag: Default::default(),
662 | },
663 | self.allocator,
664 | )
665 | );
666 | }
667 | ast::Expression::ArrowFunctionExpression(_) => {}
668 | _ => {}
669 | }
670 | }
671 | _ => {}
672 | }
673 | }
674 | walk_mut::walk_variable_declarator_mut(self, declarator);
675 | }
676 | _ => {}
677 | }
678 | }
679 | self.allow_emit_export = false;
680 | walk_mut::walk_variable_declarator_mut(self, declarator);
681 | self.allow_emit_export = true;
682 | }
683 |
684 | fn visit_function(&mut self, func: &mut ast::Function<'ast>, flags: Option) {
685 | // if this function is a top-level function, we should add it to rsc here
686 | let is_top_level_function: bool = match func.scope_id.get() {
687 | None => false,
688 | Some(scope_id) => {
689 | let parent_id = self.semantic.scopes().get_parent_id(scope_id);
690 | match parent_id {
691 | Some(parent_id) => {
692 | self.semantic.scopes().root_scope_id() == parent_id
693 | }
694 | None => false
695 | }
696 | }
697 | };
698 | if is_top_level_function {
699 | let (file_id, fn_id) = self.generate_action_id(self.file_name.as_str(), func.span.start);
700 |
701 | self.try_add_function_as_rsc(
702 | func,
703 | file_id,
704 | fn_id,
705 | );
706 | }
707 | walk_mut::walk_function_mut(self, func, flags);
708 | }
709 |
710 | fn visit_expression(&mut self, expr: &mut ast::Expression<'ast>) {
711 | match expr {
712 | ast::Expression::ObjectExpression(obj) => {
713 | for kind in obj.properties.iter_mut() {
714 | match kind {
715 | ast::ObjectPropertyKind::ObjectProperty(obj) => {
716 | match &obj.value {
717 | ast::Expression::FunctionExpression(func) => {
718 | let is_server_action = self.is_server_action(func);
719 | if is_server_action && self.is_server_layer {
720 | let export_id = self.emit_anonymous_rsc_export(func);
721 | obj.value = ast::Expression::Identifier(
722 | Box::new_in(
723 | ast::IdentifierReference {
724 | span: Default::default(),
725 | name: Atom::from(export_id),
726 | reference_id: Cell::new(None),
727 | reference_flag: Default::default(),
728 | },
729 | self.allocator,
730 | )
731 | );
732 | }
733 | }
734 | _ => {}
735 | }
736 | }
737 | _ => {}
738 | }
739 | }
740 | }
741 | _ => {}
742 | }
743 | walk_mut::walk_expression_mut(self, expr);
744 | }
745 |
746 | fn visit_export_default_declaration(&mut self, decl: &mut ast::ExportDefaultDeclaration<'ast>) {
747 | if self.validate_result.is_client() && self.is_server_layer {
748 | // todo: unfinished
749 | // convert to `registerClientReference(fn, file_id, export_id);`
750 | *decl = ast::ExportDefaultDeclaration {
751 | span: Default::default(),
752 | declaration: ast::ExportDefaultDeclarationKind::FunctionDeclaration(
753 | Box::new_in(
754 | ast::Function {
755 | r#type: ast::FunctionType::FunctionDeclaration,
756 | span: Default::default(),
757 | id: Some(ast::BindingIdentifier {
758 | span: Default::default(),
759 | name: "invalid_rsc_call_default".into(),
760 | symbol_id: Cell::new(None),
761 | }),
762 | generator: false,
763 | r#async: false,
764 | declare: false,
765 | this_param: None,
766 | params: Box::new_in(
767 | ast::FormalParameters {
768 | span: Default::default(),
769 | kind: ast::FormalParameterKind::FormalParameter,
770 | items: Vec::new_in(self.allocator),
771 | rest: None,
772 | },
773 | self.allocator,
774 | ),
775 | type_parameters: None,
776 | return_type: None,
777 | scope_id: Cell::new(None),
778 | body: None,
779 | },
780 | self.allocator,
781 | )
782 | ),
783 | exported: ast::ModuleExportName::IdentifierName(ast::IdentifierName {
784 | span: Default::default(),
785 | name: "default".into(),
786 | }),
787 | }
788 | }
789 | }
790 |
791 | fn visit_export_named_declaration(&mut self, export_decl: &mut ast::ExportNamedDeclaration<'ast>) {
792 | if self.validate_result.is_client() && self.is_server_layer {
793 | // convert to `registerClientReference(fn, file_id, export_id);`
794 | let (file_id, fn_id) = self.generate_action_id(self.file_name.as_str(), export_decl.span.start);
795 | if let Some(decl) = &export_decl.declaration {
796 | if let Some(id) = decl.id() {
797 | self.emit_rsc_export(id.name.as_str(), file_id, fn_id);
798 | *export_decl = ast::ExportNamedDeclaration {
799 | span: Default::default(),
800 | declaration: None,
801 | specifiers: Vec::new_in(self.allocator),
802 | source: None,
803 | export_kind: ast::ImportOrExportKind::Value,
804 | with_clause: None,
805 | }
806 | }
807 | }
808 | }
809 | walk_mut::walk_export_named_declaration_mut(self, export_decl);
810 | }
811 |
812 | fn visit_declaration(&mut self, decl: &mut ast::Declaration<'ast>) {
813 | match decl {
814 | ast::Declaration::FunctionDeclaration(func) => {
815 | let is_server_action = self.is_server_action(func);
816 | if !self.is_server_layer & is_server_action {
817 | // convert to `createServerReference(id, callServerRSC);`
818 | match &func.id {
819 | Some(id) => {
820 | let (_, fn_id) = self.generate_action_id(self.file_name.as_str(), func.span.start);
821 | *decl = self.generate_rsc_reference_call(
822 | id.name.as_str(),
823 | self.get_export_id(fn_id),
824 | );
825 | }
826 | None => {}
827 | }
828 | } else if self.is_server_layer && self.validate_result.is_client() {
829 | // convert to `registerClientReference(fn, file_id, export_id);`
830 | match &func.id {
831 | Some(_) => {
832 | let (_, _) = self.generate_action_id(self.file_name.as_str(), func.span.start);
833 | // self.emit_rsc_export(
834 | // id.name.as_str(),
835 | // self.get_export_id(fn_id),
836 | // fn_id,
837 | // );
838 | }
839 | None => {}
840 | }
841 | }
842 | }
843 | _ => {}
844 | }
845 | walk_mut::walk_declaration_mut(self, decl);
846 | }
847 | }
848 |
849 | #[cfg(test)]
850 | mod tests {
851 | use super::*;
852 |
853 | fn test_tsx_server_input(
854 | input: &str,
855 | expected_output: &str,
856 | ) {
857 | let parsed_code = react_server_action_impl(
858 | input.to_string(),
859 | "__waku__server__",
860 | TSX_FILE_PATH.into(),
861 | IS_SERVER_LAYER,
862 | );
863 | assert_eq!(parsed_code, expected_output);
864 | }
865 |
866 | fn test_tsx_client_input(
867 | input: &str,
868 | expected_output: &str,
869 | ) {
870 | let parsed_code = react_server_action_impl(
871 | input.to_string(),
872 | "__waku__server__",
873 | TSX_FILE_PATH.into(),
874 | NOT_SERVER_LAYER,
875 | );
876 | assert_eq!(parsed_code, expected_output);
877 | }
878 |
879 | fn test_ts_server_input(
880 | input: &str,
881 | expected_output: &str,
882 | ) {
883 | let parsed_code = react_server_action_impl(
884 | input.to_string(),
885 | "__waku__server__",
886 | NORMAL_FILE_PATH.into(),
887 | IS_SERVER_LAYER,
888 | );
889 | assert_eq!(parsed_code, expected_output);
890 | }
891 |
892 | const NORMAL_FILE_PATH: &str = "./file.ts";
893 | const TSX_FILE_PATH: &str = "./file.tsx";
894 | const IS_SERVER_LAYER: bool = true;
895 | const NOT_SERVER_LAYER: bool = false;
896 |
897 | #[test]
898 | fn test_vercel_ai_rsc() {
899 | let input = r#"
900 | const AI = createAI({
901 | actions: {
902 | foo: async function() {
903 | "use server";
904 | return 0;
905 | }
906 | }
907 | });
908 | export { AI };
909 | "#;
910 | test_ts_server_input(input, r#"const AI = createAI({actions: {foo: __waku__server__92cfceb39d57d914ed8b14d0e37643de0797ae56}});
911 | export { AI };
912 | export const __waku__server__92cfceb39d57d914ed8b14d0e37643de0797ae56 = registerServerReference(async function() {
913 | 'use server';
914 | return 0;
915 | }, '9a024afde04fb48946fa537e9d0b5e8a4bfde606', '92cfceb39d57d914ed8b14d0e37643de0797ae56');
916 | "#)
917 | }
918 |
919 | #[test]
920 | fn test_client_import_rsc() {
921 | let input = r#"
922 | export async function a() {
923 | "use server";
924 | return 0;
925 | }
926 | "#;
927 | test_tsx_client_input(
928 | input, r#"export const a = registerServerReference('__waku__server__fe5dbbcea5ce7e2988b8c69bcfdfde8904aabc1f', callServerRSC);
929 | "#,
930 | );
931 |
932 | test_tsx_server_input(input, r#"export async function a() {
933 | 'use server';
934 | return 0;
935 | }
936 | export const __waku__server__fe5dbbcea5ce7e2988b8c69bcfdfde8904aabc1f = registerServerReference(a, 'aa08e78087e8703bec46e0df0ebc4c78800fdbaa', 'fe5dbbcea5ce7e2988b8c69bcfdfde8904aabc1f');
937 | "#);
938 |
939 | // test_tsx_server_input(r#"
940 | // "use client"
941 | // export default async function () {
942 | // return 0;
943 | // }"#, r#""#);
944 | }
945 |
946 | #[test]
947 | fn test_client_import_general_function() {
948 | test_ts_server_input(r#"
949 | "use client"
950 | export async function foo() {}"#,
951 | r#"'use client';
952 | export {};
953 | export const foo = registerClientReference(invalid_rsc_call, '9a024afde04fb48946fa537e9d0b5e8a4bfde606', 'fa35e192121eabf3dabf9f5ea6abdbcbc107ac3b');
954 | "#);
955 | }
956 |
957 | #[test]
958 | fn test_rsc_inside_component() {
959 | // fixme: this is wrong, nested function should be converted to rsc correctly
960 | test_tsx_server_input(
961 | r#"
962 | export default function Home () {
963 | const ctx = getContext()
964 |
965 | async function a () {
966 | "use server";
967 | return ctx.a
968 | }
969 |
970 | return (
971 |
972 | )
973 | }
974 | "#, r#"export default function Home() {
975 | const ctx = getContext();
976 | async function a() {
977 | 'use server';
978 | return ctx.a;
979 | }
980 | return ;
981 | }"#,
982 | );
983 | }
984 |
985 | #[test]
986 | fn test_react_server_action() {
987 | // a "use server" function should be converted correctly
988 | test_ts_server_input(
989 | r#"
990 | async function test() {
991 | "use server"
992 | return 0;
993 | }
994 | "#, r#"async function test() {
995 | 'use server';
996 | return 0;
997 | }
998 | export const __waku__server__356a192b7913b04c54574d18c28d46e6395428ab = registerServerReference(test, '9a024afde04fb48946fa537e9d0b5e8a4bfde606', '356a192b7913b04c54574d18c28d46e6395428ab');
999 | "#);
1000 | // if it is not declared as "use server", it should not be converted
1001 |
1002 | test_ts_server_input(
1003 | r#"
1004 | async function test() {
1005 | return 0;
1006 | }
1007 | "#, r#"async function test() {
1008 | return 0;
1009 | }
1010 | export const __waku__server__356a192b7913b04c54574d18c28d46e6395428ab = registerServerReference(test, '9a024afde04fb48946fa537e9d0b5e8a4bfde606', '356a192b7913b04c54574d18c28d46e6395428ab');
1011 | "#);
1012 |
1013 | // if it's an anonymous function, it should be converted correctly
1014 | test_ts_server_input(
1015 | r#"
1016 | const a = function () {
1017 | "use server"
1018 | return 0;
1019 | }
1020 | "#, r#"const a = __waku__server__17ba0791499db908433b80f37c5fbc89b870084b;
1021 | export const __waku__server__17ba0791499db908433b80f37c5fbc89b870084b = registerServerReference(function() {
1022 | 'use server';
1023 | return 0;
1024 | }, '9a024afde04fb48946fa537e9d0b5e8a4bfde606', '17ba0791499db908433b80f37c5fbc89b870084b');
1025 | "#);
1026 |
1027 | // server action in object
1028 | test_ts_server_input(
1029 | r#"
1030 | const a = {
1031 | b: async function() {
1032 | "use server"
1033 | return 0;
1034 | }
1035 | }
1036 | "#, r#"const a = {b: __waku__server__0716d9708d321ffb6a00818614779e779925365c};
1037 | export const __waku__server__0716d9708d321ffb6a00818614779e779925365c = registerServerReference(async function() {
1038 | 'use server';
1039 | return 0;
1040 | }, '9a024afde04fb48946fa537e9d0b5e8a4bfde606', '0716d9708d321ffb6a00818614779e779925365c');
1041 | "#,
1042 | );
1043 | }
1044 | }
--------------------------------------------------------------------------------
/src/transform/validate.rs:
--------------------------------------------------------------------------------
1 | use std::path::Path;
2 | use napi::{Error, Status};
3 | use oxc_allocator::Allocator;
4 | use oxc_ast::ast;
5 | use oxc_ast::{Visit};
6 | use oxc_ast::visit::walk;
7 | use oxc_parser::Parser;
8 | use oxc_span::SourceType;
9 | use oxc_syntax::scope::ScopeFlags;
10 |
11 | #[napi(object)]
12 | pub struct ValidateResult {
13 | pub file_type: FileType,
14 | pub is_server_action: bool,
15 | pub error: Option,
16 | pub imports: Vec,
17 | }
18 |
19 | #[napi]
20 | #[derive(Debug, PartialEq)]
21 | pub enum RSCError {
22 | CannotUseBothClientAndServer,
23 | ServerActionMustBeAsync,
24 | }
25 |
26 | #[napi(object)]
27 | #[derive(Debug)]
28 | pub struct ModuleImports {
29 | pub name: String,
30 | }
31 |
32 | impl ValidateResult {
33 | pub(crate) fn is_client(&self) -> bool {
34 | self.file_type == FileType::Client
35 | }
36 | }
37 |
38 | ///
39 | /// Validate a file is a valid Server file or Client File
40 | ///
41 | /// @param code: string - the code to validate
42 | ///
43 | /// @param file_path: string - the path to the file
44 | ///
45 | /// @param is_server_layer: boolean - if the file is in the server layer, enable this in server side rendering
46 | #[napi]
47 | pub fn validate(
48 | code: String,
49 | file_path: String,
50 | is_server_layer: bool,
51 | ) -> napi::Result {
52 | let path = Path::new(&file_path);
53 | let source_type = SourceType::from_path(path).unwrap();
54 | validate_string(&code, source_type, is_server_layer)
55 | }
56 |
57 | pub fn validate_string(
58 | source_text: &String,
59 | source_type: SourceType,
60 | is_server_layer: bool,
61 | ) -> napi::Result {
62 | let allocator = Allocator::default();
63 | let ret = Parser::new(&allocator, source_text, source_type).parse();
64 |
65 | let size = ret.errors.len();
66 | for error in ret.errors {
67 | let error = error.with_source_code(source_text.clone());
68 | println!("{error:?}");
69 | }
70 |
71 | if size > 0 {
72 | return Err(Error::new(Status::Unknown, "Failed to parse file"));
73 | }
74 |
75 | let program = ret.program;
76 |
77 | let mut rsc = ReactServerComponent {
78 | is_server_layer,
79 |
80 | is_server_action: false,
81 | is_client_entry: false,
82 | error: None,
83 | has_use_client: false,
84 | has_use_server: false,
85 | imports: vec![],
86 | has_async_function: false,
87 | };
88 |
89 | rsc.visit_program(&program);
90 |
91 | if rsc.error.is_none() {
92 | if rsc.has_use_server {
93 | assert_eq!(rsc.has_use_client, false);
94 | } else if rsc.has_use_client {
95 | assert_eq!(rsc.has_use_server, false);
96 | } else {
97 | assert_eq!(rsc.has_use_server, false);
98 | assert_eq!(rsc.has_use_client, false);
99 | }
100 | }
101 |
102 | let result = ValidateResult {
103 | file_type: if rsc.has_use_client {
104 | FileType::Client
105 | } else if rsc.has_use_server {
106 | FileType::Server
107 | } else {
108 | FileType::Isomorphic
109 | },
110 | is_server_action: rsc.is_server_action,
111 | error: rsc.error,
112 | imports: rsc.imports,
113 | };
114 |
115 | Ok(result)
116 | }
117 |
118 | #[derive(Debug, PartialEq)]
119 | #[napi(string_enum)]
120 | pub enum FileType {
121 | Client,
122 | Server,
123 | Isomorphic,
124 | }
125 |
126 | #[derive(Debug)]
127 | pub struct ReactServerComponent {
128 | pub is_server_layer: bool,
129 |
130 | // could this file be treated as server action files
131 | pub is_server_action: bool,
132 | // is this file a client entry file
133 | pub is_client_entry: bool,
134 |
135 | pub error: Option,
136 | pub imports: Vec,
137 |
138 | // has "use client" directive on top of the file
139 | pub has_use_client: bool,
140 | // has "use server" directive on top of the file
141 | pub has_use_server: bool,
142 | pub has_async_function: bool,
143 | }
144 |
145 | impl ReactServerComponent {
146 | fn has_server_directive(&self, function_body: &ast::FunctionBody) -> bool {
147 | for d in &function_body.directives {
148 | if &d.expression.value == "use server" {
149 | return true;
150 | }
151 | }
152 | false
153 | }
154 | }
155 |
156 |
157 | impl<'a> Visit<'a> for ReactServerComponent {
158 | fn visit_program(&mut self, program: &ast::Program<'a>) {
159 | program.directives.iter().for_each(|d| {
160 | if &d.expression.value == "use server" {
161 | self.has_use_server = true;
162 | } else if &d.expression.value == "use client" {
163 | self.has_use_client = true;
164 | }
165 | });
166 | if self.has_use_server && self.has_use_client {
167 | self.error = Some(RSCError::CannotUseBothClientAndServer);
168 | } else {
169 | walk::walk_program(self, program);
170 | if self.has_use_server && self.has_use_client {
171 | self.error = Some(RSCError::CannotUseBothClientAndServer);
172 | }
173 | // final check if this file is a server action file
174 | if !self.has_use_client {
175 | if !self.is_server_action {
176 | if self.has_use_server && self.has_async_function {
177 | self.is_server_action = true;
178 | } else if !self.has_use_server & !self.has_use_client {
179 | self.is_server_action = self.has_async_function && self.is_server_layer;
180 | }
181 | }
182 | }
183 | }
184 | }
185 |
186 | fn visit_function(&mut self, func: &ast::Function<'a>, flags: Option) {
187 | let mut is_server_action = false;
188 | if let Some(body) = &func.body {
189 | is_server_action = self.has_server_directive(body);
190 | }
191 | // check if server action is valid
192 | if !func.r#async && is_server_action {
193 | self.error = Some(RSCError::ServerActionMustBeAsync);
194 | return;
195 | }
196 |
197 | self.has_async_function |= func.r#async;
198 |
199 | walk::walk_function(self, func, flags);
200 | }
201 |
202 | fn visit_arrow_expression(&mut self, func: &ast::ArrowFunctionExpression<'a>) {
203 | let is_server_action = self.has_server_directive(&func.body);
204 |
205 | // check if server action is valid
206 | if !func.r#async && is_server_action {
207 | self.error = Some(RSCError::ServerActionMustBeAsync);
208 | return;
209 | }
210 |
211 | self.has_async_function |= func.r#async;
212 |
213 | walk::walk_arrow_expression(self, func);
214 | }
215 |
216 | fn visit_import_declaration(&mut self, decl: &ast::ImportDeclaration<'a>) {
217 | if decl.source.value == "client-only" {
218 | self.has_use_client = true;
219 | } else if decl.source.value == "server-only" {
220 | self.has_use_server = true;
221 | }
222 | self.imports.push(
223 | ModuleImports {
224 | name: decl.source.value.to_string()
225 | }
226 | );
227 | walk::walk_import_declaration(self, decl);
228 | }
229 | }
230 |
231 | #[cfg(test)]
232 | mod tests {
233 | use super::*;
234 |
235 | #[test]
236 | fn test_use_server() {
237 | let source_text = r#"
238 | "use server"
239 | "#;
240 | let rsc = validate_string(&source_text.to_string(), SourceType::from_path("test.js").unwrap(), true).unwrap();
241 | assert_eq!(rsc.is_server_action, false);
242 | assert_eq!(rsc.file_type, FileType::Server);
243 | assert_eq!(rsc.error, None);
244 | }
245 |
246 | #[test]
247 | fn test_use_client() {
248 | let source_text = r#"
249 | "use client"
250 | "#;
251 | let rsc = validate_string(&source_text.to_string(), SourceType::from_path("test.js").unwrap(), true).unwrap();
252 | assert_eq!(rsc.is_server_action, false);
253 | assert_eq!(rsc.file_type, FileType::Client);
254 | assert_eq!(rsc.error, None);
255 | }
256 |
257 | #[test]
258 | fn test_use_server_and_client() {
259 | let source_text = r#"
260 | "use server"
261 | "use client"
262 | "#;
263 | let rsc = validate_string(&source_text.to_string(), SourceType::from_path("test.js").unwrap(), true).unwrap();
264 | assert_eq!(rsc.error, Some(RSCError::CannotUseBothClientAndServer));
265 | }
266 |
267 | #[test]
268 | fn test_use_client_and_server_action() {
269 | let source_text = r#"
270 | "use client"
271 |
272 | async function foo() {}
273 | "#;
274 | let rsc = validate_string(&source_text.to_string(), SourceType::from_path("test.js").unwrap(), true).unwrap();
275 | assert_eq!(rsc.is_server_action, false);
276 | assert_eq!(rsc.file_type, FileType::Client);
277 | assert_eq!(rsc.error, None);
278 | }
279 |
280 | #[test]
281 | fn test_use_server_and_server_action_without_directive() {
282 | let source_text = r#"
283 | "use server"
284 |
285 | export async function foo() {
286 | // no directive
287 | return 0
288 | }
289 |
290 | export default function () {
291 | return 1
292 | }
293 | "#;
294 | let rsc = validate_string(&source_text.to_string(), SourceType::from_path("test.js").unwrap(), true).unwrap();
295 | // cannot tell if 'foo' is a server action, depends on if there's a Server component that uses it
296 | assert_eq!(rsc.is_server_action, true);
297 | assert_eq!(rsc.file_type, FileType::Server);
298 | assert_eq!(rsc.error, None);
299 | }
300 |
301 | #[test]
302 | fn test_arrow_function() {
303 | let source_text = r#"
304 | "use server"
305 |
306 | const foo = async () => {
307 | "use server"
308 | }
309 | "#;
310 | let rsc = validate_string(&source_text.to_string(), SourceType::from_path("test.js").unwrap(), true).unwrap();
311 | assert_eq!(rsc.is_server_action, true);
312 | assert_eq!(rsc.file_type, FileType::Server);
313 | assert_eq!(rsc.error, None);
314 | }
315 |
316 | #[test]
317 | fn client_side_isomorphic() {
318 | let source_text = r#"
319 | export async function foo() {
320 | // unknown if this is a server action
321 | }
322 | "#;
323 | let rsc = validate_string(&source_text.to_string(), SourceType::from_path("test.js").unwrap(), false).unwrap();
324 | assert_eq!(rsc.is_server_action, false);
325 | assert_eq!(rsc.file_type, FileType::Isomorphic);
326 | assert_eq!(rsc.error, None);
327 | }
328 |
329 | #[test]
330 | fn server_side_isomorphic() {
331 | let source_text = r#"
332 | export async function foo() {
333 | // unknown if this is a server action
334 | }
335 | "#;
336 | let rsc = validate_string(&source_text.to_string(), SourceType::from_path("test.js").unwrap(), true).unwrap();
337 | assert_eq!(rsc.is_server_action, true);
338 | assert_eq!(rsc.file_type, FileType::Isomorphic);
339 | assert_eq!(rsc.error, None);
340 | }
341 |
342 | #[test]
343 | fn server_side_nothing() {
344 | let source_text = r#"
345 | // do nothing
346 | "#;
347 | let rsc = validate_string(&source_text.to_string(), SourceType::from_path("test.ts").unwrap(), true).unwrap();
348 | assert_eq!(rsc.is_server_action, false);
349 | assert_eq!(rsc.file_type, FileType::Isomorphic);
350 | assert_eq!(rsc.error, None);
351 | }
352 | }
353 |
--------------------------------------------------------------------------------
/tests/index.unit.ts:
--------------------------------------------------------------------------------
1 | import test from 'ava'
2 | import { validate, reactServerAction } from '..'
3 |
4 | test('function exist', async (t) => {
5 | t.is(typeof validate, 'function')
6 | t.is(typeof reactServerAction, 'function')
7 | })
8 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "target": "ESNext",
4 | "moduleResolution": "Bundler"
5 | }
6 | }
7 |
--------------------------------------------------------------------------------