Turbopack: add support for multiple options for chunk suffix

Author: sokra

crates/next-api/src/project.rs

@@ -1144,7 +1144,7 @@ impl Project {
             client_root: self.client_relative_path().owned().await?,
             client_root_to_root_path: rcstr!("/ROOT"),
             asset_prefix: self.next_config().computed_asset_prefix(),
-            chunk_suffix_path: self.next_config().chunk_suffix_path(),
+            chunk_suffix: self.next_config().chunk_suffix(),
             environment: self.client_compile_time_info().environment(),
             module_id_strategy: self.module_ids(),
             export_usage: self.export_usage(),

crates/next-core/src/next_client/context.rs

@@ -14,7 +14,7 @@ use turbopack::{
     resolve_options_context::ResolveOptionsContext,
 };
 use turbopack_browser::{
-    BrowserChunkingContext, ContentHashing, CurrentChunkMethod,
+    BrowserChunkingContext, ChunkSuffix, ContentHashing, CurrentChunkMethod,
     react_refresh::assert_can_resolve_react_refresh,
 };
 use turbopack_core::{
@@ -414,7 +414,7 @@ pub struct ClientChunkingContextOptions {
     pub client_root: FileSystemPath,
     pub client_root_to_root_path: RcStr,
     pub asset_prefix: Vc<RcStr>,
-    pub chunk_suffix_path: Vc<Option<RcStr>>,
+    pub chunk_suffix: Vc<ChunkSuffix>,
     pub environment: Vc<Environment>,
     pub module_id_strategy: Vc<Box<dyn ModuleIdStrategy>>,
     pub export_usage: Vc<OptionExportUsageInfo>,
@@ -437,7 +437,7 @@ pub async fn get_client_chunking_context(
         client_root,
         client_root_to_root_path,
         asset_prefix,
-        chunk_suffix_path,
+        chunk_suffix,
         environment,
         module_id_strategy,
         export_usage,
@@ -452,7 +452,7 @@ pub async fn get_client_chunking_context(
 
     let next_mode = mode.await?;
     let asset_prefix = asset_prefix.owned().await?;
-    let chunk_suffix_path = chunk_suffix_path.to_resolved().await?;
+    let chunk_suffix = chunk_suffix.to_resolved().await?;
     let mut builder = BrowserChunkingContext::builder(
         root_path,
         client_root.clone(),
@@ -464,7 +464,7 @@ pub async fn get_client_chunking_context(
         next_mode.runtime_type(),
     )
     .chunk_base_path(Some(asset_prefix.clone()))
-    .chunk_suffix_path(chunk_suffix_path)
+    .chunk_suffix(chunk_suffix)
     .minify_type(if *minify.await? {
         MinifyType::Minify {
             mangle: (!*no_mangling.await?).then_some(MangleType::OptimalSize),

crates/next-core/src/next_config.rs

@@ -16,6 +16,7 @@ use turbopack::module_options::{
     ConditionItem, ConditionPath, LoaderRuleItem, WebpackRules,
     module_options_context::MdxTransformOptions,
 };
+use turbopack_browser::ChunkSuffix;
 use turbopack_core::{
     chunk::SourceMapsType,
     issue::{Issue, IssueExt, IssueStage, OptionStyledString, StyledString},
@@ -1673,6 +1674,19 @@ impl NextConfig {
         }
     }
 
+    /// Returns the suffix to use for chunk loading.
+    #[turbo_tasks::function]
+    pub async fn chunk_suffix(self: Vc<Self>) -> Result<Vc<ChunkSuffix>> {
+        let this = self.await?;
+
+        match &this.deployment_id {
+            Some(deployment_id) => {
+                Ok(ChunkSuffix::Constant(format!("?dpl={deployment_id}").into()).cell())
+            }
+            None => Ok(ChunkSuffix::None.cell()),
+        }
+    }
+
     #[turbo_tasks::function]
     pub fn enable_taint(&self) -> Vc<bool> {
         Vc::cell(self.experimental.taint.unwrap_or(false))

turbopack/crates/turbopack-browser/src/chunking_context.rs

@@ -33,7 +33,7 @@ use turbopack_ecmascript::{
     chunk::EcmascriptChunk,
     manifest::{chunk_asset::ManifestAsyncModule, loader_item::ManifestLoaderChunkItem},
 };
-use turbopack_ecmascript_runtime::RuntimeType;
+use turbopack_ecmascript_runtime::{ChunkSuffix, RuntimeType};
 
 use crate::ecmascript::{
     chunk::EcmascriptBrowserChunk,
@@ -130,8 +130,8 @@ impl BrowserChunkingContextBuilder {
         self
     }
 
-    pub fn chunk_suffix_path(mut self, chunk_suffix_path: ResolvedVc<Option<RcStr>>) -> Self {
-        self.chunking_context.chunk_suffix_path = Some(chunk_suffix_path);
+    pub fn chunk_suffix(mut self, chunk_suffix: ResolvedVc<ChunkSuffix>) -> Self {
+        self.chunking_context.chunk_suffix = Some(chunk_suffix);
         self
     }
 
@@ -253,9 +253,9 @@ pub struct BrowserChunkingContext {
     /// Base path that will be prepended to all chunk URLs when loading them.
     /// This path will not appear in chunk paths or chunk data.
     chunk_base_path: Option<RcStr>,
-    /// Suffix path that will be appended to all chunk URLs when loading them.
+    /// Suffix that will be appended to all chunk URLs when loading them.
     /// This path will not appear in chunk paths or chunk data.
-    chunk_suffix_path: Option<ResolvedVc<Option<RcStr>>>,
+    chunk_suffix: Option<ResolvedVc<ChunkSuffix>>,
     /// URL prefix that will be prepended to all static asset URLs when loading
     /// them.
     asset_base_path: Option<RcStr>,
@@ -322,7 +322,7 @@ impl BrowserChunkingContext {
                 asset_root_path,
                 asset_root_paths: Default::default(),
                 chunk_base_path: None,
-                chunk_suffix_path: None,
+                chunk_suffix: None,
                 asset_base_path: None,
                 asset_base_paths: Default::default(),
                 enable_hot_module_replacement: false,
@@ -425,11 +425,11 @@ impl BrowserChunkingContext {
 
     /// Returns the asset suffix path.
     #[turbo_tasks::function]
-    pub fn chunk_suffix_path(&self) -> Vc<Option<RcStr>> {
-        if let Some(chunk_suffix_path) = self.chunk_suffix_path {
-            *chunk_suffix_path
+    pub fn chunk_suffix(&self) -> Vc<ChunkSuffix> {
+        if let Some(chunk_suffix) = self.chunk_suffix {
+            *chunk_suffix
         } else {
-            Vc::cell(None)
+            ChunkSuffix::None.cell()
         }
     }
 

turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs

@@ -173,7 +173,7 @@ impl EcmascriptBrowserEvaluateChunk {
                 let runtime_code = turbopack_ecmascript_runtime::get_browser_runtime_code(
                     environment,
                     this.chunking_context.chunk_base_path(),
-                    this.chunking_context.chunk_suffix_path(),
+                    this.chunking_context.chunk_suffix(),
                     runtime_type,
                     output_root_to_root_path,
                     source_maps,

turbopack/crates/turbopack-browser/src/lib.rs

@@ -10,3 +10,4 @@ pub mod react_refresh;
 pub use chunking_context::{
     BrowserChunkingContext, BrowserChunkingContextBuilder, ContentHashing, CurrentChunkMethod,
 };
+pub use turbopack_ecmascript_runtime::ChunkSuffix;

turbopack/crates/turbopack-ecmascript-runtime/Cargo.toml

@@ -29,4 +29,3 @@ turbo-tasks-fs = { workspace = true }
 turbopack = { workspace = true }
 turbopack-core = { workspace = true }
 turbopack-ecmascript = { workspace = true }
-

turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs

@@ -11,14 +11,16 @@ use turbopack_core::{
 };
 use turbopack_ecmascript::utils::StringifyJs;
 
-use crate::{RuntimeType, asset_context::get_runtime_asset_context, embed_js::embed_static_code};
+use crate::{
+    ChunkSuffix, RuntimeType, asset_context::get_runtime_asset_context, embed_js::embed_static_code,
+};
 
 /// Returns the code for the ECMAScript runtime.
 #[turbo_tasks::function]
 pub async fn get_browser_runtime_code(
     environment: ResolvedVc<Environment>,
     chunk_base_path: Vc<Option<RcStr>>,
-    chunk_suffix_path: Vc<Option<RcStr>>,
+    chunk_suffix: Vc<ChunkSuffix>,
     runtime_type: RuntimeType,
     output_root_to_root_path: RcStr,
     generate_source_map: bool,
@@ -80,10 +82,7 @@ pub async fn get_browser_runtime_code(
     let relative_root_path = output_root_to_root_path;
     let chunk_base_path = chunk_base_path.await?;
     let chunk_base_path = chunk_base_path.as_ref().map_or_else(|| "", |f| f.as_str());
-    let chunk_suffix_path = chunk_suffix_path.await?;
-    let chunk_suffix_path = chunk_suffix_path
-        .as_ref()
-        .map_or_else(|| "", |f| f.as_str());
+    let chunk_suffix = chunk_suffix.await?;
 
     writedoc!(
         code,
@@ -94,16 +93,42 @@ pub async fn get_browser_runtime_code(
             }}
 
             const CHUNK_BASE_PATH = {};
-            const CHUNK_SUFFIX_PATH = {};
             const RELATIVE_ROOT_PATH = {};
             const RUNTIME_PUBLIC_PATH = {};
         "#,
         StringifyJs(chunk_base_path),
-        StringifyJs(chunk_suffix_path),
         StringifyJs(relative_root_path.as_str()),
         StringifyJs(chunk_base_path),
     )?;
 
+    match &*chunk_suffix {
+        ChunkSuffix::None => {
+            writedoc!(
+                code,
+                r#"
+                    const CHUNK_SUFFIX_PATH = "";
+                "#
+            )?;
+        }
+        ChunkSuffix::Constant(suffix) => {
+            writedoc!(
+                code,
+                r#"
+                    const CHUNK_SUFFIX_PATH = {};
+                "#,
+                StringifyJs(suffix.as_str())
+            )?;
+        }
+        ChunkSuffix::FromScriptSrc => {
+            writedoc!(
+                code,
+                r#"
+                    const CHUNK_SUFFIX_PATH = document?.currentScript?.getAttribute?.('src')?.replace(/^(.*(?=\?)|^.*$)/, "") || "";
+                "#
+            )?;
+        }
+    }
+
     code.push_code(&*shared_runtime_utils_code.await?);
     for runtime_code in runtime_base_code {
         code.push_code(

turbopack/crates/turbopack-ecmascript-runtime/src/chunk_suffix.rs

@@ -0,0 +1,11 @@
+use turbo_rcstr::RcStr;
+
+#[turbo_tasks::value(shared)]
+pub enum ChunkSuffix {
+    /// No suffix.
+    None,
+    /// A constant suffix to append to chunk URLs.
+    Constant(RcStr),
+    /// Read the chunk suffix from the `src` attribute of the current script tag.
+    FromScriptSrc,
+}

turbopack/crates/turbopack-ecmascript-runtime/src/lib.rs

@@ -3,13 +3,15 @@
 
 pub(crate) mod asset_context;
 pub(crate) mod browser_runtime;
+pub(crate) mod chunk_suffix;
 #[cfg(feature = "test")]
 pub(crate) mod dummy_runtime;
 pub(crate) mod embed_js;
 pub(crate) mod nodejs_runtime;
 pub(crate) mod runtime_type;
 
 pub use browser_runtime::get_browser_runtime_code;
+pub use chunk_suffix::ChunkSuffix;
 #[cfg(feature = "test")]
 pub use dummy_runtime::get_dummy_runtime_code;
 pub use embed_js::{embed_file, embed_file_path, embed_fs};