hecks 3.13.0 → 4.0.0

data/rust/codegen/src/domain_generator.rs

@@ -5,37 +5,13 @@ use crate::exemplar::Exemplar;
 use crate::json::Json;
 use crate::manifest::{ruby_inspect, Manifest};
 use crate::registry::{
-    AggregateEntry, CommandEntry, EntityCommandEntry, EntityIdentityEntry, NestedEntityCommandEntry, PortEntry,
-    ReferenceCheck, TenantBoundaryCheck,
+    AggregateEntry, CommandEntry, EntityCommandEntry, EntityIdentityEntry,
+    NestedEntityCommandEntry, PortEntry, ReferenceCheck, TenantBoundaryCheck,
 };
+use crate::shared::{lifecycle_extra_field, puts_blank, puts_str};
 use crate::{commands, json_codec, mutations, ports, queries, reactions, read_models, types};
 use std::collections::HashMap;
 
-fn puts_str(out: &mut String, s: &str) {
-    out.push_str(s);
-    if !s.ends_with('\n') {
-        out.push('\n');
-    }
-}
-
-fn puts_blank(out: &mut String) {
-    out.push('\n');
-}
-
-fn lifecycle_extra_field(node: &Json) -> Vec<(String, String)> {
-    match node.get("lifecycle") {
-        None => vec![],
-        Some(lifecycle) => {
-            let field = lifecycle.get("field").and_then(Json::as_str).unwrap_or("");
-            let ident = crate::naming::rust_ident_field(field);
-            vec![(
-                crate::naming::rust_field(field),
-                format!("crate::kernel::Json::Str(self.{ident}.clone())"),
-            )]
-        }
-    }
-}
-
 pub struct GeneratedFile {
     pub name: String,
     pub content: String,
@@ -63,7 +39,7 @@ fn reference_checks(
     aggregates_by_name: &HashMap<String, &Json>,
     unsupported_names: &[String],
 ) -> Vec<ReferenceCheck> {
-    let attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+    let attrs = command.get("attributes").map_or_default(Json::each);
     attrs
         .iter()
         .filter_map(|attr| {
@@ -72,7 +48,7 @@ fn reference_checks(
             if unsupported_names.iter().any(|n| n == target_name) {
                 return None;
             }
-            let identified_by = target.get("identified_by").map(Json::each).unwrap_or(&[]);
+            let identified_by = target.get("identified_by").map_or_default(Json::each);
             let heads = identified_by
                 .iter()
                 .map(|p| p.to_s().split('.').next().unwrap_or("").to_string())
@@ -109,9 +85,9 @@ fn state_reference_checks(
     unsupported_names: &[String],
     value_objects_by_name: &HashMap<String, &Json>,
 ) -> Vec<ReferenceCheck> {
-    let agg_attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-    let cmd_mutations = command.get("mutations").map(Json::each).unwrap_or(&[]);
-    let cmd_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+    let agg_attrs = aggregate.get("attributes").map_or_default(Json::each);
+    let cmd_mutations = command.get("mutations").map_or_default(Json::each);
+    let cmd_attrs = command.get("attributes").map_or_default(Json::each);
 
     agg_attrs
         .iter()
@@ -122,11 +98,21 @@ fn state_reference_checks(
             let mutation = cmd_mutations.iter().find(|m| {
                 m.get("op").map(Json::to_s).as_deref() == Some("set")
                     && m.get("target").map(Json::to_s).as_deref() == Some(attr_name)
-                    && m.get("source").and_then(|s| s.get("kind")).map(Json::to_s).as_deref() == Some("argument")
+                    && m.get("source")
+                        .and_then(|s| s.get("kind"))
+                        .map(Json::to_s)
+                        .as_deref()
+                        == Some("argument")
             })?;
 
-            let source_name = mutation.get("source").and_then(|s| s.get("name")).map(Json::to_s).unwrap_or_default();
-            let source_attr = cmd_attrs.iter().find(|a| crate::attr::name(a) == source_name)?;
+            let source_name = mutation
+                .get("source")
+                .and_then(|s| s.get("name"))
+                .map(Json::to_s)
+                .unwrap_or_default();
+            let source_attr = cmd_attrs
+                .iter()
+                .find(|a| crate::attr::name(a) == source_name)?;
             if crate::naming::reference_target(crate::attr::type_name(source_attr)).is_some() {
                 return None;
             }
@@ -147,7 +133,7 @@ fn state_reference_checks(
                 return None;
             }
 
-            let identified_by = target.get("identified_by").map(Json::each).unwrap_or(&[]);
+            let identified_by = target.get("identified_by").map_or_default(Json::each);
             let heads = identified_by
                 .iter()
                 .map(|p| p.to_s().split('.').next().unwrap_or("").to_string())
@@ -178,10 +164,13 @@ fn state_reference_checks(
 fn tenant_field_for(aggregate: &Json) -> Option<String> {
     aggregate
         .get("queries")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or_default(Json::each)
         .iter()
-        .find_map(|q| q.get("authorization").and_then(|a| a.get("tenant")).map(Json::to_s))
+        .find_map(|q| {
+            q.get("authorization")
+                .and_then(|a| a.get("tenant"))
+                .map(Json::to_s)
+        })
 }
 
 /// Write-side tenant boundary checks for a command's references.
@@ -198,14 +187,22 @@ fn tenant_boundary_checks(
     let Some(own_tenant_field) = tenant_field_for(aggregate) else {
         return Vec::new();
     };
-    let cmd_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
-    let Some(own_tenant_attr) = cmd_attrs.iter().find(|a| crate::attr::name(a) == own_tenant_field) else {
+    let cmd_attrs = command.get("attributes").map_or_default(Json::each);
+    let Some(own_tenant_attr) = cmd_attrs
+        .iter()
+        .find(|a| crate::attr::name(a) == own_tenant_field)
+    else {
         return Vec::new();
     };
-    let Some(own_accessor) = state_reference_check_accessor(own_tenant_attr, value_objects_by_name) else {
+    let Some(own_accessor) = state_reference_check_accessor(own_tenant_attr, value_objects_by_name)
+    else {
         return Vec::new();
     };
-    let aggregate_name = aggregate.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+    let aggregate_name = aggregate
+        .get("name")
+        .and_then(Json::as_str)
+        .unwrap_or("")
+        .to_string();
 
     cmd_attrs
         .iter()
@@ -216,12 +213,17 @@ fn tenant_boundary_checks(
                 return None;
             }
             let target_tenant_field = tenant_field_for(target)?;
-            let target_attrs = target.get("attributes").map(Json::each).unwrap_or(&[]);
+            let target_attrs = target.get("attributes").map_or_default(Json::each);
             let target_tenant_attr = target_attrs
                 .iter()
                 .find(|a| crate::attr::name(a) == target_tenant_field)?;
-            let target_accessor = state_reference_check_accessor(target_tenant_attr, value_objects_by_name)?;
-            let target_decl_name = target.get("name").and_then(Json::as_str).unwrap_or("").to_string();
+            let target_accessor =
+                state_reference_check_accessor(target_tenant_attr, value_objects_by_name)?;
+            let target_decl_name = target
+                .get("name")
+                .and_then(Json::as_str)
+                .unwrap_or("")
+                .to_string();
 
             Some(TenantBoundaryCheck {
                 reference_field: crate::attr::name(attr).to_string(),
@@ -251,7 +253,7 @@ fn list_reference_check_item(
         return Some("item".to_string());
     }
     let vo = value_objects_by_name.get(type_name)?;
-    let vo_attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+    let vo_attrs = vo.get("attributes").map_or_default(Json::each);
     if vo_attrs.len() != 1 || crate::attr::type_name(&vo_attrs[0]) != "String" {
         return None;
     }
@@ -265,7 +267,10 @@ fn list_reference_check_item(
 ///
 /// `None` for a multi-attribute value object, or an optional one: `check_reference`'s
 /// optional template assumes `Option<String>`.
-fn state_reference_check_accessor(source_attr: &Json, value_objects_by_name: &HashMap<String, &Json>) -> Option<String> {
+fn state_reference_check_accessor(
+    source_attr: &Json,
+    value_objects_by_name: &HashMap<String, &Json>,
+) -> Option<String> {
     let name = crate::attr::name(source_attr);
     if crate::naming::effective_scalar_type(crate::attr::type_name(source_attr)).is_some() {
         return Some(name.to_string());
@@ -275,12 +280,15 @@ fn state_reference_check_accessor(source_attr: &Json, value_objects_by_name: &Ha
     if crate::attr::optional(source_attr) {
         return None;
     }
-    let vo_attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+    let vo_attrs = vo.get("attributes").map_or_default(Json::each);
     if vo_attrs.len() != 1 {
         return None;
     }
 
-    Some(format!("{name}.{}", crate::naming::rust_ident_field(crate::attr::name(&vo_attrs[0]))))
+    Some(format!(
+        "{name}.{}",
+        crate::naming::rust_ident_field(crate::attr::name(&vo_attrs[0]))
+    ))
 }
 
 pub fn generate(
@@ -292,7 +300,7 @@ pub fn generate(
     let resolved_ir = types::with_resolved_projection_types(ir);
     let ir = &resolved_ir;
     let domain_name = ir.get("name").and_then(Json::as_str).unwrap_or("");
-    let all_aggregates = ir.get("aggregates").map(Json::each).unwrap_or(&[]);
+    let all_aggregates = ir.get("aggregates").map_or_default(Json::each);
     let aggregates_by_name: HashMap<String, &Json> = all_aggregates
         .iter()
         .map(|a| {
@@ -309,7 +317,7 @@ pub fn generate(
     let unsupported_names: Vec<String> = all_aggregates
         .iter()
         .filter(|a| {
-            let vos = a.get("value_objects").map(Json::each).unwrap_or(&[]);
+            let vos = a.get("value_objects").map_or_default(Json::each);
             let vo_by_name: HashMap<String, &Json> = vos
                 .iter()
                 .map(|vo| {
@@ -337,18 +345,24 @@ pub fn generate(
     let mut manifest = Manifest::default();
     let process_managers: Vec<Json> = ir
         .get("process_managers")
-        .map(Json::each)
-        .unwrap_or(&[])
+        .map_or_default(Json::each)
         .to_vec();
 
     // Owner of each value object across the whole domain: a command attribute can name a value
     // object declared by another aggregate. Last writer wins per name.
     let mut domain_value_object_owner: HashMap<String, String> = HashMap::new();
     for a in all_aggregates {
-        let owner = a.get("name").and_then(Json::as_str).unwrap_or("").to_string();
-        for vo in a.get("value_objects").map(Json::each).unwrap_or(&[]) {
+        let owner = a
+            .get("name")
+            .and_then(Json::as_str)
+            .unwrap_or("")
+            .to_string();
+        for vo in a.get("value_objects").map_or_default(Json::each) {
             domain_value_object_owner.insert(
-                vo.get("name").and_then(Json::as_str).unwrap_or("").to_string(),
+                vo.get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_string(),
                 owner.clone(),
             );
         }
@@ -357,19 +371,23 @@ pub fn generate(
     // a cross-aggregate argument. Each aggregate's own map wins a name collision.
     let mut domain_value_objects_by_name: HashMap<String, &Json> = HashMap::new();
     for a in all_aggregates {
-        for vo in a.get("value_objects").map(Json::each).unwrap_or(&[]) {
-            domain_value_objects_by_name.insert(vo.get("name").and_then(Json::as_str).unwrap_or("").to_string(), vo);
+        for vo in a.get("value_objects").map_or_default(Json::each) {
+            domain_value_objects_by_name.insert(
+                vo.get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_string(),
+                vo,
+            );
         }
     }
 
     for aggregate in all_aggregates {
         let agg_name = aggregate.get("name").and_then(Json::as_str).unwrap_or("");
 
-        let value_objects = aggregate
-            .get("value_objects")
-            .map(Json::each)
-            .unwrap_or(&[]);
-        let mut value_objects_by_name: HashMap<String, &Json> = domain_value_objects_by_name.clone();
+        let value_objects = aggregate.get("value_objects").map_or_default(Json::each);
+        let mut value_objects_by_name: HashMap<String, &Json> =
+            domain_value_objects_by_name.clone();
         value_objects_by_name.extend(value_objects.iter().map(|vo| {
             (
                 vo.get("name")
@@ -388,23 +406,47 @@ pub fn generate(
                 "attribute type(s) {} not generated yet (a bare, non-list entity-typed attribute isn't resolved to a Rust type)",
                 unsupported.join(", ")
             );
-            manifest.skipped_as("aggregate", format!("{domain_name}::{agg_name}"), "attribute_type", aggregate_reason.clone());
+            manifest.skipped_as(
+                "aggregate",
+                format!("{domain_name}::{agg_name}"),
+                "attribute_type",
+                aggregate_reason.clone(),
+            );
             let cascade = format!("owning aggregate not generated: {aggregate_reason}");
-            for command in aggregate.get("commands").map(Json::each).unwrap_or(&[]) {
-                manifest.skipped_as("command", format!("{domain_name}::{agg_name}.{}", node_name(command)), "owning_aggregate", cascade.clone());
+            for command in aggregate.get("commands").map_or_default(Json::each) {
+                manifest.skipped_as(
+                    "command",
+                    format!("{domain_name}::{agg_name}.{}", node_name(command)),
+                    "owning_aggregate",
+                    cascade.clone(),
+                );
             }
-            for entity in aggregate.get("entities").map(Json::each).unwrap_or(&[]) {
+            for entity in aggregate.get("entities").map_or_default(Json::each) {
                 let entity_verb = format!("{domain_name}::{agg_name}.{}", node_name(entity));
-                manifest.skipped_as("entity", entity_verb.clone(), "owning_aggregate", cascade.clone());
-                for command in entity.get("commands").map(Json::each).unwrap_or(&[]) {
-                    manifest.skipped_as("entity_command", format!("{entity_verb}.{}", node_name(command)), "owning_aggregate", cascade.clone());
+                manifest.skipped_as(
+                    "entity",
+                    entity_verb.clone(),
+                    "owning_aggregate",
+                    cascade.clone(),
+                );
+                for command in entity.get("commands").map_or_default(Json::each) {
+                    manifest.skipped_as(
+                        "entity_command",
+                        format!("{entity_verb}.{}", node_name(command)),
+                        "owning_aggregate",
+                        cascade.clone(),
+                    );
                 }
             }
-            for port in aggregate.get("ports").map(Json::each).unwrap_or(&[]) {
-                for operation in port.get("operations").map(Json::each).unwrap_or(&[]) {
+            for port in aggregate.get("ports").map_or_default(Json::each) {
+                for operation in port.get("operations").map_or_default(Json::each) {
                     manifest.skipped_as(
                         "port_operation",
-                        format!("{domain_name}::{agg_name}.{}.{}", node_name(port), node_name(operation)),
+                        format!(
+                            "{domain_name}::{agg_name}.{}.{}",
+                            node_name(port),
+                            node_name(operation)
+                        ),
                         "owning_aggregate",
                         cascade.clone(),
                     );
@@ -428,7 +470,11 @@ pub fn generate(
         );
         puts_str(&mut out, "#![allow(dead_code, unused_variables)]");
         puts_str(&mut out, "use crate::kernel::Expr;");
-        for line in crate::bridging::cross_aggregate_vo_imports(aggregate, &domain_value_object_owner, mod_name) {
+        for line in crate::bridging::cross_aggregate_vo_imports(
+            aggregate,
+            &domain_value_object_owner,
+            mod_name,
+        ) {
             puts_str(&mut out, &line);
         }
         puts_blank(&mut out);
@@ -444,8 +490,8 @@ pub fn generate(
                 ),
             );
             puts_blank(&mut out);
-            let closed_set = vo.get("closed_set").map(Json::as_bool).unwrap_or(false);
-            let attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+            let closed_set = vo.get("closed_set").is_some_and(Json::as_bool);
+            let attrs = vo.get("attributes").map_or_default(Json::each);
             if closed_set && attrs.len() == 1 {
                 puts_str(&mut out, &json_codec::emit_closed_set_codec(exemplar, vo));
             } else if closed_set {
@@ -458,7 +504,7 @@ pub fn generate(
                     crate::naming::rust_ident(vo.get("name").and_then(Json::as_str).unwrap_or(""));
                 puts_str(
                     &mut out,
-                    &json_codec::emit_to_json_flat(exemplar, &name, attrs, &value_objects_by_name, false, &[], None),
+                    &json_codec::emit_to_json_flat(exemplar, &name, attrs, false, &[], None),
                 );
                 puts_blank(&mut out);
                 // `Some(&[])` refuses unknown keys: without it a mistyped nested field (`value`
@@ -476,6 +522,7 @@ pub fn generate(
                         false,
                         false,
                         None,
+                        None,
                     ),
                 );
             }
@@ -488,12 +535,21 @@ pub fn generate(
         // identity shape, not its command routability.
         let mut registry_entities: Vec<EntityIdentityEntry> = Vec::new();
 
-        for entity in aggregate.get("entities").map(Json::each).unwrap_or(&[]) {
+        for entity in aggregate.get("entities").map_or_default(Json::each) {
             let entity_verb = format!("{domain_name}::{agg_name}.{}", node_name(entity));
             manifest.generated("entity", entity_verb.clone());
             registry_entities.push(EntityIdentityEntry {
-                name: entity.get("name").and_then(Json::as_str).unwrap_or("").to_string(),
-                identified_by: entity.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect(),
+                name: entity
+                    .get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_string(),
+                identified_by: entity
+                    .get("identified_by")
+                    .map_or_default(Json::each)
+                    .iter()
+                    .map(Json::to_s)
+                    .collect(),
             });
             puts_str(
                 &mut out,
@@ -502,7 +558,7 @@ pub fn generate(
             puts_blank(&mut out);
             let entity_name_ident =
                 crate::naming::rust_ident(entity.get("name").and_then(Json::as_str).unwrap_or(""));
-            let entity_attrs = entity.get("attributes").map(Json::each).unwrap_or(&[]);
+            let entity_attrs = entity.get("attributes").map_or_default(Json::each);
             let extra = lifecycle_extra_field(entity);
             puts_str(
                 &mut out,
@@ -510,7 +566,6 @@ pub fn generate(
                     exemplar,
                     &entity_name_ident,
                     entity_attrs,
-                    &value_objects_by_name,
                     false,
                     &extra,
                     None,
@@ -538,7 +593,7 @@ pub fn generate(
             // dispatch at depth 2 additionally needs the same check on `nested`.
             let entity_can_route = json_codec::extract_id_supported(entity);
 
-            for nested in entity.get("entities").map(Json::each).unwrap_or(&[]) {
+            for nested in entity.get("entities").map_or_default(Json::each) {
                 let nested_verb = format!("{entity_verb}.{}", node_name(nested));
                 manifest.generated("entity", nested_verb.clone());
                 puts_str(
@@ -549,7 +604,7 @@ pub fn generate(
                 let nested_name_ident = crate::naming::rust_ident(
                     nested.get("name").and_then(Json::as_str).unwrap_or(""),
                 );
-                let nested_attrs = nested.get("attributes").map(Json::each).unwrap_or(&[]);
+                let nested_attrs = nested.get("attributes").map_or_default(Json::each);
                 let nested_extra = lifecycle_extra_field(nested);
                 puts_str(
                     &mut out,
@@ -557,7 +612,6 @@ pub fn generate(
                         exemplar,
                         &nested_name_ident,
                         nested_attrs,
-                        &value_objects_by_name,
                         false,
                         &nested_extra,
                         None,
@@ -588,16 +642,23 @@ pub fn generate(
                 if unrouted_supported {
                     puts_str(&mut out, &json_codec::emit_extract_id(exemplar, nested));
                     puts_blank(&mut out);
-                    puts_str(&mut out, &json_codec::emit_extract_id_lenient(exemplar, nested));
+                    puts_str(
+                        &mut out,
+                        &json_codec::emit_extract_id_lenient(exemplar, nested),
+                    );
                     puts_blank(&mut out);
                     puts_str(&mut out, &json_codec::emit_extract_wants(exemplar, nested));
                     puts_blank(&mut out);
                 }
 
-                let nested_identified_by = nested.get("identified_by").map(Json::each).unwrap_or(&[]);
-                for command in nested.get("commands").map(Json::each).unwrap_or(&[]) {
+                let nested_identified_by = nested.get("identified_by").map_or_default(Json::each);
+                for command in nested.get("commands").map_or_default(Json::each) {
                     let nested_command_verb = format!("{nested_verb}.{}", node_name(command));
-                    if let Some(reason) = commands::entity_command_skip_reason(command, nested, &value_objects_by_name) {
+                    if let Some(reason) = commands::entity_command_skip_reason(
+                        command,
+                        nested,
+                        &value_objects_by_name,
+                    ) {
                         manifest.skipped("entity_command", nested_command_verb, reason);
                         continue;
                     }
@@ -632,7 +693,8 @@ pub fn generate(
                         }),
                     );
 
-                    let nested_command_name = command.get("name").and_then(Json::as_str).unwrap_or("");
+                    let nested_command_name =
+                        command.get("name").and_then(Json::as_str).unwrap_or("");
                     let entity_name_str = entity.get("name").and_then(Json::as_str).unwrap_or("");
                     let nested_name_str = nested.get("name").and_then(Json::as_str).unwrap_or("");
                     nested_entity_commands.push(NestedEntityCommandEntry {
@@ -653,15 +715,8 @@ pub fn generate(
                         reference_checks: reference_checks(command, &aggregates_by_name, &unsupported_names),
                         reference_specs: crate::reference_specs::reference_specs(
                             domain_name,
-                            command.get("attributes").map(Json::each).unwrap_or(&[]),
+                            command.get("attributes").map_or_default(Json::each),
                         ),
-                        attributes: command
-                            .get("attributes")
-                            .map(Json::each)
-                            .unwrap_or(&[])
-                            .iter()
-                            .map(|a| a.get("name").map(Json::to_s).unwrap_or_default())
-                            .collect(),
                         invariant_check_lines: commands::invariant_checks_for(
                             exemplar,
                             command,
@@ -672,8 +727,7 @@ pub fn generate(
                         entity_name: entity_name_str.to_string(),
                         entity_identity_reading: entity
                             .get("identified_by")
-                            .map(Json::each)
-                            .unwrap_or(&[])
+                            .map_or_default(Json::each)
                             .iter()
                             .map(Json::to_s)
                             .collect::<Vec<_>>()
@@ -692,7 +746,10 @@ pub fn generate(
             if entity_can_route {
                 puts_str(&mut out, &json_codec::emit_extract_id(exemplar, entity));
                 puts_blank(&mut out);
-                puts_str(&mut out, &json_codec::emit_extract_id_lenient(exemplar, entity));
+                puts_str(
+                    &mut out,
+                    &json_codec::emit_extract_id_lenient(exemplar, entity),
+                );
                 puts_blank(&mut out);
                 puts_str(&mut out, &json_codec::emit_extract_wants(exemplar, entity));
                 puts_blank(&mut out);
@@ -700,9 +757,11 @@ pub fn generate(
                 puts_blank(&mut out);
             }
 
-            for command in entity.get("commands").map(Json::each).unwrap_or(&[]) {
+            for command in entity.get("commands").map_or_default(Json::each) {
                 let entity_command_verb = format!("{entity_verb}.{}", node_name(command));
-                if let Some(reason) = commands::entity_command_skip_reason(command, entity, &value_objects_by_name) {
+                if let Some(reason) =
+                    commands::entity_command_skip_reason(command, entity, &value_objects_by_name)
+                {
                     manifest.skipped("entity_command", entity_command_verb, reason);
                     continue;
                 }
@@ -739,7 +798,7 @@ pub fn generate(
                 manifest.routed("entity_command", entity_command_verb);
 
                 let entity_command_name = command.get("name").and_then(Json::as_str).unwrap_or("");
-                let identified_by = entity.get("identified_by").map(Json::each).unwrap_or(&[]);
+                let identified_by = entity.get("identified_by").map_or_default(Json::each);
                 entity_commands.push(EntityCommandEntry {
                     verb: format!(
                         "{domain_name}::{agg_name}.{entity_name_ident}.{entity_command_name}",
@@ -769,12 +828,11 @@ pub fn generate(
                     ),
                     reference_specs: crate::reference_specs::reference_specs(
                         domain_name,
-                        command.get("attributes").map(Json::each).unwrap_or(&[]),
+                        command.get("attributes").map_or_default(Json::each),
                     ),
                     attributes: command
                         .get("attributes")
-                        .map(Json::each)
-                        .unwrap_or(&[])
+                        .map_or_default(Json::each)
                         .iter()
                         .map(|a| a.get("name").map(Json::to_s).unwrap_or_default())
                         .collect(),
@@ -807,7 +865,10 @@ pub fn generate(
             &types::emit_record(exemplar, &record_for_struct, &value_objects_by_name),
         );
         puts_blank(&mut out);
-        let record_attrs_owned = record_for_struct.get("attributes").map(Json::each).unwrap_or(&[]).to_vec();
+        let record_attrs_owned = record_for_struct
+            .get("attributes")
+            .map_or_default(Json::each)
+            .to_vec();
         let record_attrs = record_attrs_owned.as_slice();
         let extra = lifecycle_extra_field(aggregate);
         puts_str(
@@ -816,7 +877,6 @@ pub fn generate(
                 exemplar,
                 &record_name,
                 record_attrs,
-                &value_objects_by_name,
                 true,
                 &extra,
                 Some(aggregate),
@@ -836,7 +896,7 @@ pub fn generate(
             ),
         );
         puts_blank(&mut out);
-        puts_str(&mut out, &format!("impl crate::kernel::ToJson for {record_name} {{\n    fn to_json(&self) -> crate::kernel::Json {{\n        {record_name}::to_json(self)\n    }}\n}}\n"));
+        puts_str(&mut out, &format!("impl crate::kernel::ToJson for {record_name} {{\n    fn to_json(&self) -> crate::kernel::Json {{\n        Self::to_json(self)\n    }}\n}}\n"));
         puts_blank(&mut out);
         puts_str(&mut out, &types::emit_set_projected_field(aggregate));
         puts_blank(&mut out);
@@ -852,9 +912,11 @@ pub fn generate(
         puts_blank(&mut out);
 
         let mut registry_commands: Vec<CommandEntry> = Vec::new();
-        for command in aggregate.get("commands").map(Json::each).unwrap_or(&[]) {
+        for command in aggregate.get("commands").map_or_default(Json::each) {
             let command_verb = format!("{domain_name}::{agg_name}.{}", node_name(command));
-            if let Some(reason) = commands::command_skip_reason(command, aggregate, &value_objects_by_name) {
+            if let Some(reason) =
+                commands::command_skip_reason(command, aggregate, &value_objects_by_name)
+            {
                 manifest.skipped("command", command_verb, reason);
                 continue;
             }
@@ -874,10 +936,10 @@ pub fn generate(
 
             let command_name = command.get("name").and_then(Json::as_str).unwrap_or("");
             let args_struct = format!("{}Args", crate::naming::rust_ident(command_name));
-            let cmd_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
+            let cmd_attrs = command.get("attributes").map_or_default(Json::each);
             puts_str(
                 &mut out,
-                &json_codec::emit_to_json_flat_sparse(exemplar, &args_struct, cmd_attrs, &value_objects_by_name),
+                &json_codec::emit_to_json_flat_sparse(exemplar, &args_struct, cmd_attrs),
             );
             puts_blank(&mut out);
             let allowlist =
@@ -894,6 +956,7 @@ pub fn generate(
                     true,
                     true,
                     Some(&aggregates_by_name),
+                    Some(agg_name),
                 ),
             );
             puts_blank(&mut out);
@@ -901,11 +964,16 @@ pub fn generate(
             // order by `kernel::decode_aggregate_arguments`.
             puts_str(
                 &mut out,
-                &json_codec::emit_argument_gates(&args_struct, command_name, cmd_attrs, Some(&allowlist)),
+                &json_codec::emit_argument_gates(
+                    &args_struct,
+                    command_name,
+                    cmd_attrs,
+                    Some(&allowlist),
+                ),
             );
             puts_blank(&mut out);
 
-            let creates = crate::shared::creates_owner(aggregate, command, &value_objects_by_name);
+            let creates = crate::shared::creates_owner(aggregate, command);
             let identity = mutations::identity_components(aggregate, command);
             let identity_extra_params: Vec<String> = if creates {
                 identity.iter().filter_map(|c| c.head.clone()).collect()
@@ -936,8 +1004,15 @@ pub fn generate(
                 identity_extra_params,
                 // `state_reference_checks` only adds entries `reference_checks` did not cover.
                 reference_checks: {
-                    let mut checks = reference_checks(command, &aggregates_by_name, &unsupported_names);
-                    checks.extend(state_reference_checks(aggregate, command, &aggregates_by_name, &unsupported_names, &value_objects_by_name));
+                    let mut checks =
+                        reference_checks(command, &aggregates_by_name, &unsupported_names);
+                    checks.extend(state_reference_checks(
+                        aggregate,
+                        command,
+                        &aggregates_by_name,
+                        &unsupported_names,
+                        &value_objects_by_name,
+                    ));
                     checks
                 },
                 tenant_boundary_checks: tenant_boundary_checks(
@@ -963,11 +1038,16 @@ pub fn generate(
         }
 
         let mut port_operations: Vec<PortEntry> = Vec::new();
-        for port in aggregate.get("ports").map(Json::each).unwrap_or(&[]) {
+        for port in aggregate.get("ports").map_or_default(Json::each) {
             let port_name = port.get("name").and_then(Json::as_str).unwrap_or("");
-            for operation in port.get("operations").map(Json::each).unwrap_or(&[]) {
-                let operation_verb = format!("{domain_name}::{agg_name}.{port_name}.{}", node_name(operation));
-                if let Some(reason) = ports::port_operation_skip_reason(operation, agg_name, &value_objects_by_name) {
+            for operation in port.get("operations").map_or_default(Json::each) {
+                let operation_verb = format!(
+                    "{domain_name}::{agg_name}.{port_name}.{}",
+                    node_name(operation)
+                );
+                if let Some(reason) =
+                    ports::port_operation_skip_reason(operation, agg_name, &value_objects_by_name)
+                {
                     manifest.skipped("port_operation", operation_verb, reason);
                     continue;
                 }
@@ -988,7 +1068,7 @@ pub fn generate(
                 puts_blank(&mut out);
 
                 let operation_name = operation.get("name").and_then(Json::as_str).unwrap_or("");
-                let operation_attrs = operation.get("attributes").map(Json::each).unwrap_or(&[]);
+                let operation_attrs = operation.get("attributes").map_or_default(Json::each);
                 let legacy_receiver_field = operation_attrs
                     .iter()
                     .find(|attr| {
@@ -999,19 +1079,19 @@ pub fn generate(
                 // A `to:`-declared operation has no Reference-typed attribute; its receiver is a
                 // plain attribute named for the aggregate's identified_by field. Kept apart from
                 // legacy_receiver_field because `split_aggregate_receiver` must not strip it.
-                let to_receiver_field = if operation.get("to").and_then(Json::as_str) == Some(agg_name) {
-                    // `identified_by` holds identity paths: a value-object identity is dotted
-                    // ("reference.value"), while the attribute is named "reference".
-                    aggregate
-                        .get("identified_by")
-                        .map(Json::each)
-                        .unwrap_or(&[])
-                        .first()
-                        .map(Json::to_s)
-                        .and_then(|s| s.split('.').next().map(str::to_string))
-                } else {
-                    None
-                };
+                let to_receiver_field =
+                    if operation.get("to").and_then(Json::as_str) == Some(agg_name) {
+                        // `identified_by` holds identity paths: a value-object identity is dotted
+                        // ("reference.value"), while the attribute is named "reference".
+                        aggregate
+                            .get("identified_by")
+                            .map_or_default(Json::each)
+                            .first()
+                            .map(Json::to_s)
+                            .and_then(|s| s.split('.').next().map(str::to_string))
+                    } else {
+                        None
+                    };
                 let operation_reference_checks =
                     reference_checks(operation, &aggregates_by_name, &unsupported_names)
                         .into_iter()
@@ -1019,7 +1099,6 @@ pub fn generate(
                         .collect();
                 port_operations.push(PortEntry {
                     verb: format!("{domain_name}::{agg_name}.{port_name}.{operation_name}"),
-                    name: operation_name.to_string(),
                     fn_name: format!(
                         "{}_{}",
                         port_name.to_lowercase(),
@@ -1054,9 +1133,14 @@ pub fn generate(
             domain_name: domain_name.to_string(),
             reference_specs: crate::reference_specs::reference_specs(
                 domain_name,
-                aggregate.get("attributes").map(Json::each).unwrap_or(&[]),
+                aggregate.get("attributes").map_or_default(Json::each),
             ),
-            identified_by: aggregate.get("identified_by").map(Json::each).unwrap_or(&[]).iter().map(Json::to_s).collect(),
+            identified_by: aggregate
+                .get("identified_by")
+                .map_or_default(Json::each)
+                .iter()
+                .map(Json::to_s)
+                .collect(),
             entities: registry_entities,
         });
     }
@@ -1065,10 +1149,7 @@ pub fn generate(
     let assignments_verb = queries::provided_assignments(ir);
     for aggregate in all_aggregates {
         let agg_name = aggregate.get("name").and_then(Json::as_str).unwrap_or("");
-        let value_objects = aggregate
-            .get("value_objects")
-            .map(Json::each)
-            .unwrap_or(&[]);
+        let value_objects = aggregate.get("value_objects").map_or_default(Json::each);
         let value_objects_by_name: HashMap<String, &Json> = value_objects
             .iter()
             .map(|vo| {
@@ -1082,40 +1163,74 @@ pub fn generate(
             })
             .collect();
 
-        for query in aggregate.get("queries").map(Json::each).unwrap_or(&[]) {
+        for query in aggregate.get("queries").map_or_default(Json::each) {
             let query_name = query.get("name").and_then(Json::as_str).unwrap_or("");
-            if let Some(reason) = queries::query_skip_reason(query, aggregate, &value_objects_by_name, &aggregates_by_name) {
-                manifest.skipped("query", format!("{domain_name}::{agg_name}.{query_name}"), reason);
+            if let Some(reason) = queries::query_skip_reason(
+                query,
+                aggregate,
+                &value_objects_by_name,
+                &aggregates_by_name,
+            ) {
+                manifest.skipped(
+                    "query",
+                    format!("{domain_name}::{agg_name}.{query_name}"),
+                    reason,
+                );
                 continue;
             }
             manifest.generated("query", format!("{domain_name}::{agg_name}.{query_name}"));
 
-            let (conditions, reference_hop_conditions) = queries::query_conditions_and_hops(domain_name, query, aggregate, &aggregates_by_name);
+            let (conditions, reference_hop_conditions) = queries::query_conditions_and_hops(
+                domain_name,
+                query,
+                aggregate,
+                &aggregates_by_name,
+            );
             query_defs.push(queries::QueryDef {
                 verb: format!("{domain_name}::{agg_name}.{query_name}"),
                 aggregate: format!("{domain_name}::{agg_name}"),
-                arg_checks: queries::query_arg_checks(query, &format!("crate::generated::{mod_name}::{}", crate::naming::aggregate_module(agg_name)), &value_objects_by_name),
+                arg_checks: queries::query_arg_checks(
+                    query,
+                    &format!(
+                        "crate::generated::{mod_name}::{}",
+                        crate::naming::aggregate_module(agg_name)
+                    ),
+                    &value_objects_by_name,
+                ),
                 conditions,
                 reference_hop_conditions,
-                order_by: query.get("order_by").map(|ob| queries::emit_query_order_by(ob, query.get("null_semantics"))),
+                order_by: query
+                    .get("order_by")
+                    .map(|ob| queries::emit_query_order_by(ob, query.get("null_semantics"))),
                 offset: query.get("offset").map(queries::emit_query_offset),
                 limit: query.get("limit").map(queries::emit_query_limit),
-                authorization: queries::emit_query_authorization(query_name, query.get("authorization")),
-                assignments: assignments_verb.as_deref() == Some(format!("{agg_name}.{query_name}").as_str()),
+                authorization: queries::emit_query_authorization(
+                    query_name,
+                    query.get("authorization"),
+                ),
+                assignments: assignments_verb.as_deref()
+                    == Some(format!("{agg_name}.{query_name}").as_str()),
                 entity: None,
             });
         }
 
         // Entity queries, one level down.
         let aggregate_id = format!("{domain_name}::{agg_name}");
-        let attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
-        for entity in aggregate.get("entities").map(Json::each).unwrap_or(&[]) {
+        let attrs = aggregate.get("attributes").map_or_default(Json::each);
+        for entity in aggregate.get("entities").map_or_default(Json::each) {
             let entity_name = entity.get("name").and_then(Json::as_str).unwrap_or("");
-            let list_attr = attrs.iter().find(|a| crate::attr::list(a) && crate::attr::type_name(a) == entity_name);
-            for query in entity.get("queries").map(Json::each).unwrap_or(&[]) {
+            let list_attr = attrs
+                .iter()
+                .find(|a| crate::attr::list(a) && crate::attr::type_name(a) == entity_name);
+            for query in entity.get("queries").map_or_default(Json::each) {
                 let query_name = query.get("name").and_then(Json::as_str).unwrap_or("");
                 let query_verb = format!("{aggregate_id}.{entity_name}.{query_name}");
-                if let Some(reason) = queries::entity_query_skip_reason(query, entity, list_attr.is_some(), &value_objects_by_name) {
+                if let Some(reason) = queries::entity_query_skip_reason(
+                    query,
+                    entity,
+                    list_attr.is_some(),
+                    &value_objects_by_name,
+                ) {
                     manifest.skipped("query", query_verb, reason);
                     continue;
                 }
@@ -1123,8 +1238,7 @@ pub fn generate(
                 manifest.generated("query", query_verb);
                 let identity_keys = entity
                     .get("identified_by")
-                    .map(Json::each)
-                    .unwrap_or(&[])
+                    .map_or_default(Json::each)
                     .iter()
                     .map(|path| Json::to_s(path).split('.').next().unwrap_or("").to_string())
                     .collect();
@@ -1134,26 +1248,33 @@ pub fn generate(
                     arg_checks: Vec::new(),
                     conditions: queries::query_conditions(query),
                     reference_hop_conditions: Vec::new(),
-                    order_by: query.get("order_by").map(|ob| queries::emit_query_order_by(ob, query.get("null_semantics"))),
+                    order_by: query
+                        .get("order_by")
+                        .map(|ob| queries::emit_query_order_by(ob, query.get("null_semantics"))),
                     offset: query.get("offset").map(queries::emit_query_offset),
                     limit: query.get("limit").map(queries::emit_query_limit),
                     authorization: None,
                     assignments: false,
                     entity: Some(queries::EntityScope {
                         list_field: crate::attr::name(list_attr).to_string(),
-                        parent_key: crate::naming::snake(agg_name),
+                        parent_key: crate::hecks_naming::snake(agg_name),
                         identity_keys,
                     }),
                 });
             }
-            manifest.entity_query_gaps(&format!("{aggregate_id}.{entity_name}"), entity.get("entities").map(Json::each).unwrap_or(&[]));
+            manifest.entity_query_gaps(
+                &format!("{aggregate_id}.{entity_name}"),
+                entity.get("entities").map_or_default(Json::each),
+            );
         }
     }
 
     let mut read_model_defs: Vec<read_models::ReadModelDef> = Vec::new();
-    for read_model in ir.get("read_models").map(Json::each).unwrap_or(&[]) {
+    for read_model in ir.get("read_models").map_or_default(Json::each) {
         let read_model_id = format!("{domain_name}::{}", node_name(read_model));
-        if let Some(reason) = read_models::read_model_skip_reason(read_model, &aggregates_by_name, &unsupported_names) {
+        if let Some(reason) =
+            read_models::read_model_skip_reason(read_model, &aggregates_by_name, &unsupported_names)
+        {
             manifest.skipped("read_model", read_model_id, reason);
             continue;
         }
@@ -1166,14 +1287,20 @@ pub fn generate(
     }
 
     // Policies and process managers have no per-instance skip condition.
-    for policy in ir.get("policies").map(Json::each).unwrap_or(&[]) {
+    for policy in ir.get("policies").map_or_default(Json::each) {
         manifest.routed("policy", format!("{domain_name}::{}", node_name(policy)));
     }
     for pm in &process_managers {
-        manifest.routed("process_manager", format!("{domain_name}::{}", node_name(pm)));
+        manifest.routed(
+            "process_manager",
+            format!("{domain_name}::{}", node_name(pm)),
+        );
     }
     // Lineage-capable aggregates are always generated and routed; the journal path is generic.
-    let lineage_aggregates = ir.get("lineage").and_then(|l| l.get("capable_aggregates")).map(Json::each).unwrap_or(&[]);
+    let lineage_aggregates = ir
+        .get("lineage")
+        .and_then(|l| l.get("capable_aggregates"))
+        .map_or_default(Json::each);
     for lineage_aggregate in lineage_aggregates {
         manifest.record(
             "lineage_aggregate",
@@ -1189,10 +1316,10 @@ pub fn generate(
         );
     }
 
-    let policies: Vec<Json> = ir.get("policies").map(Json::each).unwrap_or(&[]).to_vec();
+    let policies: Vec<Json> = ir.get("policies").map_or_default(Json::each).to_vec();
     // Raw aggregate JSON: a fan-out's addressing key comes from the target command's declared
     // `references`/`attributes`, which `AggregateEntry` does not carry.
-    let policy_aggregates: Vec<Json> = ir.get("aggregates").map(Json::each).unwrap_or(&[]).to_vec();
+    let policy_aggregates: Vec<Json> = ir.get("aggregates").map_or_default(Json::each).to_vec();
 
     let mut registry_rs = String::new();
     puts_str(
@@ -1254,7 +1381,10 @@ pub fn generate(
         &queries::emit_query_table(exemplar, &query_defs),
     );
     puts_blank(&mut registry_rs);
-    puts_str(&mut registry_rs, &queries::emit_query_arg_check_table(&query_defs));
+    puts_str(
+        &mut registry_rs,
+        &queries::emit_query_arg_check_table(&query_defs),
+    );
     puts_blank(&mut registry_rs);
     for rmd in &read_model_defs {
         if let Some(body) = &rmd.group_by_fn_body {