hecks 3.5.0 → 3.7.0

data/lib/hecks/bluebook/behaviour/read_model.rb

@@ -56,13 +56,12 @@ module Hecks
         # @return [Array<Symbol>] the `:as` name of each many-side head that filtering
         #   applies to; `[]` if this read model has no many-side head
         def filtered_head_names
-          many = @aggregate_heads.select { |head| head[:many] }
+          many = many_heads
           return [] if many.empty?
 
           return single_filtered_head_name(many) if many.one?
 
-          targets = (wheres.map(&:target) + [order_by&.target, limit&.target, offset&.target]).compact.uniq
-          targets.filter_map { |target| many.find { |head| head[:aggregate] == target.to_s } }.map { |head| head[:as] }
+          filtering_targets.filter_map { |target| many.find { |head| head[:aggregate] == target.to_s } }.map { |head| head[:as] }
         end
 
         # Split out only to keep `filtered_head_names` under this file's own
@@ -73,8 +72,7 @@ module Hecks
         # @return [Array<Symbol>] `[the one head's :as name]` if any filtering option is
         #   declared, else `[]`
         def single_filtered_head_name(many)
-          declared = wheres.any? || order_by || limit || offset || authorization&.tenant ||
-                     @group_by.any? || reducing?
+          declared = scoped_options? || authorization&.tenant || @group_by.any? || reducing?
           declared ? [many.first[:as]] : []
         end
 
@@ -87,20 +85,35 @@ module Hecks
         # @return [FilteredOptions] the `wheres`/`order_by`/`limit`/`offset` that apply to
         #   `head_as`, and this read model's own `null_semantics`
         def options_for(head_as)
-          many = @aggregate_heads.select { |head| head[:many] }
-          aggregate_name = @aggregate_heads.find { |head| head[:as] == head_as }&.fetch(:aggregate)
-          applies = lambda do |target|
-            target.nil? ? many.one? : target.to_s == aggregate_name
-          end
+          applies = scope_test(head_as)
 
           FilteredOptions.new(
             wheres.select { |where| applies.call(where.target) },
-            order_by && applies.call(order_by.target) ? order_by : nil,
-            limit && applies.call(limit.target) ? limit : nil,
-            offset && applies.call(offset.target) ? offset : nil,
+            scoped(order_by, applies),
+            scoped(limit, applies),
+            scoped(offset, applies),
             null_semantics
           )
         end
+
+        private
+
+        def many_heads = @aggregate_heads.select { |head| head[:many] }
+
+        def filtering_targets
+          (wheres.map(&:target) + [order_by&.target, limit&.target, offset&.target]).compact.uniq
+        end
+
+        def scoped_options? = wheres.any? || order_by || limit || offset
+
+        # An untargeted option applies to the one many-side head; a targeted one to its own.
+        def scope_test(head_as)
+          many = many_heads
+          aggregate_name = @aggregate_heads.find { |head| head[:as] == head_as }&.fetch(:aggregate)
+          ->(target) { target.nil? ? many.one? : target.to_s == aggregate_name }
+        end
+
+        def scoped(option, applies) = (option if option && applies.call(option.target))
       end
     end
   end

data/lib/hecks/bluebook/chapter.rb

@@ -1,5 +1,6 @@
 require_relative "behaviour/chapter"
 require_relative "capabilities"
+require_relative "keyword_fields"
 require_relative "../ir"
 
 module Hecks
@@ -58,29 +59,36 @@ module Hecks
       attr_reader :name, :version, :vision, :aggregates, :policies, :process_managers,
                   :classification, :read_models, :ports, :formerly_known_as, :namespace, :attaches_to, :provides
 
+      # Every optional field and what it holds when the declaration omits it.
+      FIELD_DEFAULTS = {
+        version: nil, vision: nil, aggregates: [], policies: [], process_managers: [],
+        classification: nil, read_models: [], formerly_known_as: nil, namespace: nil,
+        attaches_to: [], provides: []
+      }.freeze
+
       # @param policies [Array<Bluebook::Policy>] every reaction declared across the
       #   chapter's own aggregates, hoisted here
       # @param classification [String, Symbol, nil] whether this chapter is central to
       #   its project's own domain model, or `nil` if undeclared
