version: 1.0.79

.test/tests.md

@@ -0,0 +1,11 @@
+# 🗒️ Test Report (punc/framework)
+
+_Generated at Wed Mar 18 05:21:40 EDT 2026_
+
+## Summary
+
+| Lang | Status | Tests | Passed | Failed | Duration |
+| :--- | :---: | :---: | :---: | :---: | ---: |
+
+## Results
+

fixtures/queryer.json

@@ -858,27 +858,6 @@
           ]
         }
       },
-      {
-        "description": "Simple entity select on root stem",
-        "action": "query",
-        "schema_id": "entity",
-        "stem": "",
-        "expect": {
-          "success": true,
-          "sql": [
-            [
-              "(SELECT jsonb_build_object(",
-              "    'archived', entity_1.archived,",
-              "    'created_at', entity_1.created_at,",
-              "    'id', entity_1.id,",
-              "    'name', entity_1.name,",
-              "    'type', entity_1.type)",
-              "FROM agreego.entity entity_1",
-              "WHERE NOT entity_1.archived)"
-            ]
-          ]
-        }
-      },
       {
         "description": "Simple entity select with multiple filters",
         "action": "query",
@@ -1016,7 +995,7 @@
               "        JOIN agreego.entity entity_8 ON entity_8.id = address_7.id",
               "        WHERE",
               "            NOT entity_8.archived",
-              "            AND relationship_5.target_id = address_7.id),",
+              "            AND relationship_5.target_id = entity_8.id),",
               "        'type', entity_6.type",
               "    )), '[]'::jsonb)",
               "    FROM agreego.contact contact_4",
@@ -1024,7 +1003,7 @@
               "    JOIN agreego.entity entity_6 ON entity_6.id = relationship_5.id",
               "    WHERE",
               "        NOT entity_6.archived",
-              "        AND contact_4.source_id = entity_3.id),",
+              "        AND relationship_5.source_id = entity_3.id),",
               "    'age', person_1.age,",
               "    'archived', entity_3.archived,",
               "    'contacts',",
@@ -1048,7 +1027,7 @@
               "                 JOIN agreego.entity entity_17 ON entity_17.id = address_16.id",
               "                 WHERE",
               "                     NOT entity_17.archived",
-              "                     AND relationship_10.target_id = address_16.id))",
+              "                     AND relationship_10.target_id = entity_17.id))",
               "            WHEN entity_11.target_type = 'email_address' THEN",
               "                ((SELECT jsonb_build_object(",
               "                     'address', email_address_14.address,",
@@ -1062,7 +1041,7 @@
               "                 JOIN agreego.entity entity_15 ON entity_15.id = email_address_14.id",
               "                 WHERE",
               "                     NOT entity_15.archived",
-              "                     AND relationship_10.target_id = email_address_14.id))",
+              "                     AND relationship_10.target_id = entity_15.id))",
               "            WHEN entity_11.target_type = 'phone_number' THEN",
               "                ((SELECT jsonb_build_object(",
               "                     'archived', entity_13.archived,",
@@ -1076,7 +1055,7 @@
               "                 JOIN agreego.entity entity_13 ON entity_13.id = phone_number_12.id",
               "                 WHERE",
               "                     NOT entity_13.archived",
-              "                     AND relationship_10.target_id = phone_number_12.id))",
+              "                     AND relationship_10.target_id = entity_13.id))",
               "            ELSE NULL END,",
               "        'type', entity_11.type",
               "    )), '[]'::jsonb)",
@@ -1085,7 +1064,7 @@
               "    JOIN agreego.entity entity_11 ON entity_11.id = relationship_10.id",
               "    WHERE",
               "        NOT entity_11.archived",
-              "        AND contact_9.source_id = entity_3.id),",
+              "        AND relationship_10.source_id = entity_3.id),",
               "    'created_at', entity_3.created_at,",
               "    'email_addresses',",
               "    (SELECT COALESCE(jsonb_agg(jsonb_build_object(",
@@ -1107,7 +1086,7 @@
               "        JOIN agreego.entity entity_22 ON entity_22.id = email_address_21.id",
               "        WHERE",
               "            NOT entity_22.archived",
-              "            AND relationship_19.target_id = email_address_21.id),",
+              "            AND relationship_19.target_id = entity_22.id),",
               "        'type', entity_20.type",
               "    )), '[]'::jsonb)",
               "    FROM agreego.contact contact_18",
@@ -1115,7 +1094,7 @@
               "    JOIN agreego.entity entity_20 ON entity_20.id = relationship_19.id",
               "    WHERE",
               "        NOT entity_20.archived",
-              "        AND contact_18.source_id = entity_3.id),",
+              "        AND relationship_19.source_id = entity_3.id),",
               "    'first_name', person_1.first_name,",
               "    'id', entity_3.id,",
               "    'last_name', person_1.last_name,",
@@ -1140,7 +1119,7 @@
               "        JOIN agreego.entity entity_27 ON entity_27.id = phone_number_26.id",
               "        WHERE",
               "            NOT entity_27.archived",
-              "            AND relationship_24.target_id = phone_number_26.id),",
+              "            AND relationship_24.target_id = entity_27.id),",
               "        'type', entity_25.type",
               "    )), '[]'::jsonb)",
               "    FROM agreego.contact contact_23",
@@ -1148,7 +1127,7 @@
               "    JOIN agreego.entity entity_25 ON entity_25.id = relationship_24.id",
               "    WHERE",
               "        NOT entity_25.archived",
-              "        AND contact_23.source_id = entity_3.id),",
+              "        AND relationship_24.source_id = entity_3.id),",
               "    'type', entity_3.type",
               ")",
               "FROM agreego.person person_1",
@@ -1253,7 +1232,7 @@
               "        JOIN agreego.entity entity_8 ON entity_8.id = address_7.id",
               "        WHERE",
               "            NOT entity_8.archived",
-              "            AND relationship_5.target_id = address_7.id),",
+              "            AND relationship_5.target_id = entity_8.id),",
               "        'type', entity_6.type",
               "    )), '[]'::jsonb)",
               "    FROM agreego.contact contact_4",
@@ -1261,7 +1240,7 @@
               "    JOIN agreego.entity entity_6 ON entity_6.id = relationship_5.id",
               "    WHERE",
               "        NOT entity_6.archived",
-              "        AND contact_4.source_id = entity_3.id),",
+              "        AND relationship_5.source_id = entity_3.id),",
               "    'age', person_1.age,",
               "    'archived', entity_3.archived,",
               "    'contacts',",
@@ -1285,7 +1264,7 @@
               "                 JOIN agreego.entity entity_17 ON entity_17.id = address_16.id",
               "                 WHERE",
               "                     NOT entity_17.archived",
-              "                     AND relationship_10.target_id = address_16.id))",
+              "                     AND relationship_10.target_id = entity_17.id))",
               "            WHEN entity_11.target_type = 'email_address' THEN",
               "                ((SELECT jsonb_build_object(",
               "                     'address', email_address_14.address,",
@@ -1299,7 +1278,7 @@
               "                 JOIN agreego.entity entity_15 ON entity_15.id = email_address_14.id",
               "                 WHERE",
               "                     NOT entity_15.archived",
-              "                     AND relationship_10.target_id = email_address_14.id))",
+              "                     AND relationship_10.target_id = entity_15.id))",
               "            WHEN entity_11.target_type = 'phone_number' THEN",
               "                ((SELECT jsonb_build_object(",
               "                     'archived', entity_13.archived,",
@@ -1313,7 +1292,7 @@
               "                 JOIN agreego.entity entity_13 ON entity_13.id = phone_number_12.id",
               "                 WHERE",
               "                     NOT entity_13.archived",
-              "                     AND relationship_10.target_id = phone_number_12.id))",
+              "                     AND relationship_10.target_id = entity_13.id))",
               "            ELSE NULL END,",
               "        'type', entity_11.type",
               "    )), '[]'::jsonb)",
@@ -1323,7 +1302,7 @@
               "    WHERE",
               "        NOT entity_11.archived",
               "        AND contact_9.is_primary = ($11#>>'{}')::boolean",
-              "        AND contact_9.source_id = entity_3.id),",
+              "        AND relationship_10.source_id = entity_3.id),",
               "    'created_at', entity_3.created_at,",
               "    'email_addresses',",
               "    (SELECT COALESCE(jsonb_agg(jsonb_build_object(",
@@ -1345,7 +1324,7 @@
               "        JOIN agreego.entity entity_22 ON entity_22.id = email_address_21.id",
               "        WHERE",
               "            NOT entity_22.archived",
-              "            AND relationship_19.target_id = email_address_21.id),",
+              "            AND relationship_19.target_id = entity_22.id),",
               "        'type', entity_20.type",
               "    )), '[]'::jsonb)",
               "    FROM agreego.contact contact_18",
@@ -1353,7 +1332,7 @@
               "    JOIN agreego.entity entity_20 ON entity_20.id = relationship_19.id",
               "    WHERE",
               "        NOT entity_20.archived",
-              "        AND contact_18.source_id = entity_3.id),",
+              "        AND relationship_19.source_id = entity_3.id),",
               "    'first_name', person_1.first_name,",
               "    'id', entity_3.id,",
               "    'last_name', person_1.last_name,",
@@ -1379,7 +1358,7 @@
               "        WHERE",
               "            NOT entity_27.archived",
               "            AND phone_number_26.number ILIKE $32#>>'{}'",
-              "            AND relationship_24.target_id = phone_number_26.id),",
+              "            AND relationship_24.target_id = entity_27.id),",
               "        'type', entity_25.type",
               "    )), '[]'::jsonb)",
               "    FROM agreego.contact contact_23",
@@ -1387,7 +1366,7 @@
               "    JOIN agreego.entity entity_25 ON entity_25.id = relationship_24.id",
               "    WHERE",
               "        NOT entity_25.archived",
-              "        AND contact_23.source_id = entity_3.id),",
+              "        AND relationship_24.source_id = entity_3.id),",
               "    'type', entity_3.type",
               ")",
               "FROM agreego.person person_1",
@@ -1429,94 +1408,6 @@
           ]
         }
       },
