hecks 1.1.0 → 1.2.0

data/lib/hecks/runtime/interpreting.rb

@@ -77,15 +77,24 @@ module Hecks
       # lost-update gap itself, via `step_save`'s CAS + `#call`'s own
       # `StaleWrite` retry loop — an extra in-process lock here would be
       # pointless overhead, not incorrect, so it's skipped for clarity.
-      # Every other repository (Heki, Memory — confirmed process-local
-      # data, never a second process writing the same store) gets a
-      # striped `Mutex` held for the WHOLE dispatch-order run, so a second
-      # thread's own hydrate can't start until the first thread's save has
-      # landed. `lock_key_id` is best-effort (`Identity.best_effort`) —
-      # `nil` still locks correctly, just coarser (by aggregate type).
+      # A repository that declares `:cross_process_lock` (PostgresEra —
+      # ADR 0036) holds a REAL Postgres advisory lock for the whole
+      # dispatch order instead: unlike Heki/Memory (confirmed
+      # process-local, never a second process writing the same store),
+      # PostgresEra's own tables can be dispatched against concurrently
+      # by `rust/host` from a separate OS process, and an in-process
+      # `Mutex` is invisible to that. Every OTHER repository gets the
+      # striped `Mutex` below, held for the WHOLE dispatch-order run, so
+      # a second thread's own hydrate can't start until the first
+      # thread's save has landed. `lock_key_id` is best-effort
+      # (`Identity.best_effort`) — `nil` still locks correctly, just
+      # coarser (by aggregate type).
       def run_dispatch_order_with_isolation(order, ctx, lock_key_id:)
-        if ctx.repository.capabilities.include?(:optimistic_concurrency)
+        capabilities = ctx.repository.capabilities
+        if capabilities.include?(:optimistic_concurrency)
           run_dispatch_order(order, ctx)
+        elsif capabilities.include?(:cross_process_lock)
+          ctx.repository.with_write_lock { run_dispatch_order(order, ctx) }
         else
           AggregateLock.for(ctx.domain, ctx.aggregate, lock_key_id).synchronize { run_dispatch_order(order, ctx) }
         end

data/lib/hecks/runtime/read_model_interpreter.rb

@@ -50,10 +50,11 @@ module Hecks
         refuse_object_reference(model, args) unless rootless
         reference_id = reference(args.fetch(model.reference_name)) unless rootless
         # Computed off the ORIGINAL model, before TenantScope wraps it — the
-        # "which head do options apply to" question is about what the
+        # "which head(s) do options apply to" question is about what the
         # bluebook author declared, not about the synthetic tenant clause
-        # the wrapper adds underneath.
-        eligible = model.filtered_head_name
+        # the wrapper adds underneath. Plural (ADR 0055) — `on:` lets more
+        # than one many-side head be eligible at once.
+        eligible = model.filtered_head_names
         model = TenantScope.apply(model, args)
         # A ROOTLESS, `group_by`-declared, or `count`/`median`-declared
         # model skips the SQLite native escape hatch entirely (there is
@@ -119,7 +120,7 @@ module Hecks
                      end
                    end
                  end
-          rows = Ports::Query::InMemory.execute(rows, model, args) if head[:as] == eligible
+          rows = Ports::Query::InMemory.execute(rows, model.options_for(head[:as]), args) if eligible.include?(head[:as])
           projected << { aggregate: head[:aggregate], rows: rows }
           rows_by_as[head[:as]] = head[:many] ? rows : rows.first
         end

data/lib/hecks/runtime/value/coercion.rb

@@ -395,9 +395,27 @@ module Hecks
 
         # Frozen through: a list read back out of the store is an answer,
         # not a handle on what is stored.
+        #
+        # ADR 0047 — this used to bail (`return value unless entity`) the
+        # moment `attribute.type` named a value object rather than an
+        # entity, handing back the raw, un-hydrated argument untouched.
+        # A `sets :field` mutation sourced from a whole-array argument (as
+        # opposed to element-by-element `append:`) went straight through
+        # `for_attribute`'s `:list` branch, so `Banking::CardPayment.
+        # Authorize`'s own `sets :tags` (`list_of(Tag)`) stored plain
+        # Ruby Hashes as its `tags` elements forever — never a real
+        # `Value`, never through `Tag`'s own `pattern:`/`invariant`
+        # checks. `remove:`'s `==` comparison (a real `Value` against a
+        # raw `Hash`) then always failed, since `Hash#==` refuses anything
+        # that isn't itself a compatible Hash — the bug ADR 0047 traces in
+        # full. Delegating to `hydrate_value_object_list` below closes
+        # that gap the same way the ENTITY branch already worked: build a
+        # real, validated `Value` per element, reusing `for_attribute`'s
+        # own composite-construction path rather than inventing a second
+        # one.
         def hydrate_entity_list(aggregate, attribute, value)
           entity = find_entity(aggregate, attribute.type.to_s)
