sequent 3.3.1 → 4.1.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model'
 
 module Sequent
@@ -5,7 +7,6 @@ module Sequent
     TypeConversionError = Class.new(RuntimeError)
 
     module Helpers
-
       # Will parse all values to the correct types.
       # The raw values are typically posted from the web and are therefor mostly strings.
       # To parse a raw value your class must have a parse_from_string method that returns the parsed values.
@@ -14,8 +15,9 @@ module Sequent
         def parse_attrs_to_correct_types
           the_copy = dup
           the_copy.class.types.each do |name, type|
-            raw_value = the_copy.send("#{name}")
+            raw_value = the_copy.send(name.to_s)
             next if raw_value.nil?
+
             if raw_value.respond_to?(:parse_attrs_to_correct_types)
               the_copy.send("#{name}=", raw_value.parse_attrs_to_correct_types)
             else
@@ -24,7 +26,7 @@ module Sequent
             end
           end
           the_copy
-        rescue => e
+        rescue StandardError => e
           raise TypeConversionError, e.message
         end
       end

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

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 require 'securerandom'
 
 module Sequent
   module Core
     module Helpers
       module UuidHelper
-
         def new_uuid
-          warn "DEPRECATION WARNING: Sequent::Core::Helpers::UuidHelper.new_uuid is deprecated. Use Sequent.new_uuid instead"
+          warn <<~EOS
+            DEPRECATION WARNING: Sequent::Core::Helpers::UuidHelper.new_uuid is deprecated. Use Sequent.new_uuid instead
+          EOS
           Sequent.new_uuid
         end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../ext/ext'
 
 module Sequent
@@ -6,7 +8,7 @@ module Sequent
       class ValueValidators
         INVALID_STRING_CHARS = [
           "\u0000",
-        ]
+        ].freeze
 
         VALIDATORS = {
           ::Symbol => ->(_) { true },
@@ -14,36 +16,48 @@ module Sequent
           ::Integer => ->(value) { valid_integer?(value) },
           ::Boolean => ->(value) { valid_bool?(value) },
           ::Date => ->(value) { valid_date?(value) },
-          ::DateTime => ->(value) { valid_date_time?(value) }
-        }
+          ::DateTime => ->(value) { valid_date_time?(value) },
+        }.freeze
 
         def self.valid_integer?(value)
           value.blank? || Integer(value)
-        rescue
+        rescue StandardError
           false
         end
 
         def self.valid_bool?(value)
           return true if value.blank?
-          value.is_a?(TrueClass) || value.is_a?(FalseClass) || value == "true" || value == "false"
+
+          value.is_a?(TrueClass) || value.is_a?(FalseClass) || value == 'true' || value == 'false'
         end
 
         def self.valid_date?(value)
           return true if value.blank?
           return true if value.is_a?(Date)
           return false unless value =~ /\d{4}-\d{2}-\d{2}/
-          !!Date.iso8601(value) rescue false
+
+          begin
+            !!Date.iso8601(value)
+          rescue StandardError
+            false
+          end
         end
 
         def self.valid_date_time?(value)
           return true if value.blank?
-          value.is_a?(DateTime) || !!DateTime.iso8601(value.dup) rescue false
+
+          begin
+            value.is_a?(DateTime) || !!DateTime.iso8601(value.dup)
+          rescue StandardError
+            false
+          end
         end
 
         def self.valid_string?(value)
           return true if value.nil?
-          value.to_s && !INVALID_STRING_CHARS.any? { |invalid_char| value.to_s.include?(invalid_char) }
-        rescue
+
+          value.to_s && INVALID_STRING_CHARS.none? { |invalid_char| value.to_s.include?(invalid_char) }
+        rescue StandardError
           false
         end
 

data/lib/sequent/core/persistors/active_record_persistor.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require_relative './persistor'
 
 module Sequent
   module Core
     module Persistors
-
       #
       # The ActiveRecordPersistor uses ActiveRecord to update the projection
       #
@@ -17,14 +18,21 @@ module Sequent
       class ActiveRecordPersistor
         include Persistor
 
-        def update_record(record_class, event, where_clause = {aggregate_id: event.aggregate_id}, options = {}, &block)
+        def update_record(record_class, event, where_clause = {aggregate_id: event.aggregate_id}, options = {})
           record = record_class.unscoped.where(where_clause).first
