sequent 4.0.0 → 4.3.0

data/lib/sequent/rake/migration_tasks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require 'rake'
 require 'rake/tasklib'
@@ -12,13 +14,14 @@ module Sequent
 
       def register_tasks!
         namespace :sequent do
-          desc 'Rake task that runs before all sequent rake tasks. Hook applications can use to for instance run other rake tasks.'
+          desc <<~EOS
+            Rake task that runs before all sequent rake tasks. Hook applications can use to for instance run other rake tasks.
+          EOS
           task :init
 
           namespace :db do
-
             desc 'Creates the database and initializes the event_store schema for the current env'
-            task :create => ['sequent:init'] do
+            task create: ['sequent:init'] do
               ensure_rack_env_set!
 
               db_config = Sequent::Support::Database.read_config(@env)
@@ -31,14 +34,18 @@ module Sequent
             task :drop, [:production] => ['sequent:init'] do |_t, args|
               ensure_rack_env_set!
 
-              fail "Wont drop db in production unless you whitelist the environment as follows: rake sequent:db:drop[yes_drop_production]" if @env == 'production' && args[:production] != 'yes_drop_production'
+              if @env == 'production' && args[:production] != 'yes_drop_production'
+                fail <<~OES
+                  Wont drop db in production unless you whitelist the environment as follows: rake sequent:db:drop[yes_drop_production]
+                OES
+              end
 
               db_config = Sequent::Support::Database.read_config(@env)
               Sequent::Support::Database.drop!(db_config)
             end
 
             desc 'Creates the view schema for the current env'
-            task :create_view_schema => ['sequent:init'] do
+            task create_view_schema: ['sequent:init'] do
               ensure_rack_env_set!
 
               db_config = Sequent::Support::Database.read_config(@env)
@@ -47,33 +54,41 @@ module Sequent
             end
 
             desc 'Creates the event_store schema for the current env'
-            task :create_event_store => ['sequent:init'] do
+            task create_event_store: ['sequent:init'] do
               ensure_rack_env_set!
               db_config = Sequent::Support::Database.read_config(@env)
               create_event_store(db_config)
             end
 
+            # rubocop:disable Lint/NestedMethodDefinition
             def create_event_store(db_config)
               event_store_schema = Sequent.configuration.event_store_schema_name
               sequent_schema = File.join(Sequent.configuration.database_schema_directory, "#{event_store_schema}.rb")
-              fail "File #{sequent_schema} does not exist. Check your Sequent configuration." unless File.exists?(sequent_schema)
+              unless File.exist?(sequent_schema)
+                fail "File #{sequent_schema} does not exist. Check your Sequent configuration."
+              end
 
               Sequent::Support::Database.establish_connection(db_config)
-              fail "Schema #{event_store_schema} already exists in the database" if Sequent::Support::Database.schema_exists?(event_store_schema)
+              if Sequent::Support::Database.schema_exists?(event_store_schema)
+                fail "Schema #{event_store_schema} already exists in the database"
+              end
 
               Sequent::Support::Database.create_schema(event_store_schema)
               Sequent::Support::Database.with_schema_search_path(event_store_schema, db_config, @env) do
                 load(sequent_schema)
               end
             end
+            # rubocop:enable Lint/NestedMethodDefinition
           end
 
           namespace :migrate do
-            desc 'Rake task that runs before all migrate rake tasks. Hook applications can use to for instance run other rake tasks.'
+            desc <<~EOS
+              Rake task that runs before all migrate rake tasks. Hook applications can use to for instance run other rake tasks.
+            EOS
             task :init
 
             desc 'Prints the current version in the database'
-            task :current_version => ['sequent:init', :init] do
+            task current_version: ['sequent:init', :init] do
               ensure_rack_env_set!
 
               Sequent::Support::Database.connect!(@env)
@@ -81,8 +96,10 @@ module Sequent
               puts "Current version in the database is: #{Sequent::Migrations::ViewSchema::Versions.maximum(:version)}"
             end
 
-            desc 'Migrates the Projectors while the app is running. Call +sequent:migrate:offline+ after this successfully completed.'
-            task :online => ['sequent:init', :init] do
+            desc <<~EOS
+              Migrates the Projectors while the app is running. Call +sequent:migrate:offline+ after this successfully completed.
+            EOS
+            task online: ['sequent:init', :init] do
               ensure_rack_env_set!
 
               db_config = Sequent::Support::Database.read_config(@env)
