sequent 4.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e0c606e57bb36fdcaeeb102904dd450a0ff9fc2a84fdd5aff7f365a914c45d3
-  data.tar.gz: ea03e8a0c7ab524ff8c73fded97a726edf3dff240b95db62496496d5a6a6d580
+  metadata.gz: 1dea4b53205452eaa68007ed47688b3fa074229677186e9342265cdd7a31d4db
+  data.tar.gz: 2d342b9a013372ca99b441c4980432f642a56741746291d814c68ad60cf6c26e
 SHA512:
-  metadata.gz: 10f78e12826549dcd0ea3677940b5b2cdbde26fb9ecdf2f5a1bca67d5dd8405447409417b6cd277bd554c3590a2a7a3814a0918ae79ceec2b6da9510d8d1fa3f
-  data.tar.gz: abde6abb5638e8ad3f4f2081eb1e9eada6588d4d74994a5a62a4ef761b9737277981a5c270e75297a5e508cc611031a2e779df43b3a70b3d5a9bb0b77c81ec34
+  metadata.gz: cea76a7429f29dcff3e73789f608c968030ade74446493effcf6cf6b51f39c3815da7e5ccc040cf0392a797a6978fa773b5f8f2791f907ebbb31830ab7ae56bc
+  data.tar.gz: e03569382132ffefabd44ebc973d78a2c1745291cf64ef17c0dc744bd513d5fe72c816a0cfb69da7297ddd076df81139a53058816f02bc215f58ad48c0b7bc67

data/bin/sequent

@@ -20,10 +20,11 @@ def new_project(args)
     Success!
 
     Your brand spanking new sequent app is waiting for you in:
-      #{File.expand_path(name, __dir__)}
+      #{File.expand_path(name, Dir.pwd)}
 
     To finish setting up your app:
       cd #{name}
+      bundle install
       bundle exec rake sequent:db:create
       bundle exec rake sequent:db:create_view_schema
       bundle exec rake sequent:migrate:online

data/lib/sequent/core/aggregate_repository.rb

@@ -57,6 +57,37 @@ module Sequent
         load_aggregates([aggregate_id], clazz)[0]
       end
 
+      # Optimised for loading lots of events and ignore snapshot events. To get the correct historical state of an
+      # AggregateRoot it is necessary to be able to ignore snapshots. For a nested AggregateRoot, there will not be a
+      # sequence number known, so a load_until timestamp can be used instead.
+      #
+      # +aggregate_id+ The id of the aggregate to be loaded
+      #
+      # +clazz+ Optional argument that checks if aggregate is of type +clazz+
+      #
+      # +load_until+ Optional argument that defines up until what point in time the AggregateRoot will be rebuilt.
+      def load_aggregate_for_snapshotting(aggregate_id, clazz = nil, load_until: nil)
+        fail ArgumentError, 'aggregate_id is required' if aggregate_id.blank?
+
+        stream = Sequent
+          .configuration
+          .event_store
+          .find_event_stream(aggregate_id)
+        aggregate = Class.const_get(stream.aggregate_type).stream_from_history(stream)
+
+        Sequent
+          .configuration
+          .event_store
+          .stream_events_for_aggregate(aggregate_id, load_until: load_until) do |event_stream|
+          aggregate.stream_from_history(event_stream)
+        end
+
+        if clazz
+          fail TypeError, "#{aggregate.class} is not a #{clazz}" unless aggregate.class <= clazz
+        end
+        aggregate
+      end
+
       ##
       # Loads multiple aggregates at once.
       # Returns the ones in the current Unit Of Work otherwise loads it from history.

data/lib/sequent/core/aggregate_root.rb

@@ -80,6 +80,26 @@ module Sequent
         events.each { |event| apply_event(event) }
       end
 
+      def initialize_for_streaming(stream)
+        @uncommitted_events = []
+        @sequence_number = 1
+        @event_stream = stream
+      end
+
+      def stream_from_history(stream_events)
+        _stream, event = stream_events
+        fail 'Empty history' if event.blank?
+
+        @id ||= event.aggregate_id
+        apply_event(event)
+      end
+
+      def self.stream_from_history(stream)
+        aggregate_root = allocate
+        aggregate_root.initialize_for_streaming(stream)
+        aggregate_root
+      end
+
       def to_s
         "#{self.class.name}: #{@id}"
       end

