feat: next typegen, automatic route types, PageProps, LayoutProps

Author: bgub

crates/napi/src/next_api/project.rs

@@ -253,6 +253,8 @@ pub struct NapiTurboEngineOptions {
     pub dependency_tracking: Option<bool>,
     /// Whether the project is running in a CI environment.
     pub is_ci: Option<bool>,
+    /// Whether the project is running in a short session.
+    pub is_short_session: Option<bool>,
 }
 
 impl From<NapiWatchOptions> for WatchOptions {
@@ -434,12 +436,14 @@ pub fn project_new(
         let persistent_caching = turbo_engine_options.persistent_caching.unwrap_or_default();
         let dependency_tracking = turbo_engine_options.dependency_tracking.unwrap_or(true);
         let is_ci = turbo_engine_options.is_ci.unwrap_or(false);
+        let is_short_session = turbo_engine_options.is_short_session.unwrap_or(false);
         let turbo_tasks = create_turbo_tasks(
             PathBuf::from(&options.dist_dir),
             persistent_caching,
             memory_limit,
             dependency_tracking,
             is_ci,
+            is_short_session,
         )?;
         let turbopack_ctx = NextTurbopackContext::new(turbo_tasks.clone(), napi_callbacks);
 

crates/napi/src/next_api/turbopack_ctx.rs

@@ -185,15 +185,20 @@ pub fn create_turbo_tasks(
     _memory_limit: usize,
     dependency_tracking: bool,
     is_ci: bool,
+    is_short_session: bool,
 ) -> Result<NextTurboTasks> {
     Ok(if persistent_caching {
         let version_info = GitVersionInfo {
             describe: env!("VERGEN_GIT_DESCRIBE"),
             dirty: option_env!("CI").is_none_or(|value| value.is_empty())
                 && env!("VERGEN_GIT_DIRTY") == "true",
         };
-        let (backing_storage, cache_state) =
-            default_backing_storage(&output_path.join("cache/turbopack"), &version_info, is_ci)?;
+        let (backing_storage, cache_state) = default_backing_storage(
+            &output_path.join("cache/turbopack"),
+            &version_info,
+            is_ci,
+            is_short_session,
+        )?;
         let tt = TurboTasks::new(TurboTasksBackend::new(
             BackendOptions {
                 storage_mode: Some(if std::env::var("TURBO_ENGINE_READ_ONLY").is_ok() {

crates/next-api/src/module_graph.rs

@@ -2,19 +2,21 @@ use std::{borrow::Cow, collections::hash_map::Entry};
 
 use anyhow::{Ok, Result};
 use either::Either;
+use futures::join;
 use next_core::{
     next_client_reference::{
         ClientReference, ClientReferenceGraphResult, ClientReferenceType, ServerEntries,
         find_server_entries,
     },
     next_dynamic::NextDynamicEntryModule,
     next_manifests::ActionLayer,
+    next_server_utility::server_utility_module::NextServerUtilityModule,
 };
-use rustc_hash::{FxHashMap, FxHashSet};
+use rustc_hash::FxHashMap;
 use tracing::Instrument;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{
-    CollectiblesSource, FxIndexMap, ReadRef, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt,
+    CollectiblesSource, FxIndexMap, FxIndexSet, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt,
     ValueToString, Vc,
 };
 use turbo_tasks_fs::FileSystemPath;
@@ -289,7 +291,8 @@ impl ClientReferencesGraph {
             // post_order callbacks which is the same as evaluation order
             let mut client_references = Vec::new();
             let mut client_reference_modules = Vec::new();
-            let mut server_components = FxHashSet::default();
+            let mut server_components = FxIndexSet::default();
+            let mut server_utils = FxIndexSet::default();
 
             // Track how we reached each client reference.  This way if a client reference is
             // referenced by the root and by a server component we don't only associate it with the
@@ -355,6 +358,12 @@ impl ClientReferencesGraph {
                 },
                 |_, node, state_map| {
                     let module = node.module();
+                    if let Some(server_util_module) =
+                        ResolvedVc::try_downcast_type::<NextServerUtilityModule>(module)
+                    {
+                        server_utils.insert(server_util_module);
+                    }
+
                     let Some(module_type) = data.manifest.get(&module) else {
                         return Ok(());
                     };
@@ -407,8 +416,9 @@ impl ClientReferencesGraph {
 
             Ok(ClientReferenceGraphResult {
                 client_references: client_references.into_iter().collect(),
-                server_utils: vec![],
-                server_component_entries: vec![],
+                // The order of server_utils does not matter
+                server_utils: server_utils.into_iter().collect(),
+                server_component_entries: server_components.into_iter().collect(),
             }
             .cell())
         }
@@ -717,46 +727,68 @@ impl GlobalBuildInformation {
     ) -> Result<Vc<ClientReferenceGraphResult>> {
         let span = tracing::info_span!("collect all client references for endpoint");
         async move {
-            let mut result = if let [graph] = &self.client_references[..] {
-                // Just a single graph, no need to merge results
-                graph
-                    .get_client_references_for_endpoint(entry)
-                    .owned()
-                    .await?
+            let result = if let [graph] = &self.client_references[..] {
+                // Just a single graph, no need to merge results  This also naturally aggregates
+                // server components and server utilities in the correct order
+                let result = graph.get_client_references_for_endpoint(entry);
+                #[cfg(debug_assertions)]
+                {
+                    let result = result.await?;
+                    if has_layout_segments {
+                        use rustc_hash::FxHashSet;
+
+                        let ServerEntries {
+                            server_utils,
+                            server_component_entries,
+                        } = &*find_server_entries(entry, include_traced).await?;
+                        // order of server utils doesn't matter, so just ensure that they match
+                        assert_eq!(
+                            FxHashSet::from_iter(result.server_utils.iter()),
+                            FxHashSet::from_iter(server_utils.iter())
+                        );
+                        // The order of server_components does matter, enforce it is identical
+                        assert_eq!(&result.server_component_entries, server_component_entries);
+                    }
+                }
+                result
             } else {
                 let results = self
                     .client_references
                     .iter()
                     .map(|graph| graph.get_client_references_for_endpoint(entry))
-                    .try_join()
-                    .await?;
-
-                let mut iter = results.into_iter();
-                let mut result = ReadRef::into_owned(iter.next().unwrap());
-                for r in iter {
-                    result.extend(&r);
-                }
-                result
-            };
+                    .try_join();
+                // Do this separately for now, because the aggregation of multiple graph traversals
+                // messes up the order of the server_component_entries.
+                let server_entries = async {
+                    if has_layout_segments {
+                        let server_entries = find_server_entries(entry, include_traced).await?;
+                        Ok(Some(server_entries))
+                    } else {
+                        Ok(None)
+                    }
+                };
+                // Wait for both in parallel since `find_server_entries` tends to be slower than the
+                // graph traversals
+                let (results, server_entries) = join!(results, server_entries);
 
-            // TODO(luke.sandberg): at least in the whole_app_module_graph case we should be able to
-            // collect server components and server utilities during the above traversals in the
-            // correct order.  `find_server_entries returns them in reverse topological order (root
-            // layout first, page last) but the above traversals find them in DFS post
-            // order which means we would need to reverse it.
-            // For server_utils the order is irrelevant.
-            if has_layout_segments {
-                // Do this separately for now, because the graph traversal order messes up the order
-                // of the server_component_entries.
-                let ServerEntries {
+                let mut result = ClientReferenceGraphResult {
+                    client_references: results?
+                        .iter()
+                        .flat_map(|r| r.client_references.iter().copied())
+                        .collect(),
+                    ..Default::default()
+                };
+                if let Some(ServerEntries {
                     server_utils,
                     server_component_entries,
-                } = &*find_server_entries(entry, include_traced).await?;
-                result.server_utils = server_utils.clone();
-                result.server_component_entries = server_component_entries.clone();
-            }
-
-            Ok(result.cell())
+                }) = server_entries?.as_deref()
+                {
+                    result.server_utils = server_utils.clone();
+                    result.server_component_entries = server_component_entries.clone();
+                }
+                result.cell()
+            };
+            Ok(result)
         }
         .instrument(span)
         .await

crates/next-core/src/next_client_reference/visit_client_reference.rs

@@ -106,17 +106,6 @@ impl ClientReferenceGraphResult {
     }
 }
 
-impl ClientReferenceGraphResult {
-    /// Merges multiple return values of client_reference_graph together.
-    pub fn extend(&mut self, other: &Self) {
-        self.client_references
-            .extend(other.client_references.iter().copied());
-        self.server_component_entries
-            .extend(other.server_component_entries.iter().copied());
-        self.server_utils.extend(other.server_utils.iter().copied());
-    }
-}
-
 #[turbo_tasks::value(shared)]
 #[derive(Clone, Debug)]
 pub struct ServerEntries {

docs/01-app/03-api-reference/04-functions/redirect.mdx

@@ -6,7 +6,7 @@ related:
     - app/api-reference/functions/permanentRedirect
 ---
 
-The `redirect` function allows you to redirect the user to another URL. `redirect` can be used in [Server Components](/docs/app/getting-started/server-and-client-components), [Route Handlers](/docs/app/api-reference/file-conventions/route), and [Server Actions](/docs/app/getting-started/updating-data).
+The `redirect` function allows you to redirect the user to another URL. `redirect` can be used while rendering in [Server and Client Components](/docs/app/getting-started/server-and-client-components), [Route Handlers](/docs/app/api-reference/file-conventions/route), and [Server Actions](/docs/app/getting-started/updating-data).
 
 When used in a [streaming context](/docs/app/getting-started/linking-and-navigating#streaming), this will insert a meta tag to emit the redirect on the client side. When used in a server action, it will serve a 303 HTTP redirect response to the caller. Otherwise, it will serve a 307 HTTP redirect response to the caller.
 

lerna.json

@@ -16,5 +16,5 @@
       "registry": "https://registry.npmjs.org/"
     }
   },
-  "version": "15.4.2-canary.25"
+  "version": "15.4.2-canary.26"
 }

packages/create-next-app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-next-app",
-  "version": "15.4.2-canary.25",
+  "version": "15.4.2-canary.26",
   "keywords": [
     "react",
     "next",

packages/create-next-app/templates/app-api/ts/next-env.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
+/// <reference path="./.next/types/routes.d.ts" />
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/basic-features/typescript for more information.

packages/create-next-app/templates/app-empty/ts/next-env.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
+/// <reference path="./.next/types/routes.d.ts" />
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

packages/create-next-app/templates/app-tw-empty/ts/next-env.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
+/// <reference path="./.next/types/routes.d.ts" />
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.