aggregate_root 2.6.0 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c8b5d964bf3266c0353d5ab5f0c3131c4f7ec006a86bf32efa9230b08396d8b
-  data.tar.gz: 8ca9aa71d57707f8f956a2230eb70369be02558812b77918a81c38648f1a91c8
+  metadata.gz: d826b6ed4e196ffabc267132bae45d6a42040f16006c9c0feb3eed559f1046b9
+  data.tar.gz: d89c1cbd5a35e0c7d2f1b8921671de56d428e0af8a5fae42a144dd444b0e5fc6
 SHA512:
-  metadata.gz: 911d1311973bed3bd58a015c2063917311c5a658593b3c67c0dd82cec5e7e415513ee795dfdd6dc17026570b3cd8b4bb40db49f958987b891a01e1eb209a9d8d
-  data.tar.gz: 7404ee7fd26f2b39e1dd5df58062bcbc28a650f6c79e68c6d814aad2e8b5fa7aa768cf7dbc5fdc4ac1eaf4669a700c039e768657251450d70857965149a0dc4b
+  metadata.gz: e758436e49345ea06fdb8236bcfbcf0a644878113c74cc3a2adf9284b4d1d8c8f2492a7a43cd83ad02646b78cb4b8623c6df67e1440c2f7291afc546e601c472
+  data.tar.gz: 127b7d1fdb8966b027d5c55897de6d96d915d94a9307f56b664a80a6044e03495eae19fd1e869fe94a33bbe9bc84be7da013a39424b4bbca4164b1375913631e

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.6.0"
+  VERSION = "2.8.0"
 end

data/lib/aggregate_root.rb

@@ -7,6 +7,7 @@ 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
@@ -60,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.6.0
+  version: 2.8.0
 platform: ruby
 authors:
 - Arkency
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-29 00:00:00.000000000 Z
+date: 2023-01-13 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.6.0
+        version: 2.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.6.0
+        version: 2.8.0
 description:
 email: dev@arkency.com
 executables: []
@@ -38,6 +38,7 @@ files:
 - 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