sequent 4.0.0 → 4.1.0

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

data/lib/sequent/core/sequent_oj.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'oj'
 
 module Sequent

data/lib/sequent/core/stream_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record'
 
 module Sequent
@@ -14,8 +16,7 @@ module Sequent
     end
 
     class StreamRecord < Sequent::ApplicationRecord
-
-      self.table_name = "stream_records"
+      self.table_name = 'stream_records'
 
       validates_presence_of :aggregate_type, :aggregate_id
       validates_numericality_of :snapshot_threshold, only_integer: true, greater_than: 0, allow_nil: true
@@ -23,7 +24,12 @@ module Sequent
       has_many :event_records
 
       def event_stream
-        EventStream.new(aggregate_type: aggregate_type, aggregate_id: aggregate_id, snapshot_threshold: snapshot_threshold, stream_record_id: id)
+        EventStream.new(
+          aggregate_type: aggregate_type,
+          aggregate_id: aggregate_id,
+          snapshot_threshold: snapshot_threshold,
+          stream_record_id: id,
+        )
       end
 
       def event_stream=(data)

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

@@ -1,15 +1,12 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     module Transactions
-
       class ActiveRecordTransactionProvider
-        def transactional
-          Sequent::ApplicationRecord.transaction(requires_new: true) do
-            yield
-          end
-          while(!after_commit_queue.empty?) do
-            after_commit_queue.pop.call
-          end
+        def transactional(&block)
+          Sequent::ApplicationRecord.transaction(requires_new: true, &block)
+          after_commit_queue.pop.call until after_commit_queue.empty?
         ensure
           clear_after_commit_queue
         end
@@ -28,7 +25,6 @@ module Sequent
           after_commit_queue.clear
         end
       end
-
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     module Transactions
@@ -11,7 +13,6 @@ module Sequent
           yield
         end
       end
-
     end
   end
 end

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

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require_relative 'active_record_transaction_provider'
 require_relative 'no_transactions'

data/lib/sequent/core/value_object.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model'
 require_relative 'helpers/string_support'
 require_relative 'helpers/equal_support'
@@ -6,7 +8,6 @@ require_relative 'helpers/attribute_support'
 require_relative 'helpers/param_support'
 
 module Sequent
-
   module Core
     #
     # ValueObject is a container for data that belongs together but requires no identity
@@ -26,20 +27,17 @@ module Sequent
     #
     # This a deep clone of the address with the street attribute containing "New Street"
     class ValueObject
-      include Sequent::Core::Helpers::StringSupport,
-              Sequent::Core::Helpers::EqualSupport,
-              Sequent::Core::Helpers::Copyable,
-              Sequent::Core::Helpers::AttributeSupport,
-              Sequent::Core::Helpers::ParamSupport,
-              ActiveModel::Validations
+      include ActiveModel::Validations
+      include Sequent::Core::Helpers::ParamSupport
+      include Sequent::Core::Helpers::AttributeSupport
+      include Sequent::Core::Helpers::Copyable
+      include Sequent::Core::Helpers::EqualSupport
+      include Sequent::Core::Helpers::StringSupport
       include Sequent::Core::Helpers::TypeConversionSupport
 
       def initialize(args = {})
         update_all_attributes args
       end
-
     end
-
   end
 end
-

data/lib/sequent/core/workflow.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'helpers/message_handler'
 require_relative 'current_event'
 
@@ -11,7 +13,7 @@ module Sequent
           begin
             old_event = CurrentEvent.current
             CurrentEvent.current = event
-            self.instance_exec(event, &block)
+            instance_exec(event, &block)
           ensure
             CurrentEvent.current = old_event
           end
@@ -31,12 +33,12 @@ module Sequent
       # jobs processor is not using the same database connection
       # to enqueue jobs.
       def after_commit(ignore_errors: false, &block)
-        Sequent.configuration.transaction_provider.after_commit &block
-      rescue StandardError => error
+        Sequent.configuration.transaction_provider.after_commit(&block)
+      rescue StandardError => e
         if ignore_errors
-          Sequent.logger.warn("An exception was raised in an after_commit hook: #{error}, #{error.inspect}")
+          Sequent.logger.warn("An exception was raised in an after_commit hook: #{e}, #{e.inspect}")
         else
-          raise error
+          raise e
         end
       end
     end