rails_event_store_active_record 1.3.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0deda45046d7c0914a105aa67fe9c694550a7a3c07aec439a80a5b01a2a13418
-  data.tar.gz: 664c1aa606c495b81081861adca51af9d9829f40cdafaba61b9b73be586fa867
+  metadata.gz: c0bef98dccdd36a255c20ef3bd059921c483fe3e9e448bd53c48fa23c6032692
+  data.tar.gz: 02f25563e5d185d4d19fbe79e92d83d2c8abe14281797f2d365db970664f464e
 SHA512:
-  metadata.gz: ef624e7e400a25baa7a6b8a444c585a0d568673914f15d51a22a910f1152e2239585df0bf8cfe0ecd958b768bb14d2c7813035f5cd80263aebcbfdb307909440
-  data.tar.gz: 218e460ff03c3efbb924a9a0911a7e82e38d2c7684d430c8b8791d674bdfa1f1a61953386f1008a3a728d5b9918f1de21aacf5d831429bb54328ea93c372d45f
+  metadata.gz: 3949e5687ec1647b7257c25cf337f488f012df089226819e4b4198937b72eb8d3d1c1e8d09fbb4cf46711abf583743c49edfd76c00def3f1f5800b555db0fa1e
+  data.tar.gz: 5dd00bbb2a01217095c8e5ed4130582e0f8a23b6cb0fdaf6cb8c94f70afe371648197b3f5cbf8a98e0711e529b3ae87c02619a1372be3679f808ee2367e49f26

data/README.md

@@ -1,5 +1,7 @@
 # RailsEventStoreActiveRecord
 
-An Active Record based implementation of events repository for [Rails Event Store](https://github.com/RailsEventStore/rails_event_store).
+Persistent event repository implementation for RubyEventStore based on ActiveRecord. Ships with database schema and migrations suitable for PostgreSQL, MySQL ans SQLite database engines.
 
-This is the default repository used in `rails_event_store` gem.
+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.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require 'rails_event_store_active_record/generators/migration_generator'
-require 'rails_event_store_active_record/generators/index_by_event_type_generator'
-require 'rails_event_store_active_record/generators/limit_for_event_id_generator'
-require 'rails_event_store_active_record/generators/binary_data_and_metadata_generator'
-require 'rails_event_store_active_record/event'
-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'

data/lib/rails_event_store_active_record/event.rb

@@ -11,6 +11,6 @@ module RailsEventStoreActiveRecord
   class EventInStream < ::ActiveRecord::Base
     self.primary_key = :id
     self.table_name = 'event_store_events_in_streams'
-    belongs_to :event
+    belongs_to :event, primary_key: :event_id
   end
 end

data/lib/rails_event_store_active_record/event_repository.rb

@@ -6,33 +6,36 @@ require 'activerecord-import'
 module RailsEventStoreActiveRecord
   class EventRepository
     POSITION_SHIFT = 1
-    SERIALIZED_GLOBAL_STREAM_NAME = "all".freeze
 
-    def initialize
-      @repo_reader = EventRepositoryReader.new
+    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(events, stream, expected_version)
-      records, event_ids = [], []
-      Array(events).each do |event|
-        records << build_event_hash(event)
-        event_ids << event.event_id
+    def append_to_stream(records, stream, expected_version)
+      hashes    = []
+      event_ids = []
+      records.each do |record|
+        hashes    << import_hash(record, record.serialize(serializer))
+        event_ids << record.event_id
       end
-      add_to_stream(event_ids, stream, expected_version, true) do
-        Event.import(records)
+      add_to_stream(event_ids, stream, expected_version) do
+        @event_klass.import(hashes)
       end
     end
 
     def link_to_stream(event_ids, stream, expected_version)
-      event_ids = Array(event_ids)
-      (event_ids - Event.where(id: event_ids).pluck(:id)).each do |id|
+      (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, nil)
+      add_to_stream(event_ids, stream, expected_version)
     end
 
     def delete_stream(stream)
-      EventInStream.where(stream: stream.name).delete_all
+      @stream_klass.where(stream: stream.name).delete_all
     end
 
     def has_event?(event_id)
@@ -51,49 +54,40 @@ module RailsEventStoreActiveRecord
       @repo_reader.count(specification)
     end
 
-    def update_messages(messages)
-      hashes = messages.map(&:to_h)
-      hashes.each{|h| h[:id] = h.delete(:event_id) }
-      for_update = messages.map(&:event_id)
+    def update_messages(records)
+      hashes  = records.map { |record| import_hash(record, record.serialize(serializer)) }
+      for_update = records.map(&:event_id)
       start_transaction do
-        existing = Event.where(id: for_update).pluck(:id)
-        (for_update - existing).each{|id| raise RubyEventStore::EventNotFound.new(id) }
-        Event.import(hashes, on_duplicate_key_update: [:data, :metadata, :event_type])
+        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])
       end
     end
 
     def streams_of(event_id)
