hecks 3.5.0 → 3.7.0

data/lib/hecks/bluebook/dsl/aggregate_builder/relationships.rb

@@ -0,0 +1,128 @@
+module Hecks
+  module Bluebook
+    module DSL
+      # The words that tie an aggregate to others: `reference_to`, `has_many`, `has_one`,
+      # `belongs_to`, and the `projects` fields read through a reference.
+      class AggregateBuilder
+        # Declares a reference from this aggregate's own head to another aggregate's identity.
+        #
+        # @param type [Module, Symbol, String] the referenced aggregate, written as a bare
+        #   constant
+        # @param as [Symbol, nil] the attribute's name; nil derives it from `type`
+        # @param optional [Boolean] whether the reference may be absent
+        # @return [void]
+        # @raise [Bluebook::DSL::Malformed] if `as` (or the derived name) is already declared
+        def reference_to_impl(type, as: nil, optional: false)
+          target = Naming.demodulise(type)
+          @reference_targets << target
+          relationship_attribute(target, :reference_to,
+                                 as || default_reference_name(target), optional: optional)
+        end
+
+        # Declares that this aggregate holds its own kept-fresh copy of a field reached through
+        # a reference, so a rule can read it locally instead of reaching across the boundary.
+        #
+        # `from:` names the local reference, not the target aggregate, so two references to the
+        # same aggregate can each carry their own projection.
+        #
+        # @param name [Symbol, String] the local field receiving the projected remote value
+        # @param from [Symbol, String] the local reference and remote field, dotted, such as
+        #   `:"customer.status"`
+        # @return [Array<Bluebook::ProjectedField>] every projected field declared so far, this
+        #   one last
+        # @raise [Bluebook::DSL::Malformed] if `from` is not `reference.field` shaped
+        def projects_impl(name, from:)
+          reference, _, remote_field = from.to_s.rpartition(".")
+
+          if reference.empty? || remote_field.empty?
+            raise Malformed,
+                  "#{@name}.projects :#{name} names #{from.inspect}, which is not " \
+                  "reference.field — say which reference and which field on it, e.g. " \
+                  "from: :\"customer.status\""
+          end
+
+          @projected_fields << ProjectedField.new(name: name.to_sym, reference: reference.to_sym,
+                                                  remote_field: remote_field.to_sym)
+        end
+
+        # `has_many_impl`/`has_one_impl` are DSL keywords (`has_many`/`has_one` in a bluebook),
+        # not real predicates, so Naming/PredicatePrefix does not apply here.
+        # rubocop:disable Naming/PredicatePrefix
+
+        # Declares a list-typed relationship to another aggregate, referenced by its plural name.
+        #
+        # Under `MetaValidator.shadow_parsing?`, routes to the collapsing single-reference
+        # form instead, so frozen era text keeps its original meaning.
+        #
+        # @param type [Module, Symbol, String] the related aggregate's plural name, a bare constant
+        # @param as [Symbol, nil] the attribute's name; nil derives it from `type`
+        # @param legacy_options [Hash] must be empty outside shadow-parsing; under
+        #   shadow-parsing, `:optional` is read for the legacy single-reference form
+        # @return [void]
+        # @raise [Bluebook::DSL::Malformed] outside shadow-parsing, if non-empty, or if the
+        #   derived name is already declared
+        def has_many_impl(type, as: nil, **legacy_options)
+          return legacy_has_many(type, as: as, optional: legacy_options.fetch(:optional, false)) if MetaValidator.shadow_parsing?
+
+          refuse_has_many_options!(legacy_options)
+
+          plural = Naming.demodulise(type)
+          target = Naming.singularize(plural)
+          @reference_targets << target
+          relationship_attribute(target, :has_many, as || Naming.snake(plural).to_sym,
+                                 list: true)
+        end
+
+        # Declares a single-valued relationship this aggregate holds toward another.
+        #
+        # @param type [Module, Symbol, String] the related aggregate, a bare constant
+        # @param as [Symbol, nil] the attribute's name; nil derives it from `type`
+        # @param optional [Boolean] whether the relationship may be absent
+        # @return [void]
+        def has_one_impl(type, as: nil, optional: false)
+          return legacy_has_one(type, as: as, optional: optional) if MetaValidator.shadow_parsing?
+
+          target = Naming.demodulise(type)
+          @reference_targets << target
+          relationship_attribute(target, :has_one, as || Naming.snake(target).to_sym,
+                                 optional: optional)
+        end
+        # rubocop:enable Naming/PredicatePrefix
+
+        # Declares a single-valued relationship toward the aggregate that owns this one.
+        #
+        # @param type [Module, Symbol, String] the owning aggregate, a bare constant
+        # @param as [Symbol, nil] the attribute's name; nil derives it from `type`
+        # @param optional [Boolean] whether the relationship may be absent
+        # @return [void]
+        def belongs_to_impl(type, as: nil, optional: false)
+          return legacy_has_one(type, as: as, optional: optional) if MetaValidator.shadow_parsing?
+
+          target = Naming.demodulise(type)
+          @reference_targets << target
+          relationship_attribute(target, :belongs_to, as || Naming.snake(target).to_sym,
+                                 optional: optional)
+        end
+
+        private
+
+        def refuse_has_many_options!(options)
+          return if options.empty?
+
+          raise Malformed,
+                "#{@name}.has_many takes no #{options.keys.first}: — an empty list already means none"
+        end
+
+        # Shadow-parsing's collapsing behavior for has_many/has_one/belongs_to.
+        def legacy_has_many(type, as:, optional: false)
+          plural = Naming.demodulise(type)
+          reference_to_impl(Naming.singularize(plural), as: as || Naming.snake(plural).to_sym, optional: optional)
+        end
+
+        def legacy_has_one(type, as:, optional: false)
+          reference_to_impl(type, as: as || Naming.snake(Naming.demodulise(type)).to_sym, optional: optional)
+        end
+      end
+    end
+  end
+end