-      def initialize(name:, version: nil, vision: nil, aggregates: [], policies: [],
-                     process_managers: [], classification: nil, read_models: [], formerly_known_as: nil,
-                     namespace: nil, attaches_to: [], provides: [])
-        @policies         = policies
-        @process_managers = process_managers
+      def initialize(name:, **given)
+        KeywordFields.assign(self, KeywordFields.fill(given, FIELD_DEFAULTS))
         @name       = name.to_s
         @hecks_name = @name
         @hecks_root = true
-        @version    = version&.to_s
-        @vision     = vision
-        @aggregates = aggregates
-        @read_models = read_models
-        @classification = classification&.to_s
-        @formerly_known_as = formerly_known_as&.to_s
-        @namespace   = namespace&.to_s
-        @attaches_to = Array(attaches_to).map(&:to_s)
-        @provides    = Array(provides).map { |row| Provision.from(row) }
+        coerce_fields
         settle
       end
+
+      # Holds every optional field as the text or rows its reader answers.
+      def coerce_fields
+        @version           = @version&.to_s
+        @classification    = @classification&.to_s
+        @formerly_known_as = @formerly_known_as&.to_s
+        @namespace         = @namespace&.to_s
+        @attaches_to       = Array(@attaches_to).map(&:to_s)
+        @provides          = Array(@provides).map { |row| Provision.from(row) }
+      end
+      private :coerce_fields
     end
   end
 end

data/lib/hecks/bluebook/command.rb

@@ -1,4 +1,5 @@
 require_relative "behaviour/command"
+require_relative "keyword_fields"
 require_relative "../vocabulary"
 require_relative "expression/ast_json"
 
@@ -62,6 +63,12 @@ module Hecks
         provenance: :provenance
       )
 
+      # Every optional declared field and what it holds when the declaration omits it.
+      FIELD_DEFAULTS = {
+        role: nil, goal: nil, attributes: [], givens: [], ensures: [], needs: [],
+        mutations: [], emits: [], references: nil, from: nil, provenance: nil
+      }.freeze
+
       class << self
         attr_reader :role, :goal, :attributes, :givens, :ensures, :needs, :mutations, :emits, :references,
                     :from, :provenance
@@ -78,13 +85,11 @@ module Hecks
         # @param references [String, Symbol, nil] the aggregate its `reference_to` addresses
         # @param from [String, Array<String>, nil] the lifecycle states it is admissible from
         # @param provenance [Object, nil] the declared canonical source, as written
-        def declare(name:, role: nil, goal: nil, attributes: [], givens: [], ensures: [], needs: [],
-                    mutations: [], emits: [], references: nil, from: nil, provenance: nil)
+        def declare(name:, **given)
+          fields = KeywordFields.fill(given, FIELD_DEFAULTS)
           verb = Class.new(self)
           verb.hecks_name = name.to_s
-          verb.absorb(role: role, goal: goal, attributes: attributes, givens: givens,
-                      ensures: ensures, needs: needs, mutations: mutations, emits: emits, references: references&.to_s,
-                      from: from, provenance: provenance)
+          verb.absorb(**fields, references: fields[:references]&.to_s)
           verb
         end
 
@@ -93,19 +98,10 @@ module Hecks
         # Takes the keywords `declare` takes, minus `name`.
         #
         # @return [Class] self
-        def absorb(role:, goal:, attributes:, givens:, ensures:, mutations:, emits:, references:,
-                   needs: [], from: nil, provenance: nil)
-          @role       = role
-          @goal       = goal
-          @attributes = attributes
-          @givens     = givens
-          @ensures    = ensures
-          @needs      = needs
-          @mutations  = mutations
-          @emits      = emits
-          @references = references
-          @from       = from
-          @provenance = provenance
+        def absorb(**fields)
+          KeywordFields.fill(fields, FIELD_DEFAULTS).each do |key, value|
+            instance_variable_set(:"@#{key}", value)
+          end
           settle
         end
       end

data/lib/hecks/bluebook/domain_port.rb

@@ -1,4 +1,5 @@
 require_relative "behaviour/domain_port"
+require_relative "keyword_fields"
 
 module Hecks
   module Bluebook
@@ -17,6 +18,11 @@ module Hecks
       # `:outbound` (`asks`) is the domain wanting something from outside, naming both
       # `answers` and `refuses` so the failure is visible to the model.
       #