-      EventInStream.where(event_id: event_id)
-        .where.not(stream: SERIALIZED_GLOBAL_STREAM_NAME)
+      @stream_klass.where(event_id: event_id)
         .pluck(:stream)
-        .map{|name| RubyEventStore::Stream.new(name)}
+        .map { |name| RubyEventStore::Stream.new(name) }
     end
 
     private
+    attr_reader :serializer
 
-    def add_to_stream(event_ids, stream, expected_version, include_global)
-      last_stream_version = ->(stream_) { EventInStream.where(stream: stream_.name).order("position DESC").first.try(:position) }
+    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) }
       resolved_version = expected_version.resolve_for(stream, last_stream_version)
 
       start_transaction do
         yield if block_given?
-        in_stream = event_ids.flat_map.with_index do |event_id, index|
-          position = compute_position(resolved_version, index)
-          collection = []
-          collection.unshift({
-            stream: SERIALIZED_GLOBAL_STREAM_NAME,
-            position: nil,
-            event_id: event_id,
-          }) if include_global
-          collection.unshift({
+        in_stream = event_ids.map.with_index do |event_id, index|
+          {
             stream:   stream.name,
-            position: position,
-            event_id: event_id
-          }) unless stream.global?
-          collection
+            position: compute_position(resolved_version, index),
+            event_id: event_id,
+          }
         end
-        fill_ids(in_stream)
-        EventInStream.import(in_stream)
+        @stream_klass.import(in_stream) unless stream.global?
       end
       self
     rescue ActiveRecord::RecordNotUnique => e
@@ -114,24 +108,26 @@ module RailsEventStoreActiveRecord
     end
 
     def detect_index_violated(message)
-      IndexViolationDetector.new.detect(message)
+      @index_violation_detector.detect(message)
     end
 
-    def build_event_hash(serialized_record)
+    def import_hash(record, serialized_record)
       {
-        id:         serialized_record.event_id,
+        event_id:   serialized_record.event_id,
         data:       serialized_record.data,
         metadata:   serialized_record.metadata,
-        event_type: serialized_record.event_type
+        event_type: serialized_record.event_type,
+        created_at: record.timestamp,
+        valid_at:   optimize_timestamp(record.valid_at, record.timestamp),
       }
     end
 
-    # Overwritten in a sub-class
-    def fill_ids(_in_stream)
+    def optimize_timestamp(valid_at, created_at)
+      valid_at unless valid_at.eql?(created_at)
     end
 
     def start_transaction(&block)
-      ActiveRecord::Base.transaction(requires_new: true, &block)
+      @event_klass.transaction(requires_new: true, &block)
     end
   end
 

data/lib/rails_event_store_active_record/event_repository_reader.rb

@@ -3,92 +3,169 @@
 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.exists?(id: event_id)
+      @event_klass.exists?(event_id: event_id)
     end
 
     def last_stream_event(stream)
-      record = EventInStream.where(stream: stream.name).order('position DESC, id DESC').first
-      record && build_serialized_record(record)
+      record_ = @stream_klass.where(stream: stream.name).order('position DESC, id DESC').first
+      record(record_) if record_
     end
 
     def read(spec)
-      raise RubyEventStore::ReservedInternalName if spec.stream.name.eql?(EventRepository::SERIALIZED_GLOBAL_STREAM_NAME)
-
       stream = read_scope(spec)
-
       if spec.batched?
