Introduce experimental Request Interceptors

crates/next-api/src/app.rs

@@ -150,7 +150,7 @@ impl AppProject {
 
     #[turbo_tasks::function]
     fn app_entrypoints(&self) -> Vc<AppEntrypoints> {
-        get_entrypoints(self.app_dir, self.project.next_config().page_extensions())
+        get_entrypoints(self.app_dir, self.project.next_config())
     }
 
     #[turbo_tasks::function]
@@ -655,13 +655,15 @@ pub fn app_entry_point_to_route(
             page,
             path,
             root_layouts,
+            interceptors,
         } => Route::AppRoute {
             original_name: page.to_string(),
             endpoint: Vc::upcast(
                 AppEndpoint {
                     ty: AppEndpointType::Route {
                         path: *path,
                         root_layouts: *root_layouts,
+                        interceptors: *interceptors,
                     },
                     app_project,
                     page,
@@ -709,6 +711,7 @@ enum AppEndpointType {
     Route {
         path: Vc<FileSystemPath>,
         root_layouts: Vc<FileSystemPathVec>,
+        interceptors: Vc<FileSystemPathVec>,
     },
     Metadata {
         metadata: MetadataItem,
@@ -741,6 +744,7 @@ impl AppEndpoint {
         &self,
         path: Vc<FileSystemPath>,
         root_layouts: Vc<FileSystemPathVec>,
+        interceptors: Vc<FileSystemPathVec>,
         next_config: Vc<NextConfig>,
     ) -> Result<Vc<AppEntry>> {
         let root_layouts = root_layouts.await?;
@@ -766,6 +770,7 @@ impl AppEndpoint {
             self.app_project.project().project_path(),
             config,
             next_config,
+            interceptors,
         ))
     }
 
@@ -793,9 +798,11 @@ impl AppEndpoint {
         let next_config = self.await?.app_project.project().next_config();
         let app_entry = match this.ty {
             AppEndpointType::Page { loader_tree, .. } => self.app_page_entry(loader_tree),
-            AppEndpointType::Route { path, root_layouts } => {
-                self.app_route_entry(path, root_layouts, next_config)
-            }
+            AppEndpointType::Route {
+                path,
+                root_layouts,
+                interceptors,
+            } => self.app_route_entry(path, root_layouts, interceptors, next_config),
             AppEndpointType::Metadata { metadata } => {
                 self.app_metadata_entry(metadata, next_config)
             }

crates/next-core/src/app_page_loader_tree.rs

@@ -36,10 +36,15 @@ impl AppPageLoaderTreeBuilder {
     fn new(
         module_asset_context: Vc<ModuleAssetContext>,
         server_component_transition: Vc<Box<dyn Transition>>,
+        project_root: Vc<FileSystemPath>,
         base_path: Option<RcStr>,
     ) -> Self {
         AppPageLoaderTreeBuilder {
-            base: BaseLoaderTreeBuilder::new(module_asset_context, server_component_transition),
+            base: BaseLoaderTreeBuilder::new(
+                module_asset_context,
+                server_component_transition,
+                project_root,
+            ),
             loader_tree_code: String::new(),
             pages: Vec::new(),
             base_path,
@@ -319,6 +324,7 @@ impl AppPageLoaderTreeBuilder {
             not_found,
             metadata,
             route: _,
+            interceptor,
         } = &modules;
 
         // Ensure global metadata being written only once at the root level
@@ -345,6 +351,8 @@ impl AppPageLoaderTreeBuilder {
             .await?;
         self.write_modules_entry(AppDirModuleType::DefaultPage, *default)
             .await?;
+        self.write_modules_entry(AppDirModuleType::Interceptor, *interceptor)
+            .await?;
 
         let modules_code = replace(&mut self.loader_tree_code, temp_loader_tree_code);
 
@@ -398,11 +406,17 @@ impl AppPageLoaderTreeModule {
         loader_tree: Vc<AppPageLoaderTree>,
         module_asset_context: Vc<ModuleAssetContext>,
         server_component_transition: Vc<Box<dyn Transition>>,
+        project_root: Vc<FileSystemPath>,
         base_path: Option<RcStr>,
     ) -> Result<Self> {
-        AppPageLoaderTreeBuilder::new(module_asset_context, server_component_transition, base_path)
-            .build(loader_tree)
-            .await
+        AppPageLoaderTreeBuilder::new(
+            module_asset_context,
+            server_component_transition,
+            project_root,
+            base_path,
+        )
+        .build(loader_tree)
+        .await
     }
 }
 

crates/next-core/src/app_route_loader_tree.rs

@@ -0,0 +1,87 @@
+use std::fmt::Write;
+
+use anyhow::Result;
+use indexmap::IndexMap;
+use turbo_tasks::{RcStr, Vc};
+use turbo_tasks_fs::FileSystemPath;
+use turbopack::{transition::Transition, ModuleAssetContext};
+use turbopack_core::module::Module;
+
+use crate::{
+    app_structure::FileSystemPathVec,
+    base_loader_tree::{AppDirModuleType, BaseLoaderTreeBuilder},
+};
+
+pub struct AppRouteLoaderTreeBuilder {
+    base: BaseLoaderTreeBuilder,
+    interceptors_code: String,
+}
+
+impl AppRouteLoaderTreeBuilder {
+    fn new(
+        module_asset_context: Vc<ModuleAssetContext>,
+        server_component_transition: Vc<Box<dyn Transition>>,
+        project_root: Vc<FileSystemPath>,
+    ) -> Self {
+        AppRouteLoaderTreeBuilder {
+            base: BaseLoaderTreeBuilder::new(
+                module_asset_context,
+                server_component_transition,
+                project_root,
+            ),
+            interceptors_code: String::new(),
+        }
+    }
+
+    async fn write_interceptors(&mut self, interceptors: Vc<FileSystemPathVec>) -> Result<()> {
+        writeln!(self.interceptors_code, "[")?;
+
+        for interceptor in interceptors.await?.iter() {
+            let tuple_code = self
+                .base
+                .create_module_tuple_code(AppDirModuleType::Interceptor, **interceptor)
+                .await?;
+
+            writeln!(self.interceptors_code, "{},", tuple_code)?;
+        }
+
+        write!(self.interceptors_code, "]")?;
+        Ok(())
+    }
+
+    async fn build(
+        mut self,
+        interceptors: Vc<FileSystemPathVec>,
+    ) -> Result<AppRouteLoaderTreeModule> {
+        self.write_interceptors(interceptors).await?;
+
+        Ok(AppRouteLoaderTreeModule {
+            imports: self.base.imports,
+            interceptors_code: self.interceptors_code.into(),
+            inner_assets: self.base.inner_assets,
+        })
+    }
+}
+
+pub struct AppRouteLoaderTreeModule {
+    pub imports: Vec<RcStr>,
+    pub interceptors_code: RcStr,
+    pub inner_assets: IndexMap<RcStr, Vc<Box<dyn Module>>>,
+}
+
+impl AppRouteLoaderTreeModule {
+    pub async fn build(
+        interceptors: Vc<FileSystemPathVec>,
+        module_asset_context: Vc<ModuleAssetContext>,
+        server_component_transition: Vc<Box<dyn Transition>>,
+        project_root: Vc<FileSystemPath>,
+    ) -> Result<Self> {
+        AppRouteLoaderTreeBuilder::new(
+            module_asset_context,
+            server_component_transition,
+            project_root,
+        )
+        .build(interceptors)
+        .await
+    }
+}