Struct Schema 

pub struct Schema {
    pub version: u32,
    pub rustio_version: String,
    pub models: Vec<SchemaModel>,
}

Top-level schema document. Serialised as rustio.schema.json.

#[serde(deny_unknown_fields)] locks the wire format: a future schema version adding a field will fail to load under the older rustio-core unless the version number is bumped in lockstep. Combined with SCHEMA_VERSION, this catches accidental silent drift.

Fields

version: u32

rustio_version: String

models: Vec<SchemaModel>

Implementations

impl Schema

pub fn relation_for(&self, model: &str, field: &str) -> Option<&Relation>

Look up the Relation descriptor attached to (model, field), if the field carries one. Returns None if the model or field doesn’t exist, or if the field has no relation metadata. A schema without relations behaves identically to pre-0.8.0 — this accessor just returns None everywhere.

pub fn incoming_relations(&self, model: &str) -> Vec<IncomingRelation>

Enumerate every belongs_to relation in the schema that points at model — i.e. the has_many view. Order follows model order, then field order inside the model. Empty when no field in the schema references model. Deterministic.

pub fn from_admin(admin: &Admin) -> Self

Build a schema from an already-constructed Admin. This is the single supported path — we don’t parse Rust sources or read the DB, so whatever the admin is serving is exactly what the schema describes.

Output is deterministic: models and fields are emitted in sorted order so two invocations on the same registry produce identical JSON bytes.

pub fn validate(&self) -> Result<(), SchemaError>

Check the schema for internal consistency. Every production writer should call this before persisting and every consumer (including the AI layer) should call it after loading. The error is the first problem found; fix and revalidate.

pub fn parse(json: &str) -> Result<Self, SchemaError>

Parse + validate a schema document. Both deserialization failure (unknown fields, wrong types, missing keys) and any semantic problem surface as SchemaError. Safe default for anything reading a rustio.schema.json off disk.

pub fn to_pretty_json(&self) -> Result<String, Error>

Serialise to pretty JSON with a trailing newline. We pretty-print on purpose: the file is meant to be read by humans during code review and by AI tools that benefit from stable line-level anchors.

pub fn write_to(&self, path: &Path) -> Result<(), Error>

Write the schema to a file, atomically. Validates first so a broken schema never lands on disk. Uses a temp-file + rename so a concurrent reader can never observe a half-written JSON file.

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Schema

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Schema

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Schema

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Schema

fn eq(&self, other: &Schema) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Schema

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Schema