hecks 3.2.0 → 3.3.0

data/rust/build/src/optional_pass.rs

@@ -1,150 +0,0 @@
-//! Marks value-object and entity fields `optional` when an `append` mutation binds them to an
-//! optional command argument, so the generated struct field is an `Option`.
-
-use crate::json::Json;
-
-pub fn run(ir: &mut Json) {
-    if let Some(aggregates) = ir.get_mut("aggregates").and_then(Json::as_array_mut) {
-        for aggregate in aggregates.iter_mut() {
-            mark_append_optional_fields(aggregate);
-        }
-    }
-}
-
-enum ElementRef {
-    ValueObject(usize),
-    Entity(usize),
-}
-
-fn find_element_ref(aggregate: &Json, target_type: &str) -> Option<ElementRef> {
-    if let Some(idx) = aggregate.get("value_objects").map(Json::each).unwrap_or(&[]).iter().position(|vo| vo.get("name").and_then(Json::as_str) == Some(target_type)) {
-        return Some(ElementRef::ValueObject(idx));
-    }
-    if let Some(idx) = aggregate.get("entities").map(Json::each).unwrap_or(&[]).iter().position(|e| e.get("name").and_then(Json::as_str) == Some(target_type)) {
-        return Some(ElementRef::Entity(idx));
-    }
-    None
-}
-
-// Gathers the fields to mark first, then applies them: the commands are read while the
-// value objects and entities are mutated.
-fn mark_append_optional_fields(aggregate: &mut Json) {
-    let target_attrs: Vec<(String, String)> = aggregate
-        .get("attributes")
-        .map(Json::each)
-        .unwrap_or(&[])
-        .iter()
-        .filter_map(|a| {
-            let name = a.get("name").and_then(Json::as_str)?;
-            let type_name = a.get("type").and_then(Json::as_str)?;
-            Some((name.to_string(), type_name.to_string()))
-        })
-        .collect();
-
-    for (attr_name, attr_type) in target_attrs {
-        let Some(element_ref) = find_element_ref(aggregate, &attr_type) else { continue };
-
-        let fields_to_mark = collect_fields_to_mark(aggregate, &attr_name);
-        if fields_to_mark.is_empty() {
-            continue;
-        }
-
-        apply_marks(aggregate, &element_ref, &fields_to_mark);
-    }
-}
-
-fn collect_fields_to_mark(aggregate: &Json, target_attr_name: &str) -> Vec<String> {
-    let mut out = Vec::new();
-
-    for command in aggregate.get("commands").map(Json::each).unwrap_or(&[]) {
-        let command_attrs = command.get("attributes").map(Json::each).unwrap_or(&[]);
-
-        for mutation in command.get("mutations").map(Json::each).unwrap_or(&[]) {
-            let op = mutation.get("op").and_then(Json::as_str).unwrap_or("");
-            let target = mutation.get("target").and_then(Json::as_str).unwrap_or("");
-            if op != "append" || target != target_attr_name {
-                continue;
-            }
-
-            let Some(fields) = mutation.get("fields").and_then(Json::as_object) else { continue };
-            for (field_name, source) in fields {
-                // Only a Symbol (an argument name) renders with a leading `:` in `Literal.render`.
-                let Some(source_text) = source.as_str() else { continue };
-                let Some(arg_name) = source_text.strip_prefix(':') else { continue };
-
-                let source_is_optional = command_attrs.iter().any(|a| {
-                    a.get("name").and_then(Json::as_str) == Some(arg_name) && a.get("optional").map(Json::as_bool).unwrap_or(false)
-                });
-                if source_is_optional {
-                    out.push(field_name.clone());
-                }
-            }
-        }
-    }
-
-    out
-}
-
-fn apply_marks(aggregate: &mut Json, element_ref: &ElementRef, fields_to_mark: &[String]) {
-    let element = match element_ref {
-        ElementRef::ValueObject(idx) => aggregate.get_mut("value_objects").and_then(Json::as_array_mut).and_then(|v| v.get_mut(*idx)),
-        ElementRef::Entity(idx) => aggregate.get_mut("entities").and_then(Json::as_array_mut).and_then(|v| v.get_mut(*idx)),
-    };
-    let Some(element) = element else { return };
-    let Some(attrs) = element.get_mut("attributes").and_then(Json::as_array_mut) else { return };
-
-    for field_name in fields_to_mark {
-        if let Some(field_attr) = attrs.iter_mut().find(|a| a.get("name").and_then(Json::as_str) == Some(field_name.as_str())) {
-            field_attr.set_bool("optional", true);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    // Banking's `Account.Credit` shape: entity list `ledger`, one `append` binding `amount` from
-    // an optional argument and `direction` from a literal Hash.
-    fn fixture() -> Json {
-        Json::parse(
-            r#"{
-  "attributes": [
-    {"name": "ledger", "type": "LedgerEntry", "list": true, "default": null, "optional": false, "pattern": null, "admits": null}
-  ],
-  "value_objects": [],
-  "entities": [
-    {
-      "name": "LedgerEntry",
-      "attributes": [
-        {"name": "amount", "type": "Money", "list": false, "default": null, "optional": false, "pattern": null, "admits": null},
-        {"name": "direction", "type": "Direction", "list": false, "default": null, "optional": false, "pattern": null, "admits": null}
-      ]
-    }
-  ],
-  "commands": [
-    {
-      "name": "Credit",
-      "attributes": [
-        {"name": "amount", "type": "PositiveMoney", "list": false, "default": null, "optional": true, "pattern": null, "admits": null}
-      ],
-      "mutations": [
-        {"target": "ledger", "op": "append", "fields": {"amount": ":amount", "direction": "{value: \"credit\"}"}}
-      ]
-    }
-  ]
-}"#,
-        )
-        .expect("fixture parses")
-    }
-
-    #[test]
-    fn marks_the_argument_sourced_field_optional() {
-        let mut aggregate = fixture();
-        mark_append_optional_fields(&mut aggregate);
-
-        let entity = &aggregate.get("entities").unwrap().each()[0];
-        let amount = entity.get("attributes").unwrap().each().iter().find(|a| a.get("name").and_then(Json::as_str) == Some("amount")).unwrap();
-        assert!(amount.get("optional").unwrap().as_bool());
-    }
-}

data/rust/project/bridging.rb

@@ -1,257 +0,0 @@
-module RustProjection
-  module Projector
-    module_function
-
-    # `use` statements for value-object types this aggregate's commands
-    # reference by name but don't declare locally (same chapter only).
-    def cross_aggregate_vo_imports(aggregate, domain_value_object_owner, mod_name)
-      local_names = aggregate[:value_objects].map { |vo| vo[:name] }.to_set
-      attrs = (aggregate[:commands] + aggregate[:entities].flat_map { |e| e[:commands] } +
-               aggregate[:ports].flat_map { |p| p[:operations] })
-              .flat_map { |c| c[:attributes] }
-
-      # A locally-declared type is never "foreign", even if some other
-      # aggregate owns a VO of the same name domain-wide.
-      foreign_types = attrs.map { |a| a[:type] }.uniq.reject { |type| local_names.include?(type) }
-      foreign_types.filter_map { |type| domain_value_object_owner[type] && [type, domain_value_object_owner[type]] }
-                   .sort_by { |(type, owner)| [owner, type] }
-                   .map { |(type, owner)| "use crate::generated::#{mod_name}::#{owner.downcase}::#{rust_ident(type)};" }
-    end
-
-    # Whether target_vo's fields can all be filled from source_vo's fields
-    # (matched by name) or the target's own defaults.
-    def vo_field_bridgeable?(source_vo, target_vo)
-      return false unless source_vo && target_vo
-      return closed_sets_bridgeable?(source_vo, target_vo) if source_vo[:closed_set] || target_vo[:closed_set]
-
-      target_vo[:attributes].all? do |t_attr|
-        source_vo[:attributes].any? { |s_attr| s_attr[:name] == t_attr[:name] } || !t_attr[:default].nil?
-      end
-    end
-
-    # Source closed-set members mappable to target members, or nil unless
-    # every source member is also a target member (so the bridge can't fail).
-    def closed_set_bridge_members(source_vo, target_vo)
-      return nil unless source_vo[:closed_set] && target_vo[:closed_set]
-      return nil unless source_vo[:attributes].size == 1 && target_vo[:attributes].size == 1
-
-      target_values = target_vo[:members].map { |row| row.to_h.values.first.to_s }
-      source_rows   = source_vo[:members]
-      return nil unless source_rows.all? { |row| target_values.include?(row.to_h.values.first.to_s) }
-
-      source_rows
-    end
-
-    def closed_sets_bridgeable?(source_vo, target_vo)
-      !closed_set_bridge_members(source_vo, target_vo).nil?
-    end
-
-    def vo_field_rhs(source_expr, source_vo, target_type, value_objects_by_name)
-      target_vo = value_objects_by_name[target_type]
-      if (rows = closed_set_bridge_members(source_vo, target_vo))
-        arms = rows.map { |row| "#{rust_ident(source_vo[:name])}::#{closed_set_variant(row)} => #{rust_ident(target_type)}::#{closed_set_variant(row)}" }
-        return "match &#{source_expr} { #{arms.join(', ')} }"
-      end
-
-      fields = target_vo[:attributes].map do |t_attr|
-        field = rust_ident_field(t_attr[:name])
-        if source_vo[:attributes].any? { |s_attr| s_attr[:name] == t_attr[:name] }
-          "#{field}: #{source_expr}.#{field}.clone()"
-        else
-          "#{field}: #{literal_rhs(t_attr[:default])}"
-        end
-      end
-      "#{rust_ident(target_type)} { #{fields.join(', ')} }"
-    end
-
-    # Whether a value can move from source_type to target_type. Shared
-    # with `value_rhs`, which performs the bridge this checks for.
-    def bridgeable_value_types?(source_type, target_type, value_objects_by_name)
-      return true if source_type == target_type
-      # Compares Rust representations, not declared type names: a
-      # `Reference<T>` and a bare `String` are both just `String`.
-      return true if effective_scalar_type(source_type) && effective_scalar_type(source_type) == effective_scalar_type(target_type)
-
-      source_vo = value_objects_by_name[source_type]
-      target_vo = value_objects_by_name[target_type]
-      return vo_field_bridgeable?(source_vo, target_vo) if target_vo
-
-      # A single-field source VO unwraps into a bare scalar target when
-      # that one field's own Rust representation already matches it.
-      return false unless source_vo && !source_vo[:closed_set] && source_vo[:attributes].size == 1
-
-      unwrapped_type = source_vo[:attributes].first[:type]
-      unwrapped_type == target_type ||
-        (effective_scalar_type(unwrapped_type) && effective_scalar_type(unwrapped_type) == effective_scalar_type(target_type))
-    end
-
-    def value_rhs(source_expr, source_type, target_type, value_objects_by_name)
-      return "#{source_expr}.clone()" if source_type == target_type
-      return "#{source_expr}.clone()" if effective_scalar_type(source_type) && effective_scalar_type(source_type) == effective_scalar_type(target_type)
-
-      source_vo = value_objects_by_name[source_type]
-      target_vo = value_objects_by_name[target_type]
-      return vo_field_rhs(source_expr, source_vo, target_type, value_objects_by_name) if target_vo
-
-      raise "unsupported coercion #{source_type} -> #{target_type} — bridgeable_value_types? should have caught this" unless source_vo && !source_vo[:closed_set] && source_vo[:attributes].size == 1
-
-      "#{source_expr}.#{rust_ident_field(source_vo[:attributes].first[:name])}.clone()"
-    end
-
-    # Whether a list `:set` needs per-element rebuilding, rather than one
-    # `.clone()`, because source and target elements differ in representation.
-    def list_bridge_requires_element_mapping?(source_type, target_type)
-      return false if source_type == target_type
-
-      !(effective_scalar_type(source_type) && effective_scalar_type(source_type) == effective_scalar_type(target_type))
-    end
-
-    # `value_rhs`, mapped over each element of a list `:set` whose source
-    # and target element types differ.
-    def list_value_rhs(source_expr, source_type, target_type, value_objects_by_name)
-      "#{source_expr}.iter().map(|item| #{value_rhs('item', source_type, target_type, value_objects_by_name)}).collect()"
-    end
-
-    def literal_set_bridgeable?(value, target_type, value_objects_by_name)
-      return literal_hash_bridgeable?(value, target_type, value_objects_by_name) if value.is_a?(Hash) && target_type
-      return false if value.is_a?(Hash)
-      return false unless value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
-      return true unless target_type && value_objects_by_name[target_type]
-
-      # A scalar literal into a single-field VO stands for that field's
-      # value (mirrors `Value.for_attribute`'s runtime rewrap).
-      sole = sole_field_of(target_type, value_objects_by_name)
-      return false unless sole
-
-      literal_hash_bridgeable?({ sole => value }, target_type, value_objects_by_name)
-    end
-
-    # The right-hand side for a literal into target_type: a Hash, a
-    # scalar rewrapped into a single-field VO, or the scalar itself.
-    def literal_rhs_for(value, target_type, value_objects_by_name)
-      return literal_hash_rhs(value, target_type, value_objects_by_name) if value.is_a?(Hash)
-
-      sole = target_type && value_objects_by_name[target_type] && sole_field_of(target_type, value_objects_by_name)
-      return literal_hash_rhs({ sole => value }, target_type, value_objects_by_name) if sole
-
-      literal_rhs(value)
-    end
-
-    # Whether a literal Hash supplies every field a target VO (or one
-    # of its closed-set members) needs.
-    def literal_hash_bridgeable?(hash, target_type, value_objects_by_name)
-      vo = value_objects_by_name[target_type]
-      return false unless vo
-
-      if vo[:closed_set]
-        vo[:members].any? { |member| member.all? { |field, value| [hash[field.to_sym], hash[field.to_s]].include?(value) } }
-      else
-        vo[:attributes].all? { |attr| hash.key?(attr[:name].to_sym) || hash.key?(attr[:name].to_s) }
-      end
-    end
-
-    def literal_hash_rhs(hash, target_type, value_objects_by_name)
-      vo = value_objects_by_name[target_type]
-      raise "unsupported literal hash source #{hash.inspect} -> #{target_type} — literal_hash_bridgeable? should have caught this" unless vo
-
-      if vo[:closed_set]
-        row = vo[:members].find { |member| member.all? { |field, value| [hash[field.to_sym], hash[field.to_s]].include?(value) } }
-        raise "literal #{hash.inspect} matches no member of #{target_type} — literal_hash_bridgeable? should have caught this" unless row
-
-        "#{rust_ident(target_type)}::#{closed_set_variant(row)}"
-      else
-        fields = vo[:attributes].map do |attr|
-          key = [attr[:name].to_sym, attr[:name].to_s].find { |k| hash.key?(k) }
-          raise "literal #{hash.inspect} missing field #{attr[:name]} for #{target_type} — literal_hash_bridgeable? should have caught this" unless key
-
-          "#{rust_ident_field(attr[:name])}: #{literal_rhs(hash[key])}"
-        end
-        "#{rust_ident(target_type)} { #{fields.join(', ')} }"
-      end
-    end
-
-    def integer_field_of(vo)
-      return nil unless vo && !vo[:closed_set]
-
-      attr = vo[:attributes].find { |a| a[:type] == "Integer" }
-      attr && attr[:name]
-    end
-
-    # The attribute and its one Integer field an `:increment`/`:decrement`
-    # touches, or nil unless the target is a single-field integer VO.
-    def arithmetic_target_field(mutation, aggregate, value_objects_by_name)
-      target_attr = aggregate[:attributes].find { |a| a[:name].to_s == mutation[:target].to_s }
-      return nil unless target_attr && !target_attr[:list]
-
-      field = integer_field_of(value_objects_by_name[target_attr[:type]])
-      field && [target_attr, field]
-    end
-
-    # The amount side of an `:increment`/`:decrement` as a raw Rust
-    # integer expression. Returns nil, not raise, when nothing bridges.
-    def arithmetic_amount_expr(source, command, value_objects_by_name, target_integer_field)
-      if source[:kind] == "literal"
-        value = source[:value]
-        return literal_rhs(value) if value.is_a?(Integer)
-        return nil unless value.is_a?(Hash)
-
-        key = [target_integer_field.to_sym, target_integer_field.to_s].find { |k| value.key?(k) }
-        key && value[key].is_a?(Integer) ? literal_rhs(value[key]) : nil
-      elsif source[:kind] == "argument"
-        arg_attr = command[:attributes].find { |a| a[:name].to_s == source[:name] }
-        return nil unless arg_attr
-        return "args.#{rust_ident_field(arg_attr[:name])}" if arg_attr[:type] == "Integer"
-
-        field = integer_field_of(value_objects_by_name[arg_attr[:type]])
-        field && "args.#{rust_ident_field(arg_attr[:name])}.#{rust_ident_field(field)}"
-      end
-    end
-
-    # `clamp:`'s literal `[min, max]` bounds, or nil for anything else
-    # (non-literal source, wrong length, non-Integer bound).
-    def clamp_bounds_ints(source)
-      return nil unless source[:kind] == "literal"
-
-      value = source[:value]
-      return nil unless value.is_a?(Array) && value.size == 2 && value.all? { |v| v.is_a?(Integer) }
-
-      value
-    end
-
-    # The default for an attribute a creating command's arguments don't
-    # mention: its own default, or one built from its VO's field defaults.
-    def creation_default_rhs(attr, value_objects_by_name)
-      default = attr[:default]
-      unless default.nil?
-        return literal_rhs(default) unless default.is_a?(Hash)
-
-        # Completes a partial Hash default with the target VO's own
-        # per-field defaults first; `literal_hash_rhs` requires every
-        # field present.
-        return literal_hash_rhs(complete_hash_default(default, attr[:type], value_objects_by_name), attr[:type], value_objects_by_name)
-      end
-
-      vo = value_objects_by_name[attr[:type]]
-      return nil unless vo && !vo[:closed_set] && vo[:attributes].all? { |f| !f[:default].nil? }
-
-      fields = vo[:attributes].map { |f| "#{rust_ident_field(f[:name])}: #{literal_rhs(f[:default])}" }
-      "#{rust_ident(attr[:type])} { #{fields.join(', ')} }"
-    end
-
-    # Fields present in `hash`, plus any the target VO defaults on its
-    # own; a field with neither is left out, not set to nil.
-    def complete_hash_default(hash, target_type, value_objects_by_name)
-      vo = value_objects_by_name[target_type]
-      return hash unless vo && !vo[:closed_set]
-
-      vo[:attributes].each_with_object({}) do |field, completed|
-        key = [field[:name].to_sym, field[:name].to_s].find { |k| hash.key?(k) }
-        if key
-          completed[field[:name].to_sym] = hash[key]
-        elsif !field[:default].nil?
-          completed[field[:name].to_sym] = field[:default]
-        end
-      end
-    end
-  end
-end