rails_event_store_active_record 2.6.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1445359a7bc2b8138812009c8d556e9a6deae03871ac6e7119f2bd987d67f993
-  data.tar.gz: 8252c208d67c7ede155d5b26590bff5bc66435b238412f8e64451f331050f4dc
+  metadata.gz: e3f323145e1e220bf6ad821dfef9b6641d0f2ed131b8e2248565dbc2ee053680
+  data.tar.gz: f7cddb0c87980a9e0145636d95f3db23a88f789adf4574edd091c607bb4aaab5
 SHA512:
-  metadata.gz: 8e5f036edb8a06087486c6daf13ddb8ce9ebfd80faffd49ee00aeae030438f6c40082f094bed22ba6b03c4a1a9369e236703b0e7406dfe1b8b841ae72a712b11
-  data.tar.gz: 403c082973e88aa2a2dc87fe5ea1c2c1b4e9f8c6b622352f79d0fa80d3c7e3ff280f4d5ea9579cf31fec41a5d79b4540048a989a4a114c0e66ec51e4ec7f4262
+  metadata.gz: b2dde62b0021363f5760984edba72bb43d7ad5f93c2679e0ef37b4b01bece918c53303a8381eea223d66fa9588aa04e6e4d4acaa57406df5c9c4ce24b4f9b81d
+  data.tar.gz: f0f78958ea44a854ca94acacd7d66fdea093012747361a8a36774e2145f9d3114cdd8822725fdb9b1c892a591deb84e1de749e147451cb54f53acd3018c78b74

data/lib/rails_event_store_active_record.rb

@@ -1,12 +1,3 @@
-# frozen_string_literal: true
+require "ruby_event_store/active_record"
 
-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"
+RailsEventStoreActiveRecord = RubyEventStore::ActiveRecord

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rails_event_store_active_record
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Arkency
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-29 00:00:00.000000000 Z
+date: 2022-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ruby_event_store
+  name: ruby_event_store-active_record
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.6.0
+        version: 2.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.6.0
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '6.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '6.0'
+        version: 2.7.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.
@@ -47,22 +33,9 @@ description: |
 email: dev@arkency.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.md
+extra_rdoc_files: []
 files:
-- README.md
 - lib/rails_event_store_active_record.rb
-- lib/rails_event_store_active_record/batch_enumerator.rb
-- lib/rails_event_store_active_record/event.rb
-- lib/rails_event_store_active_record/event_repository.rb
-- lib/rails_event_store_active_record/event_repository_reader.rb
-- lib/rails_event_store_active_record/generators/migration_generator.rb
-- lib/rails_event_store_active_record/generators/templates/create_event_store_events_template.rb
-- lib/rails_event_store_active_record/index_violation_detector.rb
-- lib/rails_event_store_active_record/pg_linearized_event_repository.rb
-- lib/rails_event_store_active_record/version.rb
-- lib/rails_event_store_active_record/with_abstract_base_class.rb
-- lib/rails_event_store_active_record/with_default_models.rb
 homepage: https://railseventstore.org
 licenses:
 - MIT

data/README.md

@@ -1,7 +0,0 @@
-# RailsEventStoreActiveRecord
-
-Persistent event repository implementation for RubyEventStore based on ActiveRecord. Ships with database schema and migrations suitable for PostgreSQL, MySQL ans SQLite database engines.
-
-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/)

data/lib/rails_event_store_active_record/batch_enumerator.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RailsEventStoreActiveRecord
-  class BatchEnumerator
-    def initialize(batch_size, total_limit, reader)
-      @batch_size = batch_size
-      @total_limit = total_limit
-      @reader = reader
-    end
-
-    def each
-      return to_enum unless block_given?
-      offset_id = nil
-
-      0.step(total_limit - 1, batch_size) do |batch_offset|
-        batch_limit = [batch_size, total_limit - batch_offset].min
-        results, offset_id = reader.call(offset_id, batch_limit)
-
-        break if results.empty?
-        yield results
-      end
-    end
-
-    def first
-      each.first
-    end
-
-    def to_a
-      each.to_a
-    end
-
-    private
-
-    attr_reader :batch_size, :total_limit, :reader
-  end
-end

