sequent 4.1.0 → 5.0.0

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        class ArgumentCoercer
+          class << self
+            def coerce_argument(arg)
+              fail ArgumentError, 'Cannot coerce nil argument' if arg.nil?
+
+              return MessageMatchers::InstanceOf.new(arg) if [Class, Module].include?(arg.class)
+              return arg if arg.respond_to?(:matches_message?)
+
+              fail ArgumentError,
+                   "Can't coerce argument '#{arg}'; " \
+                   'must be either a Class, Module or message matcher (respond to :matches_message?)'
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        class ArgumentSerializer
+          class << self
+            def serialize_value(value)
+              return value.to_s if value.respond_to?(:matches_message?)
+              return %("#{value}") if value.is_a?(String)
+
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        module DSL
+          def register_matcher(name, matcher_class)
+            if respond_to?(name)
+              fail ArgumentError, "Cannot register message 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/message_matchers/except_opt.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        module ExceptOpt
+          private
+
+          def excluded?(message)
+            [except]
+              .flatten
+              .compact
+              .any? { |x| message.is_a?(x) }
+          end
+
+          def except
+            opts.try(:[], :except)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        HasAttrs = Struct.new(:message_matcher, :expected_attrs) do
+          def initialize(message_matcher, expected_attrs)
+            super
+
+            fail ArgumentError, 'Missing required message matcher' if message_matcher.nil?
+            fail ArgumentError, 'Missing required expected attrs' if expected_attrs.blank?
+
+            self.message_matcher = ArgumentCoercer.coerce_argument(message_matcher)
+          end
+
+          def matches_message?(message)
+            message_matcher.matches_message?(message) &&
+              matches_attrs?(message, expected_attrs)
+          end
+
+          def to_s
+            'has_attrs(' \
+              "#{MessageMatchers::ArgumentSerializer.serialize_value(message_matcher)}, " \
+              "#{AttrMatchers::ArgumentSerializer.serialize_value(expected_attrs)}" \
+            ')'
+          end
+
+          private
+
+          def matches_attrs?(message, expected_attrs, path = [])
+            expected_attrs.all? do |(name, expected_value)|
+              matches_attr?(message, expected_value, path.dup.push(name))
+            end
+          end
+
+          def matches_attr?(message, expected_value, path)
+            return matches_attrs?(message, expected_value, path) if expected_value.is_a?(Hash)
+
+            expected_value = AttrMatchers::Equals.new(expected_value) unless expected_value.respond_to?(:matches_attr?)
+            value = path.reduce(message) { |memo, p| memo.public_send(p) }
+
+            expected_value.matches_attr?(value)
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::MessageMatchers.register_matcher(
+  :has_attrs,
+  Sequent::Core::Helpers::MessageMatchers::HasAttrs,
+)

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Helpers
+      module MessageMatchers
+        InstanceOf = Struct.new(:expected_class) do
+          def matches_message?(message)
+            message.instance_of?(expected_class)
+          end
+
+          def to_s
+            expected_class
+          end
+        end
+      end
+    end
+  end
+end
+
+Sequent::Core::Helpers::MessageMatchers.register_matcher(
+  :instance_of,
+  Sequent::Core::Helpers::MessageMatchers::InstanceOf,
+)

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

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

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'dsl'
+require_relative 'argument_coercer'
+require_relative 'argument_serializer'
+require_relative 'except_opt'
+require_relative 'instance_of'
+require_relative 'is_a'
+require_relative 'has_attrs'
+require_relative 'any'

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative './attr_matchers/attr_matchers'
+require_relative './message_matchers/message_matchers'
+
+module Sequent
+  module Core
+    module Helpers
+      class MessageRouter
+        attr_reader :routes
+
+        def initialize
+          clear_routes
+        end
+
+        ##
+        # Registers a handler for the given matchers.
+        #
+        # A matcher must implement #matches_message?(message) and return a truthy value when it matches,
+        # or a falsey value otherwise.
+        #
+        def register_matchers(*matchers, handler)
+          matchers.each do |matcher|
+            @routes[matcher] << handler
+          end
+        end
+
+        ##
+        # Returns a set of handlers that match the given message, or an empty set when none match.
+        #
+        def match_message(message)
+          @routes
+            .reduce(Set.new) do |memo, (matcher, handlers)|
+              memo = memo.merge(handlers) if matcher.matches_message?(message)
+              memo
+            end
+        end
+
+        ##
+        # Returns true when there is at least one handler for the given message, or false otherwise.
+        #
+        def matches_message?(message)
+          match_message(message).any?
+        end
+
+        ##
+        # Removes all routes from the router.
+        #
+        def clear_routes
+          @routes = Hash.new { |h, k| h[k] = Set.new }
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/projector.rb

