robinpath_modules/modules/

transform_mod.rs

use robinpath::{RobinPath, Value};

pub fn register(rp: &mut RobinPath) {
    // transform.pick object keys → filtered object
    rp.register_builtin("transform.pick", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let keys = args.get(1).cloned().unwrap_or(Value::Null);
        if let (Value::Object(obj), Value::Array(key_list)) = (&data, &keys) {
            let mut result = indexmap::IndexMap::new();
            for key_val in key_list {
                let key = key_val.to_display_string();
                if key.contains('.') {
                    // Nested dot notation
                    let val = get_nested(&data, &key);
                    if !matches!(val, Value::Null) {
                        result.insert(key, val);
                    }
                } else if let Some(v) = obj.get(&key) {
                    result.insert(key, v.clone());
                }
            }
            Ok(Value::Object(result))
        } else {
            Ok(data)
        }
    });

    // transform.omit object keys → filtered object
    rp.register_builtin("transform.omit", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let keys = args.get(1).cloned().unwrap_or(Value::Null);
        if let (Value::Object(obj), Value::Array(key_list)) = (&data, &keys) {
            let omit_keys: Vec<String> = key_list.iter().map(|v| v.to_display_string()).collect();
            let mut result = indexmap::IndexMap::new();
            for (k, v) in obj {
                if !omit_keys.contains(k) {
                    result.insert(k.clone(), v.clone());
                }
            }
            Ok(Value::Object(result))
        } else {
            Ok(data)
        }
    });

    // transform.rename object mapping → renamed object
    rp.register_builtin("transform.rename", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let mapping = args.get(1).cloned().unwrap_or(Value::Null);
        if let (Value::Object(obj), Value::Object(map)) = (&data, &mapping) {
            let mut result = indexmap::IndexMap::new();
            for (k, v) in obj {
                let new_key = map.get(k).map(|m| m.to_display_string()).unwrap_or_else(|| k.clone());
                result.insert(new_key, v.clone());
            }
            Ok(Value::Object(result))
        } else {
            Ok(data)
        }
    });

    // transform.mapValues object mapping → transformed values
    rp.register_builtin("transform.mapValues", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let mapping = args.get(1).cloned().unwrap_or(Value::Null);
        if let (Value::Object(obj), Value::Object(map)) = (&data, &mapping) {
            let mut result = indexmap::IndexMap::new();
            for (k, v) in obj {
                let transformed = if let Some(Value::String(transform)) = map.get(k) {
                    apply_transform(v, transform)
                } else {
                    v.clone()
                };
                result.insert(k.clone(), transformed);
            }
            Ok(Value::Object(result))
        } else {
            Ok(data)
        }
    });

    // transform.coerce value type → coerced value
    rp.register_builtin("transform.coerce", |args, _| {
        let value = args.first().cloned().unwrap_or(Value::Null);
        let target_type = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        Ok(coerce_value(&value, &target_type))
    });

    // transform.flatten object separator? → flat object with dot keys
    rp.register_builtin("transform.flatten", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let sep = args.get(1).map(|v| v.to_display_string()).unwrap_or_else(|| ".".to_string());
        let mut result = indexmap::IndexMap::new();
        flatten_object(&data, "", &sep, &mut result);
        Ok(Value::Object(result))
    });

    // transform.unflatten object separator? → nested object
    rp.register_builtin("transform.unflatten", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let sep = args.get(1).map(|v| v.to_display_string()).unwrap_or_else(|| ".".to_string());
        if let Value::Object(obj) = data {
            let mut result = indexmap::IndexMap::new();
            for (key, value) in obj {
                set_nested_path(&mut result, &key, &sep, value);
            }
            Ok(Value::Object(result))
        } else {
            Ok(data)
        }
    });

    // transform.merge ...objects → deep merged object
    rp.register_builtin("transform.merge", |args, _| {
        let mut result = indexmap::IndexMap::new();
        for arg in args {
            if let Value::Object(obj) = arg {
                deep_merge(&mut result, obj);
            }
        }
        Ok(Value::Object(result))
    });

    // transform.defaults object defaults → filled object
    rp.register_builtin("transform.defaults", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let defaults = args.get(1).cloned().unwrap_or(Value::Null);
        if let (Value::Object(mut obj), Value::Object(defs)) = (data, defaults) {
            for (k, v) in defs {
                if !obj.contains_key(&k) || matches!(obj.get(&k), Some(Value::Null)) {
                    obj.insert(k, v);
                }
            }
            Ok(Value::Object(obj))
        } else {
            Ok(args.first().cloned().unwrap_or(Value::Null))
        }
    });

    // transform.template templateStr data → rendered string
    rp.register_builtin("transform.template", |args, _| {
        let template = args.first().map(|v| v.to_display_string()).unwrap_or_default();
        let data = args.get(1).cloned().unwrap_or(Value::Null);
        let mut result = template.clone();
        if let Value::Object(obj) = &data {
            for (key, value) in obj {
                let placeholder = format!("{{{{{}}}}}", key);
                result = result.replace(&placeholder, &value.to_display_string());
            }
        }
        Ok(Value::String(result))
    });

    // transform.group array key → grouped object
    rp.register_builtin("transform.group", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let key = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        if let Value::Array(arr) = data {
            let mut groups: indexmap::IndexMap<String, Vec<Value>> = indexmap::IndexMap::new();
            for item in arr {
                let group_val = if let Value::Object(obj) = &item {
                    obj.get(&key).map(|v| v.to_display_string()).unwrap_or_else(|| "undefined".to_string())
                } else {
                    "undefined".to_string()
                };
                groups.entry(group_val).or_default().push(item);
            }
            let mut result = indexmap::IndexMap::new();
            for (k, v) in groups {
                result.insert(k, Value::Array(v));
            }
            Ok(Value::Object(result))
        } else {
            Ok(data)
        }
    });

    // transform.mapArray array mapping → mapped array
    rp.register_builtin("transform.mapArray", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let mapping = args.get(1).cloned().unwrap_or(Value::Null);
        if let (Value::Array(arr), Value::Object(map)) = (data, mapping) {
            let result: Vec<Value> = arr.iter().map(|item| {
                if let Value::Object(obj) = item {
                    let mut new_obj = indexmap::IndexMap::new();
                    for (new_key, source) in &map {
                        let source_key = source.to_display_string();
                        let val = obj.get(&source_key).cloned().unwrap_or(Value::Null);
                        new_obj.insert(new_key.clone(), val);
                    }
                    Value::Object(new_obj)
                } else {
                    item.clone()
                }
            }).collect();
            Ok(Value::Array(result))
        } else {
            Ok(args.first().cloned().unwrap_or(Value::Null))
        }
    });

    // transform.filter array conditions → filtered array
    rp.register_builtin("transform.filter", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let conditions = args.get(1).cloned().unwrap_or(Value::Null);
        if let (Value::Array(arr), Value::Object(conds)) = (data, conditions) {
            let result: Vec<Value> = arr.into_iter().filter(|item| {
                if let Value::Object(obj) = item {
                    conds.iter().all(|(k, v)| {
                        obj.get(k).map(|actual| actual.to_display_string() == v.to_display_string()).unwrap_or(false)
                    })
                } else {
                    false
                }
            }).collect();
            Ok(Value::Array(result))
        } else {
            Ok(args.first().cloned().unwrap_or(Value::Null))
        }
    });

    // transform.sort array key order? → sorted array
    rp.register_builtin("transform.sort", |args, _| {
        let data = args.first().cloned().unwrap_or(Value::Null);
        let key = args.get(1).map(|v| v.to_display_string()).unwrap_or_default();
        let order = args.get(2).map(|v| v.to_display_string()).unwrap_or_else(|| "asc".to_string());
        if let Value::Array(mut arr) = data {
            arr.sort_by(|a, b| {
                let av = if let Value::Object(obj) = a { obj.get(&key).cloned().unwrap_or(Value::Null) } else { Value::Null };
                let bv = if let Value::Object(obj) = b { obj.get(&key).cloned().unwrap_or(Value::Null) } else { Value::Null };
                let cmp = match (&av, &bv) {
                    (Value::Number(a), Value::Number(b)) => a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal),
                    _ => av.to_display_string().cmp(&bv.to_display_string()),
                };
                if order == "desc" { cmp.reverse() } else { cmp }
            });
            Ok(Value::Array(arr))
        } else {
            Ok(data)
        }
    });
}