@@ -91,8 +108,10 @@ module Sequent
               view_schema.migrate_online
             end
 
-            desc 'Migrates the events inserted while +online+ was running. It is expected +sequent:migrate:online+ ran first.'
-            task :offline => ['sequent:init', :init] do
+            desc <<~EOS
+              Migrates the events inserted while +online+ was running. It is expected +sequent:migrate:online+ ran first.
+            EOS
+            task offline: ['sequent:init', :init] do
               ensure_rack_env_set!
 
               db_config = Sequent::Support::Database.read_config(@env)
@@ -103,21 +122,35 @@ module Sequent
           end
 
           namespace :snapshots do
-            desc 'Rake task that runs before all snapshots rake tasks. Hook applications can use to for instance run other rake tasks.'
+            desc <<~EOS
+              Rake task that runs before all snapshots rake tasks. Hook applications can use to for instance run other rake tasks.
+            EOS
             task :init
 
-            task :set_snapshot_threshold, [:aggregate_type,:threshold] => ['sequent:init', :init] do
+            task :set_snapshot_threshold, %i[aggregate_type threshold] => ['sequent:init', :init] do |_t, args|
               aggregate_type = args['aggregate_type']
               threshold = args['threshold']
 
-              fail ArgumentError.new('usage rake sequent:snapshots:set_snapshot_threshold[AggregegateType,threshold]') unless aggregate_type
-              fail ArgumentError.new('usage rake sequent:snapshots:set_snapshot_threshold[AggregegateType,threshold]') unless threshold
+              unless aggregate_type
+                fail ArgumentError,
+                     'usage rake sequent:snapshots:set_snapshot_threshold[AggregegateType,threshold]'
+              end
+              unless threshold
+                fail ArgumentError,
+                     'usage rake sequent:snapshots:set_snapshot_threshold[AggregegateType,threshold]'
+              end
 
-              execute "UPDATE #{Sequent.configuration.stream_record_class} SET snapshot_threshold = #{threshold.to_i} WHERE aggregate_type = '#{aggregate_type}'"
+              execute <<~EOS
+                UPDATE #{Sequent.configuration.stream_record_class} SET snapshot_threshold = #{threshold.to_i} WHERE aggregate_type = '#{aggregate_type}'
+              EOS
             end
 
-            task :delete_all => ['sequent:init', :init] do
-              result = Sequent::ApplicationRecord.connection.execute("DELETE FROM #{Sequent.configuration.event_record_class.table_name} WHERE event_type = 'Sequent::Core::SnapshotEvent'")
+            task delete_all: ['sequent:init', :init] do
+              result = Sequent::ApplicationRecord
+                .connection
+                .execute(<<~EOS)
+                  DELETE FROM #{Sequent.configuration.event_record_class.table_name} WHERE event_type = 'Sequent::Core::SnapshotEvent'
+                EOS
               Sequent.logger.info "Deleted #{result.cmd_tuples} aggregate snapshots from the event store"
             end
           end
@@ -125,9 +158,12 @@ module Sequent
       end
 
       private
+
+      # rubocop:disable Naming/MemoizedInstanceVariableName
       def ensure_rack_env_set!
-        @env ||= ENV['RACK_ENV'] || fail("RACK_ENV not set")
+        @env ||= ENV['RACK_ENV'] || fail('RACK_ENV not set')
       end
+      # rubocop:enable Naming/MemoizedInstanceVariableName
     end
   end
 end

data/lib/sequent/rake/tasks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require 'rake'
 require 'rake/tasklib'
@@ -11,12 +13,13 @@ module Sequent
 
       DEFAULT_OPTIONS = {
         migrations_path: 'db/migrate',
-        event_store_schema: 'public'
-      }
+        event_store_schema: 'public',
+      }.freeze
 
       attr_reader :options
 
       def initialize(options)
+        super()
         @options = DEFAULT_OPTIONS.merge(options)
       end
 

data/lib/sequent/sequent.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'configuration'
 require_relative 'core/event'
 require_relative 'core/command'

data/lib/sequent/support/database.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/hash_with_indifferent_access'
 
 module Sequent
@@ -16,20 +18,25 @@ module Sequent
       end
 
       def self.read_config(env)
