sequent 4.3.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: feea2aeb3dba28570a36615392e4ecc1037bfdfd1c2d667bcc787113e4c7fdba
-  data.tar.gz: 79dc60b21109885a56f3f68cf97185afee5692167f54db1934eaa89dc9d030de
+  metadata.gz: 24d2ee32c038b179c4386d2df97025af873487c5fe333952e5fedbe5d3ed47d8
+  data.tar.gz: 8d0464ac057a6e458ee7f131caba027fbddbd751af5b9d4314907ed248d0734d
 SHA512:
-  metadata.gz: bb74d9c6cbb946bab9b00cb2ea73eab80caed4737d12ce2115a6c97348ca0e9452a14280b3d0de9ecba237c201fdd8b2914382751569224c89cae92128d5d3f5
-  data.tar.gz: 5fe084735eb4df8855b8102e68d027ca828a8dd7540d577b6e0a97616bbd22815432e684f20d48d04ad111db962fe935af4bff50afd8ebc7242f5c15f01b97a7
+  metadata.gz: 5b064934ae367d2e57baaa081c0b3f392bb932a1bb12fed00db337a6365f32c0949e5c6c4fe3eae6fa4a1374d931db517cf33efa911fdc265883bb122e8ce6ab
+  data.tar.gz: b5570de3a8b9deb24c1006486c37166f6e17d06d23a30d38a9de9b1e0755f1cbf4e57e1a2c1890ff9a68908f2077e90d7f8d1e79240ae3c5943de23f185be6f1

data/bin/sequent

@@ -31,7 +31,7 @@ def new_project(args)
       bundle exec rake sequent:migrate:offline
 
     Run the example specs:
-      RACK_ENV=test bundle exec rake sequent:db:create
+      SEQUENT_ENV=test bundle exec rake sequent:db:create
       bundle exec rspec spec
 
     To generate new aggregates use:

data/db/sequent_schema.rb

@@ -1,7 +1,7 @@
 ActiveRecord::Schema.define do
 
   create_table "event_records", :force => true do |t|
-    t.string "aggregate_id", :null => false
+    t.uuid "aggregate_id", :null => false
     t.integer "sequence_number", :null => false
     t.datetime "created_at", :null => false
     t.string "event_type", :null => false