+      # Every optional keyword and what it holds when the declaration omits it.
+      FIELD_DEFAULTS = {
+        attributes: [], emits: [], direction: :inbound, answers: nil, refuses: nil, to: nil
+      }.freeze
+
       # @param name [String, Symbol] the operation's declared name
       # @param attributes [Array<Bluebook::Attribute>] the declared payload fields
       # @param emits [Array<String>] the events an inbound operation records
@@ -24,15 +30,12 @@ module Hecks
       # @param answers [String, nil] an outbound operation's event for the adapter's answer
       # @param refuses [String, nil] an outbound operation's event for the adapter's refusal
       # @param to [String, nil] the aggregate this operation routes to, if any
-      def initialize(name:, attributes: [], emits: [], direction: :inbound, answers: nil, refuses: nil, to: nil)
+      def initialize(name:, **given)
+        fields = KeywordFields.fill(given, FIELD_DEFAULTS)
         @hecks_name = name.to_s
-        @attributes = attributes
-        @emits      = emits
-        @direction  = direction.to_sym
-        @answers    = answers
-        @refuses    = refuses
-        @to         = to
-        @attributes_by_name = attributes.to_h { |attribute| [attribute.name, attribute] }
+        KeywordFields.assign(self, fields)
+        @direction = fields[:direction].to_sym
+        @attributes_by_name = @attributes.to_h { |attribute| [attribute.name, attribute] }
       end
 
       # Says whether this operation is the domain asking something of an adapter.

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