fn get_nested(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 apply_transform(val: &Value, transform: &str) -> Value {
    match transform {
        "toString" => Value::String(val.to_display_string()),
        "toNumber" => Value::Number(val.to_number()),
        "toBoolean" => Value::Bool(match val {
            Value::Bool(b) => *b,
            Value::Number(n) => *n != 0.0,
            Value::String(s) => !s.is_empty() && s != "false" && s != "0",
            Value::Null => false,
            _ => true,
        }),
        "toUpperCase" => Value::String(val.to_display_string().to_uppercase()),
        "toLowerCase" => Value::String(val.to_display_string().to_lowercase()),
        "trim" => Value::String(val.to_display_string().trim().to_string()),
        _ => val.clone(),
    }
}

fn coerce_value(val: &Value, target: &str) -> Value {
    match target {
        "string" => Value::String(val.to_display_string()),
        "number" | "float" => Value::Number(val.to_number()),
        "integer" => Value::Number((val.to_number() as i64) as f64),
        "boolean" => Value::Bool(match val {
            Value::Bool(b) => *b,
            Value::Number(n) => *n != 0.0,
            Value::String(s) => s == "true" || s == "1",
            Value::Null => false,
            _ => true,
        }),
        "array" => match val {
            Value::Array(_) => val.clone(),
            _ => Value::Array(vec![val.clone()]),
        },
        _ => val.clone(),
    }
}

fn flatten_object(val: &Value, prefix: &str, sep: &str, result: &mut indexmap::IndexMap<String, Value>) {
    match val {
        Value::Object(obj) => {
            for (k, v) in obj {
                let key = if prefix.is_empty() { k.clone() } else { format!("{}{}{}", prefix, sep, k) };
                flatten_object(v, &key, sep, result);
            }
        }
        _ => {
            result.insert(prefix.to_string(), val.clone());
        }
    }
}

fn set_nested_path(obj: &mut indexmap::IndexMap<String, Value>, path: &str, sep: &str, value: Value) {
    let parts: Vec<&str> = path.split(sep).collect();
    if parts.len() == 1 {
        obj.insert(path.to_string(), value);
        return;
    }
    let key = parts[0].to_string();
    let rest = parts[1..].join(sep);
    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_nested_path(inner, &rest, sep, value);
    }
}

fn deep_merge(target: &mut indexmap::IndexMap<String, Value>, source: &indexmap::IndexMap<String, Value>) {
    for (k, v) in source {
        if let (Some(Value::Object(existing)), Value::Object(incoming)) = (target.get_mut(k), v) {
            deep_merge(existing, incoming);
        } else {
            target.insert(k.clone(), v.clone());
        }
    }
}