data/lib/rails_event_store_active_record/event.rb

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

data/lib/rails_event_store_active_record/event_repository.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/array"
-
-module RailsEventStoreActiveRecord
-  class EventRepository
-    POSITION_SHIFT = 1
-
-    def initialize(model_factory: WithDefaultModels.new, serializer:)
-      @serializer = serializer
-
-      @event_klass, @stream_klass = model_factory.call
-      @repo_reader = EventRepositoryReader.new(@event_klass, @stream_klass, serializer)
-      @index_violation_detector = IndexViolationDetector.new(@event_klass.table_name, @stream_klass.table_name)
-    end
-
-    def append_to_stream(records, stream, expected_version)
-      return if records.empty?
-
-      hashes = []
-      event_ids = []
-      records.each do |record|
-        hashes << insert_hash(record, record.serialize(serializer))
-        event_ids << record.event_id
-      end
-      add_to_stream(event_ids, stream, expected_version) { @event_klass.insert_all!(hashes) }
-    end
-
-    def link_to_stream(event_ids, stream, expected_version)
-      return if event_ids.empty?
-
-      (event_ids - @event_klass.where(event_id: event_ids).pluck(:event_id)).each do |id|
-        raise RubyEventStore::EventNotFound.new(id)
-      end
-      add_to_stream(event_ids, stream, expected_version)
-    end
-
-    def delete_stream(stream)
-      @stream_klass.where(stream: stream.name).delete_all
-    end
-
-    def has_event?(event_id)
-      @repo_reader.has_event?(event_id)
-    end
-
-    def last_stream_event(stream)
-      @repo_reader.last_stream_event(stream)
-    end
-
-    def read(specification)
-      @repo_reader.read(specification)
-    end
-
-    def count(specification)
-      @repo_reader.count(specification)
-    end
-
-    def update_messages(records)
-      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, :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)
-      @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_) 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,
-              created_at: Time.now.utc
-            }
-          end
-        @stream_klass.insert_all!(in_stream) unless stream.global?
-      end
-      self
-    rescue ActiveRecord::RecordNotUnique => e
-      raise_error(e)
-    end
-
-    def raise_error(e)
-      raise RubyEventStore::EventDuplicatedInStream if detect_index_violated(e.message)
-      raise RubyEventStore::WrongExpectedEventVersion
-    end
-
-    def compute_position(resolved_version, index)
-      resolved_version + index + POSITION_SHIFT unless resolved_version.nil?
-    end
-
-    def detect_index_violated(message)
-      @index_violation_detector.detect(message)
-    end
-
-    def insert_hash(record, serialized_record)
-      {
-        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)
-      }
-    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
-
-    def optimize_timestamp(valid_at, created_at)
-      valid_at unless valid_at.eql?(created_at)
-    end
-
-    def start_transaction(&block)
-      @event_klass.transaction(requires_new: true, &block)
-    end
-  end
-end

