version: 1.0.199

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ucym7qy7pFC1hbhoVHwJFX

GEMINI.md

@@ -184,6 +184,28 @@ It evaluates as an **Independent Declarative Rules Engine**. Every `Case` block
     *   **`array`**: Homogeneous collection of items matching the `items` schema. Validation is homogeneous, so strictness checking does not apply. `"extensible"` is not applicable at the `array` level (tuple-like `prefixItems` are removed).
 *   **Inheritance Boundaries**: Strictness resets when crossing non-primitive `type` boundaries. A schema extending a strict parent remains strict unless it explicitly overrides with `"extensible": true`.
 
+### Immutable Properties (`"immutable": "always" | "external"`)
+To distinguish read-only hydrated endpoint references, computed properties, system-managed timestamps (`created_at`, `modified_at`), or audit fields from writable properties, JSPG supports the `"immutable"` property schema attribute, which takes string enum values (`"always"`, `"external"`, or omitted).
+
+*   **Enum Values**:
+    *   `"always"`: Property is permanently read-only across all boundaries (e.g. system-managed audit timestamps like `created_at`, `modified_at`, or computed fields).
+    *   `"external"`: Property is read-only from external client API requests (`.request` payloads), but can be populated or mutated by internal system operations.
+    *   Omitted: Property is fully writable.
+*   **Developer Perspective**: Annotate properties in database schemas or trait definitions with `"immutable": "always"` or `"immutable": "external"` when the property should be visible on reads (`jspg_query` / `.response`), but rejected or ignored on writes (`jspg_merge` / `.request`).
+    ```json
+    "properties": {
+      "source": {
+        "family": "lite.organization",
+        "immutable": "always",
+        "description": "Read-only hydrated member entity summary on a membership edge."
+      }
+    }
+    ```
+*   **Behavior Across Pillars**:
+    *   **Queryer (`jspg_query`)**: Hydrates and includes `"immutable"` properties in output read responses without restriction.
+    *   **Validator (`jspg_validate`)**: Context-aware. Rejects specified `"immutable"` properties supplied in write/request payloads. Response schemas (`.response`) permit `"immutable"` fields.
+    *   **Merger (`jspg_merge`)**: Automatically skips `"immutable"` properties during object graph merging so client payloads can never mutate database columns or relationship edges.
+
 ### Format Leniency for Empty Strings
 To simplify frontend form validation, format validators specifically for `uuid`, `date-time`, and `email` explicitly allow empty strings (`""`), treating them as "present but unset".
 
@@ -302,6 +324,7 @@ JSPG implements specific extensions to the Draft 2020-12 standard to support the
 *   **Missing Type Ultimatum**: If an entity logically requires a discriminator and the JSON payload omits it, JSPG short-circuits branch execution entirely, bubbling a single, perfectly-pathed `MISSING_TYPE` error back to the UI natively to prevent confusing cascading failures.
 *   **Golden Match Context**: When exactly one structural candidate perfectly maps a discriminator, the Validator exclusively cascades that specific structural error context directly to the user, stripping away all noise generated by other parallel schemas.
 *   **Topological Array Pathing**: Instead of relying on explicit `$id` references or injected properties, array iteration paths are dynamically typed based on their compiler boundary constraints. If the array's `items` schema resolves to a topological table-backed entity (e.g., inheriting via a `family` macro tracked in the global DB catalog), the array locks paths and derives element indexes from their actual UUID paths (`array/widget-1/name`), natively enforcing database continuity. If evaluating isolated ad-hoc JSONB elements, strict numeric indexing is enforced natively (`array/1/name`) preventing synthetic payload manipulation.
+*   **Context-Aware Immutability Validation**: `jspg_validate` evaluates the target schema ID context. If the target schema ID does not end with `.response` (inbound write/request context), any property present in the payload marked with `"immutable": true` raises an `IMMUTABLE_PROPERTY_VIOLATION` error. Response schemas (`.response`) permit `immutable` fields for read hydration.
 
 ---
 
@@ -316,8 +339,11 @@ The Merger provides an automated, high-performance graph synchronization engine.
 
 *   **Caching Strategy**: The Merger leverages the native `compiled_edges` permanently cached onto the Schema AST via `OnceLock` to instantly resolve Foreign Key mapping graphs natively in absolute `O(1)` time. It additionally utilizes the concurrent `GLOBAL_JSPG` application memory (`DashMap`) to cache statically constructed SQL `SELECT` strings used during deduplication (`lookup_fields`) and difference tracking calculations.
 *   **Deep Graph Merging**: The Merger walks arbitrary levels of deeply nested JSON schemas (e.g. tracking an `order`, its `customer`, and an array of its `lines`). It intelligently discovers the correct parent-to-child or child-to-parent Foreign Keys stored in the registry and automatically maps the UUIDs across the relationships during UPSERT.
+*   **Immutable Property Filtering**: Properties declaring `"immutable": true` are filtered out during schema property traversal prior to edge classification or column assembly, guaranteeing client payloads cannot write or mutate read-only/computed properties or hydrated endpoint references.
+*   **Factual Creation Dependency Validation**: When `stage_entity` confirms `kind == "create"` via database lookup, `jspg_merge` evaluates `schema.obj.dependencies.get("created")`. If required creation fields are missing from `entity_fields`, `entity_objects`, or `entity_arrays`, `jspg_merge` halts and returns a structured `REQUIRED_FIELD_MISSING` `Drop`.
+*   **Structured Fail-Fast Error Propagation**: Internal merger operations return typed `Result<T, crate::drop::Error>` instances, allowing clean fail-fast `?` traversal and returning `Drop::with_errors(vec![err])` directly at the top-level API boundary on failure.
 *   **Prefix Foreign Key Matching**: Handles scenario where multiple relations point to the same table by using database Foreign Key constraint prefixes (`fk_`). For example, if a schema has `shipping_address` and `billing_address`, the merger resolves against `fk_shipping_address_entity` vs `fk_billing_address_entity` automatically to correctly route object properties.
-*   **Dynamic Deduplication & Lookups**: If a nested object is provided without an `id`, the Merger utilizes custom `lookup_fields` declared directly in the schema registry JSON comments. It validates at setup compile-time that a corresponding unique index exists in PostgreSQL for these fields. When merging, it dynamically builds query predicates for any satisfied `lookup_fields` sets in the entity's type hierarchy (checking child-to-parent hierarchies order-independently and combining satisfied keys with `UNION` queries) to discover the correct UUID to perform an UPDATE, preventing data duplication.
+*   **Dynamic Deduplication & Lookups (`lookup_fields` & `field_defaults`)**: If an entity payload is provided without an `id`, the Merger utilizes custom `lookup_fields` declared directly in the schema metadata (`COMMENT ON TABLE`). When searching for an existing database record (`fetch_entity`), it iterates candidate `lookup_fields` sets across the entity's type hierarchy. For any column in a lookup set that is omitted from the input payload, `fetch_entity` checks for a default value in `field_defaults` (populated from Postgres table column `DEFAULT` expressions during setup). If a default is found (e.g. `start_date: "0001-01-01T00:00:00+00:00"`), `fetch_entity` uses that default value to satisfy the lookup query predicate (`WHERE ... AND start_date = ...`). Crucially, `entity_fields` itself is **never mutated** with defaults during `merge_entity`, ensuring input payloads remain pure, preventing false `modified_at` updates or spurious change notifications, and allowing PostgreSQL to handle column default generation natively server-side on `INSERT`.
 *   **Hierarchical Table Inheritance**: The Punc system uses distributed table inheritance (e.g. `person` inherits `user` inherits `organization` inherits `entity`). The Merger splits the incoming JSON payload and performs atomic row updates across *all* relevant tables in the lineage map.
 *   **The Archive Paradigm**: Data is never deleted in the Punc system. The Merger securely enforces referential integrity by toggling the `archived` Boolean flag on the base `entity` table rather than issuing SQL `DELETE` commands.
 *   **Change Tracking & Reactivity**: The Merger diffs the incoming JSON against the existing database row (utilizing static, `DashMap`-cached `lookup` SELECT string templates). Every detected change is recorded into the `agreego.change` audit table, tracking the user mapping. It then natively uses `pg_notify` to broadcast a completely flat row-level diff out to the Go WebSocket server for O(1) routing.
