hecks 3.4.0 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6180e44456a48f89b02b8812b4f327fe1642f98756e8e4c0b1bb295a04f826b
-  data.tar.gz: 6bc10cd76fb9c112ce9d7a5b82295a2e2a4c101d1b10b195ab48cd1afefd75c7
+  metadata.gz: b47e9f61f073e7c8512365b3bb5112f4e214c26cec46e08a323c6f02c509d555
+  data.tar.gz: d84b642199556cc1b9bbcbc6635c2e248f3f4b63232bb0ca6abee589f85661ca
 SHA512:
-  metadata.gz: 56cfe2cebc08a7aac900d8ef700590aa66855ea0baf28eebb9096f0f74c4d51da5ef42167cffdc6f1bcc733c3cacf8e329bf1352821655247c36e17275614123
-  data.tar.gz: 37cc4287ecf68af46b507dff79b3041de0a6e28fe2a1a7e5d89bea393b74d5f84eead4e11509c0f16d47d11ec8abfe9b292d73ec14845d9466e086dcec3bf350
+  metadata.gz: e2280fdb747d6d8a299bd58f4ab261e71a0d977ed805e9fcfe86ae108cc248724c96960614b9af6796d4617ef9102be1343107a91c6044123a97f298ba6002f1
+  data.tar.gz: 6558a4e9698ca6e01a665ab3d9aa435da6990e20a69ef06b0c0cd91bc0edcedc771a976dc664c4501d56883ebca1435adb534d3516a20d8fd55dca3c90ff40ff

data/lib/hecks/adapters/driven/memory/shared_elements.rb