data/lib/rails_event_store_active_record/event_repository_reader.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-module RailsEventStoreActiveRecord
-  class EventRepositoryReader
-    def initialize(event_klass, stream_klass, serializer)
-      @event_klass = event_klass
-      @stream_klass = stream_klass
-      @serializer = serializer
-    end
-
-    def has_event?(event_id)
-      @event_klass.exists?(event_id: event_id)
-    end
-
-    def last_stream_event(stream)
-      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?
-        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_
-      elsif spec.last?
-        record_ = stream.last
-        record(record_) if record_
-      else
-        stream.map(&method(:record)).each
-      end
-    end
-
-    def count(spec)
-      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 = 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.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_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 = ordered(stream.joins(:event), spec)
-        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_or_equal_condition(spec)) if spec.newer_than_or_equal
-        stream
-      end
-    end
-
-    def ordered(stream, spec)
-      case spec.time_sort_by
-      when :as_at
-        stream.order("#{@event_klass.table_name}.created_at #{order(spec)}")
-      when :as_of
-        stream.order("#{@event_klass.table_name}.valid_at #{order(spec)}")
-      else
-        stream
-      end
-    end
-
-    def start_offset_condition(specification, record_id, search_in)
-      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, record_id]
-    end
-
-    def start_condition(specification)
-      start_offset_condition(
-        specification,
-        @stream_klass.find_by!(event_id: specification.start, stream: specification.stream.name),
-        @stream_klass.table_name
-      )
-    end
-
-    def stop_condition(specification)
-      stop_offset_condition(
-        specification,
-        @stream_klass.find_by!(event_id: specification.stop, stream: specification.stream.name),
-        @stream_klass.table_name
-      )
-    end
-
-    def start_condition_in_global_stream(specification)
-      start_offset_condition(
-        specification,
-        @event_klass.find_by!(event_id: specification.start),
-        @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)
-    end
-
-    def older_than_condition(specification)
-      ["#{@event_klass.table_name}.created_at < ?", specification.older_than]
-    end
-
-    def older_than_or_equal_condition(specification)
-      ["#{@event_klass.table_name}.created_at <= ?", specification.older_than_or_equal]
-    end
-
-    def newer_than_condition(specification)
-      ["#{@event_klass.table_name}.created_at > ?", specification.newer_than]
-    end
-
-    def newer_than_or_equal_condition(specification)
-      ["#{@event_klass.table_name}.created_at >= ?", specification.newer_than_or_equal]
-    end
-
-    def order(spec)
-      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)
-    end
-  end
-
-  private_constant(:EventRepositoryReader)
-end

data/lib/rails_event_store_active_record/generators/migration_generator.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "rails/generators"
-rescue LoadError
-end
-
-module RailsEventStoreActiveRecord
-  class MigrationGenerator < Rails::Generators::Base
-    class Error < Thor::Error
-    end
-
-    DATA_TYPES = %w[binary json jsonb].freeze
-
-    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("/")})"
-    )
-
-    def initialize(*args)
-      super
-
-      if DATA_TYPES.exclude?(options.fetch(:data_type))
-        raise Error, "Invalid value for --data-type option. Supported for options are: #{DATA_TYPES.join(", ")}."
-      end
-    end
-
-    def create_migration
-      template "create_event_store_events_template.rb", "db/migrate/#{timestamp}_create_event_store_events.rb"
-    end
-
-    private
-
-    def data_type
-      options.fetch("data_type")
-    end
-
-    def migration_version
-      "[4.2]"
-    end
-
-    def timestamp
-      Time.now.strftime("%Y%m%d%H%M%S")
-    end
-  end
-end if defined?(Rails::Generators::Base)

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-class CreateEventStoreEvents < ActiveRecord::Migration<%= migration_version %>
-  def change
-    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
-      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, 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.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
-        t.binary      :metadata
-        t.binary      :data,        null: false
-        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
-  end
-end

data/lib/rails_event_store_active_record/index_violation_detector.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module RailsEventStoreActiveRecord
-  class IndexViolationDetector
-    def initialize(event_store_events, event_store_events_in_streams)
-      @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
-    end
-
-    def detect(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)
-    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)
-    end
-
-    def detect_sqlite(message)
-      message.include?(@sqlite3_pkey_error) || message.include?(@sqlite3_index_error)
-    end
-  end
-
-  private_constant(:IndexViolationDetector)
-end

data/lib/rails_event_store_active_record/pg_linearized_event_repository.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-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 {}
-
-        proc.call
-      end
-    end
-  end
-end

data/lib/rails_event_store_active_record/version.rb

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

data/lib/rails_event_store_active_record/with_abstract_base_class.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RailsEventStoreActiveRecord
-  class WithAbstractBaseClass
-    def initialize(base_klass)
-      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)]
-    end
-
-    private
-
-    def build_event_klass(instance_id)
-      Object.const_set(
-        "Event_#{instance_id}",
-        Class.new(@base_klass) do
-          self.primary_key = :id
-          self.table_name = "event_store_events"
-        end
-      )
-    end
-
-    def build_stream_klass(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"
-          belongs_to :event, primary_key: :event_id, class_name: "Event_#{instance_id}"
-        end
-      )
-    end
-  end
-end

data/lib/rails_event_store_active_record/with_default_models.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module RailsEventStoreActiveRecord
-  class WithDefaultModels
-    def call
-      [Event, EventInStream]
-    end
-  end
-end