feat(node): support packages with multiple executables (#1226)

* feat(runner): add support for npm package executable names

* feat: finish implementing executable names

* fix: working support for deno

* refactor: temporarily disable yarn tests

* refactor(codegen): support disabling homebrew install

Author: hougesen

.github/workflows/test.yml

@@ -89,6 +89,8 @@ jobs:
       - run: curl -LsSf https://github.com/posit-dev/air/releases/latest/download/air-installer.sh | sh
       - name: actionlint
         run: ( ( which actionlint ) || ( ( which brew &&  brew install actionlint ) || ( which go && go install github.com/rhysd/actionlint/cmd/actionlint@latest ) ) || ( echo "Unable to install tool" ) )
+      - name: air
+        run: ( ( which air ) || ( ( which brew &&  brew install air ) ) || ( echo "Unable to install tool" ) )
       - name: alejandra
         run: ( ( which alejandra ) || ( ( which cargo && ( cargo binstall alejandra || cargo install alejandra ) ) ) || ( echo "Unable to install tool" ) )
       - name: alex
@@ -131,6 +133,8 @@ jobs:
         run: ( ( which csscomb ) || ( ( which npm && npm i -g csscomb ) ) || ( echo "Unable to install tool" ) )
       - name: csslint
         run: ( ( which csslint ) || ( ( which npm && npm i -g csslint ) ) || ( echo "Unable to install tool" ) )
+      - name: deno
+        run: ( ( which deno ) || ( ( which cargo && ( cargo binstall deno || cargo install deno ) ) || ( which brew &&  brew install deno ) ) || ( echo "Unable to install tool" ) )
       - name: dfmt
         run: ( ( which dfmt ) || ( ( which brew &&  brew install dfmt ) ) || ( echo "Unable to install tool" ) )
       - name: dockerfmt
@@ -331,6 +335,8 @@ jobs:
         run: ( ( which toml-sort ) || ( ( which pipx && pipx install toml-sort ) ) || ( echo "Unable to install tool" ) )
       - name: topiary
         run: ( ( which topiary ) || ( ( which cargo && ( cargo binstall topiary-cli || cargo install topiary-cli ) ) ) || ( echo "Unable to install tool" ) )
+      - name: tsp
+        run: ( ( which tsp ) || ( ( which npm && npm i -g @typespec/compiler ) ) || ( echo "Unable to install tool" ) )
       - name: ty
         run: ( ( which ty ) || ( ( which pipx && pipx install ty ) ) || ( echo "Unable to install tool" ) )
       - name: typos

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file. Dates are d
 
 #### [Unreleased](https://github.com/hougesen/mdsf/compare/v0.10.4...HEAD)
 
+- feat(node): support packages with multiple executables [`#1226`](https://github.com/hougesen/mdsf/pull/1226)
+- build(deps-dev): bump typescript from 5.8.3 to 5.9.2 in /mdsf-vscode [`#1221`](https://github.com/hougesen/mdsf/pull/1221)
+- build(deps-dev): bump @typescript-eslint/eslint-plugin in /mdsf-vscode [`#1223`](https://github.com/hougesen/mdsf/pull/1223)
+- build(deps-dev): bump @biomejs/biome in /github-action [`#1224`](https://github.com/hougesen/mdsf/pull/1224)
+- build(deps-dev): bump @biomejs/biome from 2.1.2 to 2.1.3 in /mdsf-vscode [`#1225`](https://github.com/hougesen/mdsf/pull/1225)
+- build(deps-dev): bump @typescript-eslint/parser in /mdsf-vscode [`#1222`](https://github.com/hougesen/mdsf/pull/1222)
+- build(cargo-dist): bump version to v0.29.0 [`#1220`](https://github.com/hougesen/mdsf/pull/1220)
 - build(deps): bump serde_json from 1.0.141 to 1.0.142 [`#1219`](https://github.com/hougesen/mdsf/pull/1219)
 - build(deps): bump clap from 4.5.41 to 4.5.42 [`#1218`](https://github.com/hougesen/mdsf/pull/1218)
 

codegen/src/actions/packages.rs

@@ -40,7 +40,11 @@ fn generate_brew(tool: &ToolPackagesBrew) -> String {
         .map(|tap| format!("brew tap {tap} &&"))
         .unwrap_or_default();
 
-    format!("( which brew && {} brew install {} )", tap, tool.package)
+    let package_name = &tool.package;
+
+    let cask = if tool.cask { "--cask " } else { "" };
+
+    format!("( which brew && {tap} brew install {cask}{package_name} )")
 }
 
 fn generate_luarocks(tool: &str) -> String {
@@ -106,7 +110,9 @@ pub fn generate_install_steps(tools: &Vec<Tool>) -> Vec<WorkflowJobsStep> {
         }
 
         if let Some(brew) = &tool.packages.brew {
-            install_options.push(generate_brew(brew));
+            if !brew.skip_brew_install {
+                install_options.push(generate_brew(brew));
+            }
         }
 
         if let Some(apt) = &tool.packages.apt {

codegen/src/tools.rs

@@ -58,6 +58,12 @@ pub struct ToolPackagesApt {
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema, Clone, Default, serde::Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct ToolPackagesBrew {
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub cask: bool,
+
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub skip_brew_install: bool,
+
     pub package: String,
 
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -138,7 +144,26 @@ pub struct ToolPackagesNimble {
 
 #[derive(Debug, serde::Deserialize, schemars::JsonSchema, Clone, Default, serde::Serialize)]
 #[serde(deny_unknown_fields)]
+#[allow(clippy::struct_excessive_bools)]
 pub struct ToolPackagesNpm {
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub disable_bunx: bool,
+
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub disable_deno_run: bool,
+
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub disable_npx: bool,
+
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub disable_pnpm_dlx: bool,
+
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub disable_yarn_exec: bool,
+
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub executable: Option<String>,
+
     pub package: String,
 }
 
@@ -388,6 +413,7 @@ impl Tool {
     }
 
     #[allow(clippy::too_many_lines)]
+    #[allow(clippy::cognitive_complexity)]
     fn generate(&self) -> Vec<GeneratedCommand> {
         let mut all_commands = Vec::new();
 
@@ -411,28 +437,56 @@ impl Tool {
                 command_types.push(format!("CommandType::Direct(\"{}\")", self.binary));
 
                 if let Some(npm) = &self.packages.npm {
-                    command_types.push(format!("CommandType::Npm(\"{}\")", &npm.package));
+                    let package_name = &npm.package;
+                    let executable_name = npm.executable.as_ref().unwrap_or(&npm.package);
+
+                    let mut flavors = Vec::new();
 
-                    command_types.push(format!("CommandType::Pnpm(\"{}\")", &npm.package));
+                    if !npm.disable_npx {
+                        flavors.push("Npm");
+                    }
 
-                    command_types.push(format!("CommandType::Bun(\"{}\")", &npm.package));
+                    if !npm.disable_pnpm_dlx {
+                        flavors.push("Pnpm");
+                    }
 
-                    command_types.push(format!("CommandType::Deno(\"{}\")", &npm.package));
+                    if !npm.disable_bunx {
+                        flavors.push("Bun");
+                    }
+
+                    if !npm.disable_deno_run {
+                        flavors.push("Deno");
+                    }
 
-                    command_types.push(format!("CommandType::Yarn(\"{}\")", &npm.package));
+                    if !npm.disable_yarn_exec {
+                        flavors.push("Yarn");
+                    }
+
+                    for flavor in flavors {
+                        command_types.push(format!(
+                            "CommandType::{flavor}(\"{package_name}\", \"{executable_name}\")"
+                        ));
+                    }
                 }
 
                 if let Some(pip) = &self.packages.pip {
+                    let package_name = &pip.package;
+                    let executable_name = pip.executable.as_ref().unwrap_or(&pip.package);
+
+                    let mut flavors = Vec::new();
+
                     if !pip.disable_uv_tool_run {
-                        command_types.push(format!(
-                            "CommandType::Uv(\"{}\", \"{}\")",
-                            &pip.package,
-                            &pip.executable.clone().as_ref().unwrap_or(&pip.package)
-                        ));
+                        flavors.push("Uv");
                     }
 
                     if !pip.disable_pipx_run {
-                        command_types.push(format!("CommandType::Pipx(\"{}\")", &pip.package));
+                        flavors.push("Pipx");
+                    }
+
+                    for flavor in flavors {
+                        command_types.push(format!(
+                            "CommandType::{flavor}(\"{package_name}\", \"{executable_name}\")"
+                        ));
                     }
                 }
 

github-action/biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.1.2/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.1.3/schema.json",
   "assist": {
     "actions": {
       "source": {

mdsf-vscode/biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.1.2/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.1.3/schema.json",
   "assist": {
     "actions": {
       "source": {

mdsf/src/execution/mod.rs

@@ -423,7 +423,10 @@ mod test_run_tools {
     #[test]
     fn it_should_skip_if_bun_runner_is_disabled() -> Result<(), MdsfError> {
         let (was_not_modified, _) = super::run_tools(
-            &[CommandType::Bun("thisbinarydoesnotexist")],
+            &[CommandType::Bun(
+                "thisbinarydoesnotexist",
+                "thisbinarydoesnotexist",
+            )],
             std::path::Path::new("thisdoesnotexist"),
             |_, _| unreachable!(),
             crate::testing::DEFAULT_TEST_FORMATTER_TIMEOUT,
@@ -452,7 +455,10 @@ mod test_run_tools {
     #[test]
     fn it_should_skip_if_deno_runner_is_disabled() -> Result<(), MdsfError> {
         let (was_not_modified, _) = super::run_tools(
-            &[CommandType::Deno("thisbinarydoesnotexist")],
+            &[CommandType::Deno(
+                "thisbinarydoesnotexist",
+                "thisbinarydoesnotexist",
+            )],
             std::path::Path::new("thisdoesnotexist"),
             |_, _| unreachable!(),
             crate::testing::DEFAULT_TEST_FORMATTER_TIMEOUT,
@@ -572,7 +578,10 @@ mod test_run_tools {
     #[test]
     fn it_should_skip_if_npx_runner_is_disabled() -> Result<(), MdsfError> {
         let (was_not_modified, _) = super::run_tools(
-            &[CommandType::Npm("thisbinarydoesnotexist")],
+            &[CommandType::Npm(
+                "thisbinarydoesnotexist",
+                "thisbinarydoesnotexist",
+            )],
             std::path::Path::new("thisdoesnotexist"),
             |_, _| unreachable!(),
             crate::testing::DEFAULT_TEST_FORMATTER_TIMEOUT,
@@ -602,7 +611,10 @@ mod test_run_tools {
     #[test]
     fn it_should_skip_if_pipx_runner_is_disabled() -> Result<(), MdsfError> {
         let (was_not_modified, _) = super::run_tools(
-            &[CommandType::Pipx("thisbinarydoesnotexist")],
+            &[CommandType::Pipx(
+                "thisbinarydoesnotexist",
+                "thisbinarydoesnotexist",
+            )],
             std::path::Path::new("thisdoesnotexist"),
             |_, _| unreachable!(),
             crate::testing::DEFAULT_TEST_FORMATTER_TIMEOUT,
@@ -632,7 +644,10 @@ mod test_run_tools {
     #[test]
     fn it_should_skip_if_pnpm_runner_is_disabled() -> Result<(), MdsfError> {
         let (was_not_modified, _) = super::run_tools(
-            &[CommandType::Pnpm("thisbinarydoesnotexist")],
+            &[CommandType::Pnpm(
+                "thisbinarydoesnotexist",
+                "thisbinarydoesnotexist",
+            )],
             std::path::Path::new("thisdoesnotexist"),
             |_, _| unreachable!(),
             crate::testing::DEFAULT_TEST_FORMATTER_TIMEOUT,
@@ -695,7 +710,10 @@ mod test_run_tools {
     #[test]
     fn it_should_skip_if_yarn_runner_is_disabled() -> Result<(), MdsfError> {
         let (was_not_modified, _) = super::run_tools(
-            &[CommandType::Yarn("thisbinarydoesnotexist")],
+            &[CommandType::Yarn(
+                "thisbinarydoesnotexist",
+                "thisbinarydoesnotexist",
+            )],
             std::path::Path::new("thisdoesnotexist"),
             |_, _| unreachable!(),
             crate::testing::DEFAULT_TEST_FORMATTER_TIMEOUT,

mdsf/src/runners/bun.rs

@@ -1,10 +1,11 @@
 #[inline]
-pub fn setup_bunx_command(package_name: &str) -> std::process::Command {
+pub fn setup_bunx_command(package_name: &str, _executable_name: &str) -> std::process::Command {
     let mut cmd = std::process::Command::new("bunx");
 
     // Auto install package
     cmd.arg("--yes");
 
+    // TODO: figure out how to actually select executable using bun
     cmd.arg(package_name);
 
     cmd
@@ -15,15 +16,16 @@ mod test_bun {
     #[test_with::executable(bunx)]
     #[test]
     fn it_can_execute_an_npm_package_script() {
-        let input = "";
+        let input = "[1,2,3,4,5,6]";
+        let output = "[1, 2, 3, 4, 5, 6]\n";
 
         let file_ext = crate::filetype::get_file_extension("json");
 
         let snippet =
             crate::execution::setup_snippet(input, &file_ext).expect("it to create a snippet file");
 
-        crate::execution::run_tools(
-            &[crate::runners::CommandType::Bun("prettier")],
+        let result = crate::execution::run_tools(
+            &[crate::runners::CommandType::Bun("prettier", "prettier")],
             snippet.path(),
             crate::tools::prettier::set_args,
             crate::testing::DEFAULT_TEST_FORMATTER_TIMEOUT,
@@ -34,6 +36,50 @@ mod test_bun {
                 ..Default::default()
             },
         )
-        .expect("it to succeed");
+        .expect("it to succeed")
+        .1
+        .expect("it to be some");
+
+        assert_eq!(result, output);
+    }
+
+    #[test_with::executable(bunx)]
+    #[test]
+    fn it_works_with_executable_name() {
+        let input = r#"model Pet {  name: string;  age: int32;kind: "dog" | "cat" | "fish";}
+"#;
+
+        let output = r#"model Pet {
+  name: string;
+  age: int32;
+  kind: "dog" | "cat" | "fish";
+}
+"#;
+
+        let file_ext = crate::filetype::get_file_extension("typespec");
+
+        let snippet =
+            crate::execution::setup_snippet(input, &file_ext).expect("it to create a snippet file");
+
+        let result = crate::execution::run_tools(
+            &[crate::runners::CommandType::Bun(
+                "@typespec/compiler",
+                "tsp",
+            )],
+            snippet.path(),
+            crate::tools::tsp_format::set_args,
+            crate::testing::DEFAULT_TEST_FORMATTER_TIMEOUT,
+            crate::tools::tsp_format::IS_STDIN,
+            crate::testing::DEFAULT_TEST_DEBUG_ENABLED,
+            &crate::config::MdsfConfigRunners {
+                bunx: true,
+                ..Default::default()
+            },
+        )
+        .expect("it to be successful")
+        .1
+        .expect("it to be some");
+
+        assert_eq!(result, output);
     }
 }

mdsf/src/runners/composer.rs

@@ -6,7 +6,7 @@ pub fn setup_php_vender_bin_command(binary_name: &str) -> std::process::Command
 }
 
 #[cfg(test)]
-mod test_mago_format {
+mod test_composer {
     #[test_with::executable(./vendor/bin/mago)]
     fn test_composer_path() {
         let input = r#"<?php
@@ -28,7 +28,18 @@ echo 'Hello World!';
             crate::testing::DEFAULT_TEST_FORMATTER_TIMEOUT,
             crate::tools::mago_format::IS_STDIN,
             crate::testing::DEFAULT_TEST_DEBUG_ENABLED,
-            &crate::config::MdsfConfigRunners::default(),
+            &crate::config::MdsfConfigRunners {
+                bunx: false,
+                deno: false,
+                dotnet: false,
+                dub: false,
+                gem_exec: false,
+                npx: false,
+                pipx: false,
+                pnpm: false,
+                uv: false,
+                yarn: false,
+            },
         )
         .expect("it to be successful")
         .1