data/lib/hecks/bluebook/dsl/aggregate_builder/rules.rb

@@ -0,0 +1,84 @@
+module Hecks
+  module Bluebook
+    module DSL
+      # The rule words of an aggregate: `given` preconditions, shared across the chapter by
+      # description, and whole-aggregate `invariant`s.
+      class AggregateBuilder
+        # Declares a rule this aggregate's own commands must satisfy, or references a sibling's.
+        # `declared_by:` disambiguates a bare reference when two aggregates share a description.
+        #
+        # @param description [String] the rule's description; also its name for a sibling reference
+        # @param declared_by [Module, Symbol, String, nil] which aggregate's rule; only meaningful
+        #   with no block
+        # @yield the predicate body; evaluated for its extracted source, never called directly
+        # @return [void]
+        # @raise [Bluebook::DSL::Malformed] if the source can't be extracted, or a bare reference
+        #   resolves to none or more than one candidate once the chapter has loaded
+        def given_impl(description, declared_by: nil, &predicate)
+          return reference_named_chapter_given(description, declared_by: declared_by) unless predicate
+
+          named = build_rule(Given, description, predicate, owner_name: @name, word: "given",
+                              extraction_failure: "its source could not be read, so no other runtime could ever evaluate it")
+          @named_givens[description] = named
+          # Keyed by [description, this aggregate's name] so two aggregates sharing a
+          # description are distinct candidates, never merged into one slot.
+          @chapter_named_givens[description] ||= {}
+          @chapter_named_givens[description][@name] ||= named
+        end
+
+        # Declares a rule the whole aggregate must satisfy, checked after every command, before
+        # save.
+        #
+        # @param description [String] the rule's description
+        # @yield the predicate body; evaluated for its extracted source, never called directly
+        # @return [void]
+        # @raise [Bluebook::DSL::Malformed] if the block's source could not be extracted
+        def invariant_impl(description, &predicate)
+          @invariants << build_rule(Invariant, description, predicate, owner_name: @name, word: "invariant",
+                                     extraction_failure: "it would be a rule the IR cannot carry")
+        end
+
+        private
+
+        # Unresolved (no candidate yet) doesn't raise here — a chapter split across files
+        # may still declare this precondition in a later file (see `#pending_chapter_given`).
+        def reference_named_chapter_given(description, declared_by:)
+          verify_resolves_via!("given", "Aggregate", "owner_keyed")
+          candidates = resolve_owner_keyed(@chapter_named_givens, description)
+
+          @named_givens[description] = pick_chapter_given(candidates, description, declared_by)
+        end
+
+        def pick_chapter_given(candidates, description, declared_by)
+          return declared_chapter_given(candidates, description, declared_by) if declared_by
+          return candidates.values.first if candidates.size == 1
+          return pending_chapter_given(description, declared_by: nil) if candidates.empty?
+
+          raise Malformed, ambiguous_chapter_given_message(candidates, description)
+        end
+
+        def declared_chapter_given(candidates, description, declared_by)
+          owner = Naming.demodulise(declared_by)
+          candidates[owner] || pending_chapter_given(description, declared_by: owner)
+        end
+
+        def ambiguous_chapter_given_message(candidates, description)
+          "#{@name}'s given #{description.inspect} is ambiguous in this chapter — " \
+            "#{candidates.keys.join(", ")} each declare a DIFFERENT predicate under " \
+            "this same description; name which one with declared_by: (e.g. " \
+            "given(#{description.inspect}, declared_by: #{candidates.keys.first}))"
+        end
+
+        # Returns a placeholder `Given`, embedded by reference in this aggregate's IR;
+        # `BluebookBuilder#resolve_pending_chapter_givens!` mutates it in place once the
+        # whole chapter loads, so every existing reference sees the resolved fields together.
+        def pending_chapter_given(description, declared_by:)
+          placeholder = Given.new(description: description, canonical: nil, predicate: nil)
+          @chapter_pending_givens << { aggregate: @name, description: description,
+                                        declared_by: declared_by, placeholder: placeholder }
+          placeholder
+        end
+      end
+    end
+  end
+end

