Inherit prototools version.

Author: milesj

.yarn/versions/94da93c8.yml

@@ -1,9 +1,15 @@
 releases:
-  "@moonrepo/cli": patch
-  "@moonrepo/core-linux-arm64-gnu": patch
-  "@moonrepo/core-linux-arm64-musl": patch
-  "@moonrepo/core-linux-x64-gnu": patch
-  "@moonrepo/core-linux-x64-musl": patch
-  "@moonrepo/core-macos-arm64": patch
-  "@moonrepo/core-macos-x64": patch
-  "@moonrepo/core-windows-x64-msvc": patch
+  '@moonrepo/cli': patch
+  '@moonrepo/core-linux-arm64-gnu': patch
+  '@moonrepo/core-linux-arm64-musl': patch
+  '@moonrepo/core-linux-x64-gnu': patch
+  '@moonrepo/core-linux-x64-musl': patch
+  '@moonrepo/core-macos-arm64': patch
+  '@moonrepo/core-macos-x64': patch
+  '@moonrepo/core-windows-x64-msvc': patch
+  '@moonrepo/types': patch
+
+declined:
+  - '@moonrepo/report'
+  - '@moonrepo/runtime'
+  - website

CHANGELOG.md

@@ -4,10 +4,14 @@
 
 #### 🚀 Updates
 
+- Added a new setting for toolchain plugins, `versionFromPrototools`, which controls how we inherit
+  a version from the root `.prototools` file. By default this is enabled, but can be configured with
+  a string if the IDs don't match.
 - Updated `moon setup` to also install toolchain plugins.
 
 #### 🐞 Fixes
 
+- Fixed an issue where toolchain plugins do not inherit versions from `.prototools`.
 - Fixed an issue where a file lock would be created for proto installation, even when it didn't need
   to be installed.
 

crates/config/src/toolchain/plugin_config.rs

@@ -1,10 +1,26 @@
-use crate::config_struct;
-use schematic::Config;
+use crate::{config_enum, config_struct};
+use schematic::{Config, Schematic};
 use serde_json::Value;
 use std::collections::BTreeMap;
 use version_spec::UnresolvedVersionSpec;
 use warpgate_api::PluginLocator;
 
