Turbopack: Add new webpack loader rule/condition syntax in config

Author: bgw

Cargo.lock

@@ -248,11 +248,11 @@ pub async fn get_client_module_options_context(
     let mut foreign_conditions = loader_conditions.clone();
     foreign_conditions.insert(WebpackLoaderBuiltinCondition::Foreign);
     let foreign_enable_webpack_loaders =
-        webpack_loader_options(project_path.clone(), next_config, true, foreign_conditions).await?;
+        webpack_loader_options(project_path.clone(), next_config, foreign_conditions).await?;
 
     // Now creates a webpack rules that applies to all code.
     let enable_webpack_loaders =
-        webpack_loader_options(project_path.clone(), next_config, false, loader_conditions).await?;
+        webpack_loader_options(project_path.clone(), next_config, loader_conditions).await?;
 
     let tree_shaking_mode_for_user_code = *next_config
         .tree_shaking_mode_for_user_code(next_mode.is_development())

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

@@ -566,53 +566,92 @@ pub struct TurbopackConfig {
     pub module_ids: Option<ModuleIds>,
 }
 
-#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, Debug)]
+#[derive(
+    Serialize, Deserialize, Clone, PartialEq, Eq, Debug, TraceRawVcs, NonLocalValue, OperationValue,
+)]
 pub struct RegexComponents {
     source: RcStr,
     flags: RcStr,
 }
 
-#[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+#[derive(
+    Clone, PartialEq, Eq, Debug, Serialize, Deserialize, TraceRawVcs, NonLocalValue, OperationValue,
+)]
 #[serde(tag = "type", content = "value", rename_all = "camelCase")]
 pub enum ConfigConditionPath {
     Glob(RcStr),
     Regex(RegexComponents),
 }
 