-        fail ArgumentError.new("env is mandatory") unless env
+        fail ArgumentError, 'env is mandatory' unless env
 
         database_yml = File.join(Sequent.configuration.database_config_directory, 'database.yml')
-        YAML.load(ERB.new(File.read(database_yml)).result)[env]
+        config = YAML.safe_load(ERB.new(File.read(database_yml)).result, aliases: true)[env]
+        if Gem.loaded_specs['activerecord'].version >= Gem::Version.create('6.1.0')
+          ActiveRecord::Base.configurations.resolve(config).configuration_hash.with_indifferent_access
+        else
+          ActiveRecord::Base.resolve_config_for_connection(config)
+        end
       end
 
       def self.create!(db_config)
-        ActiveRecord::Base.establish_connection(db_config.merge('database' => 'postgres'))
-        ActiveRecord::Base.connection.create_database(db_config['database'])
+        ActiveRecord::Base.establish_connection(db_config.merge(database: 'postgres'))
+        ActiveRecord::Base.connection.create_database(db_config[:database])
       end
 
       def self.drop!(db_config)
-        ActiveRecord::Base.establish_connection(db_config.merge('database' => 'postgres'))
-        ActiveRecord::Base.connection.drop_database(db_config['database'])
+        ActiveRecord::Base.establish_connection(db_config.merge(database: 'postgres'))
+        ActiveRecord::Base.connection.drop_database(db_config[:database])
       end
 
       def self.establish_connection(db_config)
@@ -46,9 +53,8 @@ module Sequent
 
       def self.create_schema(schema)
         sql = "CREATE SCHEMA IF NOT EXISTS #{schema}"
-        if user = ActiveRecord::Base.connection_config[:username]
-          sql += %Q{ AUTHORIZATION "#{user}"}
-        end
+        user = configuration_hash[:username]
+        sql += %( AUTHORIZATION "#{user}") if user
         execute_sql(sql)
       end
 
@@ -57,32 +63,41 @@ module Sequent
       end
 
       def self.with_schema_search_path(search_path, db_config, env = ENV['RACK_ENV'])
-        fail ArgumentError.new("env is required") unless env
+        fail ArgumentError, 'env is required' unless env
 
         disconnect!
-        original_search_paths = db_config['schema_search_path'].dup
+        original_search_paths = db_config[:schema_search_path].dup
 
         if ActiveRecord::VERSION::MAJOR < 6
-          ActiveRecord::Base.configurations[env.to_s] = ActiveSupport::HashWithIndifferentAccess.new(db_config).stringify_keys
+          ActiveRecord::Base.configurations[env.to_s] =
+            ActiveSupport::HashWithIndifferentAccess.new(db_config).stringify_keys
         end
 
-        db_config['schema_search_path'] = search_path
+        db_config[:schema_search_path] = search_path
 
         ActiveRecord::Base.establish_connection db_config
 
         yield
       ensure
         disconnect!
-        db_config['schema_search_path'] = original_search_paths
+        db_config[:schema_search_path] = original_search_paths
         establish_connection(db_config)
       end
 
       def self.schema_exists?(schema)
         ActiveRecord::Base.connection.execute(
-          "SELECT schema_name FROM information_schema.schemata WHERE schema_name like '#{schema}'"
+          "SELECT schema_name FROM information_schema.schemata WHERE schema_name like '#{schema}'",
         ).count == 1
       end
 
+      def self.configuration_hash
+        if Gem.loaded_specs['activesupport'].version >= Gem::Version.create('6.1.0')
+          ActiveRecord::Base.connection_db_config.configuration_hash
+        else
+          ActiveRecord::Base.connection_config
+        end
+      end
+
       def schema_exists?(schema)
         self.class.schema_exists?(schema)
       end

data/lib/sequent/support/view_projection.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require 'postgresql_cursor'
 
 module Sequent
   module Support
     class ViewProjection
       attr_reader :name, :version, :schema_definition
+
       def initialize(options)
         @name = options.fetch(:name)
         @version = options.fetch(:version)
@@ -20,7 +23,7 @@ module Sequent
           ordering = Events::ORDERED_BY_STREAM
           event_store.replay_events_from_cursor(
             block_size: 10_000,
-            get_events: ->() { ordering[event_store] }
+            get_events: -> { ordering[event_store] },
           )
         end
       end
