@devaloop/devalang 0.0.1-beta.3 → 0.1.1

package/rust/cli/addon/download.rs

@@ -1,234 +0,0 @@
-use crate::{
-    cli::addon::{metadata::AddonToDownloadMetadata, utils::ask_api_for_signed_url},
-    config::ops::load_config,
-    web::cdn::download_from_cdn,
-};
-use devalang_core::config::driver::{ProjectConfig, ProjectConfigExt};
-use devalang_types::{AddonType, ProjectConfigBankEntry, ProjectConfigPluginEntry};
-use devalang_utils::{
-    file::extract_zip_safely,
-    logger::{LogLevel, Logger},
-    spinner::start_spinner,
-};
-use std::fs;
-
-pub async fn download_addon(
-    slug: &str,
-    addon_metadata: &AddonToDownloadMetadata,
-) -> Result<(), String> {
-    let logger = Logger::new();
-    let deva_dir = devalang_utils::path::ensure_deva_dir()?;
-
-    let target_dir = match addon_metadata.addon_type {
-        AddonType::Bank => deva_dir.join("banks"),
-        AddonType::Plugin => deva_dir.join("plugins"),
-        AddonType::Preset => deva_dir.join("presets"),
-        AddonType::Template => deva_dir.join("templates"),
-    };
-
-    if !target_dir.exists() {
-        fs::create_dir_all(&target_dir).map_err(|e| {
-            format!(
-                "Failed to create target dir '{}': {}",
-                target_dir.display(),
-                e
-            )
-        })?;
-    }
-
-    let user_provided_publisher = slug.contains('.');
-    let display_name = if user_provided_publisher {
-        format!("{}.{}", addon_metadata.publisher, addon_metadata.name)
-    } else {
-        addon_metadata.name.clone()
-    };
-
-    let archive_path = {
-        let tmp_root = deva_dir.join("tmp");
-        if !tmp_root.exists() {
-            fs::create_dir_all(&tmp_root)
-                .map_err(|e| format!("Failed to create tmp dir '{}': {}", tmp_root.display(), e))?;
-        }
-        tmp_root.join(&display_name).with_extension("tar.gz")
-    };
-
-    if let Some(parent) = archive_path.parent() {
-        if !parent.exists() {
-            fs::create_dir_all(parent)
-                .map_err(|e| format!("Failed to prepare tmp dir '{}': {}", parent.display(), e))?;
-        }
-    }
-
-    let extract_path = target_dir
-        .join(&addon_metadata.publisher)
-        .join(&addon_metadata.name);
-
-    let signed_url = {
-        let spinner =
-            start_spinner(format!("Requesting download link for {}", display_name).as_str());
-        let request = if user_provided_publisher {
-            ask_api_for_signed_url(
-                addon_metadata.addon_type.clone(),
-                addon_metadata.publisher.clone(),
-                &addon_metadata.name,
-            )
-        } else {
-            ask_api_for_signed_url(
-                addon_metadata.addon_type.clone(),
-                String::new(),
-                &addon_metadata.name,
-            )
-        };
-
-        match request.await {
-            Ok(url) => url,
-            Err(err) => {
-                let message = format!("Failed to obtain download link: {}", err);
-                println!("{}", message);
-                return Err(message);
-            }
-        }
-    };
-
-    let config_path = devalang_utils::path::get_devalang_config_path()?;
-    let mut config = load_config(Some(&config_path))
-        .ok_or_else(|| format!("Failed to load config from '{}'", config_path.display()))?;
-
-    if extract_path.exists() {
-        logger.log_message(
-            LogLevel::Info,
-            format!(
-                "Addon '{}' already present at {}",
-                display_name.as_str(),
-                extract_path.display()
-            )
-            .as_str(),
-        );
-
-        if ensure_config_entry(&mut config, addon_metadata) {
-            if let Err(err) = config.write_config(&config) {
-                logger.log_message(
-                    LogLevel::Error,
-                    format!("Failed to write config: {}", err).as_str(),
-                );
-            }
-        }
-
-        if matches!(
-            addon_metadata.addon_type,
-            AddonType::Preset | AddonType::Template
-        ) {
-            logger.log_message(
-                LogLevel::Info,
-                "Presets and templates are not tracked in project config yet.",
-            );
-        }
-
-        return Ok(());
-    }
-
-    let download_spinner = start_spinner("Downloading archive...");
-    match download_from_cdn(&signed_url, &archive_path).await {
-        Ok(_) => println!("Downloaded archive to {}", archive_path.display()),
-        Err(err) => {
-            let message = format!("Failed to download archive: {}", err);
-            println!("{}", message);
-            return Err(message);
-        }
-    }
-
-    let extract_spinner = start_spinner("Extracting archive");
-    match extract_zip_safely(&archive_path, &extract_path) {
-        Ok(_) => println!("Installed at {}", extract_path.display()),
-        Err(err) => {
-            println!("Failed to extract archive: {}", err);
-            return Err(err);
-        }
-    }
-
-    let mut config_updated = false;
-    if ensure_config_entry(&mut config, addon_metadata) {
-        match config.write_config(&config) {
-            Ok(_) => {
-                config_updated = true;
-            }
-            Err(err) => {
-                logger.log_message(
-                    LogLevel::Error,
-                    format!("Failed to write config: {}", err).as_str(),
-                );
-            }
-        }
-    }
-
-    logger.log_message(
-        LogLevel::Info,
-        format!(
-            "Addon '{}' installed at {}",
-            display_name,
-            extract_path.display()
-        )
-        .as_str(),
-    );
-
-    if config_updated {
-        logger.log_message(LogLevel::Info, "Project config updated");
-    } else if matches!(
-        addon_metadata.addon_type,
-        AddonType::Preset | AddonType::Template
-    ) {
-        logger.log_message(
-            LogLevel::Info,
-            "Presets and templates are not tracked in project config yet.",
-        );
-    }
-
-    // Cleanup temporary files used during download/install
-    if let Err(err) = devalang_utils::file::clear_tmp_folder() {
-        logger.log_message(
-            LogLevel::Warning,
-            format!("Failed to clear tmp folder: {}", err).as_str(),
-        );
-    }
-
-    Ok(())
-}
-
-fn ensure_config_entry(
-    config: &mut ProjectConfig,
-    addon_metadata: &AddonToDownloadMetadata,
-) -> bool {
-    match addon_metadata.addon_type {
-        AddonType::Bank => {
-            let dependency_path = format!(
-                "devalang://bank/{}/{}",
-                addon_metadata.publisher, addon_metadata.name
-            );
-            let banks = config.banks.get_or_insert_with(Vec::new);
-            if banks.iter().any(|entry| entry.path == dependency_path) {
-                false
-            } else {
-                banks.push(ProjectConfigBankEntry {
-                    path: dependency_path,
-                });
-                true
-            }
-        }
-        AddonType::Plugin => {
-            let dependency_path = format!(
-                "devalang://plugin/{}/{}",
-                addon_metadata.publisher, addon_metadata.name
-            );
-            let plugins = config.plugins.get_or_insert_with(Vec::new);
-            if plugins.iter().any(|entry| entry.path == dependency_path) {
-                false
-            } else {
-                plugins.push(ProjectConfigPluginEntry {
-                    path: dependency_path,
-                });
-                true
-            }
-        }
-        AddonType::Preset | AddonType::Template => false,
-    }
-}