@@ -0,0 +1,137 @@
+require "objspace"
+require_relative "../../../freezer"
+require_relative "../../../ports/persistence/state_codec"
+require_relative "../../../runtime/value"
+
+module Hecks
+  module Adapters
+    class Memory
+      # Lets a Memory save of a growing `list_of` copy and hydrate only the elements it has not
+      # seen. A hydrated composite element is frozen, so its codec copy (the journal form) and
+      # its hydrated form are each computed once, frozen, and shared by every journal entry and
+      # record that holds it. Shared nodes are immutable, so a caller cannot reach the journal
+      # through a returned instance. Everything else in the state goes through `StateCodec`
+      # whole. Both tables are weak and identity-keyed: a cache, never the only holder.
+      class SharedElements
+        # @param aggregate [Bluebook::Aggregate] the aggregate whose state this shares elements of
+        def initialize(aggregate)
+          @aggregate = aggregate
+          reset!
+        end
+
+        # Forgets every remembered element.
+        #
+        # @return [SharedElements] self, now empty
+        def reset!
+          @journal = ObjectSpace::WeakMap.new   # live element => frozen decoded copy
+          @live    = ObjectSpace::WeakMap.new   # frozen decoded copy => hydrated element
+          self
+        end
+
+        # Copies state into the shape the journal holds: `StateCodec.copy`, with every
+        # shareable list element copied once and reused.
+        #
+        # @param state [Hash, nil] live state, such as `Instance#state`; nil for a delete entry
+        # @return [Hash{Symbol => Object}, nil] the decoded copy; its shareable list elements
+        #   are frozen and shared with every other copy that holds them, nothing else is shared
+        #   with `state`
+        def journal_state(state)
+          lists = shareable_lists(state)
+          return Ports::Persistence::StateCodec.copy(@aggregate, state) if lists.empty?
+
+          copied = Ports::Persistence::StateCodec.copy(@aggregate, placeholders(state, lists))
+          lists.each { |name, (attribute, elements)| copied[name] = journal_list(attribute, elements) }
+          copied
+        end
+
+        # Hydrates journal-shaped state into the state a record holds.
+        #
+        # @param decoded [Hash] a fresh state in the shape `journal_state` returns; its non-shared
+        #   values are hydrated in place of copies, so it must not be a journal entry's own state
+        # @return [Hash{Symbol => Object}] hydrated state, defaults filled; the lists it shares
+        #   are frozen arrays of frozen elements, and nothing mutable is shared with `decoded`
+        def live_state(decoded)
+          lists = shareable_lists(decoded)
+          hydrated = Runtime::Instance.hydrate_with_defaults(@aggregate, placeholders(decoded, lists))
+          lists.each { |name, (attribute, elements)| hydrated[name] = live_list(attribute, elements) }
+          hydrated
+        end
+
+        private
+
+        # The list attributes of `state` whose elements can be shared: composite, not a
+        # reference, and actually held as an Array.
+        def shareable_lists(state)
+          return {} unless state.is_a?(Hash)
+
+          composite_lists.each_with_object({}) do |(name, attribute), found|
+            elements = state[name]
+            found[name] = [attribute, elements] if elements.is_a?(Array)
+          end
+        end
+
+        def composite_lists
+          @composite_lists ||= @aggregate.attributes.each_with_object({}) do |attribute, found|
+            next unless attribute.list? && !attribute.reference? && composite?(attribute)
+
+            found[attribute.name.to_sym] = attribute
+          end
+        end
+
+        def composite?(attribute)
+          type = attribute.type.to_s
+          !Runtime::Value.find_entity(@aggregate, type).nil? ||
+            (@aggregate.respond_to?(:value_object) && !Runtime::Value.value_object_for(@aggregate, type).nil?)
+        end
+
+        # `state` with each shared list replaced by nil, which the codec leaves alone and
+        # which holds the list's place in the key order.
+        def placeholders(state, lists)
+          return state if lists.empty?
+
+          state.merge(lists.transform_values { nil })
+        end
+
+        def journal_list(attribute, elements)
+          elements.map { |element| journal_element(attribute, element) }.freeze
+        end
+
+        def journal_element(attribute, element)
+          known = @journal[element]
+          return known if known
+          return element if @live.key?(element)
+
+          copy = Ports::Persistence::StateCodec.copy_list_element(@aggregate, attribute, element)
+          return copy unless immutable?(element)
+
+          @journal[element] = Freezer.deep(copy)
+        end
+
+        def live_list(attribute, elements)
+          elements.map { |element| live_element(attribute, element) }.freeze
+        end
+
+        def live_element(attribute, element)
+          known = @live[element]
+          return known if known
+
+          live = Runtime::Value.trusting_stored_state do
+            Runtime::Value.hydrate_entity_list(@aggregate, attribute, [element]).first
+          end
+          return live unless element.is_a?(Hash) && immutable?(element)
+
+          @journal[live] = element
+          @live[element] = live
+        end
+
+        def immutable?(element)
+          case element
+          when Runtime::Value then element.frozen?
+          when Hash then Freezer.deeply_frozen?(element)
+          else false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/adapters/driven/memory.rb

@@ -2,6 +2,7 @@ require_relative "../../ports/persistence/append_only"
 require_relative "../../ports/query/in_memory"
 require_relative "in_memory_ordering"
 require_relative "../../runtime/instance"
+require_relative "memory/shared_elements"
 
 module Hecks
   module Adapters
@@ -30,6 +31,7 @@ module Hecks
       #   constructor shape and ignored
       def initialize(aggregate:, settings: {}, root: nil)
         @aggregate = aggregate
+        @elements  = SharedElements.new(aggregate)
         @records   = {}
         @events    = []
         @entries   = []
@@ -105,7 +107,7 @@ module Hecks
       # @param instance [Runtime::Instance] the instance to store
       # @return [Runtime::Instance] the stored record, a fresh instance over a copy of the state
       def save(instance)
-        entry = Ports::Persistence::Entry.new(operation: "save", id: instance.id.to_s, state: copy(instance.state))
+        entry = Ports::Persistence::Entry.new(operation: "save", id: instance.id.to_s, state: instance.state)
         append(entry)
         project(entry)
       end
@@ -164,6 +166,7 @@ module Hecks
         @entries = []
         @outbox  = []
         @outbox_deliveries = {}
+        @elements.reset!
         self
       end
 
@@ -260,15 +263,20 @@ module Hecks
       def copy(state)
         return state.dup if bootstrap_fast_path?(state)
 