-        batch_reader = ->(offset_id, limit) do
-          records = offset_id.nil? ? stream.limit(limit) : stream.where(start_offset_condition(spec, offset_id)).limit(limit)
-          [records.map(&method(:build_serialized_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
-        build_serialized_record(record) if record
+        record_ = stream.first
+        record(record_) if record_
       elsif spec.last?
-        record = stream.last
-        build_serialized_record(record) if record
+        record_ = stream.last
+        record(record_) if record_
       else
-        stream.map(&method(:build_serialized_record)).each
+        stream.map(&method(:record)).each
       end
     end
 
     def count(spec)
-      raise RubyEventStore::ReservedInternalName if spec.stream.name.eql?(EventRepository::SERIALIZED_GLOBAL_STREAM_NAME)
-
       read_scope(spec).count
     end
 
     private
+    attr_reader :serializer
+
+    def offset_limit_batch_reader(spec, stream)
+      batch_reader = ->(offset, limit) do
+        stream
+          .offset(offset)
+          .limit(limit)
+          .map(&method(:record))
+      end
+      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 = 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
+    end
 
     def read_scope(spec)
-      stream = EventInStream.preload(:event).where(stream: normalize_stream_name(spec))
-      stream = stream.where(event_id: spec.with_ids) if spec.with_ids?
-      stream = stream.joins(:event).where(event_store_events: {event_type: spec.with_types}) if spec.with_types?
-      stream = stream.order(position: order(spec)) unless spec.stream.global?
-      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.order(id: order(spec))
-      stream
+      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(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.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 normalize_stream_name(specification)
-      specification.stream.global? ? EventRepository::SERIALIZED_GLOBAL_STREAM_NAME : specification.stream.name
+    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)
-      condition = specification.forward? ? 'event_store_events_in_streams.id > ?' : 'event_store_events_in_streams.id < ?'
+    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)
-      condition = specification.forward? ? 'event_store_events_in_streams.id < ?' : 'event_store_events_in_streams.id > ?'
+    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,
-        EventInStream.find_by!(event_id: specification.start, stream: normalize_stream_name(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,
-        EventInStream.find_by!(event_id: specification.stop, stream: normalize_stream_name(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 build_serialized_record(record)
+    def record(record)
+      record = record.event if @stream_klass === record
+
       RubyEventStore::SerializedRecord.new(
-        event_id: record.event.id,
-        metadata: record.event.metadata,
-        data: record.event.data,
-        event_type: record.event.event_type
-      )
+        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

@@ -16,7 +16,7 @@ module RailsEventStoreActiveRecord
       :data_type,
       type: :string,
       default: 'binary',
-      desc: "Configure the data type for `data` and `meta data` feilds in Postgres migration (options: #{DATA_TYPES.join('/')})"
+      desc: "Configure the data type for `data` and `meta data` fields in Postgres migration (options: #{DATA_TYPES.join('/')})"
     )
 
     def initialize(*args)
@@ -37,12 +37,7 @@ module RailsEventStoreActiveRecord
       options.fetch('data_type')
     end
 
-    def rails_version
-      Rails::VERSION::STRING
-    end
-
     def migration_version
-      return nil if Gem::Version.new(rails_version) < Gem::Version.new("5.0.0")
       "[4.2]"
     end
 

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

@@ -4,8 +4,7 @@ class CreateEventStoreEvents < ActiveRecord::Migration<%= migration_version %>
   def change
     postgres = ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
     sqlite   = ActiveRecord::Base.connection.adapter_name == "SQLite"
-    rails_42 = Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("5.0.0")
-    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
@@ -14,32 +13,38 @@ class CreateEventStoreEvents < ActiveRecord::Migration<%= migration_version %>
       else
         t.references :event, null: false, type: :string, limit: 36
       end
-      t.datetime    :created_at,  null: false
+      if postgres
+        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
 
     if postgres
-      create_table(:event_store_events, id: :uuid, default: 'gen_random_uuid()', force: false) do |t|
+      create_table(:event_store_events, 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
     else
-      create_table(:event_store_events, id: false, force: false) do |t|
-        t.string :id, limit: 36, primary_key: true, null: false
+      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
-      end
-      if sqlite && rails_42
-        add_index :event_store_events, :id, unique: true
+        t.datetime    :created_at,  null: false, precision: 6
+        t.datetime    :valid_at,    null: true,  precision: 6
       end
     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,28 +2,43 @@
 
 module RailsEventStoreActiveRecord
   class IndexViolationDetector
-    MYSQL5_PKEY_ERROR   = "for key 'PRIMARY'".freeze
-    MYSQL8_PKEY_ERROR   = "for key 'event_store_events.PRIMARY'".freeze
-    POSTGRES_PKEY_ERROR = 'event_store_events_pkey'.freeze
-    SQLITE3_PKEY_ERROR  = 'event_store_events.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
-    POSTGRES_INDEX_ERROR = 'Key (stream, event_id)'.freeze
-    SQLITE3_INDEX_ERROR  = 'event_store_events_in_streams.stream, event_store_events_in_streams.event_id'.freeze
+    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)
-      message.include?(MYSQL5_PKEY_ERROR) ||
-        message.include?(MYSQL8_PKEY_ERROR) ||
-        message.include?(POSTGRES_PKEY_ERROR)  ||
-        message.include?(SQLITE3_PKEY_ERROR)   ||
-
-        message.include?(MYSQL5_INDEX_ERROR)    ||
-        message.include?(MYSQL8_INDEX_ERROR)    ||
-        message.include?(POSTGRES_INDEX_ERROR) ||
-        message.include?(SQLITE3_INDEX_ERROR)
+      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
+end

data/lib/rails_event_store_active_record/version.rb

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

data/lib/rails_event_store_active_record/with_abstract_base_class.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+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?
+      @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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_event_store_active_record
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Arkency
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2020-12-15 00:00:00.000000000 Z
+date: 2021-04-09 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: 1.3.0
+        version: 2.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: activemodel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: activerecord-import
   requirement: !ruby/object:Gem::Requirement
@@ -66,42 +52,36 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.2
-description: Implementation of events repository based on Rails Active Record for
-  Rails Event Store
-email:
-- dev@arkency.com
+description: |
+  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.
+email: dev@arkency.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
 files:
-- CHANGELOG.md
-- Gemfile
-- Makefile
 - README.md
-- bin/console
-- bin/setup
 - 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/binary_data_and_metadata_generator.rb
-- lib/rails_event_store_active_record/generators/index_by_event_type_generator.rb
-- lib/rails_event_store_active_record/generators/limit_for_event_id_generator.rb
 - lib/rails_event_store_active_record/generators/migration_generator.rb
-- lib/rails_event_store_active_record/generators/templates/binary_data_and_metadata_template.rb
 - lib/rails_event_store_active_record/generators/templates/create_event_store_events_template.rb
-- lib/rails_event_store_active_record/generators/templates/index_by_event_type_template.rb
-- lib/rails_event_store_active_record/generators/templates/limit_for_event_id_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
-- rails_event_store_active_record.gemspec
+- 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
 metadata:
-  homepage_uri: https://railseventstore.org/
+  homepage_uri: https://railseventstore.org
   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
@@ -113,7 +93,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -123,5 +103,5 @@ requirements: []
 rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
-summary: Active Record events repository for Rails Event Store
+summary: Persistent event repository implementation for RubyEventStore based on ActiveRecord
 test_files: []

data/CHANGELOG.md

@@ -1,75 +0,0 @@
-Further changes can be tracked at [releases page](https://github.com/RailsEventStore/rails_event_store/releases).
-
-### 0.6.14 (unreleased)
-
-* Run tests in random order
-
-### 0.6.13 (24.08.2017)
-
-* Fix: Generate migration with version number for Rails versions that support it. Fixes compatibility with Rails 5.1.
-
-### 0.6.12 (21.08.2017)
-
-* ruby_event_store updated to 0.14.0
-
-### 0.6.11 (8.02.2016)
-
-* Fix: Explicit order when querying forward. Leaving it implcit to database engine choice gives different results on different engines.
-
-### 0.6.10 (23.11.2016)
-
-* Change: requires update to allow void active_record dependency when using RailsEventStore without RailsEventStoreActiveRecord
-
-### 0.6.9 (18.10.2016)
-
-* ruby_event_store updated to 0.13.0
-
-### 0.6.8 (11.08.2016)
-
-* ruby_event_store updated to 0.12.1
-* make this gem mutant free - 100% mutation tests coverage
-
-### 0.6.7 (10.08.2016)
-
-* ruby_event_store updated to 0.12.0
-
-### 0.6.6 (12.07.2016)
-
-* ruby_event_store updated to 0.11.0
-
-### 0.6.5 (12.07.2016)
-
-* ruby_event_store updated to 0.10.1
-* Fix: fixed bug which have made repository unable to load a event with associated data or metadata. Tests for this bug were added in ruby_event_store 0.10.1
-
-### 0.6.4 (12.07.2016)
-
-* ruby_event_store updated to 0.10.0
-
-### 0.6.3 (24.06.2016)
-
-* Change: ruby_event_store updated to 0.9.0 (Call instead of handle_event)
-* Fix: Clarify Licensing information
-
-### 0.6.2 (21.06.2016)
-
-* ruby_event_store updated to 0.8.0
-
-### 0.6.1 (21.06.2016)
-
-* ruby_event_store updated to 0.7.0
-* add indexes for commonly searched fields: time and type to migration template PR #6
-
-### 0.6.0 (25.05.2016)
-
-* ruby_event_store updated to 0.6.0
-
-### 0.5.1 (11.04.2016)
-
-* Change: Rename migration generator from 'migrate' to 'migration' PR #3
-* Change: Allow to provide a custom event class #2
-
-
-### 0.5.0 (25.03.2016)
-
-* Code moved from RailsEventStore 0.5.0

data/Gemfile

@@ -1,18 +0,0 @@
-source 'https://rubygems.org'
-git_source(:github) { |repo| "https://github.com/#{repo}.git" }
-gemspec
-
-eval_gemfile File.expand_path('../support/bundler/Gemfile.shared', __dir__)
-
-gem 'ruby_event_store', path: '../ruby_event_store'
-gem 'pg', '1.2.2'
-gem 'mysql2', '0.5.3'
-gem 'fakefs', '~> 0.11.2'
-gem 'childprocess'
-gem 'rails', ENV['RAILS_VERSION']
-
-if Gem::Version.new(ENV['RAILS_VERSION']) >= Gem::Version.new('6.0.0')
-  gem 'sqlite3', '1.4.2'
-else
-  gem 'sqlite3', '1.3.13'
-end

data/Makefile

@@ -1,28 +0,0 @@
-GEM_VERSION  = $(shell cat ../RES_VERSION)
-GEM_NAME     = rails_event_store_active_record
-REQUIRE      = $(GEM_NAME)
-IGNORE       = RailsEventStoreActiveRecord::IndexViolationDetector\#detect \
-               RailsEventStoreActiveRecord::PgLinearizedEventRepository* \
-               RailsEventStoreActiveRecord::EventRepository\#update_messages
-SUBJECT      ?= RailsEventStoreActiveRecord*
-DATABASE_URL ?= sqlite3::memory:
-
-include ../support/make/install.mk
-include ../support/make/test.mk
-include ../support/make/mutant.mk
-include ../support/make/gem.mk
-include ../support/make/help.mk
-
-install: install-gemfiles
-
-remove-lock: remove-lockfiles
-
-install-gemfiles:
-	@BUNDLE_GEMFILE=../support/bundler/Gemfile.0_33_0 bundle check || BUNDLE_GEMFILE=../support/bundler/Gemfile.0_33_0 bundle install
-	@BUNDLE_GEMFILE=../support/bundler/Gemfile.0_34_0 bundle check || BUNDLE_GEMFILE=../support/bundler/Gemfile.0_34_0 bundle install
-	@BUNDLE_GEMFILE=../support/bundler/Gemfile.0_35_0 bundle check || BUNDLE_GEMFILE=../support/bundler/Gemfile.0_35_0 bundle install
-
-remove-lockfiles:
-	-rm ../support/bundler/Gemfile.0_33_0.lock
-	-rm ../support/bundler/Gemfile.0_34_0.lock
-	-rm ../support/bundler/Gemfile.0_35_0.lock

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "rails_event_store_active_record"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start

data/bin/setup

@@ -1,7 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-IFS=$'\n\t'
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/lib/rails_event_store_active_record/generators/binary_data_and_metadata_generator.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require 'rails/generators'
-rescue LoadError
-end
-
-module RailsEventStoreActiveRecord
-  class BinaryDataAndMetadataGenerator < Rails::Generators::Base
-    source_root File.expand_path(File.join(File.dirname(__FILE__), '../generators/templates'))
-
-    def create_migration
-      template "binary_data_and_metadata_template.rb", "db/migrate/#{timestamp}_binary_data_and_metadata.rb"
-    end
-
-    private
-
-    def rails_version
-      Rails::VERSION::STRING
-    end
-
-    def migration_version
-      return nil if Gem::Version.new(rails_version) < Gem::Version.new("5.0.0")
-      "[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/index_by_event_type_generator.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require 'rails/generators'
-rescue LoadError
-end
-
-module RailsEventStoreActiveRecord
-  class IndexByEventTypeGenerator < Rails::Generators::Base
-    source_root File.expand_path(File.join(File.dirname(__FILE__), '../generators/templates'))
-
-    def create_migration
-      template "index_by_event_type_template.rb", "db/migrate/#{timestamp}_index_by_event_type.rb"
-    end
-
-    private
-
-    def rails_version
-      Rails::VERSION::STRING
-    end
-
-    def migration_version
-      return nil if Gem::Version.new(rails_version) < Gem::Version.new("5.0.0")
-      "[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/limit_for_event_id_generator.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require 'rails/generators'
-rescue LoadError
-end
-
-module RailsEventStoreActiveRecord
-  class LimitForEventIdGenerator < Rails::Generators::Base
-    source_root File.expand_path(File.join(File.dirname(__FILE__), '../generators/templates'))
-
-    def create_migration
-      template "limit_for_event_id_template.rb", "db/migrate/#{timestamp}_limit_for_event_id.rb"
-    end
-
-    private
-
-    def rails_version
-      Rails::VERSION::STRING
-    end
-
-    def migration_version
-      return nil if Gem::Version.new(rails_version) < Gem::Version.new("5.0.0")
-      "[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/binary_data_and_metadata_template.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-class BinaryDataAndMetadata < ActiveRecord::Migration<%= migration_version %>
-  def change
-    rails_42 = Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("5.0.0")
-
-    case ActiveRecord::Base.connection.adapter_name
-    when "SQLite"
-      rename_table :event_store_events, :old_event_store_events
-      create_table(:event_store_events, id: false, force: false) do |t|
-        t.string :id, limit: 36, primary_key: true, null: false
-        t.string      :event_type,  null: false
-        t.binary      :metadata
-        t.binary      :data,        null: false
-        t.datetime    :created_at,  null: false
-      end
-      add_index :event_store_events, :id, unique: true if rails_42
-      add_index :event_store_events, :created_at
-      add_index :event_store_events, :event_type
-      execute <<-SQL
-        INSERT INTO event_store_events(id, event_type, metadata, data, created_at)
-        SELECT id, event_type, metadata, data, created_at FROM old_event_store_events;
-      SQL
-      drop_table :old_event_store_events
-    when "PostgreSQL"
-      execute <<-SQL
-        ALTER TABLE event_store_events ALTER COLUMN data     TYPE bytea USING convert_to(data,     'UTF8');
-        ALTER TABLE event_store_events ALTER COLUMN metadata TYPE bytea USING convert_to(metadata, 'UTF8');
-      SQL
-    else
-      change_column :event_store_events, :data,     :binary
-      change_column :event_store_events, :metadata, :binary
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-class IndexByEventType < ActiveRecord::Migration<%= migration_version %>
-  def change
-    add_index :event_store_events, :event_type unless index_exists? :event_store_events, :event_type
-  end
-end

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

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-class LimitForEventId < ActiveRecord::Migration<%= migration_version %>
-  def change
-    postgres = ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
-    change_column(:event_store_events_in_streams, :event_id, :string, limit: 36) unless postgres
-  end
-end

data/rails_event_store_active_record.gemspec

@@ -1,32 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'rails_event_store_active_record/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'rails_event_store_active_record'
-  spec.version       = RailsEventStoreActiveRecord::VERSION
-  spec.licenses      = ['MIT']
-  spec.authors       = ['Arkency']
-  spec.email         = ['dev@arkency.com']
-
-  spec.summary       = %q{Active Record events repository for Rails Event Store}
-  spec.description   = %q{Implementation of events repository based on Rails Active Record for Rails Event Store}
-  spec.homepage      = 'https://railseventstore.org'
-  spec.metadata    = {
-    "homepage_uri" => "https://railseventstore.org/",
-    "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",
-  }
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.add_dependency 'ruby_event_store', '= 1.3.0'
-  spec.add_dependency 'activesupport', '>= 3.0'
-  spec.add_dependency 'activemodel', '>= 3.0'
-  spec.add_dependency 'activerecord-import', '>= 1.0.2'
-end