rails_event_store_active_record 2.1.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 291ce390bf636caf06d9949f79aa697799079a547b282095afe8f40f27d6c84a
-  data.tar.gz: ea74678de5019d72b1c82779815f12778e01871695aeeed3d704835ea64a9120
+  metadata.gz: b146f907eef70a988c0949381dbf897a4f93bd7aa9e1ccf8346559c2656feb80
+  data.tar.gz: 46b6f4ce8d62b7386d72a1219a375e012bd3d15b33b16fe552cb8adee9f4f6e4
 SHA512:
-  metadata.gz: ae73534ca38d6ecb19bc599aa8ceb0b4e3705a20b38b3981637e0f7a313b3b3e29adb2bffc1048afb4b8c41733a41e0ca51030835271ddcb79d30aae1a8e4204
-  data.tar.gz: 881dd61f6e62165dd76112b8852a20a84283d1de2fa6d601b92a8e859aab9267d55b58e8ee65cb90e04ec0c08d91f3de75c4d05bc35ecc1441443fed879c17a3
+  metadata.gz: 0be237c7518c776a5ee19e8625f39966a20f255b0076839695957df0aa337c181bc7c85351afb2a1fbffdd6b0fd75fa50217482c30d1aa82437b242a32552e8d
+  data.tar.gz: 32aa1160ba4de4081357319e25012330249b6e946d0e0b558452fe41e7a30aa25e70d65faf9897ba6b7afac841c6b2ea6011117a892a272179da58b38a96bbb4

data/README.md

@@ -4,4 +4,4 @@ Persistent event repository implementation for RubyEventStore based on ActiveRec
 
 Includes repository implementation with linearized writes to achieve log-like properties of streams on top of SQL database engine.
 