@@ -348,6 +374,7 @@ The Queryer transforms Postgres into a pre-compiled Semantic Query Engine, desig
     *   **Multi-Table Branching**: If the Physical Table is a parent to other tables (e.g. `organization` has variations `["organization", "bot", "person"]`), the compiler generates a dynamic `CASE WHEN type = '...' THEN ...` query, expanding into sub-queries for each variation. To ensure safe resolution, the compiler dynamically evaluates correlation boundaries: it attempts standard Relational Edge discovery first. If no explicit relational edge exists (indicating pure Table Inheritance rather than a standard foreign-key graph relationship), it safely invokes a **Table Parity Fallback**. This generates an explicit ID correlation constraint (`AND inner.id = outer.id`), perfectly binding the structural variations back to the parent row to eliminate Cartesian products.
     *   **Single-Table Bypass**: If the Physical Table is a leaf node with only one variation (e.g. `person` has variations `["person"]`), the compiler cleanly bypasses `CASE` generation and compiles a simple `SELECT` across the base table, as all schema extensions (e.g. `light.person`, `full.person`) are guaranteed to reside in the exact same physical row.
     *   **Polymorphic Relation Type Filtering**: When a relationship maps to a polymorphic target with variations, the Queryer compiles an `IN` clause containing all allowed table variations (e.g., `counterparty_type IN ('bot', 'organization', 'person')`) rather than matching the base type literal, ensuring all polymorphic types are loaded correctly.
+*   **Tenant Scoping & ReBAC Filtering**: When `jspg_query` compiles root-level or relationship-level entity queries, the generated SQL queries evaluate within the calling PostgreSQL transaction's session configuration (e.g. `punc.cue.organization_ids`, `punc.cue.roles`). The compiled queries seamlessly interact with PostgreSQL Row Level Security (RLS) policies on base tables (such as `agreego.entity`) and pre-materialized Zanzibar graph edges (`agreego.relationship`), ensuring multi-tenant isolation and $O(1)$ query evaluation without requiring manual WHERE scoping logic across every application punc.
 *   **Static Relation Constraints (Kind Constraints)**: When a relationship (such as a nested object or array) is defined with a schema that constrains a field value statically using a `const` or `enum` keyword (for example, `kind` constrained to `"cover"` in a `cover_attachment`), the Queryer automatically extracts these static assertions during AST compilation. It injects them directly as static filters into the SQL subquery's `WHERE` clause (e.g. `AND attachment.kind = 'cover'`), allowing developers to query pre-filtered subsets of related tables natively through the schema.
 *   **Proxy Schema Dereferencing / Resolution**: To support punc endpoints that return non-polymorphic table-backed shapes (using `type: "full.X"` proxy schemas at the root response level), the Queryer compiler automatically dereferences non-table schema pointers to their target schemas prior to checking the types. This allows the Queryer to correctly resolve the table relationship edges pre-compiled on the full schema, while avoiding polluting the database registry with relations on ad-hoc punc response schemas during setup.
 

fixtures/database.json

@@ -1027,16 +1027,31 @@
           "name": "user",
           "module": "test",
           "source": "test",
-          "hierarchy": ["user"],
-          "variations": ["user"],
-          "fields": ["id", "email"],
-          "lookup_fields": ["email"],
+          "hierarchy": [
+            "user"
+          ],
+          "variations": [
+            "user"
+          ],
+          "fields": [
+            "id",
+            "email"
+          ],
+          "lookup_fields": [
+            "email"
+          ],
           "schemas": {
             "user": {
               "type": "object",
               "properties": {
-                "id": { "type": "string", "format": "uuid" },
-                "email": { "type": "string", "format": "email" }
+                "id": {
+                  "type": "string",
+                  "format": "uuid"
+                },
+                "email": {
+                  "type": "string",
+                  "format": "email"
+                }
               }
             }
           }
@@ -1072,7 +1087,9 @@
       "indexes": [
         {
           "table": "user",
-          "columns": ["email"]
+          "columns": [
+            "email"
+          ]
         }
       ],
       "types": [
@@ -1082,16 +1099,31 @@
           "name": "user",
           "module": "test",
           "source": "test",
-          "hierarchy": ["user"],
-          "variations": ["user"],
-          "fields": ["id", "email"],
-          "lookup_fields": ["email"],
+          "hierarchy": [
+            "user"
+          ],
+          "variations": [
+            "user"
+          ],
+          "fields": [
+            "id",
+            "email"
+          ],
+          "lookup_fields": [
+            "email"
+          ],
           "schemas": {
             "user": {
               "type": "object",
               "properties": {
-                "id": { "type": "string", "format": "uuid" },
-                "email": { "type": "string", "format": "email" }
+                "id": {
+                  "type": "string",
+                  "format": "uuid"
+                },
+                "email": {
+                  "type": "string",
+                  "format": "email"
+                }
               }
             }
           }

fixtures/properties.json

@@ -873,5 +873,142 @@
         }
       }
     ]
