schema-coerce 0.1.0

//! # schema-coerce
//!
//! Coerce an LLM-emitted JSON value to a small field-schema.
//!
//! LLMs return `"42"` instead of `42`, `"true"` instead of `true`, or
//! wrap the answer in `{ "result": {...} }`. This crate gives you a
//! lossy `coerce(value, &schema)` that applies the obvious fixes:
//!
//! - String containing an integer → integer
//! - String containing a float → float
//! - String `"true"` / `"false"` / `"yes"` / `"no"` → bool
//! - Object containing a single key whose value matches the schema →
//!   unwrap (handles wrappers like `{ "result": {...} }`)
//! - Missing field → fill from default
//!
//! ## Example
//!
//! ```
//! use schema_coerce::{coerce, Field, Type};
//! use serde_json::json;
//!
//! let schema = vec![
//!     Field { name: "count", ty: Type::Int, default: None },
//!     Field { name: "ok", ty: Type::Bool, default: Some(json!(false)) },
//! ];
//! let raw = json!({ "count": "42", "ok": "yes" });
//! let fixed = coerce(raw, &schema);
//! assert_eq!(fixed["count"], json!(42));
//! assert_eq!(fixed["ok"], json!(true));
//! ```

#![deny(missing_docs)]

use serde_json::{json, Value};

/// Expected JSON type for a field.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Type {
    /// Signed 64-bit integer.
    Int,
    /// 64-bit float.
    Float,
    /// Boolean.
    Bool,
    /// UTF-8 string.
    String,
    /// JSON array (no element-type enforcement).
    Array,
    /// JSON object (no shape enforcement).
    Object,
}

/// One field in the schema.
#[derive(Debug, Clone)]
pub struct Field {
    /// Field name in the output object.
    pub name: &'static str,
    /// Expected type.
    pub ty: Type,
    /// Optional default to fill in if the field is missing or
    /// uncoercible.
    pub default: Option<Value>,
}

/// Coerce `v` to an object matching `schema`.
///
/// If `v` is wrapped in a single-key object whose value is also an
/// object, the wrapper is stripped first.
pub fn coerce(mut v: Value, schema: &[Field]) -> Value {
    v = unwrap_single_wrapper(v);

    let mut out = serde_json::Map::new();
    let src = v.as_object();

    for f in schema {
        let raw = src.and_then(|m| m.get(f.name));
        let coerced = raw
            .and_then(|x| coerce_value(x, f.ty))
            .or_else(|| f.default.clone())
            .unwrap_or(Value::Null);
        out.insert(f.name.to_string(), coerced);
    }

    Value::Object(out)
}

/// Strip `{ "result": {...} }` style wrappers.
fn unwrap_single_wrapper(v: Value) -> Value {
    if let Value::Object(map) = &v {
        if map.len() == 1 {
            let only = map.values().next().unwrap();
            if only.is_object() {
                return only.clone();
            }
        }
    }
    v
}

fn coerce_value(v: &Value, ty: Type) -> Option<Value> {
    match ty {
        Type::Int => match v {
            Value::Number(n) => n.as_i64().map(|i| json!(i)),
            Value::String(s) => s.trim().parse::<i64>().ok().map(|i| json!(i)),
            Value::Bool(b) => Some(json!(if *b { 1 } else { 0 })),
            _ => None,
        },
        Type::Float => match v {
            Value::Number(n) => n.as_f64().map(|f| json!(f)),
            Value::String(s) => s.trim().parse::<f64>().ok().map(|f| json!(f)),
            _ => None,
        },
        Type::Bool => match v {
            Value::Bool(b) => Some(json!(*b)),
            Value::String(s) => match s.trim().to_ascii_lowercase().as_str() {
                "true" | "yes" | "y" | "1" | "on" => Some(json!(true)),
                "false" | "no" | "n" | "0" | "off" => Some(json!(false)),
                _ => None,
            },
            Value::Number(n) => n.as_i64().map(|i| json!(i != 0)),
            _ => None,
        },
        Type::String => Some(match v {
            Value::String(s) => json!(s),
            _ => json!(v.to_string()),
        }),
        Type::Array => match v {
            Value::Array(_) => Some(v.clone()),
            _ => None,
        },
        Type::Object => match v {
            Value::Object(_) => Some(v.clone()),
            _ => None,
        },
    }
}