data/lib/hecks/bluebook/dsl/aggregate_builder/sealing.rb

@@ -1,12 +1,28 @@
+require_relative "query_sealing"
+require_relative "correction_sealing"
+
 module Hecks
   module Bluebook
     module DSL
       class AggregateBuilder
-        # Build-time checks that what a command, query, or default names exists on the aggregate.
-        # Included into AggregateBuilder; `#build` runs them once every declaration is in place.
+        # Build-time checks that what a command, default, or projection names exists on the
+        # aggregate. Included into AggregateBuilder; `#build` runs them once every declaration is in
+        # place. Query checks live in `QuerySealing`, correction checks in `CorrectionSealing`.
         module Sealing
+          include QuerySealing
+          include CorrectionSealing
+
           private
 
+          def seal_all
+            seal_mutation_targets
+            seal_query_targets
+            seal_defaults
+            seal_lifecycle_guards
+            seal_projected_fields
+            seal_correction_targets
+          end
+
           # Tells every reference which aggregate declares it, so it can resolve its target.
           #
           # Stamped at build because a command builder does not hold the aggregate. Walks every
@@ -43,15 +59,18 @@ module Hecks
 
             attributes.each do |attribute|
               next if attribute.default.nil? || attribute.default.is_a?(Hash)
-              next unless shapes.include?(attribute.type.to_s)
 
-              raise Malformed,
-                    "#{@name}.#{attribute.name} defaults to #{attribute.default.inspect}, but " \
-                    "#{attribute.type} is a value object — a default fills its FIELDS " \
-                    "(default: { ... }), and a bare value refuses every create instead"
+              refuse_bare_shape_default!(attribute) if shapes.include?(attribute.type.to_s)
             end
           end
 
+          def refuse_bare_shape_default!(attribute)
+            raise Malformed,
+                  "#{@name}.#{attribute.name} defaults to #{attribute.default.inspect}, but " \
+                  "#{attribute.type} is a value object — a default fills its FIELDS " \
+                  "(default: { ... }), and a bare value refuses every create instead"
+          end
+
           # A command's `from:` guard needs a lifecycle field to check against.
           def seal_lifecycle_guards
             return if @lifecycle
@@ -73,22 +92,27 @@ module Hecks
             declared = attributes.map { |attribute| attribute.name.to_sym }
 
             @projected_fields.each do |field|
-              if declared.include?(field.name)
-                raise Malformed,
-                      "#{@name}.projects :#{field.name} names a field #{@name} already declares — " \
-                      "a projected field is never a second spelling of one that already exists"
-              end
-
-              reference_attribute = attributes.find { |attribute| attribute.name == field.reference }
-              unless reference_attribute&.reference?
-                raise Malformed,
-                      "#{@name}.projects :#{field.name} reads through #{field.reference.inspect}, which " \
-                      "#{@name} never declares as a reference_to — projects reads through a REFERENCE, " \
-                      "never a value object or a scalar"
-              end
+              refuse_shadowing_projection!(field) if declared.include?(field.name)
+              refuse_projection_through_non_reference!(field)
             end
           end
 