package/rust/cli/addon/install.rs

@@ -1,33 +0,0 @@
-use devalang_utils::logger::Logger;
-
-use crate::cli::addon::{download::download_addon, metadata::get_addon_from_api};
-
-pub async fn install_addon(slug: String, no_clear_tmp: bool) -> Result<(), String> {
-    let addon_metadata = get_addon_from_api(&slug).await?;
-
-    if let Err(e) = download_addon(&slug, &addon_metadata).await {
-        eprintln!("Failed to download addon '{}': {}", slug, e);
-    }
-
-    let logger = Logger::new();
-    logger.log_message(
-        devalang_utils::logger::LogLevel::Success,
-        &format!(
-            "Successfully installed addon '{}.{}' ({})",
-            addon_metadata.publisher,
-            addon_metadata.name,
-            match addon_metadata.addon_type {
-                devalang_types::AddonType::Bank => "bank",
-                devalang_types::AddonType::Plugin => "plugin",
-                devalang_types::AddonType::Preset => "preset",
-                devalang_types::AddonType::Template => "template",
-            }
-        ),
-    );
-
-    if !no_clear_tmp {
-        let _ = devalang_utils::file::clear_tmp_folder();
-    }
-
-    Ok(())
-}

package/rust/cli/addon/list.rs

@@ -1,224 +0,0 @@
-use devalang_utils::logger::{LogLevel, Logger};
-
-#[derive(Clone)]
-struct InstalledAddon {
-    name: String,
-    addon_type: String,
-}
-
-pub async fn list_addons() -> Result<(), String> {
-    let deva_dir = devalang_utils::path::ensure_deva_dir()?;
-    let banks_dir = deva_dir.join("banks");
-    let plugins_dir = deva_dir.join("plugins");
-    let presets_dir = deva_dir.join("presets");
-    let templates_dir = deva_dir.join("templates");
-
-    let mut installed_addons = Vec::new();
-
-    if banks_dir.exists() {
-        if let Ok(entries) = std::fs::read_dir(&banks_dir) {
-            for entry in entries.flatten() {
-                if let Ok(file_type) = entry.file_type() {
-                    if file_type.is_dir() {
-                        if let Some(name) = entry.file_name().to_str() {
-                            installed_addons.push(InstalledAddon {
-                                name: name.to_string(),
-                                addon_type: "bank".to_string(),
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    if plugins_dir.exists() {
-        if let Ok(entries) = std::fs::read_dir(&plugins_dir) {
-            for entry in entries.flatten() {
-                if let Ok(file_type) = entry.file_type() {
-                    if file_type.is_dir() {
-                        if let Some(name) = entry.file_name().to_str() {
-                            installed_addons.push(InstalledAddon {
-                                name: name.to_string(),
-                                addon_type: "plugin".to_string(),
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    if presets_dir.exists() {
-        if let Ok(entries) = std::fs::read_dir(&presets_dir) {
-            for entry in entries.flatten() {
-                if let Ok(file_type) = entry.file_type() {
-                    if file_type.is_dir() {
-                        if let Some(name) = entry.file_name().to_str() {
-                            installed_addons.push(InstalledAddon {
-                                name: name.to_string(),
-                                addon_type: "preset".to_string(),
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    if templates_dir.exists() {
-        if let Ok(entries) = std::fs::read_dir(&templates_dir) {
-            for entry in entries.flatten() {
-                if let Ok(file_type) = entry.file_type() {
-                    if file_type.is_dir() {
-                        if let Some(name) = entry.file_name().to_str() {
-                            installed_addons.push(InstalledAddon {
-                                name: name.to_string(),
-                                addon_type: "template".to_string(),
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    let logger = Logger::new();
-
-    if installed_addons.is_empty() {
-        logger.log_message(LogLevel::Info, "No addon installed.");
-    } else {
-        let installed_banks = installed_addons.iter().filter(|a| a.addon_type == "bank");
-
-        let installed_plugins = installed_addons.iter().filter(|a| a.addon_type == "plugin");
-
-        let installed_presets = installed_addons.iter().filter(|a| a.addon_type == "preset");
-
-        let installed_templates = installed_addons
-            .iter()
-            .filter(|a| a.addon_type == "template");
-
-        if installed_banks.clone().count() > 0 {
-            let trace: Vec<String> = installed_addons
-                .iter()
-                .map(|a| format!("{}", a.name))
-                .collect();
-            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
-
-            logger.log_message_with_trace(LogLevel::Info, "Installed banks :", trace);
-        }
-
-        if installed_plugins.clone().count() > 0 {
-            let trace: Vec<String> = installed_addons
-                .iter()
-                .map(|a| format!("{}", a.name))
-                .collect();
-            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
-
-            logger.log_message_with_trace(LogLevel::Info, "Installed plugins :", trace);
-        }
-
-        if installed_presets.clone().count() > 0 {
-            let trace: Vec<String> = installed_addons
-                .iter()
-                .map(|a| format!("{}", a.name))
-                .collect();
-            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
-
-            logger.log_message_with_trace(LogLevel::Info, "Installed presets :", trace);
-        }
-
-        if installed_templates.clone().count() > 0 {
-            let trace: Vec<String> = installed_addons
-                .iter()
-                .map(|a| format!("{}", a.name))
-                .collect();
-            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
-
-            logger.log_message_with_trace(LogLevel::Info, "Installed templates :", trace);
-        }
-
-        if let Some(addon_not_in_config) = find_unused_addons(installed_addons.clone()) {
-            let trace: Vec<String> = addon_not_in_config
-                .iter()
-                .map(|a| format!("{} ({})", a.name, a.addon_type))
-                .collect();
-            let trace: Vec<&str> = trace.iter().map(|s| s.as_str()).collect();
-
-            logger.log_message_with_trace(
-                LogLevel::Warning,
-                "Some addons are installed but not referenced in the .devalang configuration file :",
-                trace,
-            );
-        }
-
-        logger.log_message(
-            LogLevel::Success,
-            format!("Found {} installed addon(s).", installed_addons.len()).as_str(),
-        );
-    }
-
-    Ok(())
-}
-
-fn find_unused_addons(addons: Vec<InstalledAddon>) -> Option<Vec<InstalledAddon>> {
-    let mut unused_addons = Vec::new();
-
-    let config_path = match devalang_utils::path::get_devalang_config_path() {
-        Ok(path) => path,
-        Err(_) => return None,
-    };
-
-    let config = match crate::config::ops::load_config(Some(&config_path)) {
-        Some(cfg) => cfg,
-        None => return None,
-    };
-
-    let mut referenced_addons = Vec::new();
-
-    if let Some(banks) = config.banks {
-        for bank in banks {
-            if let Some(name) = bank.path.strip_prefix("devalang://bank/") {
-                referenced_addons.push((name.to_string(), "bank".to_string()));
-            }
-        }
-    }
-
-    if let Some(plugins) = config.plugins {
-        for plugin in plugins {
-            if let Some(name) = plugin.path.strip_prefix("devalang://plugin/") {
-                referenced_addons.push((name.to_string(), "plugin".to_string()));
-            }
-        }
-    }
-
-    // TODO: Enable when presets and templates are supported in config
-    // if let Some(presets) = config.presets {
-    //     for preset in presets {
-    //         if let Some(name) = preset.path.strip_prefix("devalang://preset/") {
-    //             referenced_addons.push((name.to_string(), "preset".to_string()));
-    //         }
-    //     }
-    // }
-
-    // TODO: Enable when presets and templates are supported in config
-    // if let Some(templates) = config.templates {
-    //     for template in templates {
-    //         if let Some(name) = template.path.strip_prefix("devalang://template/") {
-    //             referenced_addons.push((name.to_string(), "template".to_string()));
-    //         }
-    //     }
-    // }
-
-    for addon in addons {
-        if !referenced_addons.contains(&(addon.name.clone(), addon.addon_type.clone())) {
-            unused_addons.push(addon);
-        }
-    }
-
-    if unused_addons.is_empty() {
-        None
-    } else {
-        Some(unused_addons)
-    }
-}

package/rust/cli/addon/metadata.rs

@@ -1,124 +0,0 @@
-use crate::web::api::get_api_url;
-
-#[derive(Debug, Clone)]
-pub struct AddonToDownloadMetadata {
-    pub name: String,
-    pub publisher: String,
-    pub addon_type: devalang_types::AddonType,
-}
-
-pub async fn get_addon_publisher_from_api(slug: &str) -> Result<String, String> {
-    let api_url = get_api_url();
-
-    let request_url = format!("{}/v1/products/getBySlug/{}", api_url, slug);
-
-    let client: reqwest::Client = reqwest::Client::builder()
-        .build()
-        .map_err(|_| "Failed to build HTTP client".to_string())?;
-
-    let resp = client
-        .get(&request_url)
-        .send()
-        .await
-        .map_err(|e| format!("Failed to receive response: {}", e))?;
-
-    let status = resp.status();
-    let body_text = resp
-        .text()
-        .await
-        .map_err(|e| format!("Failed to read response body: {}", e))?;
-
-    let json: serde_json::Value = match serde_json::from_str(&body_text) {
-        Ok(v) => v,
-        Err(_) => {
-            return Err(format!(
-                "Invalid JSON response (status {}): {}",
-                status, body_text
-            ));
-        }
-    };
-
-    let payload = json.get("payload");
-    let publisher = payload
-        .unwrap_or(&serde_json::Value::Null)
-        .get("publisher")
-        .and_then(|v| v.get("name"))
-        .and_then(|v| v.as_str())
-        .unwrap_or("unknown")
-        .to_string();
-
-    Ok(publisher)
-}
-
-pub async fn get_addon_from_api(slug: &str) -> Result<AddonToDownloadMetadata, String> {
-    let api_url = get_api_url();
-
-    let request_url = format!("{}/v1/products/getBySlug/{}", api_url, slug);
-
-    let client: reqwest::Client = reqwest::Client::builder()
-        .build()
-        .map_err(|_| "Failed to build HTTP client".to_string())?;
-
-    let resp = client
-        .get(&request_url)
-        .send()
-        .await
-        .map_err(|e| format!("Failed to receive response: {}", e))?;
-
-    let status = resp.status();
-    let body_text = resp
-        .text()
-        .await
-        .map_err(|e| format!("Failed to read response body: {}", e))?;
-
-    let json: serde_json::Value = match serde_json::from_str(&body_text) {
-        Ok(v) => v,
-        Err(_) => {
-            return Err(format!(
-                "Invalid JSON response (status {}): {}",
-                status, body_text
-            ));
-        }
-    };
-
-    let payload = json.get("payload");
-    let addon_type = payload
-        .unwrap_or(&serde_json::Value::Null)
-        .get("addon")
-        .unwrap_or(&serde_json::Value::Null)
-        .get("addon_type")
-        .and_then(|v| v.as_str())
-        .unwrap_or("unknown");
-
-    let addon_type_enum = match addon_type {
-        "bank" => devalang_types::AddonType::Bank,
-        "plugin" => devalang_types::AddonType::Plugin,
-        "preset" => devalang_types::AddonType::Preset,
-        "template" => devalang_types::AddonType::Template,
-        _ => {
-            return Err(format!("Unknown addon type: {}", addon_type));
-        }
-    };
-
-    let addon_metadata = AddonToDownloadMetadata {
-        name: payload
-            .unwrap_or(&serde_json::Value::Null)
-            .get("addon")
-            .unwrap_or(&serde_json::Value::Null)
-            .get("name")
-            .and_then(|v| v.as_str())
-            .unwrap_or("unknown")
-            .to_string(),
-        publisher: payload
-            .unwrap_or(&serde_json::Value::Null)
-            .get("publisher")
-            .unwrap_or(&serde_json::Value::Null)
-            .get("name")
-            .and_then(|v| v.as_str())
-            .unwrap_or("unknown")
-            .to_string(),
-        addon_type: addon_type_enum,
-    };
-
-    Ok(addon_metadata)
-}

package/rust/cli/addon/mod.rs

@@ -1,8 +0,0 @@
-pub mod commands;
-pub mod download;
-pub mod install;
-pub mod list;
-pub mod metadata;
-pub mod remove;
-pub mod update;
-pub mod utils;