+config_enum!(
+    /// Strategy in which to inherit a version from `.prototools`.
+    #[derive(Schematic)]
+    #[serde(untagged)]
+    pub enum ToolchainPluginVersionFrom {
+        Enabled(bool),
+        Id(String),
+    }
+);
+
+impl Default for ToolchainPluginVersionFrom {
+    fn default() -> Self {
+        Self::Enabled(true)
+    }
+}
+
 config_struct!(
     /// Configures an individual toolchain.
     #[derive(Config)]
@@ -20,6 +36,11 @@ config_struct!(
         /// The version of the toolchain to download and install.
         pub version: Option<UnresolvedVersionSpec>,
 
+        /// Inherit the version from the root `.prototools`.
+        /// When true, matches using the same ID, otherwise a
+        /// string can be provided for a custom ID.
+        pub version_from_prototools: ToolchainPluginVersionFrom,
+
         /// Arbitrary configuration that'll be passed to the WASM plugin.
         #[setting(flatten)]
         pub config: BTreeMap<String, Value>,

crates/config/src/toolchain_config.rs

@@ -242,7 +242,45 @@ impl ToolchainConfig {
         false
     }
 
+    pub fn inherit_proto_for_plugins(
+        &mut self,
+        proto_config: &proto_core::ProtoConfig,
+    ) -> miette::Result<()> {
+        use moon_common::color;
+        use tracing::trace;
+
+        for (id, config) in &mut self.plugins {
+            if config.version.is_some() {
+                continue;
+            }
+
+            let proto_id = match &config.version_from_prototools {
+                ToolchainPluginVersionFrom::Enabled(enabled) => {
+                    if *enabled {
+                        id.as_str().strip_prefix("unstable_").unwrap_or(id.as_str())
+                    } else {
+                        continue;
+                    }
+                }
+                ToolchainPluginVersionFrom::Id(custom_id) => custom_id,
+            };
+
+            if let Some(version) = proto_config.versions.get(proto_id) {
+                trace!(
+                    "Inheriting {} version {} from .prototools",
+                    color::id(id),
+                    version
+                );
+
+                config.version = Some(version.req.to_owned());
+            }
+        }
+
+        Ok(())
+    }
+
     pub fn inherit_proto(&mut self, proto_config: &proto_core::ProtoConfig) -> miette::Result<()> {
+        self.inherit_proto_for_plugins(proto_config)?;
         self.inherit_proto_bun(proto_config)?;
         self.inherit_proto_deno(proto_config)?;
         self.inherit_proto_node(proto_config)?;
@@ -285,7 +323,7 @@ impl ToolchainConfig {
             use tracing::warn;
 
             warn!(
-                "The legacy Rust toolchain and WASM based Rust toolchain must not be used together"
+                "The legacy Rust toolchain and WASM based Rust toolchain must not be used together!"
             );
         }
 

crates/config/tests/project_config_test.rs

@@ -677,10 +677,9 @@ toolchain:
             assert_eq!(
                 config.toolchain.plugins.get("example").unwrap(),
                 &ProjectToolchainEntry::Config(ToolchainPluginConfig {
-                    disabled: false,
-                    plugin: None,
                     version: Some(UnresolvedVersionSpec::parse("1.2.3").unwrap()),
                     config: BTreeMap::from_iter([("custom".into(), serde_json::Value::Bool(true))]),
+                    ..Default::default()
                 })
             );
         }
@@ -794,13 +793,11 @@ workspace:
                         plugins: FxHashMap::from_iter([(
                             Id::raw("typescript"),
                             ProjectToolchainEntry::Config(ToolchainPluginConfig {
-                                disabled: false,
-                                plugin: None,
-                                version: None,
                                 config: BTreeMap::from_iter([(
                                     "includeSharedTypes".into(),
                                     serde_json::Value::Bool(true)
                                 )]),
+                                ..Default::default()
                             })
                         )]),
                         ..Default::default()

crates/config/tests/toolchain_config_test.rs

@@ -3,8 +3,9 @@ mod utils;
 use httpmock::prelude::*;
 use moon_config::{
     BinConfig, BinEntry, ConfigLoader, NodePackageManager, NodeVersionFormat, ToolchainConfig,
+    ToolchainPluginConfig,
 };
-use proto_core::{Id, ProtoConfig, UnresolvedVersionSpec};
+use proto_core::{Id, PluginLocator, ProtoConfig, UnresolvedVersionSpec, warpgate::FileLocator};
 use schematic::ConfigLoader as BaseLoader;
 use serde_json::Value;
 use serial_test::serial;
@@ -1373,6 +1374,144 @@ typescript:
         }
     }
 