+  },
+  {
+    "description": "immutable property validation in request vs response context",
+    "database": {
+      "types": [
+        {
+          "name": "item",
+          "schemas": {
+            "save_item.request": {
+              "properties": {
+                "id": {
+                  "type": "string"
+                },
+                "created_at": {
+                  "type": "string",
+                  "immutable": "always"
+                }
+              }
+            },
+            "get_item.response": {
+              "properties": {
+                "id": {
+                  "type": "string"
+                },
+                "created_at": {
+                  "type": "string",
+                  "immutable": "always"
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    "tests": [
+      {
+        "description": "immutable property in request context causes IMMUTABLE_PROPERTY_VIOLATION",
+        "data": {
+          "id": "123",
+          "created_at": "2026-07-21T00:00:00Z"
+        },
+        "schema_id": "save_item.request",
+        "action": "validate",
+        "expect": {
+          "success": false,
+          "errors": [
+            {
+              "code": "IMMUTABLE_PROPERTY_VIOLATION",
+              "values": {
+                "property_name": "created_at"
+              },
+              "details": {
+                "path": "created_at",
+                "schema": "save_item.request"
+              }
+            }
+          ]
+        }
+      },
+      {
+        "description": "immutable property in response context is allowed",
+        "data": {
+          "id": "123",
+          "created_at": "2026-07-21T00:00:00Z"
+        },
+        "schema_id": "get_item.response",
+        "action": "validate",
+        "expect": {
+          "success": true
+        }
+      }
+    ]
+  },
+  {
+    "description": "immutable external vs always property validation",
+    "database": {
+      "types": [
+        {
+          "name": "invoice",
+          "schemas": {
+            "save_invoice.request": {
+              "properties": {
+                "id": {
+                  "type": "string"
+                },
+                "status": {
+                  "type": "string",
+                  "immutable": "external"
+                },
+                "created_at": {
+                  "type": "string",
+                  "immutable": "always"
+                }
+              }
+            }
+          }
+        }
+      ]
+    },
+    "tests": [
+      {
+        "description": "immutable external property in request context allowed when internal (punc.external = false)",
+        "data": {
+          "id": "123",
+          "status": "paid"
+        },
+        "schema_id": "save_invoice.request",
+        "action": "validate",
+        "expect": {
+          "success": true
+        }
+      },
+      {
+        "description": "immutable always property in request context rejected even when internal (punc.external = false)",
+        "data": {
+          "id": "123",
+          "created_at": "2026-07-21T00:00:00Z"
+        },
+        "schema_id": "save_invoice.request",
+        "action": "validate",
+        "expect": {
+          "success": false,
+          "errors": [
+            {
+              "code": "IMMUTABLE_PROPERTY_VIOLATION",
+              "values": {
+                "property_name": "created_at"
+              },
+              "details": {
+                "path": "created_at",
+                "schema": "save_invoice.request"
+              }
+            }
+          ]
+        }
+      }
+    ]
   }
 ]

fixtures/queryer.json

@@ -260,12 +260,9 @@
           },
           "lookup_fields": [],
           "null_fields": [],
-          "default_fields": [
-            "id",
-            "type",
-            "created_at",
-            "archived"
-          ],
+          "field_defaults": {
+            "archived": false
+          },
           "variations": [
             "bot",
             "organization",
@@ -1739,20 +1736,20 @@
               "    AND entity_1.created_at <= ($16 #>> '{}')::TIMESTAMPTZ",
               "    AND entity_1.created_at <> ($17 #>> '{}')::TIMESTAMPTZ",
               "    AND person_3.first_name ILIKE $18 #>> '{}'",
-              "    AND person_3.first_name > ($19 #>> '{)",
-              "      AND person_3.first_name >= ($20 #>> '{)",
-              "        AND person_3.first_name < ($21 #>> '{)",
-              "          AND person_3.first_name <= ($22 #>> '{)",
-              "            AND person_3.first_name NOT ILIKE $23 #>> '{}'",
-              "            AND person_3.first_name NOT IN (SELECT value FROM jsonb_array_elements_text(($24 #>> '{}')::jsonb))",
-              "            AND person_3.first_name IN (SELECT value FROM jsonb_array_elements_text(($25 #>> '{}')::jsonb))",
-              "            AND entity_1.id = ($26 #>> '{}')::UUID",
-              "            AND entity_1.id <> ($27 #>> '{}')::UUID",
-              "            AND entity_1.id NOT IN (SELECT value::UUID FROM jsonb_array_elements_text(($28 #>> '{}')::jsonb))",
-              "            AND entity_1.id IN (SELECT value::UUID FROM jsonb_array_elements_text(($29 #>> '{}')::jsonb))",
-              "            AND person_3.last_name ILIKE $30 #>> '{}'",
-              "            AND person_3.last_name NOT ILIKE $31 #>> '{}'",
-              "        ))))"
+              "    AND person_3.first_name > ($19 #>> '{}')",
+              "    AND person_3.first_name >= ($20 #>> '{}')",
+              "    AND person_3.first_name < ($21 #>> '{}')",
+              "    AND person_3.first_name <= ($22 #>> '{}')",
+              "    AND person_3.first_name NOT ILIKE $23 #>> '{}'",
+              "    AND person_3.first_name NOT IN (SELECT value FROM jsonb_array_elements_text(($24 #>> '{}')::jsonb))",
+              "    AND person_3.first_name IN (SELECT value FROM jsonb_array_elements_text(($25 #>> '{}')::jsonb))",
+              "    AND entity_1.id = ($26 #>> '{}')::UUID",
+              "    AND entity_1.id <> ($27 #>> '{}')::UUID",
+              "    AND entity_1.id NOT IN (SELECT value::UUID FROM jsonb_array_elements_text(($28 #>> '{}')::jsonb))",
+              "    AND entity_1.id IN (SELECT value::UUID FROM jsonb_array_elements_text(($29 #>> '{}')::jsonb))",
+              "    AND person_3.last_name ILIKE $30 #>> '{}'",
+              "    AND person_3.last_name NOT ILIKE $31 #>> '{}'",
+              "))))"
             ]
           ]
         }

src/database/executors/mock.rs

@@ -13,6 +13,8 @@ pub struct MockState {
   pub query_responses: Vec<Result<Value, String>>,
   pub execute_responses: Vec<Result<(), String>>,
   pub mocks: Vec<Value>,
+  pub cue_created_by: Option<String>,
+  pub cue_external: bool,
 }
 
 #[cfg(test)]
@@ -23,6 +25,8 @@ impl MockState {
       query_responses: Default::default(),
       execute_responses: Default::default(),
       mocks: Default::default(),
+      cue_created_by: Some("00000000-0000-0000-0000-000000000000".to_string()),
+      cue_external: false,
     }
   }
 }
@@ -77,16 +81,22 @@ impl DatabaseExecutor for MockExecutor {
     })
   }
 
-  fn auth_user_id(&self) -> Result<String, String> {
-    Ok("00000000-0000-0000-0000-000000000000".to_string())
+  fn cue_created_by(&self) -> Result<String, String> {
+    MOCK_STATE.with(|state| {
+      state
+        .borrow()
+        .cue_created_by
+        .clone()
+        .ok_or_else(|| "Missing cue.created_by in session context".to_string())
+    })
   }
 
   fn timestamp(&self) -> Result<String, String> {
     Ok("2026-03-10T00:00:00Z".to_string())
   }
 
-  fn is_mock(&self) -> bool {
-    true
+  fn cue_external(&self) -> Result<bool, String> {
+    Ok(MOCK_STATE.with(|state| state.borrow().cue_external))
   }
 
   #[cfg(test)]
@@ -109,6 +119,23 @@ impl DatabaseExecutor for MockExecutor {
       s.query_responses.clear();
       s.execute_responses.clear();
       s.mocks.clear();
+      s.cue_created_by = Some("00000000-0000-0000-0000-00000000000".to_string());
+      s.cue_external = false;
+    });
+  }
+}
+
+#[cfg(test)]
+impl MockExecutor {
+  pub fn set_cue_external(&self, external: bool) {
+    MOCK_STATE.with(|state| {
+      state.borrow_mut().cue_external = external;
+    });
+  }
+
+  pub fn set_cue_created_by(&self, created_by: Option<String>) {
+    MOCK_STATE.with(|state| {
+      state.borrow_mut().cue_created_by = created_by;
     });
   }
 }