-      {
-        "description": "Full person stem query on phone number contact",
-        "action": "query",
-        "schema_id": "full.person",
-        "stem": "phone_numbers.#",
-        "expect": {
-          "success": true,
-          "sql": [
-            [
-              "(SELECT jsonb_build_object(",
-              "    'archived', entity_3.archived,",
-              "    'created_at', entity_3.created_at,",
-              "    'id', entity_3.id,",
-              "    'is_primary', contact_1.is_primary,",
-              "    'name', entity_3.name,",
-              "    'target',",
-              "    (SELECT jsonb_build_object(",
-              "        'archived', entity_5.archived,",
-              "        'created_at', entity_5.created_at,",
-              "        'id', entity_5.id,",
-              "        'name', entity_5.name,",
-              "        'number', phone_number_4.number,",
-              "        'type', entity_5.type",
-              "    )",
-              "    FROM agreego.phone_number phone_number_4",
-              "    JOIN agreego.entity entity_5 ON entity_5.id = phone_number_4.id",
-              "    WHERE",
-              "        NOT entity_5.archived",
-              "        AND relationship_2.target_id = phone_number_4.id",
-              "    ),",
-              "    'type', entity_3.type",
-              ")",
-              "FROM agreego.contact contact_1",
-              "JOIN agreego.relationship relationship_2 ON relationship_2.id = contact_1.id",
-              "JOIN agreego.entity entity_3 ON entity_3.id = relationship_2.id",
-              "WHERE NOT entity_3.archived)"
-            ]
-          ]
-        }
-      },
-      {
-        "description": "Full person stem query on phone number contact on phone number",
-        "action": "query",
-        "schema_id": "full.person",
-        "stem": "phone_numbers.#.target",
-        "expect": {
-          "success": true,
-          "sql": [
-            [
-              "(SELECT jsonb_build_object(",
-              "    'archived', entity_2.archived,",
-              "    'created_at', entity_2.created_at,",
-              "    'id', entity_2.id,",
-              "    'name', entity_2.name,",
-              "    'number', phone_number_1.number,",
-              "    'type', entity_2.type",
-              ")",
-              "FROM agreego.phone_number phone_number_1",
-              "JOIN agreego.entity entity_2 ON entity_2.id = phone_number_1.id",
-              "WHERE NOT entity_2.archived)"
-            ]
-          ]
-        }
-      },
-      {
-        "description": "Full person stem query on contact email address",
-        "action": "query",
-        "schema_id": "full.person",
-        "stem": "contacts.#.target#(type==\"email_address\")",
-        "expect": {
-          "success": true,
-          "sql": [
-            [
-              "(SELECT jsonb_build_object(",
-              "    'address', email_address_1.address,",
-              "    'archived', entity_2.archived,",
-              "    'created_at', entity_2.created_at,",
-              "    'id', entity_2.id,",
-              "    'name', entity_2.name,",
-              "    'type', entity_2.type",
-              ")",
-              "FROM agreego.email_address email_address_1",
-              "JOIN agreego.entity entity_2 ON entity_2.id = email_address_1.id",
-              "WHERE NOT entity_2.archived)"
-            ]
-          ]
-        }
-      },
       {
         "description": "Order select with customer and lines",
         "action": "query",

fixtures/stems.json

@@ -1,312 +0,0 @@
-[
-  {
-    "description": "Stem Engine Unit Tests",
-    "database": {
-      "puncs": [],
-      "enums": [],
-      "relations": [
-        {
-          "id": "rel1",
-          "type": "relation",
-          "constraint": "fk_contact_entity",
-          "source_type": "contact",
-          "source_columns": [
-            "entity_id"
-          ],
-          "destination_type": "person",
-          "destination_columns": [
-            "id"
-          ],
-          "prefix": null
-        },
-        {
-          "id": "rel2",
-          "type": "relation",
-          "constraint": "fk_relationship_target",
-          "source_type": "relationship",
-          "source_columns": [
-            "target_id",
-            "target_type"
-          ],
-          "destination_type": "entity",
-          "destination_columns": [
-            "id",
-            "type"
-          ],
-          "prefix": "target"
-        }
-      ],
-      "types": [
-        {
-          "name": "entity",
-          "hierarchy": [
-            "entity"
-          ],
-          "schemas": [
-            {
-              "$id": "entity",
-              "type": "object",
-              "properties": {}
-            }
-          ]
-        },
-        {
-          "name": "person",
-          "hierarchy": [
-            "person",
-            "entity"
-          ],
-          "schemas": [
-            {
-              "$id": "person",
-              "$ref": "entity",
-              "properties": {}
-            }
-          ]
-        },
-        {
-          "name": "email_address",
-          "hierarchy": [
-            "email_address",
-            "entity"
-          ],
-          "schemas": [
-            {
-              "$id": "email_address",
-              "$ref": "entity",
-              "properties": {}
-            }
-          ]
-        },
-        {
-          "name": "phone_number",
-          "hierarchy": [
-            "phone_number",
-            "entity"
-          ],
-          "schemas": [
-            {
-              "$id": "phone_number",
-              "$ref": "entity",
-              "properties": {}
-            }
-          ]
-        },
-        {
-          "name": "relationship",
-          "relationship": true,
-          "hierarchy": [
-            "relationship",
-            "entity"
-          ],
-          "schemas": [
-            {
-              "$id": "relationship",
-              "$ref": "entity",
-              "properties": {}
-            }
-          ]
-        },
-        {
-          "name": "contact",
-          "relationship": true,
-          "hierarchy": [
-            "contact",
-            "relationship",
-            "entity"
-          ],
-          "schemas": [
-            {
-              "$id": "contact",
-              "$ref": "relationship",
-              "properties": {
-                "target": {
-                  "oneOf": [
-                    {
-                      "$ref": "phone_number"
-                    },
-                    {
-                      "$ref": "email_address"
-                    }
-                  ]
-                }
-              }
-            }
-          ]
-        },
-        {
-          "name": "save_person",
-          "schemas": [
-            {
-              "$id": "save_person.response",
-              "$ref": "person",
-              "properties": {
-                "contacts": {
-                  "type": "array",
-                  "items": {
-                    "$ref": "contact"
-                  }
-                }
-              }
-            }
-          ]
-        }
-      ]
-    },
-    "tests": [
-      {
-        "description": "correctly squashes deep oneOf refs through array paths",
-        "action": "compile",
-        "expect": {
-          "success": true,
-          "stems": {
-            "contact": {
-              "": {
-                "schema": {
-                  "$id": "contact",
-                  "$ref": "relationship",
-                  "properties": {
-                    "target": {
-                      "oneOf": [
-                        {
-                          "$ref": "phone_number"
-                        },
-                        {
-                          "$ref": "email_address"
-                        }
-                      ]
-                    }
-                  }
-                },
-                "type": "contact"
-              },
-              "target#(type==\"email_address\")": {
-                "relation": "target_id",
-                "schema": {
-                  "$id": "email_address",
-                  "$ref": "entity",
-                  "properties": {}
-                },
-                "type": "email_address"
-              },
-              "target#(type==\"phone_number\")": {
-                "relation": "target_id",
-                "schema": {
-                  "$id": "phone_number",
-                  "$ref": "entity",
-                  "properties": {}
-                },
-                "type": "phone_number"
-              }
-            },
-            "email_address": {
-              "": {
-                "schema": {
-                  "$id": "email_address",
-                  "$ref": "entity",
-                  "properties": {}
-                },
-                "type": "email_address"
-              }
-            },
-            "entity": {
-              "": {
-                "schema": {
-                  "$id": "entity",
-                  "properties": {},
-                  "type": "object"
-                },
-                "type": "entity"
-              }
-            },
-            "person": {
-              "": {
-                "schema": {
-                  "$id": "person",
-                  "$ref": "entity",
-                  "properties": {}
-                },
-                "type": "person"
-              }
-            },
-            "phone_number": {
-              "": {
-                "schema": {
-                  "$id": "phone_number",
-                  "$ref": "entity",
-                  "properties": {}
-                },
-                "type": "phone_number"
-              }
-            },
-            "relationship": {
-              "": {
-                "schema": {
-                  "$id": "relationship",
-                  "$ref": "entity",
-                  "properties": {}
-                },
-                "type": "relationship"
-              }
-            },
-            "save_person.response": {
-              "": {
-                "schema": {
-                  "$id": "save_person.response",
-                  "$ref": "person",
-                  "properties": {
-                    "contacts": {
-                      "items": {
-                        "$ref": "contact"
-                      },
-                      "type": "array"
-                    }
-                  }
-                },
-                "type": "person"
-              },
-              "contacts.#": {
-                "relation": "contacts_id",
-                "schema": {
-                  "$id": "contact",
-                  "$ref": "relationship",
-                  "properties": {
-                    "target": {
-                      "oneOf": [
-                        {
-                          "$ref": "phone_number"
-                        },
-                        {
-                          "$ref": "email_address"
-                        }
-                      ]
-                    }
-                  }
-                },
-                "type": "contact"
-              },
-              "contacts.#.target#(type==\"email_address\")": {
-                "relation": "target_id",
-                "schema": {
-                  "$id": "email_address",
-                  "$ref": "entity",
-                  "properties": {}
-                },
-                "type": "email_address"
-              },
-              "contacts.#.target#(type==\"phone_number\")": {
-                "relation": "target_id",
-                "schema": {
-                  "$id": "phone_number",
-                  "$ref": "entity",
-                  "properties": {}
-                },
-                "type": "phone_number"
-              }
-            }
-          }
-        }
-      }
-    ]
-  }
-]

src/database/mod.rs

@@ -18,24 +18,19 @@ use executors::pgrx::SpiExecutor;
 #[cfg(test)]
 use executors::mock::MockExecutor;
 
-pub mod stem;
 use punc::Punc;
 use relation::Relation;
 use schema::Schema;
 use serde_json::Value;
 use std::collections::{HashMap, HashSet};
-use std::sync::Arc;
-use stem::Stem;
 use r#type::Type;
 
 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>>>,
   pub descendants: HashMap<String, Vec<String>>,
   pub depths: HashMap<String, usize>,
   pub executor: Box<dyn DatabaseExecutor + Send + Sync>,
@@ -46,10 +41,9 @@ 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(),
       descendants: HashMap::new(),
       depths: HashMap::new(),
       #[cfg(not(test))]
@@ -74,12 +68,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 +105,7 @@ impl Database {
       }
     }
 
