tranquil-pds/crates/tranquil-lexicon/src/schema.rs

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use tranquil_types::Nsid;

#[derive(Debug, Serialize, Deserialize)]
pub struct LexiconDoc {
    pub lexicon: u32,
    pub id: Nsid,
    #[serde(default)]
    pub defs: HashMap<String, LexDef>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum LexDef {
    #[serde(rename = "record")]
    Record(LexRecord),
    #[serde(rename = "object")]
    Object(LexObject),
    #[serde(rename = "token")]
    Token {},
    #[serde(rename = "string")]
    StringDef(LexStringDef),
    #[serde(rename = "query")]
    Query {},
    #[serde(rename = "procedure")]
    Procedure {},
    #[serde(rename = "subscription")]
    Subscription {},
    #[serde(rename = "params")]
    Params {},
    #[serde(rename = "permission")]
    Permission {},
    #[serde(rename = "permission-set")]
    PermissionSet {},
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LexRecord {
    #[serde(default)]
    pub key: Option<String>,
    pub record: LexObject,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LexObject {
    #[serde(default)]
    pub required: Vec<String>,
    #[serde(default)]
    pub nullable: Vec<String>,
    #[serde(default)]
    pub properties: HashMap<String, LexProperty>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum LexProperty {
    #[serde(rename = "string")]
    String(LexString),
    #[serde(rename = "integer")]
    Integer(LexInteger),
    #[serde(rename = "boolean")]
    Boolean {},
    #[serde(rename = "bytes")]
    Bytes(LexBytes),
    #[serde(rename = "cid-link")]
    CidLink {},
    #[serde(rename = "blob")]
    Blob(LexBlob),
    #[serde(rename = "unknown")]
    Unknown {},
    #[serde(rename = "ref")]
    Ref(LexRef),
    #[serde(rename = "union")]
    Union(LexUnion),
    #[serde(rename = "array")]
    Array(LexArray),
    #[serde(rename = "object")]
    Object(LexObject),
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LexString {
    #[serde(default)]
    pub max_length: Option<u64>,
    #[serde(default)]
    pub min_length: Option<u64>,
    #[serde(default)]
    pub max_graphemes: Option<u64>,
    #[serde(default)]
    pub min_graphemes: Option<u64>,
    #[serde(default)]
    pub format: Option<StringFormat>,
    #[serde(default)]
    pub known_values: Option<Vec<String>>,
    #[serde(rename = "enum", default)]
    pub enum_values: Option<Vec<String>>,
    #[serde(rename = "const", default)]
    pub const_value: Option<String>,
    #[serde(default)]
    pub default: Option<String>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LexInteger {
    #[serde(default)]
    pub minimum: Option<i64>,
    #[serde(default)]
    pub maximum: Option<i64>,
    #[serde(default)]
    pub default: Option<i64>,
    #[serde(rename = "enum", default)]
    pub enum_values: Option<Vec<i64>>,
    #[serde(rename = "const", default)]
    pub const_value: Option<i64>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LexBytes {
    #[serde(default)]
    pub max_length: Option<u64>,
    #[serde(default)]
    pub min_length: Option<u64>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LexBlob {
    #[serde(default)]
    pub accept: Option<Vec<String>>,
    #[serde(default)]
    pub max_size: Option<u64>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LexArray {
    pub items: Box<LexProperty>,
    #[serde(default)]
    pub min_length: Option<u64>,
    #[serde(default)]
    pub max_length: Option<u64>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LexUnion {
    #[serde(default)]
    pub refs: Vec<String>,
    #[serde(default)]
    pub closed: bool,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LexRef {
    #[serde(rename = "ref")]
    pub reference: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum StringFormat {
    #[serde(rename = "did")]
    Did,
    #[serde(rename = "handle")]
    Handle,
    #[serde(rename = "at-uri")]
    AtUri,
    #[serde(rename = "datetime")]
    Datetime,
    #[serde(rename = "uri")]
    Uri,
    #[serde(rename = "cid")]
    Cid,
    #[serde(rename = "language")]
    Language,
    #[serde(rename = "tid")]
    Tid,
    #[serde(rename = "record-key")]
    RecordKey,
    #[serde(rename = "at-identifier")]
    AtIdentifier,
    #[serde(rename = "nsid")]
    Nsid,
}

pub enum ParsedRef<'a> {
    Local(&'a str),
    Qualified { nsid: &'a str, fragment: &'a str },
    Bare(&'a str),
}

pub fn parse_ref(reference: &str) -> ParsedRef<'_> {
    match reference.strip_prefix('#') {
        Some(local) => ParsedRef::Local(local),
        None => {
            let stripped = reference.strip_prefix("lex:").unwrap_or(reference);
            match stripped.split_once('#') {
                Some((nsid, fragment)) => ParsedRef::Qualified { nsid, fragment },
                None => ParsedRef::Bare(stripped),
            }
        }
    }
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LexStringDef {}