-          return value unless entity
+          return hydrate_value_object_list(aggregate, attribute, value) unless entity
 
           hydrated = Array(value).map do |element|
             next element unless element.is_a?(Hash)
@@ -411,6 +429,51 @@ module Hecks
           Freezer.deep(hydrated)
         end
 
+        # The value-object sibling of the entity branch above: an element
+        # already shaped like the target `Value` (or a `Hash`/scalar that
+        # `fields_for` can still open) is rebuilt through the SAME `build`
+        # a scalar composite attribute already uses (`for_attribute`'s own
+        # `coerced = ... build(value_object, fields_for(...), aggregate)`
+        # line) — same defaults, same `pattern:`/`admits:`/invariant
+        # checks, same `trusting_stored_state?` bypass on a trusted load.
+        # `attribute.type` naming neither an entity nor a value object
+        # (a `list_of(String)`, say) has no shape to rebuild into, so the
+        # element passes through unchanged, exactly as the entity branch's
+        # own non-Hash elements do.
+        #
+        # NOT `Array(value).map` (unlike the entity branch above) — `value`
+        # here is not always genuinely list-shaped. `MutationApplier#
+        # removed`'s own `Value.for_attribute(aggregate, attribute, value)`
+        # call (`attribute` = the LIST attribute, `mutation.target`; `value`
+        # = the single REMOVE-target argument, already a real `Value` by
+        # the time it gets here) reuses this exact branch — for `remove:`,
+        # not for a whole-list `sets`. `Array(a_real_Value)` alone would be
+        # harmless (`Value` defines neither `to_a` nor `to_ary`, so Kernel
+        # wraps it `[value]`), but `Array(a_Hash)` is NOT harmless: Ruby's
+        # `Array()` opens a bare Hash into its own `[[k, v], ...]` pairs,
+        # not `[hash]` — silently shredding a single-element Hash-shaped
+        # target into garbage instead of hydrating it. Branching on
+        # `value.is_a?(Array)` up front (true only for a genuine whole-list
+        # `sets`/hydrate load) keeps the single-target shape a single
+        # target, hydrated the same way, never listified.
+        def hydrate_value_object_list(aggregate, attribute, value)
+          return value unless aggregate.respond_to?(:value_object)
+
+          value_object = value_object_for(aggregate, attribute.type)
+          return value unless value_object
+
+          return hydrate_value_object_element(aggregate, attribute, value_object, value) unless value.is_a?(Array)
+
+          hydrated = value.map { |element| hydrate_value_object_element(aggregate, attribute, value_object, element) }
+          Freezer.deep(hydrated)
+        end
+
+        def hydrate_value_object_element(aggregate, attribute, value_object, element)
+          return element if element.is_a?(self) && element.type_name == value_object.hecks_name
+
+          build(value_object, fields_for(value_object, attribute.name, element), aggregate)
+        end
+
         # `Value.identifier` used to live here: hand it a one-field value object
         # and it opened it, so `identified_by :number` could pass for an identity
         # and the runtime would guess which field was meant. THAT GUESS IS GONE.

data/lib/hecks/version.rb

@@ -12,5 +12,5 @@ module Hecks
   # it there, or even in the consuming Gemfile, never closed the gap,
   # because gemspec evaluation happens before anything Bundler
   # resolves is actually loadable yet.
-  VERSION = "1.1.0".freeze
+  VERSION = "1.2.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hecks
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Chris Young
@@ -68,6 +68,7 @@ files:
 - lib/hecks/adapters/driven/postgres.rb
 - lib/hecks/adapters/driven/postgres/codec.rb
 - lib/hecks/adapters/driven/postgres/outbox.rb
+- lib/hecks/adapters/driven/postgres/reconnect.rb
 - lib/hecks/adapters/driven/postgres/schema_builder.rb
 - lib/hecks/adapters/driven/postgres_era.adapter
 - lib/hecks/adapters/driven/prism.adapter
@@ -343,6 +344,7 @@ files:
 - lib/hecks/ports/query/ordering.rb
 - lib/hecks/projections.rb
 - lib/hecks/projections/diagrams.rb
+- lib/hecks/projections/glossary.rb
 - lib/hecks/projections/ir.rb
 - lib/hecks/projections/model.rb
 - lib/hecks/projections/model/deviations.rb