@@ -42,13 +45,13 @@ module Sequent
     module Events
       extend ActiveRecord::ConnectionAdapters::Quoting
 
-      ORDERED_BY_STREAM = lambda do |event_store|
+      ORDERED_BY_STREAM = ->(_event_store) do
         event_records = quote_table_name(Sequent.configuration.event_record_class.table_name)
         stream_records = quote_table_name(Sequent.configuration.stream_record_class.table_name)
         snapshot_event_type = quote(Sequent.configuration.snapshot_event_class)
 
         Sequent.configuration.event_record_class
-          .select("event_type, event_json")
+          .select('event_type, event_json')
           .joins("INNER JOIN #{stream_records} ON #{event_records}.stream_record_id = #{stream_records}.id")
           .where("event_type <> #{snapshot_event_type}")
           .order!("#{stream_records}.id, #{event_records}.sequence_number")

data/lib/sequent/support/view_schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Support
     class ViewSchema < ActiveRecord::Schema

data/lib/sequent/support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'support/database'
 require_relative 'support/view_projection'
 require_relative 'support/view_schema'

data/lib/sequent/test/command_handler_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thread_safe'
 require 'sequent/core/event_store'
 
@@ -36,7 +38,6 @@ module Sequent
     #
     # end
     module CommandHandlerHelpers
-
       class FakeEventStore
         extend Forwardable
 
@@ -89,7 +90,7 @@ module Sequent
         end
 
         def stream_exists?(aggregate_id)
-          @event_streams.has_key?(aggregate_id)
+          @event_streams.key?(aggregate_id)
         end
 
         def events_exists?(aggregate_id)
@@ -99,15 +100,21 @@ module Sequent
         private
 
         def to_event_streams(events)
-          # Specs use a simple list of given events. We need a mapping from StreamRecord to the associated events for the event store.
+          # Specs use a simple list of given events.
+          # We need a mapping from StreamRecord to the associated events for the event store.
           streams_by_aggregate_id = {}
           events.map do |event|
             event_stream = streams_by_aggregate_id.fetch(event.aggregate_id) do |aggregate_id|
               streams_by_aggregate_id[aggregate_id] =
                 find_event_stream(aggregate_id) ||
                 begin
-                  aggregate_type = FakeEventStore.aggregate_type_for_event(event)
-                  raise "cannot find aggregate type associated with creation event #{event}, did you include an event handler in your aggregate for this event?" unless aggregate_type
+                  aggregate_type = aggregate_type_for_event(event)
+                  unless aggregate_type
+                    fail <<~EOS
+                      Cannot find aggregate type associated with creation event #{event}, did you include an event handler in your aggregate for this event?
+                    EOS
+                  end
+
                   Sequent::Core::EventStream.new(aggregate_type: aggregate_type.name, aggregate_id: aggregate_id)
                 end
             end
@@ -115,10 +122,10 @@ module Sequent
           end
         end
 
-        def self.aggregate_type_for_event(event)
+        def aggregate_type_for_event(event)
           @event_to_aggregate_type ||= ThreadSafe::Cache.new
           @event_to_aggregate_type.fetch_or_store(event.class) do |klass|
-            Sequent::Core::AggregateRoot.descendants.find { |x| x.message_mapping.has_key?(klass) }
+            Sequent::Core::AggregateRoots.all.find { |x| x.message_mapping.key?(klass) }
           end
         end
 
@@ -133,30 +140,41 @@ module Sequent
         end
       end
 
-      def given_events *events
+      def given_events(*events)
         Sequent.configuration.event_store.given_events(events.flatten(1))
       end
 
-      def when_command command
+      def when_command(command)
         Sequent.configuration.command_service.execute_commands command
       end
 
       def then_events(*expected_events)
-        expected_classes = expected_events.flatten(1).map { |event| event.class == Class ? event : event.class }
+        expected_classes = expected_events.flatten(1).map { |event| event.instance_of?(Class) ? event : event.class }
         expect(Sequent.configuration.event_store.stored_events.map(&:class)).to eq(expected_classes)
 
