vx-tool-bun 0.4.0

Bun package manager support for vx
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Bun package manager support for vx
//!
//! This provides Bun package manager integration for the vx tool.

use anyhow::Result;
use std::path::Path;
use vx_plugin::{Ecosystem, PackageSpec, VxPackageManager, VxPlugin, VxTool};

/// Bun package manager implementation
#[derive(Default)]
pub struct BunPackageManager;

#[async_trait::async_trait]
impl VxPackageManager for BunPackageManager {
    fn name(&self) -> &str {
        "bun"
    }

    fn ecosystem(&self) -> Ecosystem {
        Ecosystem::Node
    }

    fn description(&self) -> &str {
        "Incredibly fast JavaScript runtime, bundler, test runner, and package manager"
    }

    /// Detect if this is a bun project by looking for bun.lockb
    fn is_preferred_for_project(&self, project_path: &Path) -> bool {
        project_path.join("bun.lockb").exists()
    }

    fn get_config_files(&self) -> Vec<&str> {
        vec!["package.json", "bun.lockb", "bunfig.toml"]
    }

    async fn install_packages(&self, packages: &[PackageSpec], project_path: &Path) -> Result<()> {
        if packages.is_empty() {
            self.run_command(&["install"], &[], project_path).await
        } else {
            let package_names: Vec<String> = packages
                .iter()
                .map(|pkg| {
                    if let Some(version) = &pkg.version {
                        format!("{}@{}", pkg.name, version)
                    } else {
                        pkg.name.clone()
                    }
                })
                .collect();

            let command = if packages.iter().any(|pkg| pkg.dev_dependency) {
                vec!["add", "--dev"]
            } else {
                vec!["add"]
            };

            self.run_command(&command, &package_names, project_path)
                .await
        }
    }

    async fn remove_packages(&self, packages: &[String], project_path: &Path) -> Result<()> {
        self.run_command(&["remove"], packages, project_path).await
    }

    async fn update_packages(&self, packages: &[String], project_path: &Path) -> Result<()> {
        if packages.is_empty() {
            self.run_command(&["update"], &[], project_path).await
        } else {
            self.run_command(&["update"], packages, project_path).await
        }
    }
}

/// Bun plugin
#[derive(Default)]
pub struct BunPlugin;

#[async_trait::async_trait]
impl VxPlugin for BunPlugin {
    fn name(&self) -> &str {
        "bun"
    }

    fn description(&self) -> &str {
        "Bun package manager support for vx"
    }

    fn version(&self) -> &str {
        "1.0.0"
    }

    fn tools(&self) -> Vec<Box<dyn VxTool>> {
        vec![]
    }

    fn package_managers(&self) -> Vec<Box<dyn VxPackageManager>> {
        vec![Box::new(BunPackageManager)]
    }

    fn supports_tool(&self, _tool_name: &str) -> bool {
        false
    }
}

/// Factory function to create the plugin
pub fn create_bun_plugin() -> Box<dyn VxPlugin> {
    Box::new(BunPlugin)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_bun_package_manager() {
        let pm = BunPackageManager;
        assert_eq!(pm.name(), "bun");
        assert_eq!(pm.ecosystem(), Ecosystem::Node);
        assert_eq!(
            pm.description(),
            "Incredibly fast JavaScript runtime, bundler, test runner, and package manager"
        );
    }

    #[test]
    fn test_bun_plugin() {
        let plugin = BunPlugin;
        assert_eq!(plugin.name(), "bun");
        assert_eq!(plugin.version(), "1.0.0");
    }
}