aggregate_root 2.5.1 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f75cec09db6eaf2240eb085574f991b1e2c64d66fcb295bb86edfc23bebcd466
-  data.tar.gz: e624359318264e4bc1a37f5ddaeb0340d4cf8af2a347305cdd414e18ac6e10ba
+  metadata.gz: 49a93ca40dc58a4ddfe19ac4836cbc1b77d63a5ed8fd804f55413696bb2a6c5c
+  data.tar.gz: 3e3a4614d3b3c4444c21529f17bb106d65391b8d48c193b9ebc39e954125467c
 SHA512:
-  metadata.gz: 97a4f3220f21427b373427340e7ed1d7fae73f8bb559fc34bef386f6a82b0ab15486dc2515ad84b99b34892bf5972ca4c474aeb2dcb4a3863f4da18a070135a2
-  data.tar.gz: 03c61cd4a921c235dd216aae38bb937a4c80be1ed34342f558a8dec78c2d879718c626154aa202e132b57f3c269445c1110972af8ca5f10ce17d7088d8e53cef
+  metadata.gz: d9c9ca99d24ed3523a3c21ccec297bd1ccd3afc2be6836063f53331fe4b59b202dcba2fe3160d0f9b4f2d417d142a0f7a23bffc2342c47a1335d6509224d83b2
+  data.tar.gz: 36e601598b6754cb8f4b120044bd45ee91b7729f094b7d2084f5a4075a3c12e2015abe89c1ea6e37961d5c8280691d538ddf926f4c1c4a6501dc8442ffcc2c5b

data/lib/aggregate_root/instrumented_apply_strategy.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AggregateRoot
+  class InstrumentedApplyStrategy
+    def initialize(strategy, instrumentation)
+      @strategy = strategy
+      @instrumentation = instrumentation
+    end
+
+    def call(aggregate, event)
+      instrumentation.instrument("apply.aggregate_root",
+        aggregate: aggregate,
+        event:     event) do
+        strategy.call(aggregate, event)
+      end
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      if respond_to?(method_name)
+        strategy.public_send(method_name, *arguments, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, _include_private)
+      strategy.respond_to?(method_name)
+    end
+
+    private
+
+    attr_reader :instrumentation, :strategy
+  end
+end

data/lib/aggregate_root/instrumented_repository.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-
+require 'delegate'
 module AggregateRoot
   class InstrumentedRepository
     def initialize(repository, instrumentation)
       @repository = repository
       @instrumentation = instrumentation
+      self.error_handler = method(:handle_error) if respond_to?(:error_handler=)
     end
 
     def load(aggregate, stream_name)
@@ -42,6 +43,14 @@ module AggregateRoot
 
     private
 
+    def handle_error(error)
+      instrumentation.instrument(
+        "error_occured.repository.aggregate_root",
+        exception: [error.class.name, error.message],
+        exception_object: error,
+      )
+    end
+
     attr_reader :instrumentation, :repository
   end
 end