@@ -92,6 +92,11 @@ module Sequent
         @persistor = persistor
       end
 
+      def self.inherited(subclass)
+        super
+        Projectors << subclass
+      end
+
       def self.replay_persistor
         nil
       end
@@ -125,5 +130,28 @@ module Sequent
         end
       end
     end
+
+    #
+    # Utility class containing all subclasses of Projector
+    #
+    class Projectors
+      class << self
+        def projectors
+          @projectors ||= []
+        end
+
+        def all
+          projectors
+        end
+
+        def <<(projector)
+          projectors << projector
+        end
+
+        def find(projector_name)
+          projectors.find { |c| c.name == projector_name }
+        end
+      end
+    end
   end
 end

data/lib/sequent/core/transactions/active_record_transaction_provider.rb

@@ -3,6 +3,31 @@
 module Sequent
   module Core
     module Transactions
+      ##
+      # Always require a new transaction.
+      #
+      # Read:
+      # http://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html
+      #
+      # Without this change, there is a potential bug:
+      #
+      # ```ruby
+      # ActiveRecord::Base.transaction do
+      #   Sequent.configuration.command_service.execute_commands command
+      # end
+      #
+      # on Command do
+      #   do.some.things
+      #   fail ActiveRecord::Rollback
+      # end
+      # ```
+      #
+      # In this example, you might be surprised to find that `do.some.things`
+      # does not get rolled back! This is because AR doesn't automatically make
+      # a "savepoint" for us when we call `.transaction` in a nested manner. In
+      # order to enable this behaviour, we have to call `.transaction` like
+      # this: `.transaction(requires_new: true)`.
+      #
       class ActiveRecordTransactionProvider
         def transactional(&block)
           Sequent::ApplicationRecord.transaction(requires_new: true, &block)

data/lib/sequent/core/transactions/read_only_active_record_transaction_provider.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    module Transactions
+      class ReadOnlyActiveRecordTransactionProvider
+        def initialize(transaction_provider)
+          @transaction_provider = transaction_provider
+        end
+
+        def transactional(&block)
+          register_call
+          @transaction_provider.transactional do
+            Sequent::ApplicationRecord.connection.execute('SET TRANSACTION READ ONLY')
+            block.call
+          rescue ActiveRecord::StatementInvalid
+            @skip_set_transaction = true
+            raise
+          ensure
+            deregister_call
+            reset_stack_size if stack_size == 0
+          end
+        end
+
+        private
+
+        def stack_size
+          Thread.current[:read_only_active_record_transaction_provider_calls]
+        end
+
+        def register_call
+          Thread.current[:read_only_active_record_transaction_provider_calls] ||= 0
+          Thread.current[:read_only_active_record_transaction_provider_calls] += 1
+        end
+
+        def deregister_call
+          Thread.current[:read_only_active_record_transaction_provider_calls] -= 1
+        end
+
+        def reset_stack_size
+          Thread.current[:read_only_active_record_transaction_provider_calls] = nil
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/transactions/transactions.rb

@@ -2,3 +2,4 @@
 
 require_relative 'active_record_transaction_provider'
 require_relative 'no_transactions'
+require_relative 'read_only_active_record_transaction_provider'

data/lib/sequent/core/workflow.rb

@@ -8,7 +8,12 @@ module Sequent
     class Workflow
       include Helpers::MessageHandler
 
-      def self.on(*message_classes, &block)
+      def self.inherited(subclass)
+        super
+        Workflows << subclass
+      end
+
+      def self.on(*args, **opts, &block)
         decorated_block = ->(event) do
           begin
             old_event = CurrentEvent.current
@@ -18,7 +23,7 @@ module Sequent
             CurrentEvent.current = old_event
           end
         end
-        super(*message_classes, &decorated_block)
+        super(*args, **opts, &decorated_block)
       end
 
       def execute_commands(*commands)
@@ -42,5 +47,28 @@ module Sequent
         end
       end
     end
+
+    #
+    # Utility class containing all subclasses of Workflow
+    #
+    class Workflows
+      class << self
+        def workflows
+          @workflows ||= []
+        end
+
+        def all
+          workflows
+        end
+
+        def <<(workflow)
+          workflows << workflow
+        end
+
+        def find(workflow_name)
+          workflows.find { |c| c.name == workflow_name }
+        end
+      end
+    end
   end
 end