data/lib/sequent/core/command_record.rb

@@ -8,7 +8,7 @@ module Sequent
     module SerializesCommand
       def command
         args = Sequent::Core::Oj.strict_load(command_json)
-        Class.const_get(command_type.to_sym).deserialize_from_json(args)
+        Class.const_get(command_type).deserialize_from_json(args)
       end
 
       def command=(command)

data/lib/sequent/core/event_store.rb

@@ -51,7 +51,38 @@ module Sequent
       end
 
       ##
-      # Returns all events for the aggregate ordered by sequence_number
+      # Returns all events for the AggregateRoot ordered by sequence_number, disregarding snapshot events.
+      #
+      # This streaming is done in batches to prevent loading many events in memory all at once. A usecase for ignoring
+      # the snapshots is when events of a nested AggregateRoot need to be loaded up until a certain moment in time.
+      #
+      # @param aggregate_id Aggregate id of the AggregateRoot
+      # @param load_until The timestamp up until which you want to built the aggregate. Optional.
+      # @param &block Block that should be passed to handle the batches returned from this method
+      def stream_events_for_aggregate(aggregate_id, load_until: nil, &block)
+        stream = find_event_stream(aggregate_id)
+        fail ArgumentError, 'no stream found for this aggregate' if stream.blank?
+
+        q = Sequent
+          .configuration
+          .event_record_class
+          .where(aggregate_id: aggregate_id)
+          .where.not(event_type: Sequent.configuration.snapshot_event_class.name)
+          .order(:sequence_number)
+        q = q.where('created_at < ?', load_until) if load_until.present?
+        has_events = false
+
+        q.select('event_type, event_json').each_row do |event_hash|
+          has_events = true
+          event = deserialize_event(event_hash)
+          block.call([stream, event])
+        end
+        fail ArgumentError, 'no events for this aggregate' unless has_events
+      end
+
+      ##
+      # Returns all events for the aggregate ordered by sequence_number, loading them from the latest snapshot
+      # event onwards, if a snapshot is present
       #
       def load_events(aggregate_id)
         load_events_for_aggregates([aggregate_id])[0]

data/lib/sequent/core/helpers/attr_matchers/argument_serializer.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        class ArgumentSerializer
+          class << self
+            def serialize_value(value, enclose_hash: false)
+              return value.to_s if value.respond_to?(:matches_attr?)
+              return %("#{value}") if value.is_a?(String)
+              return serialize_hash(value, enclose_hash: enclose_hash) if value.is_a?(Hash)
+
+              value
+            end
+
+            private
+
+            def serialize_hash(hash, enclose_hash:)
+              serialized = hash
+                .map do |(name, value)|
+                  "#{name}: #{serialize_value(value, enclose_hash: true)}"
+                end
+                .join(', ')
+
+              return "{#{serialized}}" if enclose_hash
+
+              serialized
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/attr_matchers/attr_matchers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'dsl'
+require_relative 'argument_serializer'
+require_relative 'equals'
+require_relative 'not_equals'
+require_relative 'greater_than_equals'
+require_relative 'greater_than'
+require_relative 'less_than_equals'
+require_relative 'less_than'

data/lib/sequent/core/helpers/attr_matchers/dsl.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        module DSL
+          def register_matcher(name, matcher_class)
+            if respond_to?(name)
+              fail ArgumentError, "Cannot register attr matcher because it would overwrite existing method '#{name}'"
+            end
+
+            define_method(name) do |*expected|
+              matcher_class.new(*expected)
+            end
+          end
+        end
+
+        extend DSL
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/attr_matchers/equals.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        Equals = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value == expected_value
+          end
+
+          def to_s
+            "eq(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :eq,
+  Sequent::Core::Helpers::AttrMatchers::Equals,
+)

data/lib/sequent/core/helpers/attr_matchers/greater_than.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        GreaterThan = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value > expected_value
+          end
+
+          def to_s
+            "gt(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :gt,
+  Sequent::Core::Helpers::AttrMatchers::GreaterThan,
+)

data/lib/sequent/core/helpers/attr_matchers/greater_than_equals.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        GreaterThanEquals = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value >= expected_value
+          end
+
+          def to_s
+            "gte(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :gte,
+  Sequent::Core::Helpers::AttrMatchers::GreaterThanEquals,
+)

