use core::fmt;
use crate::{EventId, SchemaRevision, WireMajor};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum FieldKind {
Bool,
Unsigned,
Signed,
Text,
Bytes,
Message(EventId),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum FieldPresence {
Required,
Optional,
Defaulted,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct FieldSpec {
pub tag: u32,
pub kind: FieldKind,
pub presence: FieldPresence,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Schema<'a> {
pub event: EventId,
pub wire_major: WireMajor,
pub revision: SchemaRevision,
pub fields: &'a [FieldSpec],
pub reserved_tags: &'a [u32],
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum SchemaError {
DuplicateTag(u32),
FieldKindChanged(u32),
NewlyRequired(u32),
RequiredFieldMadeOptional(u32),
RequiredFieldRemoved(u32),
RemovedTagNotReserved(u32),
ReservedTagReused(u32),
ReservedTagRemoved(u32),
EventChanged,
MajorChanged,
}
impl fmt::Display for SchemaError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::DuplicateTag(tag) => write!(formatter, "schema tag {tag} is duplicated"),
Self::FieldKindChanged(tag) => {
write!(formatter, "field kind changed for schema tag {tag}")
}
Self::NewlyRequired(tag) => {
write!(formatter, "schema tag {tag} became required")
}
Self::RequiredFieldMadeOptional(tag) => {
write!(formatter, "required schema tag {tag} became optional")
}
Self::RequiredFieldRemoved(tag) => {
write!(formatter, "required schema tag {tag} was removed")
}
Self::RemovedTagNotReserved(tag) => {
write!(formatter, "removed schema tag {tag} is not reserved")
}
Self::ReservedTagReused(tag) => {
write!(formatter, "reserved schema tag {tag} was reused")
}
Self::ReservedTagRemoved(tag) => {
write!(formatter, "reserved schema tag {tag} is no longer reserved")
}
Self::EventChanged => formatter.write_str("schema event identity changed"),
Self::MajorChanged => formatter.write_str("schema wire major changed"),
}
}
}
#[cfg(feature = "std")]
impl std::error::Error for SchemaError {}
pub fn validate_schema(schema: &Schema<'_>) -> Result<(), SchemaError> {
for (index, field) in schema.fields.iter().enumerate() {
if schema.fields[index + 1..]
.iter()
.any(|other| other.tag == field.tag)
|| schema.reserved_tags.contains(&field.tag)
{
return Err(SchemaError::DuplicateTag(field.tag));
}
}
for (index, tag) in schema.reserved_tags.iter().enumerate() {
if schema.reserved_tags[index + 1..]
.iter()
.any(|other| other == tag)
{
return Err(SchemaError::DuplicateTag(*tag));
}
}
Ok(())
}
pub fn validate_evolution(previous: &Schema<'_>, next: &Schema<'_>) -> Result<(), SchemaError> {
validate_schema(previous)?;
validate_schema(next)?;
if previous.event != next.event {
return Err(SchemaError::EventChanged);
}
if previous.wire_major != next.wire_major {
return Err(SchemaError::MajorChanged);
}
for tag in previous.reserved_tags {
if next.fields.iter().any(|field| field.tag == *tag) {
return Err(SchemaError::ReservedTagReused(*tag));
}
if !next.reserved_tags.contains(tag) {
return Err(SchemaError::ReservedTagRemoved(*tag));
}
}
for old in previous.fields {
let Some(current) = next.fields.iter().find(|field| field.tag == old.tag) else {
if old.presence == FieldPresence::Required {
return Err(SchemaError::RequiredFieldRemoved(old.tag));
}
if !next.reserved_tags.contains(&old.tag) {
return Err(SchemaError::RemovedTagNotReserved(old.tag));
}
continue;
};
if old.kind != current.kind {
return Err(SchemaError::FieldKindChanged(old.tag));
}
match (old.presence, current.presence) {
(FieldPresence::Required, FieldPresence::Optional | FieldPresence::Defaulted) => {
return Err(SchemaError::RequiredFieldMadeOptional(old.tag));
}
(FieldPresence::Optional | FieldPresence::Defaulted, FieldPresence::Required) => {
return Err(SchemaError::NewlyRequired(old.tag));
}
_ => {}
}
}
for field in next.fields {
if !previous.fields.iter().any(|old| old.tag == field.tag)
&& field.presence == FieldPresence::Required
{
return Err(SchemaError::NewlyRequired(field.tag));
}
}
Ok(())
}