@@ -0,0 +1,78 @@
+module Hecks
+  module Bluebook
+    module DSL
+      class AggregateBuilder
+        # Build-time checks of `corrects`: the corrected event must be one this aggregate emits,
+        # and a derived reversal must be statically invertible. Included into AggregateBuilder
+        # through `Sealing`.
+        module CorrectionSealing
+          # The mutation op that undoes each op a `corrects ... reverses: true` can derive from.
+          INVERSE_OP = { increment: :decrement, decrement: :increment }.freeze
+
+          private
+
+          # 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.
+          def seal_correction_targets
+            emitted_by = commands_by_emitted_event
+
+            @commands.each do |command|
+              correction = command.mutations.find { |mutation| mutation.op == :corrects }
+              seal_correction(command, correction, emitted_by[correction.target]) if correction
+            end
+          end
+
+          def commands_by_emitted_event
+            emitted_by = Hash.new { |hash, key| hash[key] = [] }
+            @commands.each { |command| command.emits.each { |event_name| emitted_by[event_name] << command } }
+            emitted_by
+          end
+
+          def seal_correction(command, correction, sources)
+            event = correction.target
+            refuse_unemitted_correction!(command, event) if sources.empty?
+            return unless correction.source[:reverses]
+
+            refuse_reversal_with_own_sets!(command, event)
+            derived = sources.flat_map(&:mutations).reject { |mutation| mutation.op == :corrects }
+            refuse_uninvertible_sources!(command, event, derived)
+            derived.each { |mutation| command.mutations << inverse_of(mutation) }
+          end
+
+          def inverse_of(mutation)
+            Mutation.new(target: mutation.target, op: INVERSE_OP.fetch(mutation.op), source: mutation.source)
+          end
+
+          def refuse_unemitted_correction!(command, event)
+            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
+
+          def refuse_reversal_with_own_sets!(command, event)
+            return unless command.mutations.any? { |mutation| mutation.op != :corrects }
+
+            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
+
+          def refuse_uninvertible_sources!(command, event, derived)
+            unsupported = derived.reject { |mutation| INVERSE_OP.key?(mutation.op) }
+            return if unsupported.empty?
+
+            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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Hecks
+  module Bluebook
+    module DSL
+      # The words that queue a nested piece, command or query, and the build of what they
+      # queued once every sibling has been seen.
+      class AggregateBuilder
+        # Queues a piece nested in this aggregate, built later once every sibling has been seen.
+        #
+        # @param name [String] the nested piece's name
+        # @yield the piece body, evaluated against an `EntityBuilder` once drained
+        # @return [Array<Array>] every pending piece queued so far, this one last
+        def entity_impl(name, &block)
+          @pending_entities << [name, block]
+        end
+
+        # Queues a query declared on this aggregate, built later once every sibling has been seen.
+        #
+        # @param name [String] the query's name
+        # @yield the query body, evaluated against a `QueryBuilder` once drained
+        # @return [Array<Array>] every pending query queued so far, this one last
+        def query_impl(name, &block)
+          @pending_queries << [name, block]
+        end
+
+        # Queues a command declared on this aggregate, built later once every sibling has been
+        # seen.
+        #
+        # `from:` is checked against this aggregate's own lifecycle field, never a target
+        # state or transition, so a guard can't drift out of sync with the state machine.
+        #
+        # @param name [String] the command's name
+        # @param from [String, Symbol, Array<String, Symbol>, nil] the lifecycle state(s) this
+        #   command guards from; nil admits from any state
+        # @yield the command body, evaluated against a `CommandBuilder` once drained
+        # @return [Array<Array>] every pending command queued so far, this one last
+        def command_impl(name, from: nil, &block)
+          # Owner is stamped once `Aggregate#initialize` runs; an entity's own commands are
+          # owned by the entity instead.
+          @pending_commands << [name, from, block]
+        end
+
+        private
+
+        # Deferred: entity/command/query queue a descriptor instead of building eagerly, so a
+        # later-declared piece can still be referenced from an earlier line. Entities drain
+        # first and fully — a command's own `sets` may need an entity's attributes already built.
+        def drain_pending!
+          @entities = @pending_entities.map { |name, block| build_entity(name, block) }
+          @commands = @pending_commands.map { |name, from, block| build_command(name, from, block) }
+          @queries  = @pending_queries.map do |name, block|
+            QueryBuilder.build(name, owner_attributes: attributes, &block)
+          end
+        end
+
+        def build_entity(name, block)
+          EntityBuilder.build(name, owner_value_objects:             @value_objects + closed_sets,
+                                    owner_named_givens:              @entity_named_givens,
+                                    identity_name_prefix:            "#{Naming.demodulise(@name)}#{Naming.demodulise(name)}",
+                                    identity_value_object_installer: ->(value_object) { @value_objects << value_object },
+                                    aggregate_name:                  @name,
+                                    chapter_entity_named_givens:     @chapter_entity_named_givens,
+                                    chapter_entity_pending_givens:   @chapter_entity_pending_givens,
+                              &block)
+        end
+
+        def build_command(name, from, block)
+          CommandBuilder.build(name, owner: @name, from: from, named_givens: @named_givens,
+                                     owner_attributes: attributes,
+                                     owner_constructs: @value_objects + closed_sets + @entities, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module Hecks
+  module Bluebook
+    module DSL
+      class AggregateBuilder
+        # The query being sealed, with the shape it asks about: its owner's label, the owner's
+        # attributes and its lifecycle.
+        QueryScope = Struct.new(:owner, :query, :fields, :lifecycle) do
+          # @return [String] how a refusal names this query: `Owner.QueryName`
+          def label = "#{owner}.#{query.hecks_name}"
+        end
+        private_constant :QueryScope
+
+        # Build-time checks that a query's fields resolve: where a field can land (a hop, a local
+        # scalar, the lifecycle field, a value object), and which member a bare value-object field
+        # means. Included into AggregateBuilder through `QuerySealing`.
+        module QueryFieldSealing
+          private
+
+          # `/` 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).
+          def seal_query_field(scope, field, ordering: false)
+            return seal_query_hop(scope, field, ordering: ordering) if field.to_s.include?("/")
+
+            name, *nested = field.to_s.split(".")
+            attribute = scope.fields.find { |candidate| candidate.name.to_s == name }
+            return refuse_ambiguous_comparison!(scope, field, attribute) if nested.empty? && attribute
+            return if resolvable_query_field?(scope, name, nested, attribute)
+
+            refuse_unresolvable_query_field!(scope, field, attribute, nested)
+          end
+
+          def resolvable_query_field?(scope, name, nested, attribute)
+            return scope.lifecycle&.field.to_s == name if nested.empty?
+
+            attribute && scalar_path?(attribute, nested)
+          end
+
+          def refuse_unresolvable_query_field!(scope, field, attribute, nested)
+            if nested.any? && attribute && resolves?(attribute, nested)
+              raise Malformed,
+                    "#{scope.label} 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
+
+            refuse_undeclared_query_field!(scope, field)
+          end
+
+          def refuse_undeclared_query_field!(scope, field)
+            raise Malformed,
+                  "#{scope.label} asks about #{field}, which #{scope.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(scope, field, ordering:)
+            refuse_undeclared_query_field!(scope, field) unless QuerySpecification::HopPath.hop_head?(field, scope.fields)
+            return unless ordering
+
+            raise Malformed,
+                  "#{scope.label} 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"
+          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!(scope, 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,
+                  "#{scope.label} 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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+require_relative "query_field_sealing"
+
+module Hecks
+  module Bluebook
+    module DSL
+      class AggregateBuilder
+        # Build-time checks that what a query asks about exists on the aggregate or the piece that
+        # declares it. Included into AggregateBuilder; `#build` runs them once every declaration is
+        # in place.
+        module QuerySealing
+          include QueryFieldSealing
+
+          ORDERED_COMPARATORS = %i[lt lte gt gte].freeze
+
+          private
+
+          # 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.
+          def seal_query_targets
+            query_surfaces.each do |owner, fields, lifecycle, queries|
+              queries.each { |query| seal_query(QueryScope.new(owner, query, fields, lifecycle)) }
+            end
+          end
+
+          def seal_query(scope)
+            query = scope.query
+            query.wheres.each { |clause| seal_where_clause(scope, clause) }
+            seal_query_field(scope, query.order_by.field, ordering: true) if query.order_by
+            seal_query_argument(scope, query.limit&.value)
+            seal_query_argument(scope, query.offset&.value)
+          end
+
+          def seal_where_clause(scope, clause)
+            seal_query_field(scope, clause.field)
+            seal_ordered_comparator(scope, clause)
+            infer_local_query_argument(scope, clause)
+            seal_query_argument(scope, clause.value) unless clause.field.to_s.include?("/")
+          end
+
+          def query_surfaces
+            [[@name, attributes, @lifecycle, @queries]] +
+              @entities.map { |entity| ["#{@name}::#{entity.hecks_name}", entity.attributes, entity.lifecycle, entity.queries] }
+          end
+
+          def seal_ordered_comparator(scope, 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 deferred_hop?(scope, clause)
+
+            name, *nested = clause.field.to_s.split(".")
+            attribute = field_named(scope, name)
+            return if attribute && numeric_path?(attribute, nested)
+
+            refuse_unordered_comparison!(scope, clause, attribute)
+          end
+
+          def deferred_hop?(scope, clause)
+            clause.field.to_s.include?("/") && QuerySpecification::HopPath.hop_head?(clause.field, scope.fields)
+          end
+
+          def field_named(scope, name) = scope.fields.find { |candidate| candidate.name.to_s == name }
+
+          def leaf_of(root, nested)
+            QuerySpecification::FieldPath.leaf_attribute(root, nested) { |type| declared_value_object(type) }
+          end
+
+          def numeric_path?(attribute, nested)
+            QuerySpecification::FieldPath.numeric?(attribute, nested) { |type| declared_value_object(type) }
+          end
+
+          def refuse_unordered_comparison!(scope, clause, attribute)
+            held = attribute ? "holds no number" : "is the lifecycle field, which holds text"
+            raise Malformed,
+                  "#{scope.label} 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(scope, value)
+            return unless value.is_a?(Symbol)
+            return if scope.query.attribute(value)
+
+            raise Malformed,
+                  "#{scope.label} 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(scope, clause)
+            name = clause.value
+            return unless name.is_a?(Symbol)
+            return if scope.query.attribute(name)
+            return if clause.field.to_s.include?("/")
+
+            leaf = inferred_argument(scope, name, clause.field)
+            scope.query.attributes << leaf if leaf
+          end
+
+          def inferred_argument(scope, name, field)
+            head, *nested = field.to_s.split(".")
+            return Attribute.new(name: name, type: String) if nested.empty? && scope.lifecycle&.field.to_s == head
+
+            root = field_named(scope, head)
+            found = root && leaf_of(root, nested)
+            found && Attribute.new(name: name, type: found.type, list: found.list?)
+          end
+
+          def declared_value_object(type_name)
+            (@value_objects + closed_sets).find { |shape| shape.hecks_name.to_s == type_name }
+          end
+        end
+      end
+    end
+  end
+end