@@ -116,56 +143,72 @@ impl DatabaseExecutor for MockExecutor {
 #[cfg(test)]
 fn parse_and_match_mocks(sql: &str, mocks: &[Value]) -> Option<Vec<Value>> {
   let sql_upper = sql.to_uppercase();
-  if !sql_upper.starts_with("SELECT") {
+  if !sql_upper.starts_with("SELECT") && !sql_upper.starts_with("(SELECT") {
     return None;
   }
 
-  // 1. Extract table name
-  let table_regex = Regex::new(r#"(?i)\s+FROM\s+(?:[a-zA-Z_]\w*\.)?"?([a-zA-Z_]\w*)"?"#).ok()?;
-  let table = if let Some(caps) = table_regex.captures(sql) {
-    caps.get(1)?.as_str()
-  } else {
-    return None;
-  };
+  let union_regex = Regex::new(r"(?i)\s+UNION\s+").ok()?;
+  let queries: Vec<&str> = union_regex.split(sql).collect();
 
-  // 2. Extract WHERE conditions string
-  let mut where_clause = String::new();
-  if let Some(where_idx) = sql_upper.find(" WHERE ") {
-    let mut where_end = sql_upper.find(" ORDER BY ").unwrap_or(sql_upper.len());
-    if let Some(limit_idx) = sql_upper.find(" LIMIT ") {
-      if limit_idx < where_end {
-        where_end = limit_idx;
-      }
-    }
-    where_clause = sql[where_idx + 7..where_end].to_string();
-  }
-
-  // 3. Find matching mocks
   let mut matches = Vec::new();
   let or_regex = Regex::new(r"(?i)\s+OR\s+").ok()?;
   let and_regex = Regex::new(r"(?i)\s+AND\s+").ok()?;
 
   for mock in mocks {
-    if let Some(mock_obj) = mock.as_object() {
-      if let Some(t) = mock_obj.get("type") {
-        if t.as_str() != Some(table) {
-          continue;
-        }
-      }
+    let mock_obj = match mock.as_object() {
+      Some(obj) => obj,
+      None => continue,
+    };
 
-      if where_clause.is_empty() {
-        matches.push(mock.clone());
+    let mock_type = mock_obj.get("type").and_then(|v| v.as_str()).unwrap_or("");
+
+    let mut mock_matched = false;
+
+    for query in &queries {
+      let q_upper = query.to_uppercase();
+
+      // Check if mock type matches the table or any joined tables in this query
+      let table_regex =
+        Regex::new(r#"(?i)\s+(?:FROM|JOIN)\s+(?:[a-zA-Z_]\w*\.)?"?([a-zA-Z_]\w*)"?"#).ok()?;
+      let tables: Vec<String> = table_regex
+        .captures_iter(query)
+        .filter_map(|c| c.get(1).map(|m| m.as_str().to_string()))
+        .collect();
+
+      if !mock_type.is_empty() && !tables.is_empty() && !tables.iter().any(|t| t == mock_type) {
         continue;
       }
 
-      let or_parts = or_regex.split(&where_clause);
-      let mut any_branch_matched = false;
+      // Extract WHERE clause
+      let mut where_clause = String::new();
+      if let Some(where_idx) = q_upper.find(" WHERE ") {
+        let mut where_end = q_upper.find(" ORDER BY ").unwrap_or(q_upper.len());
+        if let Some(limit_idx) = q_upper.find(" LIMIT ") {
+          if limit_idx < where_end {
+            where_end = limit_idx;
+          }
+        }
+        where_clause = query[where_idx + 7..where_end]
+          .trim_end_matches(')')
+          .to_string();
+      }
 
+      if where_clause.is_empty() {
+        mock_matched = true;
+        break;
+      }
+
+      let or_parts = or_regex.split(&where_clause);
       for or_part in or_parts {
         let branch_str = or_part.replace('(', "").replace(')', "");
         let mut branch_matches = true;
 
         for part in and_regex.split(&branch_str) {
+          let part = part.trim();
+          if part.is_empty() {
+            continue;
+          }
+
           if let Some(eq_idx) = part.find('=') {
             let left = part[..eq_idx]
               .trim()
@@ -179,7 +222,7 @@ fn parse_and_match_mocks(sql: &str, mocks: &[Value]) -> Option<Vec<Value>> {
               Some(Value::String(s)) => s.clone(),
               Some(Value::Number(n)) => n.to_string(),
               Some(Value::Bool(b)) => b.to_string(),
-              Some(Value::Null) => "null".to_string(),
+              Some(Value::Null) | None => "null".to_string(),
               _ => "".to_string(),
             };
             if mock_val_str != right {
@@ -187,19 +230,21 @@ fn parse_and_match_mocks(sql: &str, mocks: &[Value]) -> Option<Vec<Value>> {
               break;
             }
           } else if part.to_uppercase().contains(" IS NULL") {
-            let left = part[..part.to_uppercase().find(" IS NULL").unwrap()]
+            let is_null_idx = part.to_uppercase().find(" IS NULL").unwrap();
+            let left = part[..is_null_idx]
               .trim()
               .split('.')
               .last()
               .unwrap_or("")
               .trim_matches('"');
 
-            let mock_val_str = match mock_obj.get(left) {
-              Some(Value::Null) => "null".to_string(),
-              _ => "".to_string(),
+            let is_null_val = match mock_obj.get(left) {
+              Some(Value::Null) | None => true,
+              Some(Value::String(s)) if s.is_empty() => true,
+              _ => false,
             };
 
-            if mock_val_str != "null" {
+            if !is_null_val {
               branch_matches = false;
               break;
             }
@@ -207,15 +252,19 @@ fn parse_and_match_mocks(sql: &str, mocks: &[Value]) -> Option<Vec<Value>> {
         }
 
         if branch_matches {
-          any_branch_matched = true;
+          mock_matched = true;
           break;
         }
       }
 
-      if any_branch_matched {
-        matches.push(mock.clone());
+      if mock_matched {
+        break;
       }
     }
+
+    if mock_matched {
+      matches.push(mock.clone());
+    }
   }
 
   Some(matches)

src/database/executors/mod.rs

@@ -14,16 +14,14 @@ pub trait DatabaseExecutor: Send + Sync {
   /// Executes an operation (INSERT, UPDATE, DELETE, or pg_notify) that does not return rows.
   fn execute(&self, sql: &str, args: Option<Vec<Value>>) -> Result<(), String>;
 
-  /// Returns the current authenticated user's ID
-  fn auth_user_id(&self) -> Result<String, String>;
+  /// Returns the current authenticated user's ID (from cue.created_by)
+  fn cue_created_by(&self) -> Result<String, String>;
 
   /// Returns the current transaction timestamp
   fn timestamp(&self) -> Result<String, String>;
 
-  /// Returns whether this is a mock executor (bypassing pg_catalog index checks)
-  fn is_mock(&self) -> bool {
-    false
-  }
+  /// Returns true if the current execution context is marked as an external client API cue (cue.external = true)
+  fn cue_external(&self) -> Result<bool, String>;
 
   #[cfg(test)]
   fn get_queries(&self) -> Vec<String>;

src/database/executors/pgrx.rs

@@ -77,8 +77,8 @@ impl DatabaseExecutor for SpiExecutor {
 
     pgrx::debug1!("JSPG_SQL: {}", sql);
     self.transact(|| {
-      Spi::connect(|client| {
-        match client.select(sql, Some(args_with_oid.len() as i64), &args_with_oid) {
+      Spi::connect_mut(|client| {
+        match client.update(sql, Some(args_with_oid.len() as i64), &args_with_oid) {
           Ok(tup_table) => {
             let mut results = Vec::new();
             for row in tup_table {
@@ -113,12 +113,12 @@ impl DatabaseExecutor for SpiExecutor {
     })
   }
 
-  fn auth_user_id(&self) -> Result<String, String> {
+  fn cue_created_by(&self) -> Result<String, String> {
     self.transact(|| {
       Spi::connect(|client| {
         let mut tup_table = client
           .select(
-            "SELECT COALESCE(current_setting('auth.user_id', true), 'ffffffff-ffff-ffff-ffff-ffffffffffff')",
+            "SELECT NULLIF(current_setting('punc.cue', true), '')::jsonb->>'created_by'",
             None,
             &[],
           )
@@ -126,10 +126,10 @@ impl DatabaseExecutor for SpiExecutor {
 
         let row = tup_table
           .next()
-          .ok_or("No user id setting returned from context".to_string())?;
+          .ok_or("No cue setting returned from context".to_string())?;
         let user_id: Option<String> = row.get(1).map_err(|e| e.to_string())?;
 
-        user_id.ok_or("Missing user_id".to_string())
+        user_id.ok_or("Missing cue.created_by in session context".to_string())
       })
     })
   }
@@ -150,4 +150,25 @@ impl DatabaseExecutor for SpiExecutor {
       })
     })
   }
+
+  fn cue_external(&self) -> Result<bool, String> {
+    self.transact(|| {
+      Spi::connect(|client| {
+        let mut tup_table = client
+          .select(
+            "SELECT COALESCE((NULLIF(current_setting('punc.cue', true), '')::jsonb->>'external')::boolean, false)",
+            None,
+            &[],
+          )
+          .map_err(|e| format!("SPI Select Error: {}", e))?;
+
+        let row = tup_table
+          .next()
+          .ok_or("No setting returned from context".to_string())?;
+        let is_external: Option<bool> = row.get(1).map_err(|e| e.to_string())?;
+
+        Ok(is_external.unwrap_or(false))
+      })
+    })
+  }
 }

src/database/mod.rs

@@ -232,9 +232,9 @@ impl Database {
     self.executor.execute(sql, args)
   }
 
-  /// Returns the current authenticated user's ID
-  pub fn auth_user_id(&self) -> Result<String, String> {
-    self.executor.auth_user_id()
+  /// Returns the current authenticated user's ID (from cue.created_by)
+  pub fn cue_created_by(&self) -> Result<String, String> {
+    self.executor.cue_created_by()
   }
 
   /// Returns the current transaction timestamp
@@ -242,6 +242,11 @@ impl Database {
     self.executor.timestamp()
   }
 
+  /// Returns true if the current execution context is marked as an external client API cue (cue.external = true)
+  pub fn cue_external(&self) -> Result<bool, String> {
+    self.executor.cue_external()
+  }
+
   pub fn compile(&mut self, errors: &mut Vec<crate::drop::Error>) {
     // Phase 1: Registration
     self.collect_schemas(errors);

src/database/object.rs

@@ -149,6 +149,9 @@ pub struct SchemaObject {
   #[serde(default)]
   #[serde(skip_serializing_if = "Option::is_none")]
   pub extensible: Option<bool>,
+  #[serde(default)]
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub immutable: Option<ImmutableMode>,
 
   // Contains ALL structural fields perfectly flattened from the ENTIRE Database inheritance tree (e.g. `entity` fields like `id`) as well as local fields hidden inside conditional `cases` blocks.
   // This JSON exported array gives clients absolute deterministic visibility to O(1) validation and masking bounds without duplicating structural memory.
@@ -260,6 +263,13 @@ pub fn is_primitive_type(t: &str) -> bool {
   )
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ImmutableMode {
+  Always,
+  External,
+}
+
 impl SchemaObject {
   pub fn get_discriminator_value(&self, dim: &str, schema_id: &str) -> Option<String> {
     let is_split = self
@@ -306,4 +316,12 @@ impl SchemaObject {
 
     false
   }
+
+  pub fn is_immutable(&self, is_external: bool) -> bool {
+    match self.immutable {
+      Some(ImmutableMode::Always) => true,
+      Some(ImmutableMode::External) => is_external,
+      None => false,
+    }
+  }
 }

src/database/type.rs

@@ -5,6 +5,14 @@ use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use serde_json::Value;
 
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct Roles {
+  #[serde(default, skip_serializing_if = "Vec::is_empty")]
+  pub read: Vec<String>,
+  #[serde(default, skip_serializing_if = "Vec::is_empty")]
+  pub write: Vec<String>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 #[serde(default)]
 pub struct Type {
@@ -36,8 +44,10 @@ pub struct Type {
   #[serde(default)]
   pub null_fields: Vec<String>,
   #[serde(default)]
-  pub default_fields: Vec<String>,
+  pub field_defaults: IndexMap<String, Value>,
   pub field_types: Option<Value>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub roles: Option<Roles>,
   #[serde(default)]
   pub schemas: IndexMap<String, Arc<Schema>>,
 }

src/lib.rs

@@ -57,7 +57,7 @@ pub fn jspg_setup(database: Json) -> Json {
   Json(serde_json::to_value(drop).unwrap())
 }
 
-#[cfg_attr(not(test), pg_extern)]
+#[cfg_attr(not(test), pg_extern(volatile))]
 pub fn jspg_merge(schema_id: &str, data: JsonB) -> JsonB {
   // Try to acquire a read lock to get a clone of the Engine Arc
   let engine_opt = {
@@ -74,7 +74,7 @@ pub fn jspg_merge(schema_id: &str, data: JsonB) -> JsonB {
   }
 }
 
-#[cfg_attr(not(test), pg_extern)]
+#[cfg_attr(not(test), pg_extern(volatile))]
 pub fn jspg_merge_ordered(schema_id: &str, data: Json) -> Json {
   let engine_opt = {
     let lock = GLOBAL_JSPG.read().unwrap();

src/merger/mod.rs

@@ -6,8 +6,8 @@ pub mod cache;
 use crate::database::Database;
 use crate::database::r#type::Type;
 use crate::drop::{Drop, Error, ErrorDetails};
-use serde_json::Value;
 use indexmap::IndexMap;
+use serde_json::Value;
 use std::sync::Arc;
 
 pub struct Merger {
@@ -31,9 +31,10 @@ impl Merger {
       None => {
         return Drop::with_errors(vec![Error {
           code: "SCHEMA_NOT_FOUND".to_string(),
-          values: Some(IndexMap::from([
-            ("schema".to_string(), schema_id.to_string()),
-          ])),
+          values: Some(IndexMap::from([(
+            "schema".to_string(),
+            schema_id.to_string(),
+          )])),
           details: ErrorDetails {
             path: None,
             cause: None,
@@ -48,47 +49,7 @@ impl Merger {
 
     let val_resolved = match result {
       Ok(val) => val,
-      Err(msg) => {
-        let mut final_code = "MERGE_FAILED".to_string();
-        let mut final_message = msg.clone();
-        let mut final_cause = None;
-
-        if let Ok(Value::Object(map)) = serde_json::from_str::<Value>(&msg) {
-          if let (Some(Value::String(e_msg)), Some(Value::String(e_code))) =
-            (map.get("error"), map.get("code"))
-          {
-            final_message = e_msg.clone();
-            final_code = e_code.clone();
-            let mut cause_parts = Vec::new();
-            if let Some(Value::String(d)) = map.get("detail") {
-              if !d.is_empty() {
-                cause_parts.push(d.clone());
-              }
-            }
-            if let Some(Value::String(h)) = map.get("hint") {
-              if !h.is_empty() {
-                cause_parts.push(h.clone());
-              }
-            }
-            if !cause_parts.is_empty() {
-              final_cause = Some(cause_parts.join("\n"));
-            }
-          }
-        }
-
-        return Drop::with_errors(vec![Error {
-          code: final_code,
-          values: Some(IndexMap::from([
-            ("error".to_string(), final_message),
-          ])),
-          details: ErrorDetails {
-            path: None,
-            cause: final_cause,
-            context: None,
-            schema: None,
-          },
-        }]);
-      }
+      Err(err) => return Drop::with_errors(vec![err]),
     };
 
     // Execute the globally collected, pre-ordered notifications last!
@@ -96,12 +57,10 @@ impl Merger {
       if let Err(e) = self.db.execute(&notify_sql, None) {
         return Drop::with_errors(vec![Error {
           code: "MERGE_FAILED".to_string(),
-          values: Some(IndexMap::from([
-            ("error".to_string(), e.to_string()),
-          ])),
+          values: Some(IndexMap::from([("error".to_string(), e.clone())])),
           details: ErrorDetails {
             path: None,
-            cause: None,
+            cause: Some(e),
             context: None,
             schema: None,
           },
@@ -144,7 +103,7 @@ impl Merger {
     notifications: &mut Vec<String>,
     parent_org_id: Option<String>,
     is_child: bool,
-  ) -> Result<Value, String> {
+  ) -> Result<Value, Error> {
     match data {
       Value::Array(items) => {
         self.merge_array(schema, items, notifications, parent_org_id, is_child)
@@ -159,10 +118,20 @@ impl Merger {
                   if let Some(target_schema) = self.db.schemas.get(target_id) {
                     schema = target_schema.clone();
                   } else {
-                    return Err(format!(
-                      "Polymorphic mapped target '{}' not found in database registry",
-                      target_id
-                    ));
+                    return Err(Error {
+                      code: "TARGET_SCHEMA_NOT_FOUND".to_string(),
+                      values: Some(IndexMap::from([(
+                        "target_id".to_string(),
+                        target_id.clone(),
+                      )])),
+                      details: ErrorDetails {
+                        cause: Some(format!(
+                          "Polymorphic mapped target '{}' not found in database registry",
+                          target_id
+                        )),
+                        ..Default::default()
+                      },
+                    });
                   }
                 } else if let Some(idx) = idx_opt {
                   if let Some(target_schema) = schema
@@ -173,31 +142,72 @@ impl Merger {
                   {
                     schema = Arc::clone(target_schema);
                   } else {
-                    return Err(format!(
-                      "Polymorphic index target '{}' not found in local oneOf array",
-                      idx
-                    ));
+                    return Err(Error {
+                      code: "ONE_OF_INDEX_NOT_FOUND".to_string(),
+                      values: Some(IndexMap::from([("index".to_string(), idx.to_string())])),
+                      details: ErrorDetails {
+                        cause: Some(format!(
+                          "Polymorphic index target '{}' not found in local oneOf array",
+                          idx
+                        )),
+                        ..Default::default()
+                      },
+                    });
                   }
                 } else {
-                  return Err(format!("Polymorphic mapped target has no path"));
+                  return Err(Error {
+                    code: "INVALID_POLYMORPHIC_TARGET".to_string(),
+                    values: None,
+                    details: ErrorDetails {
+                      cause: Some("Polymorphic mapped target has no path".to_string()),
+                      ..Default::default()
+                    },
+                  });
                 }
               } else {
-                return Err(format!(
-                  "Polymorphic discriminator {}='{}' matched no compiled options",
-                  disc, v
-                ));
+                return Err(Error {
+                  code: "DISCRIMINATOR_MISMATCH".to_string(),
+                  values: Some(IndexMap::from([
+                    ("discriminator".to_string(), disc.to_string()),
+                    ("value".to_string(), v.to_string()),
+                  ])),
+                  details: ErrorDetails {
+                    cause: Some(format!(
+                      "Polymorphic discriminator {}='{}' matched no compiled options",
+                      disc, v
+                    )),
+                    ..Default::default()
+                  },
+                });
               }
             } else {
-              return Err(format!(
-                "Polymorphic merging failed: missing required discriminator '{}'",
-                disc
-              ));
+              return Err(Error {
+                code: "MISSING_DISCRIMINATOR".to_string(),
+                values: Some(IndexMap::from([(
+                  "discriminator".to_string(),
+                  disc.to_string(),
+                )])),
+                details: ErrorDetails {
+                  cause: Some(format!(
+                    "Polymorphic merging failed: missing required discriminator '{}'",
+                    disc
+                  )),
+                  ..Default::default()
+                },
+              });
             }
           }
         }
         self.merge_object(schema, map, notifications, parent_org_id, is_child)
       }
-      _ => Err("Invalid merge payload: root must be an Object or Array".to_string()),
+      _ => Err(Error {
+        code: "INVALID_MERGE_PAYLOAD".to_string(),
+        values: None,
+        details: ErrorDetails {
+          cause: Some("Invalid merge payload: root must be an Object or Array".to_string()),
+          ..Default::default()
+        },
+      }),
     }
   }
 
@@ -208,7 +218,7 @@ impl Merger {
     notifications: &mut Vec<String>,
     parent_org_id: Option<String>,
     is_child: bool,
-  ) -> Result<Value, String> {
+  ) -> Result<Value, Error> {
     let mut item_schema = schema.clone();
     if let Some(crate::database::object::SchemaTypeOrArray::Single(t)) = &schema.obj.type_ {
       if t == "array" {
@@ -239,22 +249,49 @@ impl Merger {
     notifications: &mut Vec<String>,
     parent_org_id: Option<String>,
     is_child: bool,
-  ) -> Result<Value, String> {
+  ) -> Result<Value, Error> {
     let queue_start = notifications.len();
 
     let type_name = match obj.get("type").and_then(|v| v.as_str()) {
       Some(t) => t.to_string(),
-      None => return Err("Missing required 'type' field on object".to_string()),
+      None => {
+        return Err(Error {
+          code: "MISSING_TYPE".to_string(),
+          values: None,
+          details: ErrorDetails {
+            cause: Some("Missing required 'type' field on object".to_string()),
+            ..Default::default()
+          },
+        });
+      }
     };
 
     let type_def = match self.db.types.get(&type_name) {
       Some(t) => t,
-      None => return Err(format!("Unknown entity type: {}", type_name)),
+      None => {
+        return Err(Error {
+          code: "UNKNOWN_ENTITY_TYPE".to_string(),
+          values: Some(IndexMap::from([("type".to_string(), type_name.clone())])),
+          details: ErrorDetails {
+            cause: Some(format!("Unknown entity type: {}", type_name)),
+            ..Default::default()
+          },
+        });
+      }
     };
 
     let compiled_props = match schema.obj.compiled_properties.get() {
       Some(props) => props,
-      None => return Err("Schema has no compiled properties for merging".to_string()),
+      None => {
+        return Err(Error {
+          code: "UNCOMPILED_SCHEMA".to_string(),
+          values: None,
+          details: ErrorDetails {
+            cause: Some("Schema has no compiled properties for merging".to_string()),
+            ..Default::default()
+          },
+        });
+      }
     };
 
     let mut entity_fields = serde_json::Map::new();
@@ -298,6 +335,8 @@ impl Merger {
       }
     }
 
+
+
     let mut current_org_id = None;
     if let Some(compiled_props) = schema.obj.compiled_properties.get() {
       if let Some(org_schema) = compiled_props.get("organization_id") {
@@ -312,8 +351,22 @@ impl Merger {
       current_org_id = parent_org_id.clone();
     }
 
-    let user_id = self.db.auth_user_id()?;
-    let timestamp = self.db.timestamp()?;
+    let user_id = self.db.cue_created_by().map_err(|e| Error {
+      code: "CUE_CREATED_BY_FAILED".to_string(),
+      values: Some(IndexMap::from([("error".to_string(), e.clone())])),
+      details: ErrorDetails {
+        cause: Some(e),
+        ..Default::default()
+      },
+    })?;
+    let timestamp = self.db.timestamp().map_err(|e| Error {
+      code: "TIMESTAMP_FAILED".to_string(),
+      values: Some(IndexMap::from([("error".to_string(), e.clone())])),
+      details: ErrorDetails {
+        cause: Some(e),
+        ..Default::default()
+      },
+    })?;
 
     let mut entity_change_kind = None;
     let mut entity_fetched = None;
@@ -328,6 +381,33 @@ impl Merger {
       entity_replaces = replaces;
 
       if entity_change_kind.as_deref() == Some("create") {
+        if let Some(deps) = &schema.obj.dependencies {
+          if let Some(crate::database::object::Dependency::Props(req_props)) = deps.get("created") {
+            for req in req_props {
+              if !entity_fields.contains_key(req)
+                && !entity_objects.contains_key(req)
+                && !entity_arrays.contains_key(req)
+              {
+                return Err(Error {
+                  code: "REQUIRED_FIELD_MISSING".to_string(),
+                  values: Some(IndexMap::from([
+                    ("property_name".to_string(), req.to_string()),
+                    ("entity_type".to_string(), type_name.clone()),
+                  ])),
+                  details: ErrorDetails {
+                    path: Some(req.to_string()),
+                    cause: Some(format!(
+                      "Missing required creation field '{}' for entity {}",
+                      req, type_name
+                    )),
+                    ..Default::default()
+                  },
+                });
+              }
+            }
+          }
+        }
+
         if is_child {
           if !entity_fields.contains_key("organization_id") {
             if let Some(ref org_id) = current_org_id {
@@ -430,7 +510,7 @@ impl Merger {
       entity_change_kind.as_deref().unwrap_or(""),
       &type_name,
       type_def,
-      &entity_fields,
+      &mut entity_fields,
       entity_fetched.as_ref(),
     )?;
 
@@ -538,7 +618,7 @@ impl Merger {
       Option<serde_json::Map<String, Value>>,
       Option<String>,
     ),
-    String,
+    Error,
   > {
     let type_name = type_def.name.as_str();
 
@@ -673,7 +753,7 @@ impl Merger {
     &self,
     entity_fields: &serde_json::Map<String, Value>,
     entity_type: &crate::database::r#type::Type,
-  ) -> Result<Option<serde_json::Map<String, Value>>, String> {
+  ) -> Result<Option<serde_json::Map<String, Value>>, Error> {
     let id_val = entity_fields.get("id");
     let entity_type_name = entity_type.name.as_str();
 
@@ -682,21 +762,34 @@ impl Merger {
       if let Some(parent_type) = self.db.types.get(parent_type_name) {
         if !parent_type.lookup_fields.is_empty() {
           let mut lookup_complete = true;
+          let mut has_provided_fields = false;
           for column in &parent_type.lookup_fields {
-            match entity_fields.get(column) {
+            let is_nullable = parent_type.null_fields.contains(column);
+            let val = entity_fields.get(column).or_else(|| {
+              parent_type.field_defaults.get(column)
+            });
+            match val {
               Some(Value::Null) | None => {
-                lookup_complete = false;
-                break;
+                if !is_nullable {
+                  lookup_complete = false;
+                  break;
+                }
               }
               Some(Value::String(s)) if s.is_empty() => {
-                lookup_complete = false;
-                break;
+                if !is_nullable {
+                  lookup_complete = false;
+                  break;
+                }
+              }
+              _ => {
+                if entity_fields.contains_key(column) {
+                  has_provided_fields = true;
+                }
               }
-              _ => {}
             }
           }
-          if lookup_complete {
-            lookup_satisfied_keys.push(&parent_type.lookup_fields);
+          if lookup_complete && has_provided_fields {
+            lookup_satisfied_keys.push((&parent_type.lookup_fields, parent_type));
           }
         }
       }
@@ -709,7 +802,7 @@ impl Merger {
     let fetch_sql_template = if let Some(cached) = self.cache.get(entity_type_name) {
       cached
     } else {
-      let mut select_list = String::from("to_jsonb(t1.*)");
+      let mut select_list = String::from("COALESCE(to_jsonb(t1.*), '{}')");
       let mut join_clauses = format!("FROM agreego.\"{}\" t1", entity_type.hierarchy[0]);
 
       for (i, table_name) in entity_type.hierarchy.iter().enumerate().skip(1) {
@@ -718,7 +811,7 @@ impl Merger {
           " LEFT JOIN agreego.\"{}\" {} ON {}.id = t1.id",
           table_name, t_alias, t_alias
         ));
-        select_list.push_str(&format!(" || to_jsonb({}.*)", t_alias));
+        select_list.push_str(&format!(" || COALESCE(to_jsonb({}.*), '{{}}')", t_alias));
       }
 
       let template = format!("SELECT {} {}", select_list, join_clauses);
@@ -734,14 +827,24 @@ impl Merger {
       where_parts.push(format!("t1.id = {}", Self::quote_literal(id)));
     }
 
-    for lookup_fields in lookup_satisfied_keys {
+    for (lookup_fields, parent_type) in lookup_satisfied_keys {
+      let t_alias = entity_type
+        .hierarchy
+        .iter()
+        .position(|name| name == &parent_type.name)
+        .map(|idx| format!("t{}", idx + 1))
+        .unwrap_or_else(|| "t1".to_string());
+
       let mut lookup_predicates = Vec::new();
       for column in lookup_fields {
-        let val = entity_fields.get(column).unwrap_or(&Value::Null);
-        if column == "type" {
-          lookup_predicates.push(format!("t1.\"{}\" = {}", column, Self::quote_literal(val)));
+        let val = entity_fields
+          .get(column)
+          .or_else(|| parent_type.field_defaults.get(column))
+          .unwrap_or(&Value::Null);
+        if val.is_null() || val.as_str() == Some("") {
+          lookup_predicates.push(format!("{}.\"{}\" IS NULL", t_alias, column));
         } else {
-          lookup_predicates.push(format!("\"{}\" = {}", column, Self::quote_literal(val)));
+          lookup_predicates.push(format!("{}.\"{}\" = {}", t_alias, column, Self::quote_literal(val)));
         }
       }
       where_parts.push(format!("({})", lookup_predicates.join(" AND ")));
@@ -764,22 +867,53 @@ impl Merger {
     let fetched = match self.db.query(&final_sql, None) {
       Ok(Value::Array(table)) => {
         if table.len() > 1 {
-          Err(format!(
-            "TOO_MANY_LOOKUP_ROWS: Lookup for {} found too many existing rows",
-            entity_type_name
-          ))
+          Err(Error {
+            code: "TOO_MANY_LOOKUP_ROWS".to_string(),
+            values: Some(IndexMap::from([(
+              "entity_type".to_string(),
+              entity_type_name.to_string(),
+            )])),
+            details: ErrorDetails {
+              cause: Some(format!(
+                "Lookup for {} found too many existing rows",
+                entity_type_name
+              )),
+              ..Default::default()
+            },
+          })
         } else if table.is_empty() {
           Ok(None)
         } else {
           let row = table.first().unwrap();
           match row {
             Value::Object(map) => Ok(Some(map.clone())),
-            other => Err(format!("Expected JSON object, got: {:?}", other)),
+            other => Err(Error {
+              code: "UNEXPECTED_QUERY_RESULT".to_string(),
+              values: None,
+              details: ErrorDetails {
+                cause: Some(format!("Expected JSON object, got: {:?}", other)),
+                ..Default::default()
+              },
+            }),
           }
         }
       }
-      Ok(_) => Err("Expected array from query in fetch_entity".to_string()),
-      Err(e) => Err(format!("SPI error in fetch_entity: {:?}", e)),
+      Ok(_) => Err(Error {
+        code: "UNEXPECTED_QUERY_RESULT".to_string(),
+        values: None,
+        details: ErrorDetails {
+          cause: Some("Expected array from query in fetch_entity".to_string()),
+          ..Default::default()
+        },
+      }),
+      Err(e) => Err(Error {
+        code: "DATABASE_SPI_ERROR".to_string(),
+        values: Some(IndexMap::from([("error".to_string(), e.clone())])),
+        details: ErrorDetails {
+          cause: Some(format!("SPI error in fetch_entity: {:?}", e)),
+          ..Default::default()
+        },
+      }),
     }?;
 
     Ok(fetched)
@@ -790,25 +924,44 @@ impl Merger {
     change_kind: &str,
     entity_type_name: &str,
     entity_type: &crate::database::r#type::Type,
-    entity_fields: &serde_json::Map<String, Value>,
+    entity_fields: &mut serde_json::Map<String, Value>,
     _entity_fetched: Option<&serde_json::Map<String, Value>>,
-  ) -> Result<(), String> {
+  ) -> Result<(), Error> {
     if change_kind.is_empty() {
       return Ok(());
     }
 
     let id_str = match entity_fields.get("id").and_then(|v| v.as_str()) {
-      Some(id) => id,
-      None => return Err("Missing 'id' for merge execution".to_string()),
+      Some(id) => id.to_string(),
+      None => {
+        return Err(Error {
+          code: "MISSING_ENTITY_ID".to_string(),
+          values: None,
+          details: ErrorDetails {
+            cause: Some("Missing 'id' for merge execution".to_string()),
+            ..Default::default()
+          },
+        });
+      }
     };
 
     let grouped_fields = match &entity_type.grouped_fields {
       Some(Value::Object(map)) => map,
       _ => {
-        return Err(format!(
-          "Grouped fields missing for type {}",
-          entity_type_name
-        ));
+        return Err(Error {
+          code: "MISSING_GROUPED_FIELDS".to_string(),
+          values: Some(IndexMap::from([(
+            "type".to_string(),
+            entity_type_name.to_string(),
+          )])),
+          details: ErrorDetails {
+            cause: Some(format!(
+              "Grouped fields missing for type {}",
+              entity_type_name
+            )),
+            ..Default::default()
+          },
+        });
       }
     };
 
@@ -822,7 +975,7 @@ impl Merger {
       };
 
       let mut entity_pairs = serde_json::Map::new();
-      for (k, v) in entity_fields {
+      for (k, v) in entity_fields.iter() {
         if table_fields.contains(k) {
           entity_pairs.insert(k.clone(), v.clone());
         }
@@ -856,12 +1009,34 @@ impl Merger {
         }
 
         let sql = format!(
-          "INSERT INTO agreego.\"{}\" ({}) VALUES ({})",
+          "INSERT INTO agreego.\"{}\" ({}) VALUES ({}) RETURNING to_jsonb(\"{}\".*)",
           table_name,
           columns.join(", "),
-          values.join(", ")
+          values.join(", "),
+          table_name
         );
-        self.db.execute(&sql, None)?;
+        match self.db.query(&sql, None) {
+          Ok(Value::Array(rows)) => {
+            if let Some(Value::Object(row_map)) = rows.into_iter().next() {
+              for (k, v) in row_map {
+                if !v.is_null() {
+                  entity_fields.insert(k, v);
+                }
+              }
+            }
+          }
+          Err(e) => {
+            return Err(Error {
+              code: "DATABASE_SPI_ERROR".to_string(),
+              values: Some(IndexMap::from([("error".to_string(), e.clone())])),
+              details: ErrorDetails {
+                cause: Some(e),
+                ..Default::default()
+              },
+            });
+          }
+          _ => {}
+        }
       } else if change_kind == "update" || change_kind == "delete" {
         entity_pairs.remove("id");
         entity_pairs.remove("type");
@@ -888,12 +1063,34 @@ impl Merger {
         }
 
         let sql = format!(
-          "UPDATE agreego.\"{}\" SET {} WHERE id = {}",
+          "UPDATE agreego.\"{}\" SET {} WHERE id = {} RETURNING to_jsonb(\"{}\".*)",
           table_name,
           set_clauses.join(", "),
-          Self::quote_literal(&Value::String(id_str.to_string()))
+          Self::quote_literal(&Value::String(id_str.to_string())),
+          table_name
         );
-        self.db.execute(&sql, None)?;
+        match self.db.query(&sql, None) {
+          Ok(Value::Array(rows)) => {
+            if let Some(Value::Object(row_map)) = rows.into_iter().next() {
+              for (k, v) in row_map {
+                if !v.is_null() {
+                  entity_fields.insert(k, v);
+                }
+              }
+            }
+          }
+          Err(e) => {
+            return Err(Error {
+              code: "DATABASE_SPI_ERROR".to_string(),
+              values: Some(IndexMap::from([("error".to_string(), e.clone())])),
+              details: ErrorDetails {
+                cause: Some(e),
+                ..Default::default()
+              },
+            });
+          }
+          _ => {}
+        }
       }
     }
 
@@ -909,7 +1106,7 @@ impl Merger {
     user_id: &str,
     timestamp: &str,
     replaces_id: Option<&str>,
-  ) -> Result<Option<String>, String> {
+  ) -> Result<Option<String>, Error> {
     let change_kind = match entity_change_kind {
       Some(k) => k,
       None => return Ok(None),
@@ -1002,7 +1199,16 @@ impl Merger {
         Self::quote_literal(&Value::String(user_id.to_string()))
       );
 
-      self.db.execute(&change_sql, None)?;
+      if let Err(e) = self.db.execute(&change_sql, None) {
+        return Err(Error {
+          code: "DATABASE_SPI_ERROR".to_string(),
+          values: Some(IndexMap::from([("error".to_string(), e.clone())])),
+          details: ErrorDetails {
+            cause: Some(e),
+            ..Default::default()
+          },
+        });
+      }
     }
 
     if type_obj.notify {

src/tests/fixtures.rs

@@ -2519,6 +2519,30 @@ fn test_properties_12_0() {
     crate::tests::runner::run_test_case(&path, 12, 0).unwrap();
 }
 
+#[test]
+fn test_properties_13_0() {
+    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
+    crate::tests::runner::run_test_case(&path, 13, 0).unwrap();
+}
+
+#[test]
+fn test_properties_13_1() {
+    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
+    crate::tests::runner::run_test_case(&path, 13, 1).unwrap();
+}
+
+#[test]
+fn test_properties_14_0() {
+    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
+    crate::tests::runner::run_test_case(&path, 14, 0).unwrap();
+}
+
+#[test]
+fn test_properties_14_1() {
+    let path = format!("{}/fixtures/properties.json", env!("CARGO_MANIFEST_DIR"));
+    crate::tests::runner::run_test_case(&path, 14, 1).unwrap();
+}
+
 #[test]
 fn test_max_contains_0_0() {
     let path = format!("{}/fixtures/maxContains.json", env!("CARGO_MANIFEST_DIR"));

src/tests/formatter.rs

@@ -97,7 +97,14 @@ impl SqlFormatter {
             self.push_line("VALUES (");
             self.indent += 2;
             
-            let vals = if suffix.ends_with(")") { &suffix[..suffix.len() - 1] } else { suffix };
+            let (vals, returning_clause) = if let Some(ret_idx) = suffix.rfind(") RETURNING ") {
+                (&suffix[..ret_idx], Some(&suffix[ret_idx + 2..]))
+            } else if suffix.ends_with(")") {
+                (&suffix[..suffix.len() - 1], None)
+            } else {
+                (suffix, None)
+            };
+
             let mut val_tokens = Vec::new();
             let mut curr = String::new();
             let mut in_str = false;
@@ -119,7 +126,7 @@ impl SqlFormatter {
             for (i, val) in val_tokens.iter().enumerate() {
                 let comma = if i < val_tokens.len() - 1 { "," } else { "" };
                 
-                if val.starts_with("'{") && val.ends_with("}'") {
+                if val.starts_with("'{") && val.ends_with("}'") && val.len() > 4 {
                     let inner = &val[1..val.len() - 1];
                     // Unescape single quotes from SQL strings
                     let unescaped = inner.replace("''", "'");
@@ -146,6 +153,9 @@ impl SqlFormatter {
             }
             self.indent -= 2;
             self.push_line(")");
+            if let Some(ret) = returning_clause {
+                self.push_line(ret);
+            }
         } else {
             self.push_line(&s);
         }
@@ -168,10 +178,19 @@ impl SqlFormatter {
             self.indent -= 2;
             
             if let Some(w) = where_idx {
-                self.push_line("WHERE");
-                self.indent += 2;
-                self.push_line(&after_set[w + 7..]);
-                self.indent -= 2;
+                let where_clause = &after_set[w + 7..];
+                if let Some(ret_idx) = where_clause.find(" RETURNING ") {
+                    self.push_line("WHERE");
+                    self.indent += 2;
+                    self.push_line(&where_clause[..ret_idx]);
+                    self.indent -= 2;
+                    self.push_line(&where_clause[ret_idx + 1..]);
+                } else {
+                    self.push_line("WHERE");
+                    self.indent += 2;
+                    self.push_line(where_clause);
+                    self.indent -= 2;
+                }
             }
         } else {
             self.push_line(&s);
@@ -341,7 +360,7 @@ impl SqlFormatter {
             }
 
             Expr::Value(sqlparser::ast::ValueWithSpan { value: Value::SingleQuotedString(s), .. }) | Expr::Value(sqlparser::ast::ValueWithSpan { value: Value::EscapedStringLiteral(s), .. }) => {
-                if s.starts_with('{') && s.ends_with('}') {
+                if s.starts_with('{') && s.ends_with('}') && s.len() > 2 {
                     if let Ok(json) = serde_json::from_str::<serde_json::Value>(s) {
                         if let Ok(pretty) = serde_json::to_string_pretty(&json) {
                             let lines: Vec<&str> = pretty.split('\n').collect();

src/tests/mod.rs

@@ -104,7 +104,7 @@ fn test_library_api() {
             },
             "types": {
                 "source_schema": {
-                    "default_fields": [],
+                    "field_defaults": {},
                     "field_types": null,
                     "fields": [],
                     "grouped_fields": null,
@@ -169,7 +169,7 @@ fn test_library_api() {
                     "variations": ["source_schema"]
                 },
                 "target_schema": {
-                    "default_fields": [],
+                    "field_defaults": {},
                     "field_types": null,
                     "fields": [],
                     "grouped_fields": null,

src/validator/context.rs

@@ -16,6 +16,7 @@ pub struct ValidationContext<'a> {
   pub reporter: bool,
   pub overrides: HashSet<String>,
   pub parents: Vec<&'a serde_json::Value>,
+  pub response: bool,
 }
 
 impl<'a> ValidationContext<'a> {
@@ -27,6 +28,7 @@ impl<'a> ValidationContext<'a> {
     overrides: HashSet<String>,
     extensible: bool,
     reporter: bool,
+    response: bool,
   ) -> Self {
     let effective_extensible = schema.extensible.unwrap_or(extensible);
     Self {
@@ -40,6 +42,7 @@ impl<'a> ValidationContext<'a> {
       reporter,
       overrides,
       parents: Vec::new(),
+      response,
     }
   }
 
@@ -79,6 +82,7 @@ impl<'a> ValidationContext<'a> {
       reporter,
       overrides,
       parents,
+      response: self.response,
     }
   }
 

src/validator/mod.rs

@@ -48,6 +48,7 @@ impl Validator {
     let schema_opt = self.db.schemas.get(schema_id);
 
     if let Some(schema) = schema_opt {
+      let response = schema_id.ends_with(".response");
       let ctx = ValidationContext::new(
         &self.db,
         &schema,
@@ -56,6 +57,7 @@ impl Validator {
         HashSet::new(),
         false,
         false,
+        response,
       );
       match ctx.validate_scoped() {
         Ok(result) => {

src/validator/rules/object.rs

@@ -179,6 +179,37 @@ impl<'a> ValidationContext<'a> {
         }
       }
 
+      if !self.response {
+        let is_external = self.db.cue_external().unwrap_or(false);
+        if let Some(compiled_props) = self.schema.compiled_properties.get() {
+          for (key, sub_schema) in compiled_props {
+            if sub_schema.is_immutable(is_external) && obj.contains_key(key) {
+              result.errors.push(ValidationError {
+                code: "IMMUTABLE_PROPERTY_VIOLATION".to_string(),
+                values: Some(IndexMap::from([
+                  ("property_name".to_string(), key.to_string()),
+                ])),
+                path: self.join_path(key),
+              });
+            }
+          }
+        } else if let Some(props) = &self.schema.properties {
+          for (key, sub_schema) in props {
+            if sub_schema.is_immutable(is_external) && obj.contains_key(key) {
+              result.errors.push(ValidationError {
+                code: "IMMUTABLE_PROPERTY_VIOLATION".to_string(),
+                values: Some(IndexMap::from([
+                  ("property_name".to_string(), key.to_string()),
+                ])),
+                path: self.join_path(key),
+              });
+            }
+          }
+        }
+      }
+
+
+
       if let Some(props) = &self.schema.properties {
         for (key, sub_schema) in props {
           if self.overrides.contains(key) {
@@ -228,6 +259,7 @@ impl<'a> ValidationContext<'a> {
             HashSet::new(),
             self.extensible,
             self.reporter,
+            self.response,
           );
 
           result.merge(ctx.validate()?);

version

@@ -1 +1 @@
-1.0.183
+1.0.199