added keyword to jspg

src/lib.rs

@@ -11,8 +11,13 @@ mod schema;
 pub mod util;
 mod validator;
 
-use crate::schema::Schema;
-use serde_json::{Value, json};
+pub mod context;
+pub mod error;
+pub mod instance;
+pub mod result;
+pub(crate) mod rules;
+
+use serde_json::json;
 use std::sync::{Arc, RwLock};
 
 lazy_static::lazy_static! {
@@ -26,79 +31,12 @@ lazy_static::lazy_static! {
 
 #[pg_extern(strict)]
 pub fn cache_json_schemas(enums: JsonB, types: JsonB, puncs: JsonB) -> JsonB {
-  // 1. Build a new Registry LOCALLY (on stack)
-  let mut registry = registry::Registry::new();
-
-  // Generate Family Schemas from Types
-  {
-    let mut family_map: std::collections::HashMap<String, std::collections::HashSet<String>> =
-      std::collections::HashMap::new();
-    if let Value::Array(arr) = &types.0 {
-      for item in arr {
-        if let Some(name) = item.get("name").and_then(|v| v.as_str()) {
-          if let Some(hierarchy) = item.get("hierarchy").and_then(|v| v.as_array()) {
-            for ancestor in hierarchy {
-              if let Some(anc_str) = ancestor.as_str() {
-                family_map
-                  .entry(anc_str.to_string())
-                  .or_default()
-                  .insert(name.to_string());
-              }
-            }
-          }
-        }
-      }
-    }
-
-    for (family_name, members) in family_map {
-      let id = format!("{}.family", family_name);
-
-      // Object Union (for polymorphic object validation)
-      // This allows the schema to match ANY of the types in the family hierarchy
-      let object_refs: Vec<Value> = members.iter().map(|s| json!({ "$ref": s })).collect();
-
-      let schema_json = json!({
-          "$id": id,
-          "oneOf": object_refs
-      });
-
-      if let Ok(schema) = serde_json::from_value::<Schema>(schema_json) {
-        registry.add(schema);
-      }
-    }
-
-    // Helper to parse and cache a list of items
-    let mut cache_items = |items: JsonB| {
-      if let Value::Array(arr) = items.0 {
-        for item in arr {
-          // For now, we assume the item structure matches what the generator expects
-          // or what `json_schemas.sql` sends.
-          // The `Schema` struct in `schema.rs` is designed to deserialize standard JSON Schema.
-          // However, the input here is an array of objects that *contain* a `schemas` array.
-          // We need to extract those inner schemas.
-
-          if let Some(schemas_val) = item.get("schemas") {
-            if let Value::Array(schemas) = schemas_val {
-              for schema_val in schemas {
-                // Deserialize into our robust Schema struct to ensure validity/parsing
-                if let Ok(schema) = serde_json::from_value::<Schema>(schema_val.clone()) {
-                  // Registry handles compilation
-                  registry.add(schema);
-                }
-              }
-            }
-          }
-        }
-      }
-    };
-
-    cache_items(enums);
-    cache_items(types);
-    cache_items(puncs); // public/private distinction logic to come later
-  }
-
-  // 2. Wrap in Validator and Arc
-  let new_validator = validator::Validator::new(registry);
+  // 1 & 2. Build Registry, Families, and Wrap in Validator all in one shot
+  let new_validator = crate::validator::Validator::from_punc_definition(
+    Some(&enums.0),
+    Some(&types.0),
+    Some(&puncs.0),
+  );
   let new_arc = Arc::new(new_validator);
 
   // 3. ATOMIC SWAP