sequent 4.0.0 → 4.1.0

data/lib/sequent/migrations/view_schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'parallel'
 require 'postgresql_cursor'
 
@@ -24,11 +26,13 @@ module Sequent
     # - AlterTable (For instance if you introduce a new column)
     #
     # To maintain your migrations you need to:
-    # 1. Create a class that extends `Sequent::Migrations::Projectors` and specify in `Sequent.configuration.migrations_class_name`
+    # 1. Create a class that extends `Sequent::Migrations::Projectors`
+    #    and specify in `Sequent.configuration.migrations_class_name`
     # 2. Define per version which migrations you want to execute
     #    See the definition of `Sequent::Migrations::Projectors.versions` and `Sequent::Migrations::Projectors.version`
     # 3. Specify in Sequent where your sql files reside (Sequent.configuration.migration_sql_files_directory)
-    # 4. Ensure that you add %SUFFIX% to each name that needs to be unique in postgres (like TABLE names, INDEX names, PRIMARY KEYS)
+    # 4. Ensure that you add %SUFFIX% to each name that needs to be unique in postgres
+    #    (like TABLE names, INDEX names, PRIMARY KEYS)
     #    E.g. `create table foo%SUFFIX% (id serial NOT NULL, CONSTRAINT foo_pkey%SUFFIX% PRIMARY KEY (id))`
     # 5. If you want to run an `alter_table` migration ensure that
     #   a sql file named `table_name_VERSION.sql` exists.
@@ -96,7 +100,10 @@ module Sequent
         create_view_schema_if_not_exists
         in_view_schema do
           Sequent::Core::Migratable.all.flat_map(&:managed_tables).each do |table|
-            statements = sql_file_to_statements("#{Sequent.configuration.migration_sql_files_directory}/#{table.table_name}.sql") { |raw_sql| raw_sql.remove('%SUFFIX%') }
+            sql_file = "#{Sequent.configuration.migration_sql_files_directory}/#{table.table_name}.sql"
+            statements = sql_file_to_statements(sql_file) do |raw_sql|
+              raw_sql.remove('%SUFFIX%')
+            end
             statements.each { |statement| exec_sql(statement) }
 
             indexes_file_name = "#{Sequent.configuration.migration_sql_files_directory}/#{table.table_name}.indexes.sql"
@@ -121,10 +128,14 @@ module Sequent
       #
       # This method is mainly useful during an initial setup of the view schema
       def create_view_schema_if_not_exists