-Find out more at [https://railseventstore.org](https://railseventstore.org/)
+Find out more at [https://railseventstore.org](https://railseventstore.org/)

data/lib/rails_event_store_active_record/batch_enumerator.rb

@@ -3,9 +3,9 @@
 module RailsEventStoreActiveRecord
   class BatchEnumerator
     def initialize(batch_size, total_limit, reader)
-      @batch_size  = batch_size
+      @batch_size = batch_size
       @total_limit = total_limit
-      @reader      = reader
+      @reader = reader
     end
 
     def each
@@ -13,7 +13,7 @@ module RailsEventStoreActiveRecord
       offset_id = nil
 
       0.step(total_limit - 1, batch_size) do |batch_offset|
-        batch_limit        = [batch_size, total_limit - batch_offset].min
+        batch_limit = [batch_size, total_limit - batch_offset].min
         results, offset_id = reader.call(offset_id, batch_limit)
 
         break if results.empty?
@@ -34,4 +34,3 @@ module RailsEventStoreActiveRecord
     attr_reader :batch_size, :total_limit, :reader
   end
 end
-

data/lib/rails_event_store_active_record/event.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'active_record'
+require "active_record"
 
 module RailsEventStoreActiveRecord
   class Event < ::ActiveRecord::Base
     self.primary_key = :id
-    self.table_name = 'event_store_events'
+    self.table_name = "event_store_events"
   end
 
   class EventInStream < ::ActiveRecord::Base
     self.primary_key = :id
-    self.table_name = 'event_store_events_in_streams'
+    self.table_name = "event_store_events_in_streams"
     belongs_to :event, primary_key: :event_id
   end
 end

data/lib/rails_event_store_active_record/event_repository.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/array'
-require 'activerecord-import'
+require "active_support/core_ext/array"
 
 module RailsEventStoreActiveRecord
   class EventRepository
     POSITION_SHIFT = 1
 
     def initialize(model_factory: WithDefaultModels.new, serializer:)
-      @serializer  = serializer
+      @serializer = serializer
 
       @event_klass, @stream_klass = model_factory.call
       @repo_reader = EventRepositoryReader.new(@event_klass, @stream_klass, serializer)
@@ -16,15 +15,13 @@ module RailsEventStoreActiveRecord
     end
 
     def append_to_stream(records, stream, expected_version)
-      hashes    = []
+      hashes = []
       event_ids = []
       records.each do |record|
-        hashes    << import_hash(record, record.serialize(serializer))
+        hashes << insert_hash(record, record.serialize(serializer))
         event_ids << record.event_id
       end
-      add_to_stream(event_ids, stream, expected_version) do
-        @event_klass.import(hashes)
-      end
+      add_to_stream(event_ids, stream, expected_version) { @event_klass.insert_all!(hashes) }
     end
 
     def link_to_stream(event_ids, stream, expected_version)
@@ -55,39 +52,61 @@ module RailsEventStoreActiveRecord
     end
 
     def update_messages(records)
-      hashes  = records.map { |record| import_hash(record, record.serialize(serializer)) }
+      hashes = records.map { |record| upsert_hash(record, record.serialize(serializer)) }
       for_update = records.map(&:event_id)
       start_transaction do
-        existing = @event_klass.where(event_id: for_update).pluck(:event_id, :id).to_h
-        (for_update - existing.keys).each{|id| raise RubyEventStore::EventNotFound.new(id) }
-        hashes.each { |h| h[:id] = existing.fetch(h.fetch(:event_id)) }
-        @event_klass.import(hashes, on_duplicate_key_update: [:data, :metadata, :event_type, :valid_at])
+        existing =
+          @event_klass
+            .where(event_id: for_update)
+            .pluck(:event_id, :id, :created_at)
+            .reduce({}) { |acc, (event_id, id, created_at)| acc.merge(event_id => [id, created_at]) }
+        (for_update - existing.keys).each { |id| raise RubyEventStore::EventNotFound.new(id) }
+        hashes.each do |h|
+          h[:id] = existing.fetch(h.fetch(:event_id)).at(0)
+          h[:created_at] = existing.fetch(h.fetch(:event_id)).at(1)
+        end
+        @event_klass.upsert_all(hashes)
       end
     end
 
     def streams_of(event_id)
-      @stream_klass.where(event_id: event_id)
-        .pluck(:stream)
-        .map { |name| RubyEventStore::Stream.new(name) }
+      @repo_reader.streams_of(event_id)
+    end
+
+    def position_in_stream(event_id, stream)
+      @repo_reader.position_in_stream(event_id, stream)
+    end
+
+    def global_position(event_id)
+      @repo_reader.global_position(event_id)
+    end
+
+    def event_in_stream?(event_id, stream)
+      @repo_reader.event_in_stream?(event_id, stream)
     end
 
     private
+
     attr_reader :serializer
 
     def add_to_stream(event_ids, stream, expected_version)
-      last_stream_version = ->(stream_) { @stream_klass.where(stream: stream_.name).order("position DESC").first.try(:position) }
+      last_stream_version = ->(stream_) do
+        @stream_klass.where(stream: stream_.name).order("position DESC").first.try(:position)
+      end
       resolved_version = expected_version.resolve_for(stream, last_stream_version)
 
       start_transaction do
         yield if block_given?
-        in_stream = event_ids.map.with_index do |event_id, index|
-          {
-            stream:   stream.name,
-            position: compute_position(resolved_version, index),
-            event_id: event_id,
-          }
-        end
-        @stream_klass.import(in_stream) unless stream.global?
+        in_stream =
+          event_ids.map.with_index do |event_id, index|
+            {
+              stream: stream.name,
+              position: compute_position(resolved_version, index),
+              event_id: event_id,
+              created_at: Time.now.utc
+            }
+          end
+        @stream_klass.insert_all!(in_stream) unless stream.global?
       end
       self
     rescue ActiveRecord::RecordNotUnique => e
@@ -95,30 +114,36 @@ module RailsEventStoreActiveRecord
     end
 
     def raise_error(e)
-      if detect_index_violated(e.message)
-        raise RubyEventStore::EventDuplicatedInStream
-      end
+      raise RubyEventStore::EventDuplicatedInStream if detect_index_violated(e.message)
       raise RubyEventStore::WrongExpectedEventVersion
     end
 
     def compute_position(resolved_version, index)
-      unless resolved_version.nil?
-        resolved_version + index + POSITION_SHIFT
-      end
+      resolved_version + index + POSITION_SHIFT unless resolved_version.nil?
     end
 
     def detect_index_violated(message)
       @index_violation_detector.detect(message)
     end
 
-    def import_hash(record, serialized_record)
+    def insert_hash(record, serialized_record)
       {
-        event_id:   serialized_record.event_id,
-        data:       serialized_record.data,
-        metadata:   serialized_record.metadata,
+        event_id: serialized_record.event_id,
+        data: serialized_record.data,
+        metadata: serialized_record.metadata,
         event_type: serialized_record.event_type,
         created_at: record.timestamp,
-        valid_at:   optimize_timestamp(record.valid_at, record.timestamp),
+        valid_at: optimize_timestamp(record.valid_at, record.timestamp)
+      }
+    end
+
+    def upsert_hash(record, serialized_record)
+      {
+        event_id: serialized_record.event_id,
+        data: serialized_record.data,
+        metadata: serialized_record.metadata,
+        event_type: serialized_record.event_type,
+        valid_at: optimize_timestamp(record.valid_at, record.timestamp)
       }
     end
 
@@ -130,5 +155,4 @@ module RailsEventStoreActiveRecord
       @event_klass.transaction(requires_new: true, &block)
     end
   end
-
 end

data/lib/rails_event_store_active_record/event_repository_reader.rb

@@ -2,7 +2,6 @@
 
 module RailsEventStoreActiveRecord
   class EventRepositoryReader
-
     def initialize(event_klass, stream_klass, serializer)
       @event_klass = event_klass
       @stream_klass = stream_klass
@@ -14,20 +13,14 @@ module RailsEventStoreActiveRecord
     end
 
     def last_stream_event(stream)
-      record_ = @stream_klass.where(stream: stream.name).order('position DESC, id DESC').first
+      record_ = @stream_klass.where(stream: stream.name).order("position DESC, id DESC").first
       record(record_) if record_
     end
 
     def read(spec)
       stream = read_scope(spec)
-
       if spec.batched?
-        batch_reader = ->(offset_id, limit) do
-          search_in = spec.stream.global? ? @event_klass.table_name : @stream_klass.table_name
-          records = offset_id.nil? ? stream.limit(limit) : stream.where(start_offset_condition(spec, offset_id, search_in)).limit(limit)
-          [records.map(&method(:record)), records.last]
-        end
-        BatchEnumerator.new(spec.batch_size, spec.limit, batch_reader).each
+        spec.time_sort_by ? offset_limit_batch_reader(spec, stream) : monotonic_id_batch_reader(spec, stream)
       elsif spec.first?
         record_ = stream.first
         record(record_) if record_
@@ -43,35 +36,75 @@ module RailsEventStoreActiveRecord
       read_scope(spec).count
     end
 
+    def streams_of(event_id)
+      @stream_klass.where(event_id: event_id).pluck(:stream).map { |name| RubyEventStore::Stream.new(name) }
+    end
+
+    def position_in_stream(event_id, stream)
+      record = @stream_klass.select("position").where(stream: stream.name).find_by(event_id: event_id)
+      raise RubyEventStore::EventNotFoundInStream if record.nil?
+      record.position
+    end
+
+    def global_position(event_id)
+      record = @event_klass.select("id").find_by(event_id: event_id)
+      raise RubyEventStore::EventNotFound.new(event_id) if record.nil?
+      record.id - 1
+    end
+
+    def event_in_stream?(event_id, stream)
+      @stream_klass.where(event_id: event_id, stream: stream.name).exists?
+    end
+
     private
+
     attr_reader :serializer
 
+    def offset_limit_batch_reader(spec, stream)
+      batch_reader = ->(offset, limit) { stream.offset(offset).limit(limit).map(&method(:record)) }
+      RubyEventStore::BatchEnumerator.new(spec.batch_size, spec.limit, batch_reader).each
+    end
+
+    def monotonic_id_batch_reader(spec, stream)
+      batch_reader = ->(offset_id, limit) do
+        search_in = spec.stream.global? ? @event_klass.table_name : @stream_klass.table_name
+        records =
+          if offset_id.nil?
+            stream.limit(limit)
+          else
+            stream.where(start_offset_condition(spec, offset_id, search_in)).limit(limit)
+          end
+        [records.map(&method(:record)), records.last]
+      end
+      BatchEnumerator.new(spec.batch_size, spec.limit, batch_reader).each
+    end
+
     def read_scope(spec)
       if spec.stream.global?
         stream = @event_klass
-        stream = stream.where(event_id: spec.with_ids)                           if spec.with_ids?
-        stream = stream.where(event_type: spec.with_types)                       if spec.with_types?
+        stream = stream.where(event_id: spec.with_ids) if spec.with_ids?
+        stream = stream.where(event_type: spec.with_types) if spec.with_types?
         stream = ordered(stream, spec)
-        stream = stream.limit(spec.limit)                                        if spec.limit?
-        stream = stream.where(start_condition_in_global_stream(spec))            if spec.start
-        stream = stream.where(stop_condition_in_global_stream(spec))             if spec.stop
-        stream = stream.where(older_than_condition(spec))          if spec.older_than
+        stream = stream.limit(spec.limit) if spec.limit?
+        stream = stream.where(start_condition_in_global_stream(spec)) if spec.start
+        stream = stream.where(stop_condition_in_global_stream(spec)) if spec.stop
+        stream = stream.where(older_than_condition(spec)) if spec.older_than
         stream = stream.where(older_than_or_equal_condition(spec)) if spec.older_than_or_equal
-        stream = stream.where(newer_than_condition(spec))          if spec.newer_than
+        stream = stream.where(newer_than_condition(spec)) if spec.newer_than
         stream = stream.where(newer_than_or_equal_condition(spec)) if spec.newer_than_or_equal
         stream.order(id: order(spec))
       else
         stream = @stream_klass.preload(:event).where(stream: spec.stream.name)
-        stream = stream.where(event_id: spec.with_ids)                                                if spec.with_ids?
-        stream = stream.where(@event_klass.table_name => {event_type: spec.with_types}) if spec.with_types?
+        stream = stream.where(event_id: spec.with_ids) if spec.with_ids?
+        stream = stream.where(@event_klass.table_name => { event_type: spec.with_types }) if spec.with_types?
         stream = ordered(stream.joins(:event), spec)
-        stream = stream.order(position: order(spec), id: order(spec))
-        stream = stream.limit(spec.limit)                                        if spec.limit?
-        stream = stream.where(start_condition(spec))                             if spec.start
-        stream = stream.where(stop_condition(spec))                              if spec.stop
-        stream = stream.where(older_than_condition(spec))          if spec.older_than
+        stream = stream.order(id: order(spec))
+        stream = stream.limit(spec.limit) if spec.limit?
+        stream = stream.where(start_condition(spec)) if spec.start
+        stream = stream.where(stop_condition(spec)) if spec.stop
+        stream = stream.where(older_than_condition(spec)) if spec.older_than
         stream = stream.where(older_than_or_equal_condition(spec)) if spec.older_than_or_equal
-        stream = stream.where(newer_than_condition(spec))          if spec.newer_than
+        stream = stream.where(newer_than_condition(spec)) if spec.newer_than
         stream = stream.where(newer_than_or_equal_condition(spec)) if spec.newer_than_or_equal
         stream
       end
@@ -89,37 +122,41 @@ module RailsEventStoreActiveRecord
     end
 
     def start_offset_condition(specification, record_id, search_in)
-      condition = "#{search_in}.id #{specification.forward? ? '>' : '<'} ?"
+      condition = "#{search_in}.id #{specification.forward? ? ">" : "<"} ?"
       [condition, record_id]
     end
 
     def stop_offset_condition(specification, record_id, search_in)
-      condition = "#{search_in}.id #{specification.forward? ? '<' : '>'} ?"
+      condition = "#{search_in}.id #{specification.forward? ? "<" : ">"} ?"
       [condition, record_id]
     end
 
     def start_condition(specification)
-      start_offset_condition(specification,
+      start_offset_condition(
+        specification,
         @stream_klass.find_by!(event_id: specification.start, stream: specification.stream.name),
-        @stream_klass.table_name)
+        @stream_klass.table_name
+      )
     end
 
     def stop_condition(specification)
-      stop_offset_condition(specification,
+      stop_offset_condition(
+        specification,
         @stream_klass.find_by!(event_id: specification.stop, stream: specification.stream.name),
-        @stream_klass.table_name)
+        @stream_klass.table_name
+      )
     end
 
     def start_condition_in_global_stream(specification)
-      start_offset_condition(specification,
+      start_offset_condition(
+        specification,
         @event_klass.find_by!(event_id: specification.start),
-        @event_klass.table_name)
+        @event_klass.table_name
+      )
     end
 
     def stop_condition_in_global_stream(specification)
-      stop_offset_condition(specification,
-        @event_klass.find_by!(event_id: specification.stop),
-        @event_klass.table_name)
+      stop_offset_condition(specification, @event_klass.find_by!(event_id: specification.stop), @event_klass.table_name)
     end
 
     def older_than_condition(specification)
@@ -139,20 +176,22 @@ module RailsEventStoreActiveRecord
     end
 
     def order(spec)
-      spec.forward? ? 'ASC' : 'DESC'
+      spec.forward? ? "ASC" : "DESC"
     end
 
     def record(record)
       record = record.event if @stream_klass === record
 
-      RubyEventStore::SerializedRecord.new(
-        event_id: record.event_id,
-        metadata: record.metadata,
-        data: record.data,
-        event_type: record.event_type,
-        timestamp: record.created_at.iso8601(RubyEventStore::TIMESTAMP_PRECISION),
-        valid_at: (record.valid_at || record.created_at).iso8601(RubyEventStore::TIMESTAMP_PRECISION),
-      ).deserialize(serializer)
+      RubyEventStore::SerializedRecord
+        .new(
+          event_id: record.event_id,
+          metadata: record.metadata,
+          data: record.data,
+          event_type: record.event_type,
+          timestamp: record.created_at.iso8601(RubyEventStore::TIMESTAMP_PRECISION),
+          valid_at: (record.valid_at || record.created_at).iso8601(RubyEventStore::TIMESTAMP_PRECISION)
+        )
+        .deserialize(serializer)
     end
   end
 

data/lib/rails_event_store_active_record/generators/migration_generator.rb

@@ -1,22 +1,24 @@
 # frozen_string_literal: true
 
 begin
-  require 'rails/generators'
+  require "rails/generators"
 rescue LoadError
 end
 
 module RailsEventStoreActiveRecord
   class MigrationGenerator < Rails::Generators::Base
-    class Error < Thor::Error; end
+    class Error < Thor::Error
+    end
 
-    DATA_TYPES = %w(binary json jsonb).freeze
+    DATA_TYPES = %w[binary json jsonb].freeze
 
-    source_root File.expand_path(File.join(File.dirname(__FILE__), '../generators/templates'))
+    source_root File.expand_path(File.join(File.dirname(__FILE__), "../generators/templates"))
     class_option(
       :data_type,
       type: :string,
-      default: 'binary',
-      desc: "Configure the data type for `data` and `meta data` fields in Postgres migration (options: #{DATA_TYPES.join('/')})"
+      default: "binary",
+      desc:
+        "Configure the data type for `data` and `meta data` fields in Postgres migration (options: #{DATA_TYPES.join("/")})"
     )
 
     def initialize(*args)
@@ -34,7 +36,7 @@ module RailsEventStoreActiveRecord
     private
 
     def data_type
-      options.fetch('data_type')
+      options.fetch("data_type")
     end
 
     def migration_version
@@ -45,4 +47,4 @@ module RailsEventStoreActiveRecord
       Time.now.strftime("%Y%m%d%H%M%S")
     end
   end
-end if defined?(Rails::Generators::Base)
+end if defined?(Rails::Generators::Base)

data/lib/rails_event_store_active_record/generators/templates/create_event_store_events_template.rb

@@ -2,38 +2,42 @@
 
 class CreateEventStoreEvents < ActiveRecord::Migration<%= migration_version %>
   def change
-    postgres = ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
-    sqlite   = ActiveRecord::Base.connection.adapter_name == "SQLite"
-
-    enable_extension "pgcrypto" if postgres
-    create_table(:event_store_events_in_streams, force: false) do |t|
-      t.string      :stream,      null: false
-      t.integer     :position,    null: true
-      if postgres
-        t.references :event, null: false, type: :uuid
-      else
-        t.references :event, null: false, type: :string, limit: 36
-      end
-      if postgres
+    postgres =
+      ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+    if postgres
+      create_table(:event_store_events_in_streams, id: :bigserial, force: false) do |t|
+        t.string      :stream,      null: false
+        t.integer     :position,    null: true
+        t.references  :event,       null: false, type: :uuid
         t.datetime    :created_at,  null: false
-      else
-        t.datetime    :created_at,  null: false, precision: 6
       end
-    end
-    add_index :event_store_events_in_streams, [:stream, :position], unique: true
-    add_index :event_store_events_in_streams, [:created_at]
-    add_index :event_store_events_in_streams, [:stream, :event_id], unique: true
+      add_index :event_store_events_in_streams, [:stream, :position], unique: true
+      add_index :event_store_events_in_streams, [:created_at]
+      add_index :event_store_events_in_streams, [:stream, :event_id], unique: true
 
-    if postgres
-      create_table(:event_store_events, force: false) do |t|
+      create_table(:event_store_events, id: :bigserial, force: false) do |t|
         t.references  :event,       null: false, type: :uuid
         t.string      :event_type,  null: false
         t.<%= data_type %>      :metadata
-        t.<%= data_type %>      :data,        null: false
+        t.<%= data_type %>      :data, null: false
         t.datetime    :created_at,  null: false
         t.datetime    :valid_at,    null: true
       end
+      add_index :event_store_events, :event_id, unique: true
+      add_index :event_store_events, :created_at
+      add_index :event_store_events, :valid_at
+      add_index :event_store_events, :event_type
     else
+      create_table(:event_store_events_in_streams, force: false) do |t|
+        t.string      :stream,      null: false
+        t.integer     :position,    null: true
+        t.references  :event,       null: false, type: :string, limit: 36
+        t.datetime    :created_at,  null: false, precision: 6
+      end
+      add_index :event_store_events_in_streams, [:stream, :position], unique: true
+      add_index :event_store_events_in_streams, [:created_at]
+      add_index :event_store_events_in_streams, [:stream, :event_id], unique: true
+
       create_table(:event_store_events, force: false) do |t|
         t.references  :event,       null: false, type: :string, limit: 36
         t.string      :event_type,  null: false
@@ -42,10 +46,10 @@ class CreateEventStoreEvents < ActiveRecord::Migration<%= migration_version %>
         t.datetime    :created_at,  null: false, precision: 6
         t.datetime    :valid_at,    null: true,  precision: 6
       end
+      add_index :event_store_events, :event_id, unique: true
+      add_index :event_store_events, :created_at
+      add_index :event_store_events, :valid_at
+      add_index :event_store_events, :event_type
     end
-    add_index :event_store_events, :event_id, unique: true
-    add_index :event_store_events, :created_at
-    add_index :event_store_events, :valid_at
-    add_index :event_store_events, :event_type
   end
 end

data/lib/rails_event_store_active_record/index_violation_detector.rb

@@ -2,41 +2,37 @@
 
 module RailsEventStoreActiveRecord
   class IndexViolationDetector
-
     def initialize(event_store_events, event_store_events_in_streams)
-      @postgres_pkey_error  = "Key (event_id)".freeze
+      @postgres_pkey_error = "Key (event_id)".freeze
       @postgres_index_error = "Key (stream, event_id)".freeze
-      @mysql5_pkey_error    = "for key 'index_#{event_store_events}_on_event_id'".freeze
-      @mysql8_pkey_error    = "for key '#{event_store_events}.index_#{event_store_events}_on_event_id'".freeze
-      @mysql5_index_error   = "for key 'index_#{event_store_events_in_streams}_on_stream_and_event_id'".freeze
-      @mysql8_index_error   = "for key '#{event_store_events_in_streams}.index_#{event_store_events_in_streams}_on_stream_and_event_id'".freeze
-      @sqlite3_pkey_error   = "constraint failed: #{event_store_events}.event_id".freeze
-      @sqlite3_index_error  = "constraint failed: #{event_store_events_in_streams}.stream, #{event_store_events_in_streams}.event_id".freeze
+      @mysql5_pkey_error = "for key 'index_#{event_store_events}_on_event_id'".freeze
+      @mysql8_pkey_error = "for key '#{event_store_events}.index_#{event_store_events}_on_event_id'".freeze
+      @mysql5_index_error = "for key 'index_#{event_store_events_in_streams}_on_stream_and_event_id'".freeze
+      @mysql8_index_error =
+        "for key '#{event_store_events_in_streams}.index_#{event_store_events_in_streams}_on_stream_and_event_id'"
+          .freeze
+      @sqlite3_pkey_error = "constraint failed: #{event_store_events}.event_id".freeze
+      @sqlite3_index_error =
+        "constraint failed: #{event_store_events_in_streams}.stream, #{event_store_events_in_streams}.event_id".freeze
     end
 
     def detect(message)
-      detect_postgres(message) ||
-        detect_mysql(message)  ||
-        detect_sqlite(message)
+      detect_postgres(message) || detect_mysql(message) || detect_sqlite(message)
     end
 
     private
 
     def detect_postgres(message)
-      message.include?(@postgres_pkey_error) ||
-        message.include?(@postgres_index_error)
+      message.include?(@postgres_pkey_error) || message.include?(@postgres_index_error)
     end
 
     def detect_mysql(message)
-      message.include?(@mysql5_pkey_error)    ||
-        message.include?(@mysql8_pkey_error)  ||
-        message.include?(@mysql5_index_error) ||
-        message.include?(@mysql8_index_error)
+      message.include?(@mysql5_pkey_error) || message.include?(@mysql8_pkey_error) ||
+        message.include?(@mysql5_index_error) || message.include?(@mysql8_index_error)
     end
 
     def detect_sqlite(message)
-      message.include?(@sqlite3_pkey_error) ||
-        message.include?(@sqlite3_index_error)
+      message.include?(@sqlite3_pkey_error) || message.include?(@sqlite3_index_error)
     end
   end
 

data/lib/rails_event_store_active_record/pg_linearized_event_repository.rb

@@ -1,20 +1,13 @@
 # frozen_string_literal: true
 
-require 'activerecord-import'
-
 module RailsEventStoreActiveRecord
   class PgLinearizedEventRepository < EventRepository
-
     def start_transaction(&proc)
       ActiveRecord::Base.transaction(requires_new: true) do
-        ActiveRecord::Base
-          .connection
-          .execute("SELECT pg_advisory_xact_lock(1845240511599988039) as l")
-          .each{}
+        ActiveRecord::Base.connection.execute("SELECT pg_advisory_xact_lock(1845240511599988039) as l").each {}
 
         proc.call
       end
     end
-
   end
 end

data/lib/rails_event_store_active_record/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsEventStoreActiveRecord
-  VERSION = "2.1.0"
+  VERSION = "2.4.0"
 end

data/lib/rails_event_store_active_record/with_abstract_base_class.rb

@@ -3,34 +3,34 @@
 module RailsEventStoreActiveRecord
   class WithAbstractBaseClass
     def initialize(base_klass)
-      raise ArgumentError.new(
-        "#{base_klass} must be an abstract class that inherits from ActiveRecord::Base"
-      ) unless base_klass < ActiveRecord::Base && base_klass.abstract_class?
+      unless base_klass < ActiveRecord::Base && base_klass.abstract_class?
+        raise ArgumentError.new("#{base_klass} must be an abstract class that inherits from ActiveRecord::Base")
+      end
       @base_klass = base_klass
     end
 
     def call(instance_id: SecureRandom.hex)
-      [
-        build_event_klass(instance_id),
-        build_stream_klass(instance_id),
-      ]
+      [build_event_klass(instance_id), build_stream_klass(instance_id)]
     end
 
     private
+
     def build_event_klass(instance_id)
-      Object.const_set("Event_#{instance_id}",
+      Object.const_set(
+        "Event_#{instance_id}",
         Class.new(@base_klass) do
           self.primary_key = :id
-          self.table_name  = 'event_store_events'
+          self.table_name = "event_store_events"
         end
       )
     end
 
     def build_stream_klass(instance_id)
-      Object.const_set("EventInStream_#{instance_id}",
+      Object.const_set(
+        "EventInStream_#{instance_id}",
         Class.new(@base_klass) do
           self.primary_key = :id
-          self.table_name = 'event_store_events_in_streams'
+          self.table_name = "event_store_events_in_streams"
           belongs_to :event, primary_key: :event_id, class_name: "Event_#{instance_id}"
         end
       )

data/lib/rails_event_store_active_record.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'rails_event_store_active_record/generators/migration_generator'
-require 'rails_event_store_active_record/event'
-require 'rails_event_store_active_record/with_default_models'
-require 'rails_event_store_active_record/with_abstract_base_class'
-require 'rails_event_store_active_record/event_repository'
-require 'rails_event_store_active_record/batch_enumerator'
-require 'rails_event_store_active_record/event_repository_reader'
-require 'rails_event_store_active_record/index_violation_detector'
-require 'rails_event_store_active_record/pg_linearized_event_repository'
-require 'rails_event_store_active_record/version'
+require_relative "rails_event_store_active_record/generators/migration_generator"
+require_relative "rails_event_store_active_record/event"
+require_relative "rails_event_store_active_record/with_default_models"
+require_relative "rails_event_store_active_record/with_abstract_base_class"
+require_relative "rails_event_store_active_record/event_repository"
+require_relative "rails_event_store_active_record/batch_enumerator"
+require_relative "rails_event_store_active_record/event_repository_reader"
+require_relative "rails_event_store_active_record/index_violation_detector"
+require_relative "rails_event_store_active_record/pg_linearized_event_repository"
+require_relative "rails_event_store_active_record/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_event_store_active_record
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Arkency
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-07 00:00:00.000000000 Z
+date: 2022-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_event_store
@@ -16,42 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 2.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: 2.4.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: activerecord-import
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.2
+        version: '6.0'
 description: |
   Persistent event repository implementation for RubyEventStore based on ActiveRecord. Ships with database schema
   and migrations suitable for PostgreSQL, MySQL ans SQLite database engines.
@@ -85,6 +71,7 @@ metadata:
   changelog_uri: https://github.com/RailsEventStore/rails_event_store/releases
   source_code_uri: https://github.com/RailsEventStore/rails_event_store
   bug_tracker_uri: https://github.com/RailsEventStore/rails_event_store/issues
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -93,14 +80,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Persistent event repository implementation for RubyEventStore based on ActiveRecord