data/lib/aggregate_root/snapshot_repository.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+require 'base64'
+require 'ruby_event_store/event'
+
+module AggregateRoot
+  class SnapshotRepository
+    DEFAULT_SNAPSHOT_INTERVAL = 100.freeze
+    SNAPSHOT_STREAM_PATTERN = ->(base_stream_name) { "#{base_stream_name}_snapshots" }
+    NotRestorableSnapshot = Class.new(StandardError)
+    NotDumpableAggregateRoot = Class.new(StandardError)
+
+    def initialize(event_store, interval = DEFAULT_SNAPSHOT_INTERVAL)
+      raise ArgumentError, 'interval must be an Integer' unless interval.instance_of?(Integer)
+      raise ArgumentError, 'interval must be greater than 0' unless interval > 0
+      @event_store = event_store
+      @interval = interval
+      @error_handler = ->(_) { }
+    end
+
+    attr_writer :error_handler
+
+    Snapshot = Class.new(RubyEventStore::Event)
+
+    def load(aggregate, stream_name)
+      last_snapshot = load_snapshot_event(stream_name)
+      query = event_store.read.stream(stream_name)
+      if last_snapshot
+        begin
+          aggregate = load_marshal(last_snapshot)
+        rescue NotRestorableSnapshot => e
+          error_handler.(e)
+        else
+          aggregate.version = last_snapshot.data.fetch(:version)
+          query = query.from(last_snapshot.data.fetch(:last_event_id))
+        end
+      end
+      query.reduce { |_, ev| aggregate.apply(ev) }
+      aggregate.version = aggregate.version + aggregate.unpublished_events.count
+      aggregate
+    end
+
+    def store(aggregate, stream_name)
+      events = aggregate.unpublished_events.to_a
+      event_store.publish(events,
+                          stream_name: stream_name,
+                          expected_version: aggregate.version)
+
+      aggregate.version = aggregate.version + events.count
+
+      if time_for_snapshot?(aggregate.version, events.size)
+        begin
+          publish_snapshot_event(aggregate, stream_name, events.last.event_id)
+        rescue NotDumpableAggregateRoot => e
+          error_handler.(e)
+        end
+      end
+    end
+
+    private
+
+    attr_reader :event_store, :interval, :error_handler
+
+    def publish_snapshot_event(aggregate, stream_name, last_event_id)
+      event_store.publish(
+        Snapshot.new(
+          data: { marshal: build_marshal(aggregate), last_event_id: last_event_id, version: aggregate.version }
+        ),
+        stream_name: SNAPSHOT_STREAM_PATTERN.(stream_name)
+      )
+    end
+
+    def build_marshal(aggregate)
+      Marshal.dump(aggregate)
+    rescue TypeError
+      raise NotDumpableAggregateRoot, "#{aggregate.class} cannot be dumped.
+It may be caused by instance variables being: bindings, procedure or method objects, instances of class IO, or singleton objects.
+Snapshot skipped."
+    end
+
+    def load_snapshot_event(stream_name)
+      event_store.read.stream(SNAPSHOT_STREAM_PATTERN.(stream_name)).last
+    end
+
+    def load_marshal(snpashot_event)
+      Marshal.load(snpashot_event.data.fetch(:marshal))
+    rescue TypeError, ArgumentError
+      raise NotRestorableSnapshot, "Aggregate root cannot be restored from the last snapshot (event id: #{snpashot_event.event_id}).
+It may be caused by aggregate class rename or Marshal version mismatch.
+Loading aggregate based on the whole stream."
+    end
+
+    def time_for_snapshot?(aggregate_version, just_published_events)
+      events_in_stream = aggregate_version + 1
+      events_since_time_for_snapshot = events_in_stream % interval
+      just_published_events > events_since_time_for_snapshot
+    end
+  end
+end

data/lib/aggregate_root/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AggregateRoot
-  VERSION = "2.5.1"
+  VERSION = "2.7.0"
 end

data/lib/aggregate_root.rb

@@ -6,6 +6,8 @@ require_relative "aggregate_root/transform"
 require_relative "aggregate_root/default_apply_strategy"
 require_relative "aggregate_root/repository"
 require_relative "aggregate_root/instrumented_repository"
+require_relative "aggregate_root/instrumented_apply_strategy"
+require_relative 'aggregate_root/snapshot_repository'
 
 module AggregateRoot
   module OnDSL
@@ -59,6 +61,21 @@ module AggregateRoot
     def unpublished_events
       @unpublished_events.each
     end
+
+    UNMARSHALED_VARIABLES = [:@version, :@unpublished_events]
+
+    def marshal_dump
+      instance_variables.reject{|m| UNMARSHALED_VARIABLES.include? m}.inject({}) do |vars, attr|
+        vars[attr] = instance_variable_get(attr)
+        vars
+      end
+    end
+
+    def marshal_load(vars)
+      vars.each do |attr, value|
+        instance_variable_set(attr, value) unless UNMARSHALED_VARIABLES.include?(attr)
+      end
+    end
   end
 
   def self.with_default_apply_strategy

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aggregate_root
 version: !ruby/object:Gem::Version
-  version: 2.5.1
+  version: 2.7.0
 platform: ruby
 authors:
 - Arkency
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-06-24 00:00:00.000000000 Z
+date: 2022-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_event_store
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.1
+        version: 2.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.5.1
+        version: 2.7.0
 description:
 email: dev@arkency.com
 executables: []
@@ -35,8 +35,10 @@ files:
 - lib/aggregate_root.rb
 - lib/aggregate_root/configuration.rb
 - lib/aggregate_root/default_apply_strategy.rb
+- lib/aggregate_root/instrumented_apply_strategy.rb
 - lib/aggregate_root/instrumented_repository.rb
 - lib/aggregate_root/repository.rb
+- lib/aggregate_root/snapshot_repository.rb
 - lib/aggregate_root/transform.rb
 - lib/aggregate_root/version.rb
 homepage: https://railseventstore.org
@@ -63,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Event sourced aggregate root implementation for RubyEventStore