-        Sequent.configuration.event_store.stored_events.zip(expected_events.flatten(1)).each_with_index do |(actual, expected), index|
-          next if expected.class == Class
-          _actual = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))
-          _expected = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))
-          expect(_actual).to eq(_expected), "#{index+1}th Event of type #{actual.class} not equal\nexpected: #{_expected.inspect}\n     got: #{_actual.inspect}" if expected
-        end
+        Sequent
+          .configuration
+          .event_store
+          .stored_events
+          .zip(expected_events.flatten(1))
+          .each_with_index do |(actual, expected), index|
+            next if expected.instance_of?(Class)
+
+            actual_hash = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))
+            expected_hash = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))
+            next unless expected
+
+            # rubocop:disable Layout/LineLength
+            expect(actual_hash)
+              .to eq(expected_hash),
+                  "#{index + 1}th Event of type #{actual.class} not equal\nexpected: #{expected_hash.inspect}\n     got: #{actual_hash.inspect}"
+            # rubocop:enable Layout/LineLength
+          end
       end
 
       def then_no_events
         then_events
       end
-
     end
   end
 end

data/lib/sequent/test/event_handler_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Test
     ##
@@ -26,7 +28,6 @@ module Sequent
     #   end
     # end
     module WorkflowHelpers
-
       class FakeTransactionProvider
         def initialize
           @after_commit_blocks = []
@@ -55,12 +56,17 @@ module Sequent
       end
 
       def then_events(*expected_events)
-        expected_classes = expected_events.flatten(1).map { |event| event.class == Class ? event : event.class }
+        expected_classes = expected_events.flatten(1).map { |event| event.instance_of?(Class) ? event : event.class }
         expect(Sequent.configuration.event_store.stored_events.map(&:class)).to eq(expected_classes)
 
         Sequent.configuration.event_store.stored_events.zip(expected_events.flatten(1)).each do |actual, expected|
-          next if expected.class == Class
-          expect(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))).to eq(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))) if expected
+          next if expected.instance_of?(Class)
+
+          next unless expected
+
+          expect(
+            Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload)),
+          ).to eq(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload)))
         end
       end
 

data/lib/sequent/test/event_stream_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Test
     ##
@@ -41,12 +43,14 @@ module Sequent
           @events = []
         end
 
+        # rubocop:disable Style/MissingRespondToMissing
         def method_missing(name, *args, &block)
           args = prepare_arguments(args)
           @events << FactoryBot.build(name, *args, &block)
         end
+        # rubocop:enable Style/MissingRespondToMissing
 
-      private
+        private
 
         def prepare_arguments(args)
           options = args.last.is_a?(Hash) ? args.pop : {}
@@ -68,10 +72,10 @@ module Sequent
         given_events(*event_stream(aggregate_id: aggregate_id, &block))
       end
 
-      def self.included(spec)
+      def self.included(_spec)
         require 'factory_bot'
       rescue LoadError
-        raise ArgumentError, "Factory bot is required to use the event stream helpers"
+        raise ArgumentError, 'Factory bot is required to use the event stream helpers'
       end
     end
   end

data/lib/sequent/test/time_comparison.rb

@@ -1,20 +1,25 @@
+# frozen_string_literal: true
+
 module Sequent
   module Test
     module DateTimePatches
       module Normalize
         def normalize
-          in_time_zone("UTC")
+          in_time_zone('UTC')
         end
       end
 
       module Compare
-        alias_method :'___<=>', :<=>
+        # rubocop:disable Style/Alias
+        alias :'___<=>' :'<=>'
+        # rubocop:enable Style/Alias
 
         # omit nsec in datetime comparisons
         def <=>(other)
-          if other && other.is_a?(DateTimePatches::Normalize)
+          if other&.is_a?(DateTimePatches::Normalize)
             result = normalize.iso8601 <=> other.normalize.iso8601
             return result unless result == 0
+
             # use usec here, which *truncates* the nsec (ie. like Postgres)
             return normalize.usec <=> other.normalize.usec
           end
@@ -35,6 +40,8 @@ class DateTime
   prepend Sequent::Test::DateTimePatches::Compare
 end
 
-class ActiveSupport::TimeWithZone
-  prepend Sequent::Test::DateTimePatches::Normalize
+module ActiveSupport
+  class TimeWithZone
+    prepend Sequent::Test::DateTimePatches::Normalize
+  end
 end

data/lib/sequent/test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'sequent'
 require_relative 'test/command_handler_helpers'
 require_relative 'test/event_stream_helpers'