Method decode_unknown

libs/@local/hashql/eval/src/orchestrator/codec/decode/mod.rs:63–140

(&self, value: JsonValueRef<'_>)

    }

    fn decode_unknown(&self, value: JsonValueRef<'_>) -> Result<Value<'heap, A>, DecodeError<'heap>>
    where
        A: Clone,
    {
        match value {
            JsonValueRef::Null => Ok(Value::Unit),
            JsonValueRef::Bool(value) => Ok(Value::Integer(value::Int::from(value))),
            JsonValueRef::Number(number) => {
                if let Some(value) = number.as_i128() {
                    Ok(Value::Integer(value::Int::from(value)))
                } else {
                    let value = number
                        .as_f64()
                        .ok_or(DecodeError::NumberOutOfRange { expected: None })?;

                    Ok(Value::Number(value::Num::from(value)))
                }
            }
            JsonValueRef::String(string) => {
                let value = value::Str::from(Rc::from_in(string, self.alloc.clone()));
                Ok(Value::String(value))
            }
            JsonValueRef::Array(values) => {
                // We default in the output to **lists** not tuples. Very important distinction
                let mut output = value::List::new();

                for element in values {
                    output.push_back(self.decode_unknown(element.into())?);
                }

                Ok(Value::List(output))
            }
            JsonValueRef::Object(map) => {
                if !map.keys().all(|key| {
                    // Mirrors the implementation of `BaseUrl` parse validation.
                    if key.len() < 2048
                        && let Ok(url) = url::Url::parse(key)
                        && matches!(url.scheme(), "http" | "https")
                        && !url.cannot_be_a_base()
                        && key.ends_with('/')
                    {
                        true
                    } else {
                        false
                    }
                }) {
                    let mut dict = value::Dict::new();

                    for (key, value) in map {
                        let key = self.decode_unknown(JsonValueRef::String(key))?;
                        let value = self.decode_unknown(value.into())?;

                        dict.insert(key, value);
                    }

                    return Ok(Value::Dict(dict));
                }