schema ids can now contain a subschema

src/database/mod.rs

@@ -79,7 +79,18 @@ impl Database {
               db.relations.insert(def.constraint.clone(), def);
             }
           }
-          Err(e) => println!("DATABASE RELATION PARSE FAILED: {:?}", e),
+          Err(e) => {
+            return Err(crate::drop::Drop::with_errors(vec![crate::drop::Error {
+              code: "DATABASE_RELATION_PARSE_FAILED".to_string(),
+              message: format!("Failed to parse database relation: {}", e),
+              details: crate::drop::ErrorDetails {
+                path: "".to_string(),
+                cause: None,
+                context: None,
+                schema: None,
+              },
+            }]));
+          }
         }
       }
     }
@@ -137,7 +148,30 @@ impl Database {
   }
 
   pub fn compile(&mut self) -> Result<(), crate::drop::Drop> {
-    self.collect_schemas();
+    let mut harvested = Vec::new();
+    for schema in self.schemas.values_mut() {
+      if let Err(msg) = schema.collect_schemas(None, &mut harvested) {
+        return Err(crate::drop::Drop::with_errors(vec![crate::drop::Error {
+          code: "SCHEMA_VALIDATION_FAILED".to_string(),
+          message: msg,
+          details: crate::drop::ErrorDetails { path: "".to_string(), cause: None, context: None, schema: None },
+        }]));
+      }
+    }
+    self.schemas.extend(harvested);
+
+    if let Err(msg) = self.collect_schemas() {
+      return Err(crate::drop::Drop::with_errors(vec![crate::drop::Error {
+        code: "SCHEMA_VALIDATION_FAILED".to_string(),
+        message: msg,
+        details: crate::drop::ErrorDetails {
+          path: "".to_string(),
+          cause: None,
+          context: None,
+          schema: None,
+        },
+      }]));
+    }
     self.collect_depths();
     self.collect_descendants();
 
@@ -150,29 +184,31 @@ impl Database {
     Ok(())
   }
 
-  fn collect_schemas(&mut self) {
+  fn collect_schemas(&mut self) -> Result<(), String> {
     let mut to_insert = Vec::new();
 
     // Pass 1: Extract all Schemas structurally off top level definitions into the master registry.
+    // Validate every node recursively via string filters natively!
     for type_def in self.types.values() {
       for mut schema in type_def.schemas.clone() {
-        schema.harvest(&mut to_insert);
+        schema.collect_schemas(None, &mut to_insert)?;
       }
     }
     for punc_def in self.puncs.values() {
       for mut schema in punc_def.schemas.clone() {
-        schema.harvest(&mut to_insert);
+        schema.collect_schemas(None, &mut to_insert)?;
       }
     }
     for enum_def in self.enums.values() {
       for mut schema in enum_def.schemas.clone() {
-        schema.harvest(&mut to_insert);
+        schema.collect_schemas(None, &mut to_insert)?;
       }
     }
 
     for (id, schema) in to_insert {
       self.schemas.insert(id, schema);
     }
+    Ok(())
   }
 
   fn collect_depths(&mut self) {
@@ -228,82 +264,6 @@ impl Database {
     self.descendants = descendants;
   }
 
-  fn resolve_relation(
-    &self,
-    parent_type: &str,
-    child_type: &str,
-    prop_name: &str,
-    relative_keys: Option<&Vec<String>>,
-  ) -> Option<(&Relation, bool)> {
-    if parent_type == "entity" && child_type == "entity" {
-      return None; // Ignore entity <-> entity generic fallbacks, they aren't useful edges
-    }
-
-    let p_def = self.types.get(parent_type)?;
-    let c_def = self.types.get(child_type)?;
-
-    let mut matching_rels = Vec::new();
-    let mut directions = Vec::new();
-
-    for rel in self.relations.values() {
-      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 prop_name.starts_with(prefix)
-          || prefix.starts_with(prop_name)
-          || prefix.replace("_", "") == prop_name.replace("_", "")
-        {
-          chosen_idx = i;
-          resolved = true;
-          break;
-        }
-      }
-    }
-
-    // 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(
     target: &str,
     direct_refs: &std::collections::HashMap<String, Vec<String>>,