data/lib/sequent/core/helpers/attr_matchers/less_than.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        LessThan = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value < expected_value
+          end
+
+          def to_s
+            "lt(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :lt,
+  Sequent::Core::Helpers::AttrMatchers::LessThan,
+)

data/lib/sequent/core/helpers/attr_matchers/less_than_equals.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        LessThanEquals = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value <= expected_value
+          end
+
+          def to_s
+            "lte(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :lte,
+  Sequent::Core::Helpers::AttrMatchers::LessThanEquals,
+)

data/lib/sequent/core/helpers/attr_matchers/not_equals.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module AttrMatchers
+        NotEquals = Struct.new(:expected_value) do
+          def matches_attr?(actual_value)
+            actual_value != expected_value
+          end
+
+          def to_s
+            "neq(#{ArgumentSerializer.serialize_value(expected_value)})"
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::AttrMatchers.register_matcher(
+  :neq,
+  Sequent::Core::Helpers::AttrMatchers::NotEquals,
+)

data/lib/sequent/core/helpers/attribute_support.rb

@@ -40,19 +40,19 @@ module Sequent
 
         # module containing class methods to be added
         module ClassMethods
-          def types
-            @types ||= {}
-            return @merged_types if @merged_types
+          attr_reader :types
 
-            @merged_types = is_a?(Class) && superclass.respond_to?(:types) ? @types.merge(superclass.types) : @types
-            included_modules.select { |m| m.include? Sequent::Core::Helpers::AttributeSupport }.each do |mod|
-              @merged_types.merge!(mod.types)
-            end
-            @merged_types
+          # Called when this module is included or when a class which includes this module is inherited from.
+          #
+          # All declared attrs are merged into @types in order to prevent superfluous calculation of types in a class
+          # hierarchy.
+          def initialize_types
+            @types = inherited_types
           end
 
           def attrs(args)
-            @types ||= {}
+            validate_attrs!(args)
+
             @types.merge!(args)
             associations = []
             args.each do |attribute, type|
@@ -126,6 +126,18 @@ EOS
             @upcasters.push(block)
           end
 
+          private
+
+          def inherited_types
+            merged_types = is_a?(Class) && superclass.respond_to?(:types) ? superclass.types.dup : {}
+
+            included_modules
+              .select { |m| m.include? Sequent::Core::Helpers::AttributeSupport }
+              .reduce(merged_types) do |memo, mod|
+                memo.merge(mod.types)
+              end
+          end
+
           def upcast!(hash)
             return if @upcasters.nil?
 
@@ -133,11 +145,24 @@ EOS
               upcaster.call(hash)
             end
           end
+
+          def validate_attrs!(args)
+            duplicate_attrs = types.keys & args.keys
+
+            fail ArgumentError, "Attributes already defined: #{duplicate_attrs.join(', ')}" if duplicate_attrs.any?
+          end
+
+          def inherited(subclass)
+            super
+
+            subclass.initialize_types
+          end
         end
 
         # extend host class with class methods when we're included
         def self.included(host_class)
           host_class.extend(ClassMethods)
+          host_class.initialize_types
         end
 
         def attributes

data/lib/sequent/core/helpers/autoset_attributes.rb

@@ -36,11 +36,11 @@ module Sequent
             event_class.types.keys.reject { |k| @@autoset_ignore_attributes.include?(k.to_s) }
           end
 
-          def autoset_attributes_for_events(*event_classes)
-            event_classes.each do |event_class|
-              on event_class do |event|
-                self.class.event_attribute_keys(event_class).each do |attribute_name|
-                  instance_variable_set(:"@#{attribute_name}", event.send(attribute_name.to_sym))
+          def autoset_attributes_for_events(*args)
+            args.each do |arg|
+              on arg do |event|
+                self.class.event_attribute_keys(event.class).each do |attribute_name|
+                  instance_variable_set(:"@#{attribute_name}", event.public_send(attribute_name.to_sym))
                 end
               end
             end

data/lib/sequent/core/helpers/message_dispatcher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      class MessageDispatcher
+        def initialize(message_router, context)
+          @message_router = message_router
+          @context = context
+        end
+
+        def dispatch_message(message)
+          @message_router
+            .match_message(message)
+            .each { |handler| @context.instance_exec(message, &handler) }
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/message_handler.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require_relative 'message_handler_option_registry'
+require_relative 'message_router'
+require_relative 'message_dispatcher'
+
 module Sequent
   module Core
     module Helpers