-          raise("Record of class #{record_class} with where clause #{where_clause} not found while handling event #{event}") unless record
+          unless record
+            fail(<<~EOS)
+              Record of class #{record_class} with where clause #{where_clause} not found while handling event #{event}
+            EOS
+          end
+
           record.updated_at = event.created_at if record.respond_to?(:updated_at)
           yield record if block_given?
-          update_sequence_number = options.key?(:update_sequence_number) ?
-                                     options[:update_sequence_number] :
+          update_sequence_number = if options.key?(:update_sequence_number)
+                                     options[:update_sequence_number]
+                                   else
                                      record.respond_to?(:sequence_number=)
+                                   end
           record.sequence_number = event.sequence_number if update_sequence_number
           record.save!
         end
@@ -42,11 +50,13 @@ module Sequent
           query = array_of_value_hashes.map do |values|
             insert_manager = new_insert_manager
             insert_manager.into(table)
-            insert_manager.insert(values.map do |key, value|
-              convert_to_values(key, table, value)
-            end)
+            insert_manager.insert(
+              values.map do |key, value|
+                convert_to_values(key, table, value)
+              end,
+            )
             insert_manager.to_sql
-          end.join(";")
+          end.join(';')
 
           execute_sql(query)
         end

data/lib/sequent/core/persistors/persistor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     module Persistors
@@ -9,74 +11,74 @@ module Sequent
       module Persistor
         # Updates the view state
         def update_record
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Create a single record in the view state
         def create_record
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Creates multiple records at once in the view state
         def create_records
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Creates or updates a record in the view state.
         def create_or_update_record
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
         # Gets a record from the view state, fails if it not exists
         def get_record!
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Gets a record from the view state, returns +nil+ if it not exists
         def get_record
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Deletes all records given a where
         def delete_all_records
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Updates all record given a where and an update clause
         def update_all_records
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Decide for yourself what to do with the records
         # @deprecated
         def do_with_records
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Decide for yourself what to do with a single record
         # @deprecated
         def do_with_record
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Delete a single record
         # @deprecated
         def delete_record
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Find records given a where
         def find_records
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Returns the last record given a where
         def last_record
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
 
         # Hook to implement for instance the persistor batches statements
         def commit
-          fail "Method not supported in this persistor"
+          fail 'Method not supported in this persistor'
         end
       end
     end

data/lib/sequent/core/persistors/persistors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'persistor'
 require_relative 'active_record_persistor'
 require_relative 'replay_optimized_postgres_persistor'

data/lib/sequent/core/persistors/replay_optimized_postgres_persistor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 require 'active_record'
 require 'csv'
@@ -13,9 +15,10 @@ module Sequent
       # using normal sql.
       #
       # Rebuilding the view state (or projection) of an aggregate typically consists
-      # of an initial insert and then many updates and maybe a delete. With a normal Persistor (like ActiveRecordPersistor)
-      # each action is executed to the database. This persitor creates an inmemory store first and finally flushes
-      # the in memory store to the database. This can significantly reduces the amount of queries to the database.
+      # of an initial insert and then many updates and maybe a delete.
+      # With a normal Persistor (like ActiveRecordPersistor) each action is executed to the database.
+      # This persistor creates an in-memory store first and finally flushes
+      # the in-memory store to the database. This can significantly reduce the amount of queries to the database.
       # E.g. 1 insert, 6 updates is only a single insert using this Persistor.
       #
       # After lot of experimenting this turned out to be the fastest way to to bulk inserts in the database.
@@ -29,22 +32,26 @@ module Sequent
       #
       #   class InvoiceProjector < Sequent::Core::Projector
       #     on RecipientMovedEvent do |event|
-      #       update_all_records InvoiceRecord, recipient_id: event.recipient.aggregate_id do |record|
-      #         record.recipient_street = record.recipient.street
+      #       update_all_records(
+      #         InvoiceRecord,
+      #         { aggregate_id: event.aggregate_id, recipient_id: event.recipient.aggregate_id },
+      #         { recipient_street: event.recipient.street },
       #       end
       #     end
       #   end
       #
-      # In this case it is wise to create an index on InvoiceRecord on the recipient_id like you would in the database.
+      # In this case it is wise to create an index on InvoiceRecord on the aggregate_id and recipient_id
+      # like you would in the database.
       #
       # Example:
       #
       #   ReplayOptimizedPostgresPersistor.new(
       #     50,
