robinpath_modules/modules/

config_mod.rs

use robinpath::{RobinPath, Value};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

struct ConfigStore {
    data: indexmap::IndexMap<String, Value>,
    frozen: bool,
}

pub fn register(rp: &mut RobinPath) {
    let state = Arc::new(Mutex::new(HashMap::<String, ConfigStore>::new()));

    // config.create name defaults? → bool
    let s = state.clone();
    rp.register_builtin("config.create", move |args, _| {
        let name = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let defaults = args.get(1).cloned().unwrap_or(Value::Null);
        let data = if let Value::Object(obj) = defaults { obj } else { indexmap::IndexMap::new() };
        s.lock().unwrap().insert(name, ConfigStore { data, frozen: false });
        Ok(Value::Bool(true))
    });

    // config.load filePath name? → bool
    let s = state.clone();
    rp.register_builtin("config.load", move |args, _| {
        let path = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let name = args.get(1).map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let content = std::fs::read_to_string(&path)
            .map_err(|e| format!("config.load error: {}", e))?;
        let data = if path.ends_with(".json") {
            match serde_json::from_str::<serde_json::Value>(&content) {
                Ok(v) => {
                    if let Value::Object(obj) = Value::from(v) { obj }
                    else { return Err("JSON must be an object".to_string()); }
                }
                Err(e) => return Err(format!("JSON parse error: {}", e)),
            }
        } else {
            // .env format
            let mut obj = indexmap::IndexMap::new();
            for line in content.lines() {
                let trimmed = line.trim();
                if trimmed.is_empty() || trimmed.starts_with('#') { continue; }
                if let Some(eq) = trimmed.find('=') {
                    let key = trimmed[..eq].trim().to_string();
                    let val = trimmed[eq + 1..].trim().trim_matches('"').trim_matches('\'').to_string();
                    obj.insert(key, Value::String(val));
                }
            }
            obj
        };
        let mut configs = s.lock().unwrap();
        let store = configs.entry(name).or_insert_with(|| ConfigStore {
            data: indexmap::IndexMap::new(), frozen: false,
        });
        if store.frozen { return Err("Config is frozen".to_string()); }
        for (k, v) in data { store.data.insert(k, v); }
        Ok(Value::Bool(true))
    });

    // config.loadEnv prefix name? → bool
    let s = state.clone();
    rp.register_builtin("config.loadEnv", move |args, _| {
        let prefix = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let name = args.get(1).map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let mut configs = s.lock().unwrap();
        let store = configs.entry(name).or_insert_with(|| ConfigStore {
            data: indexmap::IndexMap::new(), frozen: false,
        });
        if store.frozen { return Err("Config is frozen".to_string()); }
        for (key, value) in std::env::vars() {
            if prefix.is_empty() || key.starts_with(&prefix) {
                let config_key = if prefix.is_empty() { key } else {
                    key[prefix.len()..].trim_start_matches('_').to_lowercase()
                };
                store.data.insert(config_key, Value::String(value));
            }
        }
        Ok(Value::Bool(true))
    });

    // config.get path default? name? → value
    let s = state.clone();
    rp.register_builtin("config.get", move |args, _| {
        let path = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let default = args.get(1).cloned().unwrap_or(Value::Null);
        let name = args.get(2).map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let configs = s.lock().unwrap();
        if let Some(store) = configs.get(&name) {
            let val = get_by_path(&Value::Object(store.data.clone()), &path);
            if matches!(val, Value::Null) { Ok(default) } else { Ok(val) }
        } else {
            Ok(default)
        }
    });

    // config.set path value name? → bool
    let s = state.clone();
    rp.register_builtin("config.set", move |args, _| {
        let path = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let value = args.get(1).cloned().unwrap_or(Value::Null);
        let name = args.get(2).map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let mut configs = s.lock().unwrap();
        let store = configs.entry(name).or_insert_with(|| ConfigStore {
            data: indexmap::IndexMap::new(), frozen: false,
        });
        if store.frozen { return Err("Config is frozen".to_string()); }
        set_by_path(&mut store.data, &path, value);
        Ok(Value::Bool(true))
    });

    // config.getAll name? → object
    let s = state.clone();
    rp.register_builtin("config.getAll", move |args, _| {
        let name = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let configs = s.lock().unwrap();
        if let Some(store) = configs.get(&name) {
            Ok(Value::Object(store.data.clone()))
        } else {
            Ok(Value::Object(indexmap::IndexMap::new()))
        }
    });

    // config.merge data name? → bool
    let s = state.clone();
    rp.register_builtin("config.merge", move |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let name = args.get(1).map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        if let Value::Object(incoming) = data {
            let mut configs = s.lock().unwrap();
            let store = configs.entry(name).or_insert_with(|| ConfigStore {
                data: indexmap::IndexMap::new(), frozen: false,
            });
            if store.frozen { return Err("Config is frozen".to_string()); }
            for (k, v) in incoming { store.data.insert(k, v); }
            Ok(Value::Bool(true))
        } else {
            Err("Data must be an object".to_string())
        }
    });

    // config.has path name? → bool
    let s = state.clone();
    rp.register_builtin("config.has", move |args, _| {
        let path = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let name = args.get(1).map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let configs = s.lock().unwrap();
        if let Some(store) = configs.get(&name) {
            let val = get_by_path(&Value::Object(store.data.clone()), &path);
            Ok(Value::Bool(!matches!(val, Value::Null)))
        } else {
            Ok(Value::Bool(false))
        }
    });

    // config.remove path name? → bool
    let s = state.clone();
    rp.register_builtin("config.remove", move |args, _| {
        let path = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let name = args.get(1).map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let mut configs = s.lock().unwrap();
        if let Some(store) = configs.get_mut(&name) {
            if store.frozen { return Err("Config is frozen".to_string()); }
            store.data.shift_remove(&path);
            Ok(Value::Bool(true))
        } else {
            Ok(Value::Bool(false))
        }
    });

    // config.clear name? → bool
    let s = state.clone();
    rp.register_builtin("config.clear", move |args, _| {
        let name = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let mut configs = s.lock().unwrap();
        if let Some(store) = configs.get_mut(&name) {
            if store.frozen { return Err("Config is frozen".to_string()); }
            store.data.clear();
            Ok(Value::Bool(true))
        } else {
            Ok(Value::Bool(false))
        }
    });

    // config.list → array of config names
    let s = state.clone();
    rp.register_builtin("config.list", move |_args, _| {
        let configs = s.lock().unwrap();
        let names: Vec<Value> = configs.keys().map(|k| Value::String(k.clone())).collect();
        Ok(Value::Array(names))
    });

    // config.validate required name? → {valid, missing}
    let s = state.clone();
    rp.register_builtin("config.validate", move |args, _| {
        let required = args.first().cloned().unwrap_or(Value::Null);
        let name = args.get(1).map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let configs = s.lock().unwrap();
        let store = configs.get(&name);
        let mut missing = Vec::new();
        if let Value::Array(keys) = required {
            for key in &keys {
                let k = key.to_display_string();
                let found = store.map(|s| {
                    let val = get_by_path(&Value::Object(s.data.clone()), &k);
                    !matches!(val, Value::Null)
                }).unwrap_or(false);
                if !found { missing.push(Value::String(k)); }
            }
        }
        let mut obj = indexmap::IndexMap::new();
        obj.insert("valid".to_string(), Value::Bool(missing.is_empty()));
        obj.insert("missing".to_string(), Value::Array(missing));
        Ok(Value::Object(obj))
    });

    // config.freeze name? → bool
    let s = state.clone();
    rp.register_builtin("config.freeze", move |args, _| {
        let name = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let mut configs = s.lock().unwrap();
        if let Some(store) = configs.get_mut(&name) {
            store.frozen = true;
            Ok(Value::Bool(true))
        } else {
            Ok(Value::Bool(false))
        }
    });

    // config.toEnv name? prefix? → env format string
    let s = state.clone();
    rp.register_builtin("config.toEnv", move |args, _| {
        let name = args.first().map(|v| v.to_display_string()).unwrap_or_else(|| "default".to_string());
        let prefix = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let configs = s.lock().unwrap();
        if let Some(store) = configs.get(&name) {
            let lines: Vec<String> = store.data.iter().map(|(k, v)| {
                let env_key = if prefix.is_empty() {
                    k.to_uppercase()
                } else {
                    format!("{}_{}", prefix.to_uppercase(), k.to_uppercase())
                };
                format!("{}={}", env_key, v.to_display_string())
            }).collect();
            Ok(Value::String(lines.join("\n")))
        } else {
            Ok(Value::String(String::new()))
        }
    });
}

fn get_by_path(val: &Value, path: &str) -> Value {
    let mut current = val.clone();
    for part in path.split('.') {
        if let Value::Object(obj) = &current {
            current = obj.get(part).cloned().unwrap_or(Value::Null);
        } else {
            return Value::Null;
        }
    }
    current
}

fn set_by_path(obj: &mut indexmap::IndexMap<String, Value>, path: &str, value: Value) {
    let parts: Vec<&str> = path.split('.').collect();
    if parts.len() == 1 {
        obj.insert(path.to_string(), value);
        return;
    }
    let key = parts[0].to_string();
    let rest = parts[1..].join(".");
    if !obj.contains_key(&key) {
        obj.insert(key.clone(), Value::Object(indexmap::IndexMap::new()));
    }
    if let Some(Value::Object(inner)) = obj.get_mut(&key) {
        set_by_path(inner, &rest, value);
    }
}