+    mod plugin {
+        use super::*;
+
+        #[test]
+        fn uses_defaults() {
+            let config = test_load_config(
+                FILENAME,
+                r"
+plugin:
+  plugin: file://example.wasm
+",
+                |path| load_config_from_root(path, &ProtoConfig::default()),
+            );
+
+            let cfg = config.plugins.get("plugin").unwrap();
+
+            assert_eq!(
+                cfg,
+                &ToolchainPluginConfig {
+                    plugin: Some(PluginLocator::File(Box::new(FileLocator {
+                        file: "file://example.wasm".into(),
+                        path: None
+                    }))),
+                    ..Default::default()
+                }
+            );
+        }
+
+        #[test]
+        fn inherits_proto_version() {
+            let config = test_load_config(
+                FILENAME,
+                r"
+plugin:
+  plugin: file://example.wasm
+",
+                |path| {
+                    let mut proto = ProtoConfig::default();
+                    proto.versions.insert(
+                        Id::raw("plugin"),
+                        UnresolvedVersionSpec::parse("1.0.0").unwrap().into(),
+                    );
+
+                    load_config_from_root(path, &proto)
+                },
+            );
+
+            let cfg = config.plugins.get("plugin").unwrap();
+
+            assert_eq!(
+                cfg.version.as_ref().unwrap(),
+                &UnresolvedVersionSpec::parse("1.0.0").unwrap()
+            );
+        }
+
+        #[test]
+        fn inherits_proto_version_with_different_id() {
+            let config = test_load_config(
+                FILENAME,
+                r"
+plugin:
+  plugin: file://example.wasm
+  versionFromPrototools: 'plugin-other'
+",
+                |path| {
+                    let mut proto = ProtoConfig::default();
+                    proto.versions.insert(
+                        Id::raw("plugin-other"),
+                        UnresolvedVersionSpec::parse("1.0.0").unwrap().into(),
+                    );
+
+                    load_config_from_root(path, &proto)
+                },
+            );
+
+            let cfg = config.plugins.get("plugin").unwrap();
+
+            assert_eq!(
+                cfg.version.as_ref().unwrap(),
+                &UnresolvedVersionSpec::parse("1.0.0").unwrap()
+            );
+        }
+
+        #[test]
+        fn doesnt_inherit_proto_version_when_disabled() {
+            let config = test_load_config(
+                FILENAME,
+                r"
+plugin:
+  plugin: file://example.wasm
+  versionFromPrototools: false
+",
+                |path| {
+                    let mut proto = ProtoConfig::default();
+                    proto.versions.insert(
+                        Id::raw("plugin"),
+                        UnresolvedVersionSpec::parse("1.0.0").unwrap().into(),
+                    );
+
+                    load_config_from_root(path, &proto)
+                },
+            );
+
+            let cfg = config.plugins.get("plugin").unwrap();
+
+            assert!(cfg.version.is_none());
+        }
+
+        #[test]
+        #[serial]
+        fn proto_version_doesnt_override() {
+            let config = test_load_config(
+                FILENAME,
+                r"
+plugin:
+  plugin: file://example.wasm
+  version: 1.0.0
+",
+                |path| {
+                    let mut proto = ProtoConfig::default();
+                    proto.versions.insert(
+                        Id::raw("plugin"),
+                        UnresolvedVersionSpec::parse("2.0.0").unwrap().into(),
+                    );
+
+                    load_config_from_root(path, &proto)
+                },
+            );
+
+            let cfg = config.plugins.get("plugin").unwrap();
+
+            assert_eq!(
+                cfg.version.as_ref().unwrap(),
+                &UnresolvedVersionSpec::parse("1.0.0").unwrap()
+            );
+        }
+    }
+
     mod pkl {
         use super::*;
         use moon_config::*;

packages/types/src/project-config.ts

@@ -147,6 +147,8 @@ export interface ProjectToolchainCommonToolConfig {
 	version: UnresolvedVersionSpec | null;
 }
 
+export type ToolchainPluginVersionFrom = boolean | string;
+
 export type ProjectToolchainEntry = null | boolean | ToolchainPluginConfig;
 
 /** Overrides top-level toolchain settings, scoped to this project. */

packages/types/src/toolchain-config.ts

@@ -263,6 +263,8 @@ export interface NodeConfig {
 	yarn: YarnConfig | null;
 }
 
+export type ToolchainPluginVersionFrom = boolean | string;
+
 /** Configures an individual toolchain. */
 export interface ToolchainPluginConfig {
 	/** Arbitrary configuration that'll be passed to the WASM plugin. */
@@ -272,6 +274,12 @@ export interface ToolchainPluginConfig {
 	plugin: PluginLocator | null;
 	/** The version of the toolchain to download and install. */
 	version: UnresolvedVersionSpec | null;
+	/**
+	 * Inherit the version from the root `.prototools`.
+	 * When true, matches using the same ID, otherwise a
+	 * string can be provided for a custom ID.
+	 */
+	versionFromPrototools: ToolchainPluginVersionFrom;
 }
 
 /** The available package managers for Python. */
@@ -626,6 +634,12 @@ export interface PartialToolchainPluginConfig {
 	plugin?: PluginLocator | null;
 	/** The version of the toolchain to download and install. */
 	version?: UnresolvedVersionSpec | null;
+	/**
+	 * Inherit the version from the root `.prototools`.
+	 * When true, matches using the same ID, otherwise a
+	 * string can be provided for a custom ID.
+	 */
+	versionFromPrototools?: ToolchainPluginVersionFrom | null;
 }
 
 export interface PartialPipConfig {

website/static/schemas/project.json

@@ -1613,10 +1613,32 @@
               "type": "null"
             }
           ]
+        },
+        "versionFromPrototools": {
+          "title": "versionFromPrototools",
+          "description": "Inherit the version from the root .prototools. When true, matches using the same ID, otherwise a string can be provided for a custom ID.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/ToolchainPluginVersionFrom"
+            }
+          ],
+          "markdownDescription": "Inherit the version from the root `.prototools`. When true, matches using the same ID, otherwise a string can be provided for a custom ID."
         }
       },
       "additionalProperties": false
     },
+    "ToolchainPluginVersionFrom": {
+      "description": "Strategy in which to inherit a version from .prototools.",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string"
+        }
+      ],
+      "markdownDescription": "Strategy in which to inherit a version from `.prototools`."
+    },
     "UnresolvedVersionSpec": {
       "description": "Represents an unresolved version or alias that must be resolved to a fully-qualified version.",
       "type": "string",