checkpoint

src/database/schema.rs

@@ -161,12 +161,24 @@ impl Schema {
     }
     if let Some(one_of) = &self.obj.one_of {
       for (i, child) in one_of.iter().enumerate() {
-        child.compile(db, root_id, format!("{}/oneOf/{}", path, i), visited, errors);
+        child.compile(
+          db,
+          root_id,
+          format!("{}/oneOf/{}", path, i),
+          visited,
+          errors,
+        );
       }
     }
     if let Some(arr) = &self.obj.prefix_items {
       for (i, child) in arr.iter().enumerate() {
-        child.compile(db, root_id, format!("{}/prefixItems/{}", path, i), visited, errors);
+        child.compile(
+          db,
+          root_id,
+          format!("{}/prefixItems/{}", path, i),
+          visited,
+          errors,
+        );
       }
     }
     if let Some(child) = &self.obj.not {
@@ -178,13 +190,31 @@ impl Schema {
     if let Some(cases) = &self.obj.cases {
       for (i, c) in cases.iter().enumerate() {
         if let Some(child) = &c.when {
-          child.compile(db, root_id, format!("{}/cases/{}/when", path, i), visited, errors);
+          child.compile(
+            db,
+            root_id,
+            format!("{}/cases/{}/when", path, i),
+            visited,
+            errors,
+          );
         }
         if let Some(child) = &c.then {
-          child.compile(db, root_id, format!("{}/cases/{}/then", path, i), visited, errors);
+          child.compile(
+            db,
+            root_id,
+            format!("{}/cases/{}/then", path, i),
+            visited,
+            errors,
+          );
         }
         if let Some(child) = &c.else_ {
-          child.compile(db, root_id, format!("{}/cases/{}/else", path, i), visited, errors);
+          child.compile(
+            db,
+            root_id,
+            format!("{}/cases/{}/else", path, i),
+            visited,
+            errors,
+          );
         }
       }
     }
@@ -220,7 +250,7 @@ impl Schema {
     if let Some(family) = &self.obj.family {
       // 1. Explicit horizontal routing
       parent_type_name = Some(family.split('.').next_back().unwrap_or(family).to_string());
-    } else if !path.contains('/') {
+    } else if path == root_id {
       // 2. Root nodes trust their exact registry footprint
       let base_type_name = path.split('.').next_back().unwrap_or(path).to_string();
       if db.types.contains_key(&base_type_name) {
@@ -234,7 +264,7 @@ impl Schema {
     }
 
     if parent_type_name.is_none() {
-      // 4. Absolute fallback for completely anonymous inline structures
+      // 3. Absolute fallback for anonymous inline structures
       let base_type_name = root_id
         .split('.')
         .next_back()
@@ -247,9 +277,17 @@ impl Schema {
 
     if let Some(p_type) = parent_type_name {
       // Proceed only if the resolved table physically exists within the Postgres Type hierarchy
-      if db.types.contains_key(&p_type) {
+      if let Some(type_def) = db.types.get(&p_type) {
         // Iterate over all discovered schema boundaries mapped inside the object
         for (prop_name, prop_schema) in props {
+          if let Some(field_types_map) = type_def.field_types.as_ref().and_then(|v| v.as_object()) {
+            if let Some(pg_type) = field_types_map.get(prop_name).and_then(|v| v.as_str()) {
+              if pg_type == "json" || pg_type == "jsonb" {
+                continue;
+              }
+            }
+          }
+
           let mut child_type_name = None;
           let mut target_schema = prop_schema.clone();
           let mut is_array = false;
@@ -290,7 +328,13 @@ impl Schema {
             if db.types.contains_key(&c_type) {
               // Ensure the child Schema's AST has accurately compiled its own physical property keys so we can
               // inject them securely for Many-to-Many Twin Deduction disambiguation matching.
-              target_schema.compile(db, root_id, format!("{}/{}", path, prop_name), visited, errors);
+              target_schema.compile(
+                db,
+                root_id,
+                format!("{}/{}", path, prop_name),
+                visited,
+                errors,
+              );
               if let Some(compiled_target_props) = target_schema.obj.compiled_properties.get() {
                 let keys_for_ambiguity: Vec<String> =
                   compiled_target_props.keys().cloned().collect();
@@ -559,7 +603,13 @@ impl Schema {
 
     let mut map_arr = |arr: &Vec<Arc<Schema>>, sub: &str| {
       for (i, v) in arr.iter().enumerate() {
-        Self::collect_schemas(v, root_id, format!("{}/{}/{}", path, sub, i), to_insert, errors);
+        Self::collect_schemas(
+          v,
+          root_id,
+          format!("{}/{}/{}", path, sub, i),
+          to_insert,
+          errors,
+        );
       }
     };
 

src/queryer/compiler.rs

@@ -473,6 +473,15 @@ impl<'a> Compiler<'a> {
         }
       }
 
+      if let Some(ft) = r#type.field_types.as_ref().and_then(|v| v.as_object()) {
+        if let Some(pg_type) = ft.get(prop_key).and_then(|v| v.as_str()) {
+          if pg_type == "json" || pg_type == "jsonb" {
+            select_args.push(format!("'{}', {}.{}", prop_key, owner_alias, prop_key));
+            continue;
+          }
+        }
+      }
+
       let child_node = Node {
         schema: std::sync::Arc::clone(prop_schema),
         parent_alias: owner_alias.clone(),