data/lib/sequent/generator/project.rb

@@ -14,6 +14,7 @@ module Sequent
       def execute
         make_directory
         copy_files
+        rename_ruby_version
         rename_app_file
         replace_app_name
       end
@@ -28,6 +29,12 @@ module Sequent
         FileUtils.copy_entry(File.expand_path('template_project', __dir__), path)
       end
 
+      # Hidden files are by default excluded from gem build.
+      # Therefor we need to rename the ruby-version to .ruby-version.
+      def rename_ruby_version
+        FileUtils.mv("#{path}/ruby-version", "#{path}/.ruby-version")
+      end
+
       def rename_app_file
         FileUtils.mv("#{path}/my_app.rb", "#{path}/#{name_underscored}.rb")
       end

data/lib/sequent/generator/template_project/ruby-version

@@ -0,0 +1 @@
+3.0.0

data/lib/sequent/test/command_handler_helpers.rb

@@ -11,8 +11,8 @@ module Sequent
     # This provides a nice DSL for event based testing of your CommandHandler like
     #
     # given_events InvoiceCreatedEvent.new(args)
-    # when_command PayInvoiceCommand(args)
-    # then_events InvoicePaidEvent(args)
+    # when_command PayInvoiceCommand.new(args)
+    # then_events InvoicePaidEvent.new(args)
     #
     # Example for Rspec config
     #

data/lib/sequent/util/dry_run.rb

@@ -36,18 +36,18 @@ module Sequent
 
         delegate :load_events_for_aggregates,
                  :load_events,
-                 :publish_events,
                  :stream_exists?,
+                 :events_exists?,
                  to: :event_store
 
-        def initialize(result)
-          @event_store = Sequent::Test::CommandHandlerHelpers::FakeEventStore.new
+        def initialize(result, event_store)
+          @event_store = event_store
           @command_with_events = {}
           @result = result
         end
 
         def commit_events(command, streams_with_events)
-          event_store.commit_events(command, streams_with_events)
+          Sequent.configuration.event_publisher.publish_events(streams_with_events.flat_map { |_, events| events })
 
           new_events = streams_with_events.flat_map { |_, events| events }
           @result.published_command_with_events(command, new_events)
@@ -66,18 +66,18 @@ module Sequent
         end
 
         def process_event(event)
-          Sequent.configuration.event_handlers.each do |handler|
-            next unless handler.class.handles_message?(event)
+          [*Sequent::Core::Workflows.all, *Sequent::Core::Projectors.all].each do |handler_class|
+            next unless handler_class.handles_message?(event)
 
-            if handler.is_a?(Sequent::Workflow)
-              @result.invoked_workflow(EventInvokedHandler.new(event, handler.class))
-            elsif handler.is_a?(Sequent::Projector)
-              @result.invoked_projector(EventInvokedHandler.new(event, handler.class))
+            if handler_class < Sequent::Workflow
+              @result.invoked_workflow(EventInvokedHandler.new(event, handler_class))
+            elsif handler_class < Sequent::Projector
+              @result.invoked_projector(EventInvokedHandler.new(event, handler_class))
             else
-              fail "Unrecognized event_handler #{handler.class} called for event #{event.class}"
+              fail "Unrecognized event_handler #{handler_class} called for event #{event.class}"
             end
           rescue StandardError
-            raise PublishEventError.new(handler.class, event)
+            raise PublishEventError.new(handler_class, event)
           end
         end
       end
@@ -177,10 +177,14 @@ module Sequent
       def self.these_commands(commands)
         current_event_store = Sequent.configuration.event_store
         current_event_publisher = Sequent.configuration.event_publisher
+        current_transaction_provider = Sequent.configuration.transaction_provider
+
         result = Result.new
 
-        Sequent.configuration.event_store = EventStoreProxy.new(result)
+        Sequent.configuration.event_store = EventStoreProxy.new(result, current_event_store)
         Sequent.configuration.event_publisher = RecordingEventPublisher.new(result)
+        Sequent.configuration.transaction_provider =
+          Sequent::Core::Transactions::ReadOnlyActiveRecordTransactionProvider.new(current_transaction_provider)
 
         Sequent.command_service.execute_commands(*commands)
 
@@ -188,6 +192,7 @@ module Sequent
       ensure
         Sequent.configuration.event_store = current_event_store
         Sequent.configuration.event_publisher = current_event_publisher
+        Sequent.configuration.transaction_provider = current_transaction_provider
       end
     end
   end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sequent
-  VERSION = '4.1.0'
+  VERSION = '5.0.0'
 end