-        exec_sql(%Q{CREATE SCHEMA IF NOT EXISTS #{view_schema}})
+        exec_sql(%(CREATE SCHEMA IF NOT EXISTS #{view_schema}))
         in_view_schema do
-          exec_sql(%Q{CREATE TABLE IF NOT EXISTS #{Versions.table_name} (version integer NOT NULL, CONSTRAINT version_pk PRIMARY KEY(version))})
-          exec_sql(%Q{CREATE TABLE IF NOT EXISTS #{ReplayedIds.table_name} (event_id bigint NOT NULL, CONSTRAINT event_id_pk PRIMARY KEY(event_id))})
+          exec_sql(<<~SQL.chomp)
+            CREATE TABLE IF NOT EXISTS #{Versions.table_name} (version integer NOT NULL, CONSTRAINT version_pk PRIMARY KEY(version))
+          SQL
+          exec_sql(<<~SQL.chomp)
+            CREATE TABLE IF NOT EXISTS #{ReplayedIds.table_name} (event_id bigint NOT NULL, CONSTRAINT event_id_pk PRIMARY KEY(event_id))
+          SQL
         end
       end
 
@@ -162,14 +173,14 @@ module Sequent
           executor.execute_online(plan)
         end
 
-        if plan.projectors.any?
-          replay!(Sequent.configuration.online_replay_persistor_class.new)
-        end
+        replay!(Sequent.configuration.online_replay_persistor_class.new) if plan.projectors.any?
 
         in_view_schema do
           executor.create_indexes_after_execute_online(plan)
         end
+        # rubocop:disable Lint/RescueException
       rescue Exception => e
+        # rubocop:enable Lint/RescueException
         rollback_migration
         raise e
       end
@@ -201,7 +212,13 @@ module Sequent
         executor.set_table_names_to_new_version(plan)
 
         # 1 replay events not yet replayed
-        replay!(Sequent.configuration.offline_replay_persistor_class.new, exclude_ids: true, group_exponent: 1) if plan.projectors.any?
+        if plan.projectors.any?
+          replay!(
+            Sequent.configuration.offline_replay_persistor_class.new,
+            exclude_ids: true,
+            group_exponent: 1,
+          )
+        end
 
         in_view_schema do
           Sequent::ApplicationRecord.transaction do
@@ -215,50 +232,57 @@ module Sequent
           truncate_replay_ids_table!
         end
         logger.info "Migrated to version #{Sequent.new_version}"
+        # rubocop:disable Lint/RescueException
       rescue Exception => e
+        # rubocop:enable Lint/RescueException
         rollback_migration
         raise e
       end
 
       private
 
-
       def ensure_version_correct!
         create_view_schema_if_not_exists
         new_version = Sequent.new_version
 
-        fail ArgumentError.new("new_version [#{new_version}] must be greater or equal to current_version [#{current_version}]") if new_version < current_version
-
+        if new_version < current_version
+          fail ArgumentError,
+               "new_version [#{new_version}] must be greater or equal to current_version [#{current_version}]"
+        end
       end
 
       def replay!(replay_persistor, projectors: plan.projectors, exclude_ids: false, group_exponent: 3)
         logger.info "group_exponent: #{group_exponent.inspect}"
 
         with_sequent_config(replay_persistor, projectors) do
-          logger.info "Start replaying events"
+          logger.info 'Start replaying events'
 
-          time("#{16 ** group_exponent} groups replayed") do
+          time("#{16**group_exponent} groups replayed") do
             event_types = projectors.flat_map { |projector| projector.message_mapping.keys }.uniq.map(&:name)
             disconnect!
 
-            number_of_groups = 16 ** group_exponent
+            number_of_groups = 16**group_exponent
             groups = groups_of_aggregate_id_prefixes(number_of_groups)
 
             @connected = false
             # using `map_with_index` because https://github.com/grosser/parallel/issues/175
-            result = Parallel.map_with_index(groups, in_processes: Sequent.configuration.number_of_replay_processes) do |aggregate_prefixes, index|
-              begin
-                @connected ||= establish_connection
-                time("Group (#{aggregate_prefixes.first}-#{aggregate_prefixes.last}) #{index + 1}/#{number_of_groups} replayed") do
-                  replay_events(aggregate_prefixes, event_types, exclude_ids, replay_persistor, &insert_ids)
-                end
-                nil
-              rescue => e
-                logger.error "Replaying failed for ids: ^#{aggregate_prefixes.first} - #{aggregate_prefixes.last}"
-                logger.error "+++++++++++++++ ERROR +++++++++++++++"
-                recursively_print(e)
-                raise Parallel::Kill # immediately kill all sub-processes
+            result = Parallel.map_with_index(
+              groups,
+              in_processes: Sequent.configuration.number_of_replay_processes,
+            ) do |aggregate_prefixes, index|
+              @connected ||= establish_connection
+              msg = <<~EOS.chomp
+                Group (#{aggregate_prefixes.first}-#{aggregate_prefixes.last}) #{index + 1}/#{number_of_groups} replayed
+              EOS
+              time(msg) do
+                replay_events(aggregate_prefixes, event_types, exclude_ids, replay_persistor, &insert_ids)
               end
+              nil
+            rescue StandardError => e
+              logger.error "Replaying failed for ids: ^#{aggregate_prefixes.first} - #{aggregate_prefixes.last}"
+              logger.error '+++++++++++++++ ERROR +++++++++++++++'
+              recursively_print(e)
+              raise Parallel::Kill # immediately kill all sub-processes
             end
             establish_connection
             fail if result.nil?
@@ -270,7 +294,7 @@ module Sequent
         Sequent.configuration.event_store.replay_events_from_cursor(
           block_size: 1000,
           get_events: -> { event_stream(aggregate_prefixes, event_types, exclude_already_replayed) },
-          on_progress: on_progress
+          on_progress: on_progress,
         )
 
         replay_persistor.commit
@@ -293,29 +317,31 @@ module Sequent
       end
 
       def groups_of_aggregate_id_prefixes(number_of_groups)
-        all_prefixes = (0...16 ** LENGTH_OF_SUBSTRING_INDEX_ON_AGGREGATE_ID_IN_EVENT_STORE).to_a.map { |i| i.to_s(16) } # first x digits of hex
-        all_prefixes = all_prefixes.map { |s| s.length == 3 ? s : "#{"0" * (3 - s.length)}#{s}" }
+        all_prefixes = (0...16**LENGTH_OF_SUBSTRING_INDEX_ON_AGGREGATE_ID_IN_EVENT_STORE).to_a.map do |i|
+          i.to_s(16)
+        end
+        all_prefixes = all_prefixes.map { |s| s.length == 3 ? s : "#{'0' * (3 - s.length)}#{s}" }
 
         logger.info "Number of groups #{number_of_groups}"
 
         logger.debug "Prefixes: #{all_prefixes.length}"
-        fail "Can not have more groups #{number_of_groups} than number of prefixes #{all_prefixes.length}" if number_of_groups > all_prefixes.length
+        if number_of_groups > all_prefixes.length
+          fail "Can not have more groups #{number_of_groups} than number of prefixes #{all_prefixes.length}"
+        end
 
         all_prefixes.each_slice(all_prefixes.length / number_of_groups).to_a
       end
 
-      def in_view_schema
-        Sequent::Support::Database.with_schema_search_path(view_schema, db_config) do
-          yield
-        end
+      def in_view_schema(&block)
+        Sequent::Support::Database.with_schema_search_path(view_schema, db_config, &block)
       end
 
       def drop_old_tables(new_version)
         versions_to_check = (current_version - 10)..new_version
         old_tables = versions_to_check.flat_map do |old_version|
-          exec_sql(
-            "select table_name from information_schema.tables where table_schema = '#{Sequent.configuration.view_schema_name}' and table_name LIKE '%_#{old_version}'"
-          ).flat_map { |row| row.values }
+          exec_sql(<<~SQL).flat_map(&:values)
+            select table_name from information_schema.tables where table_schema = '#{Sequent.configuration.view_schema_name}' and table_name LIKE '%_#{old_version}'
+          SQL
         end
         old_tables.each do |old_table|
           exec_sql("DROP TABLE #{Sequent.configuration.view_schema_name}.#{old_table} CASCADE")
@@ -324,7 +350,13 @@ module Sequent
 
       def insert_ids
         ->(progress, done, ids) do
-          exec_sql("insert into #{ReplayedIds.table_name} (event_id) values #{ids.map { |id| "(#{id})" }.join(',')}") unless ids.empty?
+          unless ids.empty?
+            exec_sql(
+              "insert into #{ReplayedIds.table_name} (event_id) values #{ids.map do |id|
+                                                                           "(#{id})"
+                                                                         end.join(',')}",
+            )
+          end
           Sequent::Core::EventStore::PRINT_PROGRESS[progress, done, ids] if progress > 0
         end
       end
@@ -334,7 +366,9 @@ module Sequent
 
         config = Sequent.configuration.dup
 
-        replay_projectors = projectors.map { |projector_class| projector_class.new(projector_class.replay_persistor || replay_persistor) }
+        replay_projectors = projectors.map do |projector_class|
+          projector_class.new(projector_class.replay_persistor || replay_persistor)
+        end
         config.transaction_provider = Sequent::Core::Transactions::NoTransactions.new
         config.event_handlers = replay_projectors
 
@@ -346,12 +380,17 @@ module Sequent
       end
 
       def event_stream(aggregate_prefixes, event_types, exclude_already_replayed)
-        fail ArgumentError.new("aggregate_prefixes is mandatory") unless aggregate_prefixes.present?
+        fail ArgumentError, 'aggregate_prefixes is mandatory' unless aggregate_prefixes.present?
 
         event_stream = Sequent.configuration.event_record_class.where(event_type: event_types)
-        event_stream = event_stream.where("substring(aggregate_id::varchar from 1 for #{LENGTH_OF_SUBSTRING_INDEX_ON_AGGREGATE_ID_IN_EVENT_STORE}) in (?)", aggregate_prefixes)
-        event_stream = event_stream.where("NOT EXISTS (SELECT 1 FROM #{ReplayedIds.table_name} WHERE event_id = event_records.id)") if exclude_already_replayed
-        event_stream = event_stream.where("event_records.created_at > ?", 1.day.ago) if exclude_already_replayed
+        event_stream = event_stream.where(<<~SQL, aggregate_prefixes)
+          substring(aggregate_id::varchar from 1 for #{LENGTH_OF_SUBSTRING_INDEX_ON_AGGREGATE_ID_IN_EVENT_STORE}) in (?)
+        SQL
+        if exclude_already_replayed
+          event_stream = event_stream
+            .where("NOT EXISTS (SELECT 1 FROM #{ReplayedIds.table_name} WHERE event_id = event_records.id)")
+        end
+        event_stream = event_stream.where('event_records.created_at > ?', 1.day.ago) if exclude_already_replayed
         event_stream.order('sequence_number ASC').select('id, event_type, event_json, sequence_number')
       end
 

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'