cellular/jspg
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

more fixes

Browse Source
This commit is contained in:
Alex Groleau
2026-03-18 04:39:48 -04:00
parent 885b9b5e44
commit 00375c2926
4 changed files with 137 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

155
src/database/mod.rs
View File

@ -32,7 +32,7 @@ pub struct Database {
pub enums: HashMap<String, Enum>,
pub types: HashMap<String, Type>,
pub puncs: HashMap<String, Punc>,
pub relations: HashMap<(String, String), Vec<Relation>>,
pub relations: Vec<Relation>,
pub schemas: HashMap<String, Schema>,
// Map of Schema ID -> { Entity Type -> Target Subschema Arc }
pub stems: HashMap<String, HashMap<String, Arc<Stem>>>,
@ -46,7 +46,7 @@ impl Database {
let mut db = Self {
enums: HashMap::new(),
types: HashMap::new(),
relations: HashMap::new(),
relations: Vec::new(),
puncs: HashMap::new(),
schemas: HashMap::new(),
stems: HashMap::new(),
@ -74,12 +74,15 @@ impl Database {
}
}
let mut raw_relations = Vec::new();
if let Some(arr) = val.get("relations").and_then(|v| v.as_array()) {
for item in arr {
match serde_json::from_value::<Relation>(item.clone()) {
Ok(def) => {
raw_relations.push(def);
if db.types.contains_key(&def.source_type)
&& db.types.contains_key(&def.destination_type)
{
db.relations.push(def);
}
}
Err(e) => println!("DATABASE RELATION PARSE FAILED: {:?}", e),
}
@ -108,7 +111,7 @@ impl Database {
}
}
db.compile(raw_relations)?;
db.compile()?;
Ok(db)
}
@ -138,12 +141,10 @@ impl Database {
self.executor.timestamp()
}
/// Organizes the graph of the database, compiling regex, format functions, and caching relationships.
pub fn compile(&mut self, raw_relations: Vec<Relation>) -> Result<(), crate::drop::Drop> {
pub fn compile(&mut self) -> Result<(), crate::drop::Drop> {
self.collect_schemas();
self.collect_depths();
self.collect_descendants();
self.collect_relations(raw_relations);
self.compile_schemas();
self.collect_stems()?;
@ -228,93 +229,77 @@ impl Database {
self.descendants = descendants;
}
fn collect_relations(&mut self, raw_relations: Vec<Relation>) {
let mut edges: HashMap<(String, String), Vec<Relation>> = HashMap::new();
// For every relation, map it across all polymorphic inheritance permutations
for relation in raw_relations {
if let Some(_source_type_def) = self.types.get(&relation.source_type) {
if let Some(_dest_type_def) = self.types.get(&relation.destination_type) {
let mut src_descendants = Vec::new();
let mut dest_descendants = Vec::new();
for (t_name, t_def) in &self.types {
if t_def.hierarchy.contains(&relation.source_type) {
src_descendants.push(t_name.clone());
}
if t_def.hierarchy.contains(&relation.destination_type) {
dest_descendants.push(t_name.clone());
}
}
for p_type in &src_descendants {
for c_type in &dest_descendants {
// Ignore entity <-> entity generic fallbacks, they aren't useful edges
if p_type == "entity" && c_type == "entity" {
continue;
}
// Forward edge
edges
.entry((p_type.clone(), c_type.clone()))
.or_default()
.push(relation.clone());
// Reverse edge (only if types are different to avoid duplicating self-referential edges like activity parent_id)
if p_type != c_type {
edges
.entry((c_type.clone(), p_type.clone()))
.or_default()
.push(relation.clone());
}
}
}
}
}
}
self.relations = edges;
}
pub fn get_relation(
&self,
parent_type: &str,
child_type: &str,
prop_name: &str,
relative_keys: Option<&Vec<String>>,
) -> Option<&Relation> {
if let Some(relations) = self
.relations
.get(&(parent_type.to_string(), child_type.to_string()))
{
if relations.len() == 1 {
return Some(&relations[0]);
}
) -> Option<(&Relation, bool)> {
if parent_type == "entity" && child_type == "entity" {
return None; // Ignore entity <-> entity generic fallbacks, they aren't useful edges
}
// Reduce ambiguity with prefix
for rel in relations {
if let Some(prefix) = &rel.prefix {
if prefix == prop_name {
return Some(rel);
}
}
}
let p_def = self.types.get(parent_type)?;
let c_def = self.types.get(child_type)?;
// Reduce ambiguity by checking if relative payload OMITS the prefix (M:M heuristic)
if let Some(keys) = relative_keys {
let mut missing_prefix_rels = Vec::new();
for rel in relations {
if let Some(prefix) = &rel.prefix {
if !keys.contains(prefix) {
missing_prefix_rels.push(rel);
}
}
}
if missing_prefix_rels.len() == 1 {
return Some(missing_prefix_rels[0]);
let mut matching_rels = Vec::new();
let mut directions = Vec::new();
for rel in &self.relations {
let is_forward = p_def.hierarchy.contains(&rel.source_type)
&& c_def.hierarchy.contains(&rel.destination_type);
let is_reverse = p_def.hierarchy.contains(&rel.destination_type)
&& c_def.hierarchy.contains(&rel.source_type);
if is_forward {
matching_rels.push(rel);
directions.push(true);
} else if is_reverse {
matching_rels.push(rel);
directions.push(false);
}
}
if matching_rels.is_empty() {
return None;
}
if matching_rels.len() == 1 {
return Some((matching_rels[0], directions[0]));
}
let mut chosen_idx = 0;
let mut resolved = false;
// Reduce ambiguity with prefix
for (i, rel) in matching_rels.iter().enumerate() {
if let Some(prefix) = &rel.prefix {
if prefix == prop_name {
chosen_idx = i;
resolved = true;
break;
}
}
}
None
// Reduce ambiguity by checking if relative payload OMITS the prefix (M:M heuristic)
if !resolved && relative_keys.is_some() {
let keys = relative_keys.unwrap();
let mut missing_prefix_ids = Vec::new();
for (i, rel) in matching_rels.iter().enumerate() {
if let Some(prefix) = &rel.prefix {
if !keys.contains(prefix) {
missing_prefix_ids.push(i);
}
}
}
if missing_prefix_ids.len() == 1 {
chosen_idx = missing_prefix_ids[0];
}
}
Some((matching_rels[chosen_idx], directions[chosen_idx]))
}
fn collect_descendants_recursively(
@ -427,7 +412,7 @@ impl Database {
let expected_col = format!("{}_id", prop);
let mut found = false;
if let Some(rel) = db.get_relation(pt, &entity_type, prop, None) {
if let Some((rel, _)) = db.get_relation(pt, &entity_type, prop, None) {
if rel.source_columns.contains(&expected_col) {
relation_col = Some(expected_col.clone());
found = true;