+          def refuse_shadowing_projection!(field)
+            raise Malformed,
+                  "#{@name}.projects :#{field.name} names a field #{@name} already declares — " \
+                  "a projected field is never a second spelling of one that already exists"
+          end
+
+          def refuse_projection_through_non_reference!(field)
+            reference_attribute = attributes.find { |attribute| attribute.name == field.reference }
+            return if reference_attribute&.reference?
+
+            raise Malformed,
+                  "#{@name}.projects :#{field.name} reads through #{field.reference.inspect}, which " \
+                  "#{@name} never declares as a reference_to — projects reads through a REFERENCE, " \
+                  "never a value object or a scalar"
+          end
+
           # A mutation must name a field the aggregate actually has.
           #
           # Lives here, not in the language: a command's changes and the aggregate's fields hang
@@ -98,245 +122,33 @@ module Hecks
             known << @lifecycle.field.to_sym if @lifecycle
 
             @commands.each do |command|
-              command.mutations.each do |mutation|
-                # :delegate targets an "Entity.Command" pair and :corrects an event name, not a
-                # field; the latter is checked by `seal_correction_targets`.
-                next if [:delegate, :corrects].include?(mutation.op)
-
-                # The lifecycle field moves only by transition (C5.3). Frozen era text is exempt
-                # (`MetaValidator.shadow_parsing?`) so it keeps parsing.
-                if @lifecycle && mutation.target.to_sym == @lifecycle.field.to_sym && !MetaValidator.shadow_parsing?
-                  raise Malformed,
-                        "#{@name}.#{command.hecks_name} sets #{mutation.target}, #{@name}'s lifecycle field — " \
-                        "a lifecycle field moves only by transition; declare one instead of setting it"
-                end
-                next if known.include?(mutation.target.to_sym)
-
-                raise Malformed,
-                      "#{@name}.#{command.hecks_name} sets #{mutation.target}, which #{@name} " \
-                      "never declares — a mutation into a field that does not exist " \
-                      "writes nothing and refuses nothing"
-              end
-            end
-          end
-
-          # Checks `corrects` once every sibling command is known: the named event must be emitted
-          # by a command on this aggregate, and `reverses: true` needs every source mutation to be
-          # an increment/decrement, the only ops invertible without runtime data.
-          #
-          # One cluster of sequential rules against one command, each `raise` gating the next.
-          # rubocop:disable-next Metrics/AbcSize
-          # rubocop:disable-next Metrics/CyclomaticComplexity
-          # rubocop:disable-next Metrics/PerceivedComplexity
-          def seal_correction_targets
-            inverse_op = { increment: :decrement, decrement: :increment }
-            emitted_by = Hash.new { |hash, key| hash[key] = [] }
-            @commands.each { |command| command.emits.each { |event_name| emitted_by[event_name] << command } }
-
-            @commands.each do |command|
-              correction = command.mutations.find { |mutation| mutation.op == :corrects }
-              next unless correction
-
-              event   = correction.target
-              sources = emitted_by[event]
-              if sources.empty?
-                raise Malformed,
-                      "#{@name}.#{command.hecks_name} corrects #{event.inspect}, but nothing " \
-                      "declared on #{@name} ever emits it — corrects names a fact this " \
-                      "aggregate actually announces, not an aspiration"
-              end
-
-              next unless correction.source[:reverses]
-
-              own_mutations = command.mutations.reject { |mutation| mutation.op == :corrects }
-              if own_mutations.any?
-                raise Malformed,
-                      "#{@name}.#{command.hecks_name} declares both corrects #{event.inspect}, " \
-                      "reverses: true AND its own sets — reverses: true means the correction " \
-                      "is DERIVED; write one or the other, never both"
-              end
-
-              derived     = sources.flat_map(&:mutations).reject { |mutation| mutation.op == :corrects }
-              unsupported = derived.reject { |mutation| inverse_op.key?(mutation.op) }
-              if unsupported.any?
-                raise Malformed,
-                      "#{@name}.#{command.hecks_name} corrects #{event.inspect}, reverses: " \
-                      "true, but the command(s) that emit it use " \
-                      "#{unsupported.map(&:op).uniq.join(', ')} — not statically invertible " \
-                      "(set needs the specific prior value, multiply/clamp are lossy) — " \
-                      "declare the corrective sets by hand instead"
-              end
-
-              derived.each do |mutation|
-                command.mutations << Mutation.new(target: mutation.target, op: inverse_op.fetch(mutation.op),
-                                                  source: mutation.source)
-              end
+              command.mutations.each { |mutation| seal_mutation_target(command, mutation, known) }
             end
           end
 