-impl TryInto<ConditionPath> for ConfigConditionPath {
-    fn try_into(self) -> Result<ConditionPath> {
-        Ok(match self {
+impl TryFrom<ConfigConditionPath> for ConditionPath {
+    type Error = anyhow::Error;
+
+    fn try_from(config: ConfigConditionPath) -> Result<ConditionPath> {
+        Ok(match config {
             ConfigConditionPath::Glob(path) => ConditionPath::Glob(path),
-            ConfigConditionPath::Regex(path) => ConditionPath::Regex(path.try_into()?),
+            ConfigConditionPath::Regex(path) => {
+                ConditionPath::Regex(EsRegex::try_from(path)?.resolved_cell())
+            }
         })
     }
+}
 
+impl TryFrom<RegexComponents> for EsRegex {
     type Error = anyhow::Error;
-}
 
-impl TryInto<ResolvedVc<EsRegex>> for RegexComponents {
-    fn try_into(self) -> Result<ResolvedVc<EsRegex>> {
-        Ok(EsRegex::new(&self.source, &self.flags)?.resolved_cell())
+    fn try_from(components: RegexComponents) -> Result<EsRegex> {
+        EsRegex::new(&components.source, &components.flags)
     }
-
-    type Error = anyhow::Error;
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
-pub struct ConfigConditionItem {
-    pub path: Option<ConfigConditionPath>,
-    pub content: Option<RegexComponents>,
+#[derive(
+    Serialize, Deserialize, Clone, PartialEq, Eq, Debug, TraceRawVcs, NonLocalValue, OperationValue,
+)]
+// We can end up with confusing behaviors if we silently ignore extra properties, since `Base` will
+// match nearly every object, since it has no required field.
+#[serde(deny_unknown_fields)]
+pub enum ConfigConditionItem {
+    #[serde(rename = "all")]
+    All(Box<[ConfigConditionItem]>),
+    #[serde(rename = "any")]
+    Any(Box<[ConfigConditionItem]>),
+    #[serde(rename = "not")]
+    Not(Box<ConfigConditionItem>),
+    #[serde(untagged)]
+    Builtin(WebpackLoaderBuiltinCondition),
+    #[serde(untagged)]
+    Base {
+        path: Option<ConfigConditionPath>,
+        content: Option<RegexComponents>,
+    },
 }
 
-impl TryInto<ConditionItem> for ConfigConditionItem {
-    fn try_into(self) -> Result<ConditionItem> {
-        Ok(ConditionItem {
-            path: self.path.map(|p| p.try_into()).transpose()?,
-            content: self.content.map(|r| r.try_into()).transpose()?,
+impl TryFrom<ConfigConditionItem> for ConditionItem {
+    type Error = anyhow::Error;
+
+    fn try_from(config: ConfigConditionItem) -> Result<Self> {
+        let try_from_vec = |conds: Box<[_]>| {
+            conds
+                .into_iter()
+                .map(ConditionItem::try_from)
+                .collect::<Result<_>>()
+        };
+        Ok(match config {
+            ConfigConditionItem::All(conds) => ConditionItem::All(try_from_vec(conds)?),
+            ConfigConditionItem::Any(conds) => ConditionItem::Any(try_from_vec(conds)?),
+            ConfigConditionItem::Not(cond) => ConditionItem::Not(Box::new((*cond).try_into()?)),
+            ConfigConditionItem::Builtin(cond) => {
+                ConditionItem::Builtin(RcStr::from(cond.as_str()))
+            }
+            ConfigConditionItem::Base { path, content } => ConditionItem::Base {
+                path: path.map(ConditionPath::try_from).transpose()?,
+                content: content
+                    .map(EsRegex::try_from)
+                    .transpose()?
+                    .map(EsRegex::resolved_cell),
+            },
         })
     }
-
-    type Error = anyhow::Error;
 }
 
 #[derive(
@@ -623,6 +662,7 @@ pub struct RuleConfigItemOptions {
     pub loaders: Vec<LoaderItem>,
     #[serde(default, alias = "as")]
     pub rename_as: Option<RcStr>,
+    pub condition: Option<ConfigConditionItem>,
 }
 
 #[derive(
@@ -640,8 +680,8 @@ pub enum RuleConfigItemOrShortcut {
 #[serde(rename_all = "camelCase", untagged)]
 pub enum RuleConfigItem {
     Options(RuleConfigItemOptions),
-    Conditional(FxIndexMap<RcStr, RuleConfigItem>),
-    Boolean(bool),
+    LegacyConditional(FxIndexMap<RcStr, RuleConfigItem>),
+    LegacyBoolean(bool),
 }
 
 #[derive(
@@ -1320,13 +1360,16 @@ impl NextConfig {
                 NotFound,
                 Break,
             }
+            // This logic is needed for the `LegacyConditional`/`LegacyBoolean` configuration
+            // syntax. This is technically public syntax, but was never documented and it is
+            // unlikely that anyone is depending on it (outside of some Next.js internals).
             fn find_rule<'a>(
                 rule: &'a RuleConfigItem,
                 active_conditions: &BTreeSet<WebpackLoaderBuiltinCondition>,
             ) -> FindRuleResult<'a> {
                 match rule {
                     RuleConfigItem::Options(rule) => FindRuleResult::Found(rule),
-                    RuleConfigItem::Conditional(map) => {
+                    RuleConfigItem::LegacyConditional(map) => {
                         for (condition, rule) in map.iter() {
                             let condition = WebpackLoaderBuiltinCondition::from_str(condition);
                             if let Ok(condition) = condition
@@ -1346,7 +1389,7 @@ impl NextConfig {
                         }
                         FindRuleResult::NotFound
                     }
-                    RuleConfigItem::Boolean(_) => FindRuleResult::Break,
+                    RuleConfigItem::LegacyBoolean(_) => FindRuleResult::Break,
                 }
             }
             match rule {
@@ -1356,12 +1399,16 @@ impl NextConfig {
                         LoaderRuleItem {
                             loaders: transform_loaders(loaders),
                             rename_as: None,
+                            condition: None,
                         },
                     );
                 }
                 RuleConfigItemOrShortcut::Advanced(rule) => {
-                    if let FindRuleResult::Found(RuleConfigItemOptions { loaders, rename_as }) =
-                        find_rule(rule, &active_conditions)
+                    if let FindRuleResult::Found(RuleConfigItemOptions {
+                        loaders,
+                        rename_as,
+                        condition,
+                    }) = find_rule(rule, &active_conditions)
                     {
                         // If the extension contains a wildcard, and the rename_as does not,
                         // emit an issue to prevent users from encountering duplicate module names.
@@ -1383,6 +1430,12 @@ impl NextConfig {
                             LoaderRuleItem {
                                 loaders: transform_loaders(loaders),
                                 rename_as: rename_as.clone(),
+                                // TODO(bgw): Emit `InvalidLoaderRuleError` if this fails instead of
+                                // using try (?)
+                                condition: condition
+                                    .clone()
+                                    .map(ConditionItem::try_from)
+                                    .transpose()?,
                             },
                         );
                     }
@@ -1820,3 +1873,66 @@ impl JsConfig {
         Vc::cell(self.compiler_options.clone().unwrap_or_default())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_serde_rule_config_item_options() {
+        let json_value = serde_json::json!({
+            "loaders": [],
+            "as": "*.js",
+            "condition": {
+                "all": [
+                    "production",
+                    {"not": "foreign"},
+                    {"any": [
+                        "browser",
+                        {
+                            "path": { "type": "glob", "value": "*.svg"},
+                            "content": {
+                                "source": "@someTag",
+                                "flags": ""
+                            }
+                        }
+                    ]},
+                ],
+            }
+        });
+
+        let rule_config: RuleConfigItemOptions = serde_json::from_value(json_value).unwrap();
+
+        assert_eq!(
+            rule_config,
+            RuleConfigItemOptions {
+                loaders: vec![],
+                rename_as: Some(rcstr!("*.js")),
+                condition: Some(ConfigConditionItem::All(
+                    [
+                        ConfigConditionItem::Builtin(WebpackLoaderBuiltinCondition::Production),
+                        ConfigConditionItem::Not(Box::new(ConfigConditionItem::Builtin(
+                            WebpackLoaderBuiltinCondition::Foreign
+                        ))),
+                        ConfigConditionItem::Any(
+                            vec![
+                                ConfigConditionItem::Builtin(
+                                    WebpackLoaderBuiltinCondition::Browser
+                                ),
+                                ConfigConditionItem::Base {
+                                    path: Some(ConfigConditionPath::Glob(rcstr!("*.svg"))),
+                                    content: Some(RegexComponents {
+                                        source: rcstr!("@someTag"),
+                                        flags: rcstr!(""),
+                                    }),
+                                },
+                            ]
+                            .into(),
+                        ),
+                    ]
+                    .into(),
+                )),
+            }
+        );
+    }
+}

crates/next-core/src/next_config.rs

@@ -493,11 +493,11 @@ pub async fn get_server_module_options_context(
     let mut foreign_conditions = loader_conditions.clone();
     foreign_conditions.insert(WebpackLoaderBuiltinCondition::Foreign);
     let foreign_enable_webpack_loaders =
-        webpack_loader_options(project_path.clone(), next_config, true, foreign_conditions).await?;
+        webpack_loader_options(project_path.clone(), next_config, foreign_conditions).await?;
 
     // Now creates a webpack rules that applies to all code.
     let enable_webpack_loaders =
-        webpack_loader_options(project_path.clone(), next_config, false, loader_conditions).await?;
+        webpack_loader_options(project_path.clone(), next_config, loader_conditions).await?;
 
     let tree_shaking_mode_for_user_code = *next_config
         .tree_shaking_mode_for_user_code(next_mode.is_development())

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

@@ -97,6 +97,7 @@ pub async fn maybe_add_babel_loader(
                         LoaderRuleItem {
                             loaders: ResolvedVc::cell(vec![loader]),
                             rename_as: Some(rcstr!("*")),
+                            condition: None,
                         },
                     );
                 }