ServerActionCollectModule

Author: mischnic

crates/next-api/src/app.rs

@@ -33,10 +33,7 @@ use next_core::{
     next_server_utility::{NEXT_SERVER_UTILITY_MERGE_TAG, NextServerUtilityTransition},
     parse_segment_config_from_source,
     segment_config::{NextSegmentConfig, ParseSegmentMode},
-    util::{
-        NextRuntime, app_function_name, module_styles_rule_condition, styles_rule_condition,
-        virtual_next_js_template_path,
-    },
+    util::{NextRuntime, app_function_name, module_styles_rule_condition, styles_rule_condition},
 };
 use tracing::Instrument;
 use turbo_rcstr::{RcStr, rcstr};
@@ -56,7 +53,6 @@ use turbopack_core::{
         ChunkGroupResult, ChunkingContext, ChunkingContextExt, EvaluatableAssets, SourceMapsType,
         availability_info::AvailabilityInfo,
     },
-    context::AssetContext,
     file_source::FileSource,
     ident::{AssetIdent, Layer},
     module::Module,
@@ -67,9 +63,7 @@ use turbopack_core::{
     },
     output::{OutputAsset, OutputAssets, OutputAssetsWithReferenced},
     reference::all_assets_from_entries,
-    reference_type::{
-        CommonJsReferenceSubType, CssReferenceSubType, ReferenceType, ReferenceTypeCondition,
-    },
+    reference_type::{CommonJsReferenceSubType, CssReferenceSubType, ReferenceTypeCondition},
     resolve::{ResolveErrorMode, origin::PlainResolveOrigin, parse::Request, pattern::Pattern},
     source::Source,
     source_map::SourceMapAsset,
@@ -92,7 +86,7 @@ use crate::{
     route::{
         AppPageRoute, Endpoint, EndpointOutput, EndpointOutputPaths, ModuleGraphs, Route, Routes,
     },
-    server_actions::create_server_actions_manifest,
+    server_actions::{ServerActionCollectModule, create_server_actions_manifest},
     sri_manifest::get_sri_manifest_asset,
     webpack_stats::generate_webpack_stats,
 };