-        Ports::Persistence::StateCodec.copy(@aggregate, state)
+        @elements.journal_state(state)
       end
 
       def build_instance(entry)
         if bootstrap_fast_path?(entry.state)
           Runtime::Instance.new(aggregate: @aggregate, id: entry.id, state: entry.state.dup, hydrate: false)
         else
-          decoded = Ports::Persistence::StateCodec.copy(@aggregate, entry.state)
-          Runtime::Instance.new(aggregate: @aggregate, id: entry.id, state: decoded)
+          decoded = @elements.journal_state(entry.state)
+          # The state is decoded by construction, so the boundary's re-walk of every shared
+          # list element would only repeat the copy that just built it.
+          Ports::Persistence::CodecBoundary.outside do
+            Runtime::Instance.new(aggregate: @aggregate, id: entry.id, state: decoded,
+                                  hydrate_with: @elements.method(:live_state))
+          end
         end
       end
     end

data/lib/hecks/ports/persistence/state_codec.rb

@@ -46,6 +46,19 @@ module Hecks
         #   Array with `state`; nil when `state` is nil
         def copy(aggregate, state) = decode(aggregate, encode(aggregate, state))
 
+        # Deep-copies one element of a `list_of` composite attribute, exactly as `copy` would
+        # copy it inside its list.
+        #
+        # @param aggregate [Bluebook::Aggregate, Bluebook::Entity] the construct that declares
+        #   the list attribute
+        # @param attribute [Bluebook::Attribute] a list attribute of `aggregate`
+        # @param element [Hash, Runtime::Value, Object] one element of the live list
+        # @return [Hash, Object] a new decoded Hash sharing nothing with `element`; a leaf
+        #   element is returned as its JSON round trip
+        def copy_list_element(aggregate, attribute, element)
+          decode_composite(aggregate, attribute.type.to_s, encode_value(element))
+        end
+
         # Maps every declared top-level field name to its attribute.
         #
         # An attribute that shares a name with the lifecycle field or a projected field keeps

data/lib/hecks/runtime/instance.rb

@@ -16,7 +16,10 @@ module Hecks
       # `args` is the creation payload, used only to fill a composite identity's heads.
       # `hydrate: false` skips the default re-walk for an already-hydrated, validated state,
       # keeping a `list_of` entity's Nth save O(1) rather than O(N).
-      def initialize(aggregate:, id:, state: nil, args: nil, hydrate: true)
+      # `hydrate_with:` replaces the default hydration with a callable that takes the given
+      # state and answers the hydrated one (defaults filled), for an adapter that can reuse
+      # work across saves.
+      def initialize(aggregate:, id:, state: nil, args: nil, hydrate: true, hydrate_with: nil)
         @aggregate = aggregate
         @id        = id
         # Inside a persistence adapter call this refuses undecoded stored state.
@@ -24,7 +27,7 @@ module Hecks
         @state = if !hydrate
                    state || self.class.defaults(aggregate)
                  elsif state
-                   self.class.hydrate_with_defaults(aggregate, state)
+                   hydrate_with ? hydrate_with.call(state) : self.class.hydrate_with_defaults(aggregate, state)
                  else
                    self.class.defaults(aggregate)
                  end

data/lib/hecks/version.rb

@@ -1,5 +1,5 @@
 module Hecks
   # Read directly by the gemspec, so this file must never require the
   # rest of the gem (its dependencies aren't resolved yet at that point).
-  VERSION = "3.4.0".freeze
+  VERSION = "3.4.1".freeze
 end

data/rust/host/HECKS_RELEASE

@@ -1 +1 @@
-3.4.0
+3.4.1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hecks
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 3.4.1
 platform: ruby
 authors:
 - Chris Young
@@ -74,6 +74,7 @@ files:
 - lib/hecks/adapters/driven/local_storage.rb
 - lib/hecks/adapters/driven/memory.adapter
 - lib/hecks/adapters/driven/memory.rb
+- lib/hecks/adapters/driven/memory/shared_elements.rb
 - lib/hecks/adapters/driven/mock_stripe_adapter.adapter
 - lib/hecks/adapters/driven/mock_stripe_adapter.rb
 - lib/hecks/adapters/driven/postgres.adapter