[turbopack] fully prevent usage of next/root-params outside of server components

lubieowoce · lubieowoce · commit 86f28a36a06b · 2025-06-12T12:51:25.000+02:00
diff --git a/crates/next-core/src/next_client/context.rs b/crates/next-core/src/next_client/context.rs
@@ -1,6 +1,7 @@
 use std::iter::once;
 
 use anyhow::Result;
+use either::Either;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{FxIndexMap, OptionVcExt, ResolvedVc, TaskInput, Vc};
 use turbo_tasks_env::EnvMap;
@@ -47,6 +48,7 @@ use crate::{
         get_next_client_fallback_import_map, get_next_client_import_map,
         get_next_client_resolved_map,
     },
+    next_root_params::get_invalid_next_root_params_resolve_plugin,
     next_shared::{
         resolve::{
             ModuleFeatureReportResolvePlugin, NextSharedRuntimeResolvePlugin,
@@ -172,7 +174,7 @@ pub async fn get_client_resolve_options_context(
             .to_resolved()
             .await?;
     let custom_conditions = vec![mode.await?.condition().into()];
-    let resolve_options_context = ResolveOptionsContext {
+    let mut resolve_options_context = ResolveOptionsContext {
         enable_node_modules: Some(project_path.root().to_resolved().await?),
         custom_conditions,
         import_map: Some(next_client_import_map),
@@ -205,6 +207,22 @@ pub async fn get_client_resolve_options_context(
         ..Default::default()
     };
 
+    if let Some(invalid_next_root_params_resolve_plugin) =
+        get_invalid_next_root_params_resolve_plugin(
+            *next_config.enable_root_params().await?,
+            Either::Right(ty),
+            project_path,
+        )
+    {
+        resolve_options_context
+            .before_resolve_plugins
+            .push(ResolvedVc::upcast(
+                invalid_next_root_params_resolve_plugin
+                    .to_resolved()
+                    .await?,
+            ))
+    }
+
     Ok(ResolveOptionsContext {
         enable_typescript: true,
         enable_react: true,
diff --git a/crates/next-core/src/next_import_map.rs b/crates/next-core/src/next_import_map.rs
@@ -30,7 +30,7 @@ use crate::{
         GOOGLE_FONTS_INTERNAL_PREFIX, NextFontGoogleCssModuleReplacer,
         NextFontGoogleFontFileReplacer, NextFontGoogleReplacer,
     },
-    next_root_params::get_next_root_params_mapping,
+    next_root_params::insert_next_root_params_mapping,
     next_server::context::ServerContextType,
     util::NextRuntime,
 };
@@ -682,19 +682,7 @@ async fn insert_next_server_special_aliases(
         }
     }
 
-    if *next_config.enable_root_params().await? {
-        match ty {
-            ServerContextType::AppRSC { .. } | ServerContextType::AppRoute { .. } => {
-                import_map.insert_exact_alias(
-                    "next/root-params",
-                    get_next_root_params_mapping(collected_root_params)
-                        .to_resolved()
-                        .await?,
-                );
-            }
-            _ => {}
-        }
-    }
+    insert_next_root_params_mapping(import_map, ty, collected_root_params).await?;
 
     import_map.insert_exact_alias(
         "@vercel/og",
diff --git a/crates/next-core/src/next_root_params/mod.rs b/crates/next-core/src/next_root_params/mod.rs
@@ -1,20 +1,120 @@
 use std::iter;
 
 use anyhow::Result;
+use either::Either;
 use indoc::formatdoc;
 use itertools::Itertools;
 use turbo_tasks::{ResolvedVc, Vc};
-use turbo_tasks_fs::FileContent;
+use turbo_tasks_fs::{FileContent, FileSystemPath};
 use turbopack_core::{
     asset::AssetContent,
-    resolve::{ResolveResult, options::ImportMapping},
+    resolve::{
+        ResolveResult,
+        options::{ImportMap, ImportMapping},
+    },
     virtual_source::VirtualSource,
 };
 
-use crate::{app_structure::CollectedRootParams, embed_js::next_js_file_path};
+use crate::{
+    app_structure::CollectedRootParams,
+    embed_js::next_js_file_path,
+    next_client::ClientContextType,
+    next_server::ServerContextType,
+    next_shared::resolve::{InvalidImportPattern, InvalidImportResolvePlugin},
+};
+
+pub fn get_invalid_next_root_params_resolve_plugin(
+    is_root_params_enabled: bool,
+    ty: Either<ServerContextType, ClientContextType>,
+    root: ResolvedVc<FileSystemPath>,
+) -> Option<Vc<InvalidImportResolvePlugin>> {
+    // Hard-error if the flag is not enabled, regardless of if we're on the server or on the client.
+    if !is_root_params_enabled {
+        return Some(InvalidImportResolvePlugin::new(
+            *root,
+            InvalidImportPattern::Glob("next/root-params".into()),
+            vec![
+                "'next/root-params' can only be imported when `experimental.rootParams` is \
+                 enabled."
+                    .into(),
+            ],
+        ));
+    }
+    match ty {
+        Either::Left(server_ty) => match server_ty {
+            ServerContextType::AppRSC { .. } | ServerContextType::AppRoute { .. } => {
+                // Valid usage. We'll map this request to generated code in
+                // `insert_next_root_params_mapping`.
+                None
+            }
+            ServerContextType::PagesData { .. }
+            | ServerContextType::PagesApi { .. }
+            | ServerContextType::Instrumentation { .. }
+            | ServerContextType::Middleware { .. } => {
+                // There's no sensible way to use root params outside of the app directory.
+                // TODO: make sure this error is consistent with webpack
+                Some(InvalidImportResolvePlugin::new(
+                    *root,
+                    InvalidImportPattern::Glob("next/root-params".into()),
+                    vec!["'next/root-params' can only be used inside the App Directory.".into()],
+                ))
+            }
+            _ => {
+                // In general, the compiler should prevent importing 'next/root-params' from client
+                // modules, but it doesn't catch everything. If an import slips
+                // through our validation, make it error.
+                Some(InvalidImportResolvePlugin::new(
+                    *root,
+                    InvalidImportPattern::Glob("next/root-params".into()),
+                    vec![
+                        "'next/root-params' cannot be imported from a Client Component module. It \
+                         should only be used from a Server Component."
+                            .into(),
+                    ],
+                ))
+            }
+        },
+        Either::Right(_) => {
+            // In general, the compiler should prevent importing 'next/root-params' from client
+            // modules, but it doesn't catch everything. If an import slips
+            // through our validation, make it error.
+            Some(InvalidImportResolvePlugin::new(
+                *root,
+                InvalidImportPattern::Glob("next/root-params".into()),
+                vec![
+                    "'next/root-params' cannot be imported from a Client Component module. It \
+                     should only be used from a Server Component."
+                        .into(),
+                ],
+            ))
+        }
+    }
+}
+
+pub async fn insert_next_root_params_mapping(
+    import_map: &mut ImportMap,
+    ty: ServerContextType,
+    collected_root_params: Option<Vc<CollectedRootParams>>,
+) -> Result<()> {
+    match ty {
+        ServerContextType::AppRSC { .. } | ServerContextType::AppRoute { .. } => {
+            import_map.insert_exact_alias(
+                "next/root-params",
+                get_next_root_params_mapping(collected_root_params)
+                    .to_resolved()
+                    .await?,
+            );
+        }
+        _ => {
+            // `get_invalid_next_root_params_resolve_plugin` already triggered an error for other
+            // contexts, so we can ignore them here.
+        }
+    };
+    Ok(())
+}
 
 #[turbo_tasks::function]
-pub async fn get_next_root_params_mapping(
+async fn get_next_root_params_mapping(
     collected_root_params: Option<Vc<CollectedRootParams>>,
 ) -> Result<Vc<ImportMapping>> {
     let module_content = match collected_root_params {
@@ -30,24 +130,24 @@ pub async fn get_next_root_params_mapping(
             .chain(collected_root_params.iter().map(|param_name| {
                 formatdoc!(
                     r#"
-                        export function {param_name}() {{
-                            return getRootParam('{param_name}');
+                        export function {PARAM_NAME}() {{
+                            return getRootParam('{PARAM_NAME}');
                         }}
                     "#,
-                    param_name = param_name,
+                    PARAM_NAME = param_name,
                 )
             }))
             .join("\n")
         }
     };
 
-    let js_asset = VirtualSource::new(
+    let source = VirtualSource::new(
         next_js_file_path("root-params.js".into()),
         AssetContent::file(FileContent::Content(module_content.into()).cell()),
     )
     .to_resolved()
     .await?;
 
-    let mapping = ImportMapping::Direct(ResolveResult::source(ResolvedVc::upcast(js_asset)));
+    let mapping = ImportMapping::Direct(ResolveResult::source(ResolvedVc::upcast(source)));
     Ok(mapping.cell())
 }
diff --git a/crates/next-core/src/next_server/context.rs b/crates/next-core/src/next_server/context.rs
@@ -1,6 +1,7 @@
 use std::iter::once;
 
 use anyhow::{Result, bail};
+use either::Either;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{FxIndexMap, OptionVcExt, ResolvedVc, TaskInput, Vc};
 use turbo_tasks_env::{EnvMap, ProcessEnv};
@@ -51,6 +52,7 @@ use crate::{
     next_config::NextConfig,
     next_font::local::NextFontLocalResolvePlugin,
     next_import_map::get_next_server_import_map,
+    next_root_params::get_invalid_next_root_params_resolve_plugin,
     next_server::resolve::ExternalPredicate,
     next_shared::{
         resolve::{
@@ -316,6 +318,20 @@ pub async fn get_server_resolve_options_context(
         }
     }
 
+    if let Some(invalid_next_root_params_resolve_plugin) =
+        get_invalid_next_root_params_resolve_plugin(
+            *next_config.enable_root_params().await?,
+            Either::Left(ty),
+            project_path,
+        )
+    {
+        before_resolve_plugins.push(ResolvedVc::upcast(
+            invalid_next_root_params_resolve_plugin
+                .to_resolved()
+                .await?,
+        ))
+    }
+
     let resolve_options_context = ResolveOptionsContext {
         enable_node_modules: Some(root_dir),
         enable_node_externals: true,