@@ -1287,27 +1281,13 @@ impl AppEndpoint {
     #[turbo_tasks::function]
     async fn server_action_loader_module(self: Vc<Self>) -> Result<Vc<Box<dyn Module>>> {
         let this = self.await?;
-        let app_entry = self.app_endpoint_entry().await?;
-        let runtime = app_entry.config.await?.runtime.unwrap_or_default();
-
-        let module_context = match runtime {
-            NextRuntime::Edge => this.app_project.edge_rsc_module_context(),
-            NextRuntime::NodeJs => this.app_project.rsc_module_context(),
-        };
+        // let app_entry = self.app_endpoint_entry().await?;
+        // let runtime = app_entry.config.await?.runtime.unwrap_or_default();
 
-        Ok(module_context
-            .process(
-                Vc::upcast(FileSource::new_with_query(
-                    virtual_next_js_template_path(
-                        this.app_project.project().project_path().owned().await?,
-                        "turbopack-action-loader.js",
-                    )
-                    .await?,
-                    RcStr::from(format!("?{}", this.page)),
-                )),
-                ReferenceType::Undefined,
-            )
-            .module())
+        Ok(Vc::upcast(ServerActionCollectModule::new(
+            rcstr!("next/server-actions"),
+            this.page.to_string().into(),
+        )))
     }
 
     #[turbo_tasks::function]

crates/next-api/src/server_actions.rs

@@ -4,18 +4,25 @@ use next_core::{
     next_manifests::{ActionLayer, ActionManifestWorkerEntry, ServerReferenceManifest},
     util::NextRuntime,
 };
-use turbo_rcstr::RcStr;
+use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{NonLocalValue, ResolvedVc, TryJoinIterExt, Vc, trace::TraceRawVcs};
-use turbo_tasks_fs::{self, File, FileContent, FileSystemPath};
+use turbo_tasks_fs::{self, File, FileContent, FileSystem, FileSystemPath, VirtualFileSystem};
 use turbopack_core::{
+    self,
     asset::AssetContent,
-    chunk::ChunkingContext,
-    emit_collect::EmittedModuleReference,
-    module::Module,
+    chunk::{AsyncModuleInfo, ChunkItem, ChunkableModule, ChunkingContext, EvaluatableAsset},
+    emit_collect::{CollectingModule, EmittedModuleReference},
+    ident::AssetIdent,
+    module::{Module, ModuleSideEffects, Modules},
     module_graph::{ModuleGraph, async_module_info::AsyncModulesInfo},
     output::OutputAsset,
+    reference::ModuleReferences,
+    source::OptionSource,
     virtual_output::VirtualOutputAsset,
 };
+use turbopack_ecmascript::chunk::{
+    EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports, ecmascript_chunk_item,
+};
 
 /// Scans the RSC entry point's full module graph looking for emitted Server
 /// Actions, and a manifest describing the found actions.
@@ -47,19 +54,15 @@ async fn collect_actions(
     server_action_loader: ResolvedVc<Box<dyn Module>>,
     module_graph: Vc<ModuleGraph>,
 ) -> Result<Vc<AllActions>> {
+    // This mirrors what the ServerActionCollectModule ends up chunking into the chunk.
     let collected_modules = module_graph.collected_modules().await?;
-
-    // This mirrors what the __turbopack_collect__ in
-    // packages/next/src/build/templates/turbopack-action-loader.ts ends up chunking into the chunk.
-
     // This can be none if there are no server actions
     let actions =
         collected_modules
             .collected_references
             .iter()
-            .find_map(|((entry, _loader), actions)| {
-                if *entry == server_action_loader {
-                    // TODO also filter based on _loader
+            .find_map(|((entry, loader), actions)| {
+                if *entry == server_action_loader && *loader == server_action_loader {
                     Some(actions)
                 } else {
                     None
@@ -201,3 +204,113 @@ type HashToLayerNameModule = Vec<(
 /// and exported name of each found action.
 #[turbo_tasks::value(transparent)]
 pub struct AllActions(HashToLayerNameModule);
+
+/// This module performs what `__turbopack_collect__({namespace: 'next/server-actions'})` would do
+/// chunking-wise. Except that we collect the list manually into a separate JSON, so
+/// __turbopack_collect__ would unnecessarily codegen a big list of server actions.
+#[turbo_tasks::value]
+pub struct ServerActionCollectModule {
+    namespace: RcStr,
+    page: RcStr,
+}
+
+#[turbo_tasks::value_impl]
+impl ServerActionCollectModule {
+    #[turbo_tasks::function]
+    pub fn new(namespace: RcStr, page: RcStr) -> Vc<Self> {
+        ServerActionCollectModule { namespace, page }.cell()
+    }
+}
+
+#[turbo_tasks::function]
+fn server_actions_collect_virtual_fs() -> Vc<VirtualFileSystem> {
+    VirtualFileSystem::new_with_name(rcstr!("next-server-actions-collect"))
+}
+
+#[turbo_tasks::value_impl]
+impl Module for ServerActionCollectModule {
+    #[turbo_tasks::function]
+    async fn ident(&self) -> Result<Vc<AssetIdent>> {
+        Ok(
+            AssetIdent::from_path(server_actions_collect_virtual_fs().root().owned().await?)
+                .with_modifier(self.namespace.clone())
+                .with_modifier(self.page.clone()),
+        )
+    }
+
+    #[turbo_tasks::function]
+    fn source(&self) -> Vc<OptionSource> {
+        Vc::cell(None)
+    }
+
+    #[turbo_tasks::function]
+    fn references(&self) -> Vc<ModuleReferences> {
+        ModuleReferences::empty()
+    }
+
+    #[turbo_tasks::function]
+    fn side_effects(self: Vc<Self>) -> Vc<ModuleSideEffects> {
+        ModuleSideEffects::SideEffectful.cell()
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl CollectingModule for ServerActionCollectModule {
+    #[turbo_tasks::function]
+    fn namespace(&self) -> Vc<RcStr> {
+        Vc::cell(self.namespace.clone())
+    }
+
+    #[turbo_tasks::function]
+    fn as_chunk_item(
+        self: ResolvedVc<Self>,
+        module_graph: ResolvedVc<ModuleGraph>,
+        chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
+        _chunk_group: Vc<Modules>,
+    ) -> Vc<Box<dyn ChunkItem>> {
+        ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl ChunkableModule for ServerActionCollectModule {
+    #[turbo_tasks::function]
+    fn as_chunk_item(
+        self: ResolvedVc<Self>,
+        module_graph: ResolvedVc<ModuleGraph>,
+        chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
+    ) -> Vc<Box<dyn ChunkItem>> {
+        ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl EcmascriptChunkPlaceable for ServerActionCollectModule {
+    #[turbo_tasks::function]
+    fn get_exports(&self) -> Vc<EcmascriptExports> {
+        EcmascriptExports::None.cell()
+    }
+
+    #[turbo_tasks::function]
+    async fn chunk_item_content(
+        self: Vc<Self>,
+        _chunking_context: Vc<Box<dyn ChunkingContext>>,
+        _module_graph: Vc<ModuleGraph>,
+        _async_module_info: Option<Vc<AsyncModuleInfo>>,
+        _estimated: bool,
+    ) -> Result<Vc<EcmascriptChunkItemContent>> {
+        // There is no runtime behavior needed here.
+        // - __turbopack_collect__ causes all modules to chunked together with this one
+        // - server-reference-manifest.json will contains all the module ids from above. It will do
+        //   the loading itself
+        // In the future, when server-reference-manifest might be loaded/handled by the templates
+        // themselves, then it could happen here instead.
+        Ok(EcmascriptChunkItemContent {
+            ..Default::default()
+        }
+        .cell())
+    }
+}
+
+#[turbo_tasks::value_impl]
+impl EvaluatableAsset for ServerActionCollectModule {}

crates/next-core/src/util.rs

@@ -459,7 +459,7 @@ pub async fn file_content_rope(content: Vc<FileContent>) -> Result<Vc<Rope>> {
     Ok(file.content().to_owned().cell())
 }
 
-pub async fn virtual_next_js_template_path(
+async fn virtual_next_js_template_path(
     project_path: FileSystemPath,
     file: &str,
 ) -> Result<FileSystemPath> {