parakeet / parakeet-lexgen / src / validate.rs

use crate::types::{
    Lexicon, LexiconDef, LexiconObject, LexiconProcedure, LexiconQuery, LexiconSchema,
    LexiconString, LexiconSubscription, LexiconUnion, RecordKey,
};
use std::collections::BTreeMap;

#[derive(Debug)]
pub enum ValidationError {
    InvalidReference(String),
    MissingProperty,
    MissingReference(String),
    RecordKey,
    StringConstAndDefault,
}

/// validates lexicon definition files - returns keys for any that don't
pub fn validate(lexica: &BTreeMap<String, Lexicon>) -> Vec<(String, ValidationError)> {
    let mut errors = Vec::new();

    for (lexicon_id, lexicon) in lexica {
        for (name, def) in &lexicon.defs {
            let pass = match def {
                LexiconDef::Query(query) => validate_query(query, lexica, lexicon_id),
                LexiconDef::Procedure(proc) => validate_procedure(proc, lexica, lexicon_id),
                LexiconDef::Subscription(sub) => validate_subscription(sub, lexica, lexicon_id),
                LexiconDef::Record(rec) => {
                    // validate the rkey
                    let rkey_okay = match &rec.key {
                        // typed is always okay - serde validates
                        RecordKey::Typed(_) => None,
                        // we may want to validate literals according to record key syntax but idk?
                        RecordKey::Other(text) if text.starts_with("literal:") => None,
                        RecordKey::Other(_) => Some(ValidationError::RecordKey),
                    };

                    // and the schema def
                    let obj_okay = validate_object(&rec.record, lexica, lexicon_id);

                    rkey_okay.or(obj_okay)
                }
                LexiconDef::String(lex_str) => validate_string(lex_str, lexica, lexicon_id),
                LexiconDef::Array(array) => validate_schema(&array.items, lexica, lexicon_id),
                LexiconDef::Object(obj) => validate_object(obj, lexica, lexicon_id),
                LexiconDef::Token { .. } => continue,
            };

            if let Some(err) = pass {
                errors.push((format!("{lexicon_id}#{name}"), err));
            }
        }
    }

    errors
}

fn validate_schema(
    schema: &LexiconSchema,
    lexica: &BTreeMap<String, Lexicon>,
    this_lex: &str,
) -> Option<ValidationError> {
    match schema {
        LexiconSchema::String(lex_str) => validate_string(lex_str, lexica, this_lex),
        LexiconSchema::Array(array) => validate_schema(&array.items, lexica, this_lex),
        LexiconSchema::Object(obj) => validate_object(obj, lexica, this_lex),
        LexiconSchema::Ref { ref_to, .. } => lookup(ref_to, this_lex, lexica),
        LexiconSchema::Union(union) => validate_union(union, lexica, this_lex),
        LexiconSchema::Null { .. }
        | LexiconSchema::Boolean { .. }
        | LexiconSchema::Integer(_)
        | LexiconSchema::Bytes { .. }
        | LexiconSchema::CidLink { .. }
        | LexiconSchema::Blob { .. }
        | LexiconSchema::Unknown { .. } => None,
    }
}

fn validate_query(
    query: &LexiconQuery,
    lexica: &BTreeMap<String, Lexicon>,
    this_lex: &str,
) -> Option<ValidationError> {
    if let Some(params) = &query.parameters {
        validate_schema_btree(params.properties.values(), lexica, this_lex)?;
    }
    if let Some(output) = &query.output {
        if let Some(schema) = &output.schema {
            validate_schema(schema, lexica, this_lex)?;
        }
    }

    None
}

fn validate_procedure(
    proc: &LexiconProcedure,
    lexica: &BTreeMap<String, Lexicon>,
    this_lex: &str,
) -> Option<ValidationError> {
    if let Some(params) = &proc.parameters {
        validate_schema_btree(params.properties.values(), lexica, this_lex)?;
    }

    if let Some(input) = &proc.input {
        if let Some(schema) = &input.schema {
            validate_schema(schema, lexica, this_lex)?;
        }
    }

    if let Some(output) = &proc.output {
        if let Some(schema) = &output.schema {
            validate_schema(schema, lexica, this_lex)?;
        }
    }

    None
}

fn validate_subscription(
    sub: &LexiconSubscription,
    lexica: &BTreeMap<String, Lexicon>,
    this_lex: &str,
) -> Option<ValidationError> {
    if let Some(params) = &sub.parameters {
        validate_schema_btree(params.properties.values(), lexica, this_lex)?;
    }

    sub.message.values().find_map(|item| {
        item.schema
            .as_ref()
            .map(|union| validate_union(&union, lexica, this_lex))
            .unwrap_or_default()
    })
}

fn validate_object(
    object: &LexiconObject,
    lexica: &BTreeMap<String, Lexicon>,
    this_lex: &str,
) -> Option<ValidationError> {
    // check that everything in required and nullable exists in properties
    if let Some(required) = &object.required {
        for key in required {
            if !object.properties.contains_key(key) {
                return Some(ValidationError::MissingProperty);
            }
        }
    }
    if let Some(nullable) = &object.nullable {
        for key in nullable {
            if !object.properties.contains_key(key) {
                return Some(ValidationError::MissingProperty);
            }
        }
    }

    // and now validate properties
    validate_schema_btree(object.properties.values(), lexica, this_lex)
}

fn validate_string(
    lex_string: &LexiconString,
    lexica: &BTreeMap<String, Lexicon>,
    this_lex: &str,
) -> Option<ValidationError> {
    if lex_string.constant.is_some() && lex_string.default.is_some() {
        return Some(ValidationError::StringConstAndDefault);
    }

    if let Some(known_values) = &lex_string.known_values {
        known_values.iter().find_map(|value| {
            if value.contains("#") {
                lookup(value, this_lex, lexica)
            } else {
                None
            }
        })
    } else {
        None
    }
}

fn validate_union(
    union: &LexiconUnion,
    lexica: &BTreeMap<String, Lexicon>,
    this_lex: &str,
) -> Option<ValidationError> {
    union
        .refs
        .iter()
        .find_map(|value| lookup(value, this_lex, lexica))
}

fn lookup(
    reference: &str,
    this_lex: &str,
    lexica: &BTreeMap<String, Lexicon>,
) -> Option<ValidationError> {
    let reference = if reference.contains("#") {
        match reference.strip_prefix("#") {
            Some(local_ref) => format!("{this_lex}#{local_ref}"),
            None => reference.to_string(),
        }
    } else {
        format!("{}#main", reference)
    };

    if let Some((nsid, name)) = reference.split_once("#") {
        match lexica.get(nsid) {
            Some(def) => match def.defs.contains_key(name) {
                true => None,
                false => Some(ValidationError::MissingReference(reference)),
            },
            None => Some(ValidationError::MissingReference(reference)),
        }
    } else {
        Some(ValidationError::InvalidReference(reference))
    }
}

fn validate_schema_btree<'a, T>(
    mut schema: T,
    lexica: &BTreeMap<String, Lexicon>,
    this_lex: &str,
) -> Option<ValidationError>
where
    T: Iterator<Item = &'a LexiconSchema>,
{
    schema.find_map(|schema| validate_schema(schema, lexica, this_lex))
}