-      #     {InvoiceRecord => [[:recipient_id]]}
+      #     {InvoiceRecord => [[:aggregate_id, :recipient_id]]}
       #   )
       class ReplayOptimizedPostgresPersistor
         include Persistor
+        CHUNK_SIZE = 1024
 
         attr_reader :record_store
         attr_accessor :insert_with_csv_size
@@ -65,14 +72,18 @@ module Sequent
         class Index
           def initialize(indexed_columns)
             @indexed_columns = Hash.new do |hash, record_class|
-              if record_class.column_names.include? 'aggregate_id'
-                hash[record_class] = [:aggregate_id]
-              else
-                hash[record_class] = []
-              end
+              hash[record_class] = if record_class.column_names.include? 'aggregate_id'
+                                     ['aggregate_id']
+                                   else
+                                     []
+                                   end
             end
 
-            @indexed_columns.merge!(indexed_columns)
+            @indexed_columns = @indexed_columns.merge(
+              indexed_columns.reduce({}) do |memo, (key, ics)|
+                memo.merge({key => ics.map { |c| c.map(&:to_s) }})
+              end,
+            )
 
             @index = {}
             @reverse_index = {}
@@ -82,10 +93,10 @@ module Sequent
             return unless indexed?(record_class)
 
             get_keys(record_class, record).each do |key|
-              @index[key.hash] = [] unless @index.has_key? key.hash
+              @index[key.hash] = [] unless @index.key? key.hash
               @index[key.hash] << record
 
-              @reverse_index[record.object_id.hash] = [] unless @reverse_index.has_key? record.object_id.hash
+              @reverse_index[record.object_id.hash] = [] unless @reverse_index.key? record.object_id.hash
               @reverse_index[record.object_id.hash] << key.hash
             end
           end
@@ -112,7 +123,7 @@ module Sequent
             key = [record_class.name]
             get_index(record_class, where_clause).each do |field|
               key << field
-              key << where_clause[field]
+              key << where_clause.stringify_keys[field]
             end
             @index[key.hash] || []
           end
@@ -123,13 +134,13 @@ module Sequent
           end
 
           def use_index?(record_class, where_clause)
-            @indexed_columns.has_key?(record_class) && @indexed_columns[record_class].any? { |indexed_where| where_clause.keys.size == indexed_where.size && (where_clause.keys - indexed_where).empty? }
+            @indexed_columns.key?(record_class) && get_index(record_class, where_clause).present?
           end
 
           private
 
           def indexed?(record_class)
-            @indexed_columns.has_key?(record_class)
+            @indexed_columns.key?(record_class)
           end
 
           def get_keys(record_class, record)
@@ -144,7 +155,9 @@ module Sequent
           end
 
           def get_index(record_class, where_clause)
-            @indexed_columns[record_class].find { |indexed_where| where_clause.keys.size == indexed_where.size && (where_clause.keys - indexed_where).empty? }
+            @indexed_columns[record_class].find do |indexed_where|
+              where_clause.keys.size == indexed_where.size && (where_clause.keys.map(&:to_s) - indexed_where).empty?
+            end
           end
         end
 
@@ -152,37 +165,40 @@ module Sequent
         #
         # +indices+ Hash of indices to create in memory. Greatly speeds up the replaying.
         #   Key corresponds to the name of the 'Record'
-        #   Values contains list of lists on which columns to index. E.g. [[:first_index_column], [:another_index, :with_to_columns]]
+        #   Values contains list of lists on which columns to index.
+        #   E.g. [[:first_index_column], [:another_index, :with_to_columns]]
         def initialize(insert_with_csv_size = 50, indices = {})
           @insert_with_csv_size = insert_with_csv_size
           @record_store = Hash.new { |h, k| h[k] = Set.new }
           @record_index = Index.new(indices)
         end
 
-        def update_record(record_class, event, where_clause = {aggregate_id: event.aggregate_id}, options = {}, &block)
+        def update_record(record_class, event, where_clause = {aggregate_id: event.aggregate_id}, options = {})
           record = get_record!(record_class, where_clause)
           record.updated_at = event.created_at if record.respond_to?(:updated_at)
           yield record if block_given?
           @record_index.update(record_class, record)
-          update_sequence_number = options.key?(:update_sequence_number) ?
-                                     options[:update_sequence_number] :
+          update_sequence_number = if options.key?(:update_sequence_number)
+                                     options[:update_sequence_number]
+                                   else
                                      record.respond_to?(:sequence_number=)