-    db.compile(raw_relations)?;
+    db.compile()?;
     Ok(db)
   }
 
@@ -138,14 +135,11 @@ impl Database {
     self.executor.timestamp()
   }
 
-  /// Organizes the graph of the database, compiling regex, format functions, and caching relationships.
+  pub fn compile(&mut self) -> Result<(), crate::drop::Drop> {
-  pub fn compile(&mut self, raw_relations: Vec<Relation>) -> Result<(), crate::drop::Drop> {
     self.collect_schemas();
     self.collect_depths();
     self.collect_descendants();
-    self.collect_relations(raw_relations);
     self.compile_schemas();
-    self.collect_stems()?;
 
     Ok(())
   }
@@ -228,93 +222,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> {
+  ) -> Option<(&Relation, bool)> {
-    if let Some(relations) = self
+    if parent_type == "entity" && child_type == "entity" {
-      .relations
+      return None; // Ignore entity <-> entity generic fallbacks, they aren't useful edges
-      .get(&(parent_type.to_string(), child_type.to_string()))
+    }
-    {
-      if relations.len() == 1 {
-        return Some(&relations[0]);
-      }
 
-      // Reduce ambiguity with prefix
+    let p_def = self.types.get(parent_type)?;
-      for rel in relations {
+    let c_def = self.types.get(child_type)?;
-        if let Some(prefix) = &rel.prefix {
-          if prefix == prop_name {
-            return Some(rel);
-          }
-        }
-      }
 
-      // Reduce ambiguity by checking if relative payload OMITS the prefix (M:M heuristic)
+    let mut matching_rels = Vec::new();
-      if let Some(keys) = relative_keys {
+    let mut directions = Vec::new();
-        let mut missing_prefix_rels = Vec::new();
+
-        for rel in relations {
+    for rel in &self.relations {
-          if let Some(prefix) = &rel.prefix {
+      let is_forward = p_def.hierarchy.contains(&rel.source_type)
-            if !keys.contains(prefix) {
+        && c_def.hierarchy.contains(&rel.destination_type);
-              missing_prefix_rels.push(rel);
+      let is_reverse = p_def.hierarchy.contains(&rel.destination_type)
-            }
+        && c_def.hierarchy.contains(&rel.source_type);
-          }
+
-        }
+      if is_forward {
-        if missing_prefix_rels.len() == 1 {
+        matching_rels.push(rel);
-          return Some(missing_prefix_rels[0]);
+        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(
@@ -340,236 +318,4 @@ impl Database {
       }
     }
   }
-
-  fn collect_stems(&mut self) -> Result<(), crate::drop::Drop> {
-    let mut db_stems: HashMap<String, HashMap<String, Arc<Stem>>> = HashMap::new();
-    let mut errors: Vec<crate::drop::Error> = Vec::new();
-
-    let schema_ids: Vec<String> = self.schemas.keys().cloned().collect();
-    for schema_id in schema_ids {
-      if let Some(schema) = self.schemas.get(&schema_id) {
-        let mut inner_map = HashMap::new();
-        Self::discover_stems(
-          self,
-          &schema_id,
-          schema,
-          String::from(""),
-          None,
-          None,
-          false,
-          &mut inner_map,
-          Vec::new(),
-          &mut errors,
-        );
-        if !inner_map.is_empty() {
-          db_stems.insert(schema_id, inner_map);
-        }
-      }
-    }
-
-    self.stems = db_stems;
-
-    if !errors.is_empty() {
-      return Err(crate::drop::Drop::with_errors(errors));
-    }
-    Ok(())
-  }
-
-  fn discover_stems(
-    db: &Database,
-    root_schema_id: &str,
-    schema: &Schema,
-    current_path: String,
-    parent_type: Option<String>,
-    property_name: Option<String>,
-    is_polymorphic: bool,
-    inner_map: &mut HashMap<String, Arc<Stem>>,
-    seen_entities: Vec<String>,
-    errors: &mut Vec<crate::drop::Error>,
-  ) {
-    let mut is_entity = false;
-    let mut entity_type = String::new();
-
-    // First check if the Schema's $id is a native Database Type
-    if let Some(ref id) = schema.obj.id {
-      let parts: Vec<&str> = id.split('.').collect();
-      if let Some(last_seg) = parts.last() {
-        if db.types.contains_key(*last_seg) {
-          is_entity = true;
-          entity_type = last_seg.to_string();
-        }
-      }
-    }
-
-    // If not found via $id, check the $ref pointer
-    // This allows ad-hoc schemas (like `save_person.response`) to successfully adopt the Type of what they $ref
-    if !is_entity {
-      if let Some(ref r) = schema.obj.r#ref {
-        let parts: Vec<&str> = r.split('.').collect();
-        if let Some(last_seg) = parts.last() {
-          if db.types.contains_key(*last_seg) {
-            is_entity = true;
-            entity_type = last_seg.to_string();
-          }
-        }
-      }
-    }
-
-    if is_entity {
-      if seen_entities.contains(&entity_type) {
-        return; // Break cyclical schemas!
-      }
-    }
-
-    let mut relation_col = None;
-    if is_entity {
-      if let (Some(pt), Some(prop)) = (&parent_type, &property_name) {
-        let expected_col = format!("{}_id", prop);
-        let mut found = false;
-
-        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;
-          }
-        }
-
-        if !found {
-          relation_col = Some(expected_col);
-        }
-      }
-
-      let mut final_path = current_path.clone();
-      if is_polymorphic && !final_path.is_empty() && !final_path.ends_with(&entity_type) {
-        if final_path.ends_with(".#") {
-          final_path = format!("{}(type==\"{}\")", final_path, entity_type);
-        } else {
-          final_path = format!("{}#(type==\"{}\")", final_path, entity_type);
-        }
-      }
-
-      let stem = Stem {
-        r#type: entity_type.clone(),
-        relation: relation_col,
-        schema: Arc::new(schema.clone()),
-      };
-      inner_map.insert(final_path, Arc::new(stem));
-    }
-
-    let next_parent = if is_entity {
-      Some(entity_type.clone())
-    } else {
-      parent_type.clone()
-    };
-
-    let pass_seen = if is_entity {
-      let mut ns = seen_entities.clone();
-      ns.push(entity_type.clone());
-      ns
-    } else {
-      seen_entities.clone()
-    };
-
-    // Properties branch
-    if let Some(props) = &schema.obj.properties {
-      for (k, v) in props {
-        // Standard Property Pathing
-        let next_path = if current_path.is_empty() {
-          k.clone()
-        } else {
-          format!("{}.{}", current_path, k)
-        };
-
-        Self::discover_stems(
-          db,
-          root_schema_id,
-          v,
-          next_path,
-          next_parent.clone(),
-          Some(k.clone()),
-          false,
-          inner_map,
-          pass_seen.clone(),
-          errors,
-        );
-      }
-    }
-
-    // Array Item branch
-    if let Some(items) = &schema.obj.items {
-      let next_path = if current_path.is_empty() {
-        String::from("#")
-      } else {
-        format!("{}.#", current_path)
-      };
-
-      Self::discover_stems(
-        db,
-        root_schema_id,
-        items,
-        next_path,
-        next_parent.clone(),
-        property_name.clone(),
-        false,
-        inner_map,
-        pass_seen.clone(),
-        errors,
-      );
-    }
-
-    // Follow external reference if we didn't just crawl local properties
-    if schema.obj.properties.is_none() && schema.obj.items.is_none() && schema.obj.one_of.is_none()
-    {
-      if let Some(ref r) = schema.obj.r#ref {
-        if let Some(target_schema) = db.schemas.get(r) {
-          Self::discover_stems(
-            db,
-            root_schema_id,
-            target_schema,
-            current_path.clone(),
-            next_parent.clone(),
-            property_name.clone(),
-            is_polymorphic,
-            inner_map,
-            seen_entities.clone(),
-            errors,
-          );
-        }
-      }
-    }
-
-    // Polymorphism branch
-    if let Some(arr) = &schema.obj.one_of {
-      for v in arr {
-        Self::discover_stems(
-          db,
-          root_schema_id,
-          v.as_ref(),
-          current_path.clone(),
-          next_parent.clone(),
-          property_name.clone(),
-          true,
-          inner_map,
-          pass_seen.clone(),
-          errors,
-        );
-      }
-    }
-    if let Some(arr) = &schema.obj.all_of {
-      for v in arr {
-        Self::discover_stems(
-          db,
-          root_schema_id,
-          v.as_ref(),
-          current_path.clone(),
-          next_parent.clone(),
-          property_name.clone(),
-          is_polymorphic,
-          inner_map,
-          pass_seen.clone(),
-          errors,
-        );
-      }
-    }
-  }
 }

src/database/stem.rs

@@ -1,12 +0,0 @@
-use crate::database::schema::Schema;
-use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Stem {
-  pub r#type: String,
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub relation: Option<String>,
-
-  pub schema: Arc<Schema>,
-}

src/database/type.rs

@@ -15,6 +15,8 @@ pub struct Type {
   #[serde(default)]
   pub historical: bool,
   #[serde(default)]
+  pub notify: bool,
+  #[serde(default)]
   pub sensitive: bool,
   #[serde(default)]
   pub ownable: bool,

src/drop.rs

@@ -70,7 +70,7 @@ pub struct ErrorDetails {
   #[serde(skip_serializing_if = "Option::is_none")]
   pub cause: Option<String>,
   #[serde(skip_serializing_if = "Option::is_none")]
-  pub context: Option<Vec<String>>,
+  pub context: Option<Value>,
   #[serde(skip_serializing_if = "Option::is_none")]
   pub schema: Option<String>,
 }

src/lib.rs

@@ -77,7 +77,7 @@ pub fn jspg_merge(data: JsonB) -> JsonB {
 }
 
 #[cfg_attr(not(test), pg_extern)]
-pub fn jspg_query(schema_id: &str, stem: Option<&str>, filters: Option<JsonB>) -> JsonB {
+pub fn jspg_query(schema_id: &str, filters: Option<JsonB>) -> JsonB {
   let engine_opt = {
     let lock = GLOBAL_JSPG.read().unwrap();
     lock.clone()
@@ -87,7 +87,7 @@ pub fn jspg_query(schema_id: &str, stem: Option<&str>, filters: Option<JsonB>) -
     Some(engine) => {
       let drop = engine
         .queryer
-        .query(schema_id, stem, filters.as_ref().map(|f| &f.0));
+        .query(schema_id, filters.as_ref().map(|f| &f.0));
       JsonB(serde_json::to_value(drop).unwrap())
     }
     None => jspg_failure(),
@@ -131,24 +131,6 @@ pub fn jspg_schemas() -> JsonB {
   }
 }
 
-#[cfg_attr(not(test), pg_extern)]
-pub fn jspg_stems() -> JsonB {
-  let engine_opt = {
-    let lock = GLOBAL_JSPG.read().unwrap();
-    lock.clone()
-  };
-
-  match engine_opt {
-    Some(engine) => {
-      let stems_json = serde_json::to_value(&engine.database.stems)
-        .unwrap_or(serde_json::Value::Object(serde_json::Map::new()));
-      let drop = crate::drop::Drop::success_with_val(stems_json);
-      JsonB(serde_json::to_value(drop).unwrap())
-    }
-    None => jspg_failure(),
-  }
-}
-
 #[cfg_attr(not(test), pg_extern(strict))]
 pub fn jspg_teardown() -> JsonB {
   let mut lock = GLOBAL_JSPG.write().unwrap();

src/merger/mod.rs

@@ -3,6 +3,7 @@
 
 pub mod cache;
 
+use crate::database::r#type::Type;
 use crate::database::Database;
 use serde_json::Value;
 use std::sync::Arc;
@@ -23,7 +24,7 @@ impl Merger {
   pub fn merge(&self, data: Value) -> crate::drop::Drop {
     let mut notifications_queue = Vec::new();
 
-    let result = self.merge_internal(data, &mut notifications_queue);
+    let result = self.merge_internal(data.clone(), &mut notifications_queue);
 
     let val_resolved = match result {
       Ok(val) => val,
@@ -34,7 +35,7 @@ impl Merger {
           details: crate::drop::ErrorDetails {
             path: "".to_string(),
             cause: None,
-            context: None,
+            context: Some(data),
             schema: None,
           },
         }]);
@@ -189,8 +190,7 @@ impl Merger {
         Some(&relative_keys),
       );
 
-      if let Some(relation) = relative_relation {
+      if let Some((relation, parent_is_source)) = relative_relation {
-        let parent_is_source = type_def.hierarchy.contains(&relation.source_type);
 
         if parent_is_source {
           // Parent holds FK to Child. Child MUST be generated FIRST.
@@ -292,7 +292,7 @@ impl Merger {
         Some(&relative_keys),
       );
 
-      if let Some(relation) = relative_relation {
+      if let Some((relation, _)) = relative_relation {
         let mut relative_responses = Vec::new();
         for relative_item_val in relative_arr {
           if let Value::Object(mut relative_item) = relative_item_val {
@@ -322,8 +322,9 @@ impl Merger {
       }
     }
 
-    // 7. Perform change tracking
+    // 7. Perform change tracking dynamically suppressing noise based on type bounds!
     let notify_sql = self.merge_entity_change(
+      type_def,
       &entity_fields,
       entity_fetched.as_ref(),
       entity_change_kind.as_deref(),
@@ -621,11 +622,7 @@ impl Merger {
         for key in &sorted_keys {
           columns.push(format!("\"{}\"", key));
           let val = entity_pairs.get(key).unwrap();
-          if val.as_str() == Some("") {
+          values.push(Self::format_sql_value(val, key, entity_type));
-            values.push("NULL".to_string());
-          } else {
-            values.push(Self::quote_literal(val));
-          }
         }
 
         if columns.is_empty() {
@@ -659,7 +656,11 @@ impl Merger {
           if val.as_str() == Some("") {
             set_clauses.push(format!("\"{}\" = NULL", key));
           } else {
-            set_clauses.push(format!("\"{}\" = {}", key, Self::quote_literal(val)));
+            set_clauses.push(format!(
+              "\"{}\" = {}",
+              key,
+              Self::format_sql_value(val, key, entity_type)
+            ));
           }
         }
 
@@ -681,6 +682,7 @@ impl Merger {
 
   fn merge_entity_change(
     &self,
+    type_obj: &Type,
     entity_fields: &serde_json::Map<String, Value>,
     entity_fetched: Option<&serde_json::Map<String, Value>>,
     entity_change_kind: Option<&str>,
@@ -695,7 +697,8 @@ impl Merger {
     let id_str = entity_fields.get("id").unwrap();
     let type_name = entity_fields.get("type").unwrap();
 
-    let mut changes = serde_json::Map::new();
+    let mut old_vals = serde_json::Map::new();
+    let mut new_vals = serde_json::Map::new();
     let is_update = change_kind == "update" || change_kind == "delete";
 
     if !is_update {
@@ -708,7 +711,7 @@ impl Merger {
       ];
       for (k, v) in entity_fields {
         if !system_keys.contains(k) {
-          changes.insert(k.clone(), v.clone());
+          new_vals.insert(k.clone(), v.clone());
         }
       }
     } else {
@@ -725,12 +728,13 @@ impl Merger {
           if let Some(fetched) = entity_fetched {
             let old_val = fetched.get(k).unwrap_or(&Value::Null);
             if v != old_val {
-              changes.insert(k.clone(), v.clone());
+              new_vals.insert(k.clone(), v.clone());
+              old_vals.insert(k.clone(), old_val.clone());
             }
           }
         }
       }
-      changes.insert("type".to_string(), type_name.clone());
+      new_vals.insert("type".to_string(), type_name.clone());
     }
 
     let mut complete = entity_fields.clone();
@@ -744,33 +748,48 @@ impl Merger {
       }
     }
 
+    let new_val_obj = Value::Object(new_vals);
+    let old_val_obj = if old_vals.is_empty() {
+      Value::Null
+    } else {
+      Value::Object(old_vals)
+    };
+
     let mut notification = serde_json::Map::new();
     notification.insert("complete".to_string(), Value::Object(complete));
-    if is_update {
+    notification.insert("new".to_string(), new_val_obj.clone());
-      notification.insert("changes".to_string(), Value::Object(changes.clone()));
+    
+    if old_val_obj != Value::Null {
+        notification.insert("old".to_string(), old_val_obj.clone());
     }
 
-    let change_sql = format!(
+    let mut notify_sql = None;
-      "INSERT INTO agreego.change (changes, entity_id, id, kind, modified_at, modified_by) VALUES ({}, {}, {}, {}, {}, {})",
+    if type_obj.historical {
-      Self::quote_literal(&Value::Object(changes)),
+      let change_sql = format!(
-      Self::quote_literal(id_str),
+        "INSERT INTO agreego.change (\"old\", \"new\", entity_id, id, kind, modified_at, modified_by) VALUES ({}, {}, {}, {}, {}, {}, {})",
-      Self::quote_literal(&Value::String(uuid::Uuid::new_v4().to_string())),
+        Self::quote_literal(&old_val_obj),
-      Self::quote_literal(&Value::String(change_kind.to_string())),
+        Self::quote_literal(&new_val_obj),
-      Self::quote_literal(&Value::String(timestamp.to_string())),
+        Self::quote_literal(id_str),
-      Self::quote_literal(&Value::String(user_id.to_string()))
+        Self::quote_literal(&Value::String(uuid::Uuid::new_v4().to_string())),
-    );
+        Self::quote_literal(&Value::String(change_kind.to_string())),
+        Self::quote_literal(&Value::String(timestamp.to_string())),
+        Self::quote_literal(&Value::String(user_id.to_string()))
+      );
 
-    let notify_sql = format!(
+      self
-      "SELECT pg_notify('entity', {})",
+        .db
-      Self::quote_literal(&Value::String(Value::Object(notification).to_string()))
+        .execute(&change_sql, None)
-    );
+        .map_err(|e| format!("Executor Error in change: {:?}", e))?;
+    }
 
-    self
+    if type_obj.notify {
-      .db
+      notify_sql = Some(format!(
-      .execute(&change_sql, None)
+        "SELECT pg_notify('entity', {})",
-      .map_err(|e| format!("Executor Error in change: {:?}", e))?;
+        Self::quote_literal(&Value::String(Value::Object(notification).to_string()))
+      ));
+    }
 
-    Ok(Some(notify_sql))
+    Ok(notify_sql)
   }
 
   fn compare_entities(
@@ -822,6 +841,34 @@ impl Merger {
     }
   }
 
+  fn format_sql_value(val: &Value, key: &str, entity_type: &Type) -> String {
+    if val.as_str() == Some("") {
+      return "NULL".to_string();
+    }
+
+    let mut is_pg_array = false;
+    if let Some(field_types_map) = entity_type.field_types.as_ref().and_then(|v| v.as_object()) {
+      if let Some(t_val) = field_types_map.get(key) {
+        if let Some(t_str) = t_val.as_str() {
+          if t_str.starts_with('_') {
+            is_pg_array = true;
+          }
+        }
+      }
+    }
+
+    if is_pg_array && val.is_array() {
+      let mut s = val.to_string();
+      if s.starts_with('[') && s.ends_with(']') {
+        s.replace_range(0..1, "{");
+        s.replace_range(s.len() - 1..s.len(), "}");
+      }
+      Self::quote_literal(&Value::String(s))
+    } else {
+      Self::quote_literal(val)
+    }
+  }
+
   fn quote_literal(val: &Value) -> String {
     match val {
       Value::Null => "NULL".to_string(),

src/queryer/compiler.rs

@@ -3,7 +3,6 @@ use std::sync::Arc;
 pub struct Compiler<'a> {
   pub db: &'a Database,
   pub filter_keys: &'a [String],
-  pub is_stem_query: bool,
   pub alias_counter: usize,
 }
 
@@ -15,7 +14,7 @@ pub struct Node<'a> {
   pub parent_type: Option<&'a crate::database::r#type::Type>,
   pub property_name: Option<String>,
   pub depth: usize,
-  pub stem_path: String,
+  pub ast_path: String,
 }
 
 impl<'a> Compiler<'a> {
@@ -23,7 +22,6 @@ impl<'a> Compiler<'a> {
   pub fn compile(
     &self,
     schema_id: &str,
-    stem_path: Option<&str>,
     filter_keys: &[String],
   ) -> Result<String, String> {
     let schema = self
@@ -32,32 +30,11 @@ impl<'a> Compiler<'a> {
       .get(schema_id)
       .ok_or_else(|| format!("Schema not found: {}", schema_id))?;
 
-    let target_schema = if let Some(path) = stem_path.filter(|p| !p.is_empty() && *p != "/") {
+    let target_schema = std::sync::Arc::new(schema.clone());
-      if let Some(stems_map) = self.db.stems.get(schema_id) {
-        if let Some(stem) = stems_map.get(path) {
-          stem.schema.clone()
-        } else {
-          return Err(format!(
-            "Stem entity type '{}' not found in schema '{}'",
-            path, schema_id
-          ));
-        }
-      } else {
-        return Err(format!(
-          "Stem entity type '{}' not found in schema '{}'",
-          path, schema_id
-        ));
-      }
-    } else {
-      std::sync::Arc::new(schema.clone())
-    };
-
-    let is_stem_query = stem_path.is_some();
 
     let mut compiler = Compiler {
       db: &self.db,
       filter_keys,
-      is_stem_query,
       alias_counter: 0,
     };
 
@@ -68,7 +45,7 @@ impl<'a> Compiler<'a> {
       parent_type: None,
       property_name: None,
       depth: 0,
-      stem_path: String::new(),
+      ast_path: String::new(),
     };
 
     let (sql, _) = compiler.compile_node(node)?;
@@ -89,24 +66,24 @@ impl<'a> Compiler<'a> {
 
   fn compile_array(&mut self, node: Node<'a>) -> Result<(String, String), String> {
     if let Some(items) = &node.schema.obj.items {
-      let next_path = if node.stem_path.is_empty() {
+      let next_path = if node.ast_path.is_empty() {
         String::from("#")
       } else {
-        format!("{}.#", node.stem_path)
+        format!("{}.#", node.ast_path)
       };
 
       if let Some(ref_id) = &items.obj.r#ref {
         if let Some(type_def) = self.db.types.get(ref_id) {
-          let mut entity_noke = node.clone();
+          let mut entity_node = node.clone();
-          entity_noke.stem_path = next_path;
+          entity_node.ast_path = next_path;
-          entity_noke.schema = std::sync::Arc::clone(items);
+          entity_node.schema = std::sync::Arc::clone(items);
-          return self.compile_entity(type_def, entity_noke, true);
+          return self.compile_entity(type_def, entity_node, true);
         }
       }
 
       let mut next_node = node.clone();
       next_node.depth += 1;
-      next_node.stem_path = next_path;
+      next_node.ast_path = next_path;
       next_node.schema = std::sync::Arc::clone(items);
       let (item_sql, _) = self.compile_node(next_node)?;
       return Ok((
@@ -328,16 +305,16 @@ impl<'a> Compiler<'a> {
   ) -> Result<(String, String), String> {
     let mut build_args = Vec::new();
     for (k, v) in props {
-      let next_path = if node.stem_path.is_empty() {
+      let next_path = if node.ast_path.is_empty() {
         k.clone()
       } else {
-        format!("{}.{}", node.stem_path, k)
+        format!("{}.{}", node.ast_path, k)
       };
 
       let mut child_node = node.clone();
       child_node.property_name = Some(k.clone());
       child_node.depth += 1;
-      child_node.stem_path = next_path;
+      child_node.ast_path = next_path;
       child_node.schema = std::sync::Arc::clone(v);
 
       let (child_sql, val_type) = self.compile_node(child_node)?;
@@ -479,13 +456,13 @@ impl<'a> Compiler<'a> {
       child_node.parent_type = Some(r#type);
       child_node.property_name = Some(prop_key.clone());
       child_node.depth += 1;
-      let next_path = if node.stem_path.is_empty() {
+      let next_path = if node.ast_path.is_empty() {
         prop_key.clone()
       } else {
-        format!("{}.{}", node.stem_path, prop_key)
+        format!("{}.{}", node.ast_path, prop_key)
       };
 
-      child_node.stem_path = next_path;
+      child_node.ast_path = next_path;
       child_node.schema = std::sync::Arc::clone(prop_schema);
 
       let (val_sql, val_type) = self.compile_node(child_node)?;
@@ -517,7 +494,7 @@ impl<'a> Compiler<'a> {
     where_clauses.push(format!("NOT {}.archived", entity_alias));
 
     self.compile_filter_conditions(r#type, type_aliases, &node, &base_alias, &mut where_clauses);
-    self.compile_relation_conditions(r#type, &node, &base_alias, &mut where_clauses)?;
+    self.compile_relation_conditions(r#type, type_aliases, &node, &base_alias, &mut where_clauses)?;
 
     Ok(where_clauses)
   }
@@ -593,13 +570,13 @@ impl<'a> Compiler<'a> {
       let full_field_path = parts.next().unwrap_or(filter_key);
       let op = parts.next().unwrap_or("$eq");
 
-      let field_name = if node.stem_path.is_empty() {
+      let field_name = if node.ast_path.is_empty() {
         if full_field_path.contains('.') || full_field_path.contains('#') {
           continue;
         }
         full_field_path
       } else {
-        let prefix = format!("{}.", node.stem_path);
+        let prefix = format!("{}.", node.ast_path);
         if full_field_path.starts_with(&prefix) {
           let remainder = &full_field_path[prefix.len()..];
           if remainder.contains('.') || remainder.contains('#') {
@@ -655,44 +632,65 @@ impl<'a> Compiler<'a> {
   fn compile_relation_conditions(
     &self,
     r#type: &crate::database::r#type::Type,
+    type_aliases: &std::collections::HashMap<String, String>,
     node: &Node,
     base_alias: &str,
     where_clauses: &mut Vec<String>,
   ) -> Result<(), String> {
     if let Some(prop_ref) = &node.property_name {
       let prop = prop_ref.as_str();
-      let mut relation_alias = node.parent_alias.clone();
+      let mut parent_relation_alias = node.parent_alias.clone();
-      let mut relation_resolved = false;
+      let mut child_relation_alias = base_alias.to_string();
 
       if let Some(parent_type) = node.parent_type {
         let merged_props = self.get_merged_properties(node.schema.as_ref());
         let relative_keys: Vec<String> = merged_props.keys().cloned().collect();
 
-        if let Some(relation) = self.db.get_relation(&parent_type.name, &r#type.name, prop, Some(&relative_keys)) {
+        let (relation, is_parent_source) = self
-          let source_col = &relation.source_columns[0];
+          .db
-          let dest_col = &relation.destination_columns[0];
+          .get_relation(&parent_type.name, &r#type.name, prop, Some(&relative_keys))
+          .ok_or_else(|| {
+            format!(
+              "Could not dynamically resolve database relation mapping for {} -> {} on property {}",
+              parent_type.name, r#type.name, prop
+            )
+          })?;
 
-          if let Some(pta) = &node.parent_type_aliases {
+        let source_col = &relation.source_columns[0];
-            if let Some(a) = pta.get(&relation.source_type) {
+        let dest_col = &relation.destination_columns[0];
-              relation_alias = a.clone();
-            } else if let Some(a) = pta.get(&relation.destination_type) {
-              relation_alias = a.clone();
-            }
-          }
 
-          if relation.source_type == parent_type.name || parent_type.hierarchy.contains(&relation.source_type) {
+        if let Some(pta) = &node.parent_type_aliases {
-            where_clauses.push(format!("{}.{} = {}.{}", relation_alias, source_col, base_alias, dest_col));
+          let p_search_type = if is_parent_source {
-            relation_resolved = true;
+            &relation.source_type
-          } else if relation.destination_type == parent_type.name || parent_type.hierarchy.contains(&relation.destination_type) {
+          } else {
-            where_clauses.push(format!("{}.{} = {}.{}", base_alias, source_col, relation_alias, dest_col));
+            &relation.destination_type
-            relation_resolved = true;
+          };
+          if let Some(a) = pta.get(p_search_type) {
+            parent_relation_alias = a.clone();
           }
         }
-      }
 
-      if !relation_resolved {
+        let c_search_type = if is_parent_source {
-        let parent_name = node.parent_type.map(|t| t.name.as_str()).unwrap_or("unknown");
+          &relation.destination_type
-        return Err(format!("Could not dynamically resolve database relation mapping for {} -> {} on property {}", parent_name, r#type.name, prop));
+        } else {
+          &relation.source_type
+        };
+        if let Some(a) = type_aliases.get(c_search_type) {
+          child_relation_alias = a.clone();
+        }
+
+        let sql_string = if is_parent_source {
+          format!(
+            "{}.{} = {}.{}",
+            parent_relation_alias, source_col, child_relation_alias, dest_col
+          )
+        } else {
+          format!(
+            "{}.{} = {}.{}",
+            child_relation_alias, source_col, parent_relation_alias, dest_col
+          )
+        };
+        where_clauses.push(sql_string);
       }
     }
     Ok(())

src/queryer/mod.rs

@@ -21,7 +21,6 @@ impl Queryer {
   pub fn query(
     &self,
     schema_id: &str,
-    stem_opt: Option<&str>,
     filters: Option<&serde_json::Value>,
   ) -> crate::drop::Drop {
     let filters_map = filters.and_then(|f| f.as_object());
@@ -36,18 +35,17 @@ impl Queryer {
           details: crate::drop::ErrorDetails {
             path: "".to_string(), // filters apply to the root query
             cause: Some(msg),
-            context: filters.map(|f| vec![f.to_string()]),
+            context: filters.cloned(),
             schema: Some(schema_id.to_string()),
           },
         }]);
       }
     };
 
-    let stem_key = stem_opt.unwrap_or("/");
+    let cache_key = format!("{}:{}", schema_id, filter_keys.join(","));
-    let cache_key = format!("{}(Stem:{}):{}", schema_id, stem_key, filter_keys.join(","));
 
     // 2. Fetch from cache or compile
-    let sql = match self.get_or_compile_sql(&cache_key, schema_id, stem_opt, &filter_keys) {
+    let sql = match self.get_or_compile_sql(&cache_key, schema_id, &filter_keys) {
       Ok(sql) => sql,
       Err(drop) => return drop,
     };
@@ -90,7 +88,6 @@ impl Queryer {
     &self,
     cache_key: &str,
     schema_id: &str,
-    stem_opt: Option<&str>,
     filter_keys: &[String],
   ) -> Result<String, crate::drop::Drop> {
     if let Some(cached_sql) = self.cache.get(cache_key) {
@@ -100,11 +97,10 @@ impl Queryer {
     let compiler = compiler::Compiler {
       db: &self.db,
       filter_keys: filter_keys,
-      is_stem_query: stem_opt.is_some(),
       alias_counter: 0,
     };
 
-    match compiler.compile(schema_id, stem_opt, filter_keys) {
+    match compiler.compile(schema_id, filter_keys) {
       Ok(compiled_sql) => {
         self
           .cache
@@ -144,7 +140,7 @@ impl Queryer {
         details: crate::drop::ErrorDetails {
           path: "".to_string(),
           cause: Some(format!("Expected array, got {}", other)),
-          context: Some(vec![sql.to_string()]),
+          context: Some(serde_json::json!([sql])),
           schema: Some(schema_id.to_string()),
         },
       }]),
@@ -154,7 +150,7 @@ impl Queryer {
         details: crate::drop::ErrorDetails {
           path: "".to_string(),
           cause: Some(format!("SPI error in queryer: {}", e)),
-          context: Some(vec![sql.to_string()]),
+          context: Some(serde_json::json!([sql])),
           schema: Some(schema_id.to_string()),
         },
       }]),

src/tests/fixtures.rs

@@ -1451,30 +1451,6 @@ fn test_queryer_0_6() {
     crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
 }
 
-#[test]
-fn test_queryer_0_7() {
-    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
-    crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
-}
-
-#[test]
-fn test_queryer_0_8() {
-    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
-    crate::tests::runner::run_test_case(&path, 0, 8).unwrap();
-}
-
-#[test]
-fn test_queryer_0_9() {
-    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
-    crate::tests::runner::run_test_case(&path, 0, 9).unwrap();
-}
-
-#[test]
-fn test_queryer_0_10() {
-    let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
-    crate::tests::runner::run_test_case(&path, 0, 10).unwrap();
-}
-
 #[test]
 fn test_not_0_0() {
     let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
@@ -3449,12 +3425,6 @@ fn test_if_then_else_13_1() {
     crate::tests::runner::run_test_case(&path, 13, 1).unwrap();
 }
 
-#[test]
-fn test_stems_0_0() {
-    let path = format!("{}/fixtures/stems.json", env!("CARGO_MANIFEST_DIR"));
-    crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
-}
-
 #[test]
 fn test_empty_string_0_0() {
     let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));
@@ -8566,3 +8536,9 @@ fn test_merger_0_7() {
     let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR"));
     crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
 }
+
+#[test]
+fn test_merger_0_8() {
+    let path = format!("{}/fixtures/merger.json", env!("CARGO_MANIFEST_DIR"));
+    crate::tests::runner::run_test_case(&path, 0, 8).unwrap();
+}

src/tests/types/case.rs

@@ -16,9 +16,6 @@ pub struct Case {
   pub schema_id: String,
 
   // For Query
-  #[serde(default)]
-  pub stem: Option<String>,
-
   #[serde(default)]
   pub filters: Option<serde_json::Value>,
 
@@ -38,7 +35,7 @@ fn default_action() -> String {
 }
 
 impl Case {
-  pub fn run_compile(&self, db: Arc<Database>) -> Result<(), String> {
+  pub fn run_compile(&self, _db: Arc<Database>) -> Result<(), String> {
     let expected_success = self.expect.as_ref().map(|e| e.success).unwrap_or(false);
 
     // We assume db has already been setup and compiled successfully by runner.rs's `jspg_setup`
@@ -52,24 +49,6 @@ impl Case {
       ));
     }
 
-    // Assert stems
-    if let Some(expect) = &self.expect {
-      if let Some(expected_stems) = &expect.stems {
-        // Convert the Db stems (HashMap<String, HashMap<String, Arc<Stem>>>) to matching JSON shape
-        let db_stems_json = serde_json::to_value(&db.stems).unwrap();
-        let expect_stems_json = serde_json::to_value(expected_stems).unwrap();
-
-        if db_stems_json != expect_stems_json {
-          let expected_pretty = serde_json::to_string_pretty(&expect_stems_json).unwrap();
-          let got_pretty = serde_json::to_string_pretty(&db_stems_json).unwrap();
-          return Err(format!(
-            "Stem validation failed.\nExpected:\n{}\n\nGot:\n{}",
-            expected_pretty, got_pretty
-          ));
-        }
-      }
-    }
-
     Ok(())
   }
 
@@ -158,8 +137,7 @@ impl Case {
     use crate::queryer::Queryer;
     let queryer = Queryer::new(db.clone());
 
-    let stem_opt = self.stem.as_deref();
+    let result = queryer.query(&self.schema_id, self.filters.as_ref());
-    let result = queryer.query(&self.schema_id, stem_opt, self.filters.as_ref());
 
     let expected_success = self.expect.as_ref().map(|e| e.success).unwrap_or(false);
     let got_success = result.errors.is_empty();

src/tests/types/expect/mod.rs

@@ -2,7 +2,6 @@ pub mod pattern;
 pub mod sql;
 
 use serde::Deserialize;
-use std::collections::HashMap;
 
 #[derive(Debug, Deserialize)]
 #[serde(untagged)]
@@ -16,7 +15,6 @@ pub struct Expect {
   pub success: bool,
   pub result: Option<serde_json::Value>,
   pub errors: Option<Vec<serde_json::Value>>,
-  pub stems: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
   #[serde(default)]
   pub sql: Option<Vec<SqlExpectation>>,
 }

version

@@ -1 +1 @@
-1.0.73
+1.0.79