@@ -27,7 +27,7 @@ CREATE INDEX snapshot_events ON event_records (aggregate_id, sequence_number DES
 
   create_table "command_records", :force => true do |t|
     t.string "user_id"
-    t.string "aggregate_id"
+    t.uuid "aggregate_id"
     t.string "command_type", :null => false
     t.string "event_aggregate_id"
     t.integer "event_sequence_number"
@@ -40,7 +40,7 @@ CREATE INDEX snapshot_events ON event_records (aggregate_id, sequence_number DES
   create_table "stream_records", :force => true do |t|
     t.datetime "created_at", :null => false
     t.string "aggregate_type", :null => false
-    t.string "aggregate_id", :null => false
+    t.uuid "aggregate_id", :null => false
     t.integer "snapshot_threshold"
   end
 

data/lib/sequent/configuration.rb

@@ -32,6 +32,8 @@ module Sequent
 
     DEFAULT_ERROR_LOCALE_RESOLVER = -> { I18n.locale || :en }
 
+    DEFAULT_TIME_PRECISION = ActiveSupport::JSON::Encoding.time_precision
+
     attr_accessor :aggregate_repository,
                   :event_store,
                   :command_service,
@@ -43,6 +45,7 @@ module Sequent
                   :event_record_hooks_class,
                   :command_handlers,
                   :command_filters,
+                  :command_middleware,
                   :event_handlers,
                   :uuid_generator,
                   :disable_event_handlers,
@@ -56,7 +59,11 @@ module Sequent
                   :database_config_directory,
                   :database_schema_directory,
                   :event_store_schema_name,
-                  :strict_check_attributes_on_apply_events
+                  :strict_check_attributes_on_apply_events,
+                  :enable_multiple_database_support,
+                  :primary_database_role,
+                  :primary_database_key,
+                  :time_precision
 
     attr_reader :migrations_class_name,
                 :versions_table_name,
@@ -78,6 +85,7 @@ module Sequent
       self.command_handlers = []
       self.command_filters = []
       self.event_handlers = []
+      self.command_middleware = Sequent::Core::Middleware::Chain.new
 
       self.aggregate_repository = Sequent::Core::AggregateRepository.new
       self.event_store = Sequent::Core::EventStore.new
@@ -107,6 +115,16 @@ module Sequent
 
       self.logger = Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
       self.error_locale_resolver = DEFAULT_ERROR_LOCALE_RESOLVER
+
+      self.enable_multiple_database_support = false
+      self.primary_database_role = :writing
+      self.primary_database_key = :primary
+
+      self.time_precision = DEFAULT_TIME_PRECISION
+    end
+
+    def can_use_multiple_databases?
+      enable_multiple_database_support && ActiveRecord.version > Gem::Version.new('6.1.0')
     end
 
     def replayed_ids_table_name=(table_name)

data/lib/sequent/core/aggregate_root.rb

@@ -39,14 +39,10 @@ module Sequent
       include Helpers::MessageHandler
       include Helpers::AutosetAttributes
       include SnapshotConfiguration
+      extend ActiveSupport::DescendantsTracker
 
       attr_reader :id, :uncommitted_events, :sequence_number, :event_stream
 
-      def self.inherited(subclass)
-        super
-        AggregateRoots << subclass
-      end
-
       def self.load_from_history(stream, events)
         first, *rest = events
         if first.is_a? SnapshotEvent
@@ -127,7 +123,7 @@ module Sequent
       # Provide subclasses nice DSL to 'apply' events via:
       #
       #   def send_invoice
-      #     apply InvoiceSentEvent, send_date: DateTime.now
+      #     apply InvoiceSentEvent, send_date: Time.now
       #   end
       #
       def apply(event, params = {})

data/lib/sequent/core/aggregate_roots.rb

@@ -3,21 +3,17 @@
 module Sequent
   module Core
     #
-    # Utility class containing all subclasses of AggregateRoot
+    # Utility class containing all subclasses of AggregateRoot.
     #
     class AggregateRoots
       class << self
         def aggregate_roots
-          @aggregate_roots ||= []
+          Sequent::AggregateRoot.descendants
         end
 
         def all
           aggregate_roots
         end
-
-        def <<(aggregate_root)
-          aggregate_roots << aggregate_root
-        end
       end
     end
   end

data/lib/sequent/core/command.rb

@@ -28,17 +28,17 @@ module Sequent
       include ActiveModel::Validations
       include ActiveModel::Validations::Callbacks
       include Sequent::Core::Helpers::TypeConversionSupport
+      extend ActiveSupport::DescendantsTracker
 
-      attrs created_at: DateTime
+      attrs created_at: Time
+
+      define_model_callbacks :initialize, only: :after
 
       def initialize(args = {})
         update_all_attributes args
-        @created_at = DateTime.now
-      end
+        @created_at = Time.now
 
-      def self.inherited(subclass)
-        super
-        Commands << subclass
+        _run_initialize_callbacks
       end
     end
 
@@ -56,22 +56,18 @@ module Sequent
     end
 
     #
-    # Utility class containing all subclasses of BaseCommand
+    # Utility class containing all subclasses of BaseCommand.
     #
     class Commands
       class << self
         def commands
-          @commands ||= []
+          Sequent::Core::BaseCommand.descendants
         end
 
         def all
           commands
         end
 
-        def <<(command)
-          commands << command
-        end
-
         def find(command_name)
           commands.find { |c| c.name == command_name }
         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/command_service.rb

@@ -50,7 +50,12 @@ module Sequent
       def process_commands
         Sequent::Util.skip_if_already_processing(:command_service_process_commands) do
           transaction_provider.transactional do
-            process_command(command_queue.pop) until command_queue.empty?
+            until command_queue.empty?
+              command = command_queue.pop
+              command_middleware.invoke(command) do
+                process_command(command)
+              end
+            end
             Sequent::Util.done_processing(:command_service_process_commands)
           end
         ensure
@@ -66,7 +71,9 @@ module Sequent
 
         filters.each { |filter| filter.execute(command) }
 
-        fail CommandNotValid, command unless command.valid?
+        I18n.with_locale(Sequent.configuration.error_locale_resolver.call) do
+          fail CommandNotValid, command unless command.valid?
+        end
 
         parsed_command = command.parse_attrs_to_correct_types
         command_handlers.select do |h|
@@ -98,6 +105,10 @@ module Sequent
       def command_handlers
         Sequent.configuration.command_handlers
       end
+
+      def command_middleware
+        Sequent.configuration.command_middleware
+      end
     end
 
     # Raised when BaseCommand.valid? returns false

data/lib/sequent/core/core.rb

@@ -4,6 +4,7 @@ require_relative 'sequent_oj'
 require_relative 'helpers/helpers'
 require_relative 'persistors/persistors'
 require_relative 'transactions/transactions'
+require_relative 'middleware/middleware'
 require_relative 'event'
 require_relative 'aggregate_repository'
 require_relative 'aggregate_root'

data/lib/sequent/core/event.rb

@@ -13,14 +13,14 @@ module Sequent
       include Sequent::Core::Helpers::AttributeSupport
       include Sequent::Core::Helpers::EqualSupport
       include Sequent::Core::Helpers::StringSupport
-      attrs aggregate_id: String, sequence_number: Integer, created_at: DateTime
+      attrs aggregate_id: String, sequence_number: Integer, created_at: Time
 
       def initialize(args = {})
         update_all_attributes args
         fail 'Missing aggregate_id' unless @aggregate_id
         fail 'Missing sequence_number' unless @sequence_number
 
-        @created_at ||= DateTime.now
+        @created_at ||= Time.now
       end
 
       def payload

data/lib/sequent/core/event_store.rb

@@ -26,8 +26,21 @@ module Sequent
         end
       end
 
-      def initialize
-        @event_types = ThreadSafe::Cache.new
+      ##
+      # Disables event type caching (ie. for in development).
+      #
+      class NoEventTypesCache
+        def fetch_or_store(event_type)
+          yield(event_type)
+        end
+      end
+
+      def initialize(cache_event_types: true)
+        @event_types = if cache_event_types
+                         ThreadSafe::Cache.new
+                       else
+                         NoEventTypesCache.new
+                       end
       end
 
       ##

data/lib/sequent/core/ext/ext.rb

@@ -68,6 +68,23 @@ class DateTime
   end
 end
 
+class Time
+  def self.from_params(value)
+    value.blank? ? nil : Time.iso8601(value.dup)
+  rescue ArgumentError
+    value
+  end
+
+  def self.deserialize_from_json(value)
+    value.blank? ? nil : Time.iso8601(value.dup)
+  rescue ArgumentError => e
+    return Time.parse(value.dup) if e.message =~ /invalid xmlschema format/ # ruby >= 3
+    return Time.parse(value.dup) if e.message =~ /invalid date:/ # ruby 2.7
+
+    raise
+  end
+end
+
 class Array
   def self.deserialize_from_json(value)
     value

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

@@ -6,6 +6,7 @@ require_relative 'array_with_type'
 require_relative 'default_validators'
 require_relative 'type_conversion_support'
 require_relative 'date_time_validator'
+require_relative 'time_validator'
 require_relative 'association_validator'
 
 module Sequent
@@ -40,19 +41,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 +127,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 +146,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/default_validators.rb

@@ -17,6 +17,9 @@ module Sequent
           Date => ->(klass, field) do
             klass.validates field, 'sequent::Core::Helpers::Date' => true
           end,
+          Time => ->(klass, field) do
+            klass.validates field, 'sequent::Core::Helpers::Time' => true
+          end,
           DateTime => ->(klass, field) do
             klass.validates field, 'sequent::Core::Helpers::DateTime' => true
           end,