-          # A query must ask about a field the aggregate has. A dotted path must land on a scalar
-          # member, an ordered comparator (lt/gt/gte/lte) on a numeric leaf, and a :symbol value
-          # must name one of the query's own arguments; else engines disagree or match nothing.
-          #
-          # `private` does not apply to constants; this sits beside the method that reads it.
-          # rubocop:disable-next Lint/UselessConstantScoping
-          ORDERED_COMPARATORS = %i[lt lte gt gte].freeze
+          def seal_mutation_target(command, mutation, known)
+            # :delegate targets an "Entity.Command" pair and :corrects an event name, not a
+            # field; the latter is checked by `seal_correction_targets`.
+            return if [:delegate, :corrects].include?(mutation.op)
 
-          def seal_query_targets
-            query_surfaces.each do |owner, fields, lifecycle, queries|
-              queries.each do |query|
-                query.wheres.each do |clause|
-                  seal_query_field(owner, query, fields, lifecycle, clause.field)
-                  seal_ordered_comparator(owner, query, fields, clause)
-                  infer_local_query_argument(query, fields, lifecycle, clause)
-                  seal_query_argument(owner, query, clause.value) unless clause.field.to_s.include?("/")
-                end
-                seal_query_field(owner, query, fields, lifecycle, query.order_by.field, ordering: true) if query.order_by
-                seal_query_argument(owner, query, query.limit&.value)
-                seal_query_argument(owner, query, query.offset&.value)
-              end
-            end
-          end
-
-          def query_surfaces
-            [[@name, attributes, @lifecycle, @queries]] +
-              @entities.map { |entity| ["#{@name}::#{entity.hecks_name}", entity.attributes, entity.lifecycle, entity.queries] }
-          end
-
-          # `/` crosses into another record and `.` walks fields inside this one, so a hop is
-          # routed to `seal_query_hop` before any `.`-splitting.
-          #
-          # A closed decision tree over where a field can resolve: hop, local scalar, lifecycle
-          # field, value object (refused), or nothing (refused).
-          # rubocop:disable-next Metrics/CyclomaticComplexity
-          # rubocop:disable-next Metrics/PerceivedComplexity
-          def seal_query_field(owner, query, fields, lifecycle, field, ordering: false)
-            return seal_query_hop(owner, query, fields, field, ordering: ordering) if field.to_s.include?("/")
-
-            name, *nested = field.to_s.split(".")
-            attribute = fields.find { |candidate| candidate.name.to_s == name }
-            if nested.empty? && attribute
-              refuse_ambiguous_comparison!(owner, query, field, attribute)
-              return
-            end
-            return if nested.empty? && lifecycle&.field.to_s == name
-            return if nested.any? && attribute && scalar_path?(attribute, nested)
-
-            if nested.any? && attribute && resolves?(attribute, nested)
-              raise Malformed,
-                    "#{owner}.#{query.hecks_name} asks about #{field}, which lands on a " \
-                    "value object, not a scalar — a dotted query path ends on a scalar " \
-                    "member, or the engines answer it differently"
-            end
-
-            raise Malformed,
-                  "#{owner}.#{query.hecks_name} asks about #{field}, which #{owner} " \
-                  "never declares — a query over a field that does not exist " \
-                  "matches nothing and refuses nothing"
-          end
-
-          # ORDER BY refuses a hop outright: a hop answers with a candidate set, not a sort key.
-          #
-          # A where hop is only recognised here. Its head must be one of this aggregate's own
-          # references, but the target cannot resolve before the chapter exists, so
-          # BluebookBuilder#validate_query_hops! checks the tail and the target later.
-          def seal_query_hop(owner, query, fields, field, ordering:)
-            unless QuerySpecification::HopPath.hop_head?(field, fields)
-              raise Malformed,
-                    "#{owner}.#{query.hecks_name} asks about #{field}, which #{owner} " \
-                    "never declares — a query over a field that does not exist " \
-                    "matches nothing and refuses nothing"
-            end
-
-            return unless ordering
+            refuse_lifecycle_field_write!(command, mutation)
+            return if known.include?(mutation.target.to_sym)
 
             raise Malformed,
-                  "#{owner}.#{query.hecks_name} orders by #{field}, which hops through " \
-                  "a reference — an ask is ordered by what its own answering rows " \
-                  "hold, and a hop answers with a candidate set, not a sort key"
+                  "#{@name}.#{command.hecks_name} sets #{mutation.target}, which #{@name} " \
+                  "never declares — a mutation into a field that does not exist " \
+                  "writes nothing and refuses nothing"
           end
 