@@ -36,29 +40,79 @@ module Sequent
       #
       module MessageHandler
         module ClassMethods
-          def on(*message_classes, &block)
-            message_classes.each do |message_class|
-              message_mapping[message_class] ||= []
-              message_mapping[message_class] << block
+          def on(*args, **opts, &block)
+            OnArgumentsValidator.validate_arguments!(*args)
+
+            message_matchers = args.map { |arg| MessageMatchers::ArgumentCoercer.coerce_argument(arg) }
+
+            message_router.register_matchers(
+              *message_matchers,
+              block,
+            )
+
+            opts.each do |name, value|
+              option_registry.call_option(self, name, message_matchers, value)
             end
           end
 
+          def option(name, &block)
+            option_registry.register_option(name, block)
+          end
+
           def message_mapping
-            @message_mapping ||= {}
+            message_router
+              .routes
+              .select { |matcher, _handlers| matcher.is_a?(MessageMatchers::InstanceOf) }
+              .map { |k, v| [k.expected_class, v] }
+              .to_h
           end
 
           def handles_message?(message)
-            message_mapping.keys.include? message.class
+            message_router.matches_message?(message)
+          end
+
+          def message_router
+            @message_router ||= MessageRouter.new
+          end
+        end
+
+        class OnArgumentsValidator
+          class << self
+            def validate_arguments!(*args)
+              fail ArgumentError, "Must provide at least one argument to 'on'" if args.empty?
+
+              duplicates = args
+                .select { |arg| args.count(arg) > 1 }
+                .uniq
+
+              if duplicates.any?
+                humanized_duplicates = duplicates
+                  .map { |x| MessageMatchers::ArgumentSerializer.serialize_value(x) }
+                  .join(', ')
+
+                fail ArgumentError,
+                     "Arguments to 'on' must be unique, duplicates: #{humanized_duplicates}"
+              end
+            end
           end
         end
 
         def self.included(host_class)
           host_class.extend(ClassMethods)
+          host_class.extend(MessageMatchers)
+          host_class.extend(AttrMatchers)
+
+          host_class.class_attribute :option_registry, default: MessageHandlerOptionRegistry.new
         end
 
         def handle_message(message)
-          handlers = self.class.message_mapping[message.class]
-          handlers&.each { |handler| instance_exec(message, &handler) }
+          message_dispatcher.dispatch_message(message)
+        end
+
+        private
+
+        def message_dispatcher
+          MessageDispatcher.new(self.class.message_router, self)
         end
       end
     end

data/lib/sequent/core/helpers/message_handler_option_registry.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      class MessageHandlerOptionRegistry
+        attr_reader :entries
+
+        def initialize
+          clear_options
+        end
+
+        ##
+        # Registers a handler for the given option.
+        #
+        def register_option(name, handler)
+          fail ArgumentError, "Option with name '#{name}' already registered" if option_registered?(name)
+
+          @entries[name] = handler
+        end
+
+        ##
+        # Calls the options with the given arguments with `self` bound to the given context.
+        #
+        def call_option(context, name, *args)
+          handler = find_option(name)
+          context.instance_exec(*args, &handler)
+        end
+
+        ##
+        # Removes all options from the registry.
+        #
+        def clear_options
+          @entries = {}
+        end
+
+        private
+
+        ##
+        # Returns the handler for given option.
+        #
+        def find_option(name)
+          @entries[name] || fail(
+            ArgumentError,
+            "Unsupported option: '#{name}'; " \
+            "#{@entries.keys.any? ? "registered options: #{@entries.keys.join(', ')}" : 'no registered options'}",
+          )
+        end
+
+        ##
+        # Returns true when an option for the given name is registered, or false otherwise.
+        #
+        def option_registered?(name)
+          @entries.key?(name)
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/helpers/message_matchers/any.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        Any = Struct.new(:opts) do
+          include ExceptOpt
+
+          def matches_message?(message)
+            return false if excluded?(message)
+
+            true
+          end
+
+          def to_s
+            "any#{matcher_arguments}"
+          end
+
+          private
+
+          def matcher_arguments
+            "(except: #{except})" if except
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::MessageMatchers.register_matcher(
+  :any,
+  Sequent::Core::Helpers::MessageMatchers::Any,
+)