+                                   end
           record.sequence_number = event.sequence_number if update_sequence_number
         end
 
         def create_record(record_class, values)
           column_names = record_class.column_names
           values = record_class.column_defaults.with_indifferent_access.merge(values)
-          values.merge!(updated_at: values[:created_at]) if column_names.include?("updated_at")
-          struct_class_name = "#{record_class.to_s}Struct"
-          if self.class.struct_cache.has_key?(struct_class_name)
+          values.merge!(updated_at: values[:created_at]) if column_names.include?('updated_at')
+          struct_class_name = "#{record_class}Struct"
+          if self.class.struct_cache.key?(struct_class_name)
             struct_class = self.class.struct_cache[struct_class_name]
           else
             # We create a struct on the fly.
             # Since the replay happens in memory we implement the ==, eql? and hash methods
             # to point to the same object. A record is the same if and only if they point to
             # the same object. These methods are necessary since we use Set instead of [].
-            class_def=<<-EOD
+            class_def = <<-EOD
       #{struct_class_name} = Struct.new(*#{column_names.map(&:to_sym)})
               class #{struct_class_name}
                 include InitStruct
@@ -194,7 +210,9 @@ module Sequent
                 end
               end
             EOD
-            eval("#{class_def}")
+            # rubocop:disable Security/Eval
+            eval(class_def.to_s)
+            # rubocop:enable Security/Eval
             struct_class = ReplayOptimizedPostgresPersistor.const_get(struct_class_name)
             self.class.struct_cache[struct_class_name] = struct_class
           end
@@ -214,9 +232,7 @@ module Sequent
 
         def create_or_update_record(record_class, values, created_at = Time.now)
           record = get_record(record_class, values)
-          unless record
-            record = create_record(record_class, values.merge(created_at: created_at))
-          end
+          record ||= create_record(record_class, values.merge(created_at: created_at))
           yield record if block_given?
           @record_index.update(record_class, record)
           record
@@ -224,7 +240,10 @@ module Sequent
 
         def get_record!(record_class, where_clause)
           record = get_record(record_class, where_clause)
-          raise("record #{record_class} not found for #{where_clause}, store: #{@record_store[record_class]}") unless record
+          unless record
+            fail("record #{record_class} not found for #{where_clause}, store: #{@record_store[record_class]}")
+          end
+
           record
         end
 
@@ -273,10 +292,10 @@ module Sequent
           else
             @record_store[record_class].select do |record|
               where_clause.all? do |k, v|
-                expected_value = v.kind_of?(Symbol) ? v.to_s : v
+                expected_value = v.is_a?(Symbol) ? v.to_s : v
                 actual_value = record[k.to_sym]
-                actual_value = actual_value.to_s if actual_value.kind_of? Symbol
-                if expected_value.kind_of?(Array)
+                actual_value = actual_value.to_s if actual_value.is_a? Symbol
+                if expected_value.is_a?(Array)
                   expected_value.include?(actual_value)
                 else
                   actual_value == expected_value
@@ -295,39 +314,38 @@ module Sequent
           @record_store.each do |clazz, records|
             @column_cache ||= {}
             @column_cache[clazz.name] ||= clazz.columns.reduce({}) do |hash, column|
-              hash.merge({ column.name => column })
+              hash.merge({column.name => column})
             end
             if records.size > @insert_with_csv_size
-              csv = CSV.new("")
-              column_names = clazz.column_names.reject { |name| name == "id" }
+              csv = CSV.new(StringIO.new)
+              column_names = clazz.column_names.reject { |name| name == 'id' }
               records.each do |record|
                 csv << column_names.map do |column_name|
                   cast_value_to_column_type(clazz, column_name, record)
                 end
               end
 
-              buf = ''
               conn = Sequent::ApplicationRecord.connection.raw_connection
-              copy_data = StringIO.new csv.string
+              copy_data = StringIO.new(csv.string)
               conn.transaction do
-                conn.copy_data("COPY #{clazz.table_name} (#{column_names.join(",")}) FROM STDIN WITH csv") do
-                  while copy_data.read(1024, buf)
-                    conn.put_copy_data(buf)
+                conn.copy_data("COPY #{clazz.table_name} (#{column_names.join(',')}) FROM STDIN WITH csv") do
+                  while (out = copy_data.read(CHUNK_SIZE))
+                    conn.put_copy_data(out)
                   end
                 end
               end
             else
               clazz.unscoped do
                 inserts = []