-          def seal_ordered_comparator(owner, query, fields, clause)
-            return unless ORDERED_COMPARATORS.include?(clause.op.to_s.to_sym)
-
-            # A where hop with an ordered comparator is legitimate; whether its tail is numeric
-            # is BluebookBuilder#validate_query_hops!'s question, so it is deferred.
-            return if clause.field.to_s.include?("/") && QuerySpecification::HopPath.hop_head?(clause.field, fields)
+          # The lifecycle field moves only by transition (C5.3). Frozen era text is exempt
+          # (`MetaValidator.shadow_parsing?`) so it keeps parsing.
+          def refuse_lifecycle_field_write!(command, mutation)
+            return unless @lifecycle && mutation.target.to_sym == @lifecycle.field.to_sym
+            return if MetaValidator.shadow_parsing?
 
-            name, *nested = clause.field.to_s.split(".")
-            attribute = fields.find { |candidate| candidate.name.to_s == name }
-            return if attribute &&
-                      QuerySpecification::FieldPath.numeric?(attribute, nested) { |type| declared_value_object(type) }
-
-            held = attribute ? "holds no number" : "is the lifecycle field, which holds text"
             raise Malformed,
-                  "#{owner}.#{query.hecks_name} compares #{clause.field} with #{clause.op}, " \
-                  "but #{clause.field} #{held} — an ordered comparison needs a numeric " \
-                  "field, and over anything else the adapters answer differently or not at all"
-          end
-
-          def seal_query_argument(owner, query, value)
-            return unless value.is_a?(Symbol)
-            return if query.attribute(value)
-
-            raise Malformed,
-                  "#{owner}.#{query.hecks_name} resolves :#{value} from its arguments, " \
-                  "but declares no #{value} attribute — an argument that does not exist " \
-                  "resolves to nil and matches nothing"
-          end
-
-          # A symbolic right-hand side is a query input; when the compared path lands on this
-          # owner's shape its type is known, so no `attribute` line is needed. Reference hops
-          # are inferred later by BluebookBuilder, once the chapter is owner-stamped.
-          def infer_local_query_argument(query, fields, lifecycle, clause)
-            name = clause.value
-            return unless name.is_a?(Symbol)
-            return if query.attribute(name)
-            return if clause.field.to_s.include?("/")
-
-            head, *nested = clause.field.to_s.split(".")
-            leaf = if nested.empty? && lifecycle&.field.to_s == head
-                     Attribute.new(name: name, type: String)
-                   else
-                     root = fields.find { |candidate| candidate.name.to_s == head }
-                     found = root && QuerySpecification::FieldPath.leaf_attribute(root, nested) do |type|
-                       declared_value_object(type)
-                     end
-                     found && Attribute.new(name: name, type: found.type, list: found.list?)
-                   end
-            query.attributes << leaf if leaf
-          end
-
-          # A bare field naming a value object must say which member it means when several could
-          # answer; otherwise engines disagree (first numeric member vs. no unwrap at all).
-          #
-          # Unambiguous is exactly one member, or exactly one numeric member among several.
-          # A list is exempt: `contains` reads element membership, not a scalar comparison.
-          def refuse_ambiguous_comparison!(owner, query, field, attribute)
-            return if attribute.list?
-
-            value_object = declared_value_object(attribute.type.to_s)
-            return unless value_object
-
-            members = QuerySpecification::Common::Comparison.ambiguous_members(value_object)
-            return if members.empty?
-
-            raise Malformed,
-                  "#{owner}.#{query.hecks_name} asks about #{field}, which names #{attribute.type} — " \
-                  "it has #{members.size} members (#{members.join(', ')}) and no single one a " \
-                  "comparison can mean; name the member (#{field}.#{members.first})"
-          end
-
-          def scalar_path?(attribute, nested)
-            QuerySpecification::FieldPath.scalar_leaf?(attribute, nested) { |type| declared_value_object(type) }
-          end
-
-          def resolves?(attribute, nested)
-            !QuerySpecification::FieldPath.leaf_attribute(attribute, nested) { |type| declared_value_object(type) }.nil?
-          end
-
-          def declared_value_object(type_name)
-            (@value_objects + closed_sets).find { |shape| shape.hecks_name.to_s == type_name }
+                  "#{@name}.#{command.hecks_name} sets #{mutation.target}, #{@name}'s lifecycle field — " \
+                  "a lifecycle field moves only by transition; declare one instead of setting it"
           end
         end
       end