///|
fn require(ok : Bool, message : String) -> Unit raise BranchError {
if !ok {
raise Invalid(message)
}
}
///|
fn valid_name(name : String) -> Bool {
if name.length() == 0 || name.length() > 63 {
return false
}
for i, c in name {
if !((c >= 'a' && c <= 'z') || c == '_' || (i > 0 && c >= '0' && c <= '9')) {
return false
}
}
true
}
///|
fn names_in(names : Array[String], columns : Array[String]) -> Bool {
let seen : Map[String, Bool] = Map([])
for name in names {
if !columns.contains(name) || seen.contains(name) {
return false
}
seen[name] = true
}
!names.is_empty()
}
///|
pub fn validate(spec : Spec) -> Unit raise BranchError {
require(spec.version == 1, "unsupported recipe version")
require(valid_name(spec.schema), "invalid schema identifier")
require(spec.max_rows > 0, "max_rows must be positive")
require(
!spec.tables.is_empty() && !spec.roots.is_empty(),
"tables and roots are required",
)
let tables : Map[String, Table] = Map([])
for table in spec.tables {
require(valid_name(table.name), "invalid table identifier")
require(!tables.contains(table.name), "duplicate table: \{table.name}")
tables[table.name] = table
require(
names_in(table.columns, table.columns),
"columns must be nonempty and unique in \{table.name}",
)
require(
table.columns.all(valid_name),
"invalid column identifier in \{table.name}",
)
require(
names_in(table.key, table.columns),
"invalid primary key for \{table.name}",
)
}
for table in spec.tables {
let seen_fks : Map[String, Bool] = Map([])
for fk in table.foreign_keys {
guard tables.get(fk.parent) is Some(parent) else {
raise Invalid("missing foreign key parent for \{table.name}")
}
require(
names_in(fk.columns, table.columns),
"invalid foreign key columns in \{table.name}",
)
require(
fk.columns.length() == fk.references.length() &&
fk.references == parent.key,
"foreign keys must reference the entire declared primary key of \{parent.name}",
)
let signature = @json.ToJson::to_json(fk).stringify()
require(
!seen_fks.contains(signature),
"duplicate foreign key in \{table.name}",
)
seen_fks[signature] = true
}
}
for root in spec.roots {
guard tables.get(root.table) is Some(table) else {
raise Invalid("unknown root table")
}
require(!root.keys.is_empty(), "each root needs at least one key")
for key in root.keys {
require(
key.length() == table.key.length() && key.all(fn(v) { v is String(_) }),
"root key for \{root.table} must be an array of text values matching the primary key",
)
}
}
validate_masks(spec, tables)
for edge in spec.follow {
guard tables.get(edge.child) is Some(child) else {
raise Invalid("unknown follow child table")
}
require(
edge.foreign_key >= 0 && edge.foreign_key < child.foreign_keys.length(),
"invalid follow foreign key index",
)
require(
child.foreign_keys[edge.foreign_key].parent == edge.from,
"follow source must match foreign key parent",
)
}
}