-                column_names = clazz.column_names.reject { |name| name == "id" }
-                prepared_values = (1..column_names.size).map { |i| "$#{i}" }.join(",")
+                column_names = clazz.column_names.reject { |name| name == 'id' }
+                prepared_values = (1..column_names.size).map { |i| "$#{i}" }.join(',')
                 records.each do |record|
                   values = column_names.map do |column_name|
                     cast_value_to_column_type(clazz, column_name, record)
                   end
                   inserts << values
                 end
-                sql = %Q{insert into #{clazz.table_name} (#{column_names.join(",")}) values (#{prepared_values})}
+                sql = %{insert into #{clazz.table_name} (#{column_names.join(',')}) values (#{prepared_values})}
                 inserts.each do |insert|
                   clazz.connection.raw_connection.async_exec(sql, insert)
                 end
@@ -346,7 +364,12 @@ module Sequent
         private
 
         def cast_value_to_column_type(clazz, column_name, record)
-          Sequent::ApplicationRecord.connection.type_cast(record[column_name.to_sym], @column_cache[clazz.name][column_name])
+          uncasted_value = ActiveModel::Attribute.from_database(
+            column_name,
+            record[column_name.to_sym],
+            Sequent::ApplicationRecord.connection.lookup_cast_type_from_column(@column_cache[clazz.name][column_name]),
+          ).value_for_database
+          Sequent::ApplicationRecord.connection.type_cast(uncasted_value)
         end
       end
     end

data/lib/sequent/core/projector.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require_relative 'helpers/message_handler'
 require_relative './persistors/active_record_persistor'
 
 module Sequent
   module Core
-
     module Migratable
       module ClassMethods
         def manages_tables(*tables)
@@ -16,7 +17,7 @@ module Sequent
 
         def manages_no_tables
           @manages_no_tables = true
-          manages_tables *[]
+          manages_tables
         end
 
         def manages_no_tables?
@@ -26,11 +27,11 @@ module Sequent
         private
 
         def managed_tables_from_superclass
-          self.superclass.managed_tables if self.superclass.respond_to?(:managed_tables)
+          superclass.managed_tables if superclass.respond_to?(:managed_tables)
         end
 
         def manages_no_tables_from_superclass?
-          self.superclass.manages_no_tables? if self.superclass.respond_to?(:manages_no_tables?)
+          superclass.manages_no_tables? if superclass.respond_to?(:manages_no_tables?)
         end
       end
 
@@ -53,7 +54,6 @@ module Sequent
       def managed_tables
         self.class.managed_tables
       end
-
     end
 
     # Projectors listen to events and update the view state as they see fit.
@@ -87,7 +87,6 @@ module Sequent
       include Helpers::MessageHandler
       include Migratable
 
-
       def initialize(persistor = Sequent::Core::Persistors::ActiveRecordPersistor.new)
         ensure_valid!
         @persistor = persistor
@@ -98,28 +97,32 @@ module Sequent
       end
 
       def_delegators :@persistor,
-        :update_record,
-        :create_record,
-        :create_records,
-        :create_or_update_record,
-        :get_record!,
-        :get_record,
-        :delete_all_records,
-        :update_all_records,
-        :do_with_records,
-        :do_with_record,
-        :delete_record,
-        :find_records,
-        :last_record,
-        :execute_sql,
-        :commit
+                     :update_record,
+                     :create_record,
+                     :create_records,
+                     :create_or_update_record,
+                     :get_record!,
+                     :get_record,
+                     :delete_all_records,
+                     :update_all_records,
+                     :do_with_records,
+                     :do_with_record,
+                     :delete_record,
+                     :find_records,
+                     :last_record,
+                     :execute_sql,
+                     :commit
 
       private
 
       def ensure_valid!
         return if self.class.manages_no_tables?
 
-        fail "A Projector must manage at least one table. Did you forget to add `managed_tables` to #{self.class.name}?" if self.class.managed_tables.nil? || self.class.managed_tables.empty?
+        if self.class.managed_tables.nil? || self.class.managed_tables.empty?
+          fail <<~EOS.chomp
+            A Projector must manage at least one table. Did you forget to add `managed_tables` to #{self.class.name}?
+          EOS
+        end
       end
     end
   end

data/lib/sequent/core/random_uuid_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     module RandomUuidGenerator