ruby_event_store-active_record 2.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: da1ae3857e3ed938eedebac46e1a2ca4e8fc89be6e424f9614e29300430e8278
+  data.tar.gz: 43f039fc3434fc542918682e788acbeb497a219f845da9d149ed041a06d021c0
+SHA512:
+  metadata.gz: f1a893454a79f7fb541a96fb12b5fc7d41d9aaa2ac29a8d6d23a6e128dcd349a75c387135774eee641d0e879d5124c092217f6e0e8ff1bffbf4eaf9485ccb5a6
+  data.tar.gz: 5b3a9ad5d24bff351eb8b0ae651b3d68bfc9ab5dd15fe5da2be79ed8c4aabca165cc2807f1bf1b75a6253c17287c342c820ac6d95e94bcbec23add6d2c77fa7e

data/README.md

@@ -0,0 +1,7 @@
+# RubyEventStore::ActiveRecord
+
+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.rb

@@ -0,0 +1,3 @@
+require "ruby_event_store/active_record"
+
+RailsEventStoreActiveRecord = RubyEventStore::ActiveRecord

data/lib/ruby_event_store/active_record/batch_enumerator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module ActiveRecord
+    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
+end

data/lib/ruby_event_store/active_record/event.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module RubyEventStore
+  module ActiveRecord
+    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
+end

data/lib/ruby_event_store/active_record/event_repository.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array"
+
+module RubyEventStore
+  module ActiveRecord
+    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 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 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 EventDuplicatedInStream if detect_index_violated(e.message)
+        raise 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
+end

data/lib/ruby_event_store/active_record/event_repository_reader.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module ActiveRecord
+    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| 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 EventNotFoundInStream if record.nil?
+        record.position
+      end
+
+      def global_position(event_id)
+        record = @event_klass.select("id").find_by(event_id: event_id)
+        raise 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
+
+        SerializedRecord
+          .new(
+            event_id: record.event_id,
+            metadata: record.metadata,
+            data: record.data,
+            event_type: record.event_type,
+            timestamp: record.created_at.iso8601(TIMESTAMP_PRECISION),
+            valid_at: (record.valid_at || record.created_at).iso8601(TIMESTAMP_PRECISION)
+          )
+          .deserialize(serializer)
+      end
+    end
+
+    private_constant(:EventRepositoryReader)
+  end
+end

data/lib/ruby_event_store/active_record/generators/migration_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require "erb"
+
+module RubyEventStore
+  module ActiveRecord
+    class MigrationGenerator
+      DATA_TYPES = %w[binary json jsonb].freeze
+
+      def call(data_type, migration_path)
+        raise ArgumentError, "Invalid value for data type. Supported for options are: #{DATA_TYPES.join(", ")}." unless DATA_TYPES.include?(data_type)
+
+        migration_code = migration_code(data_type)
+        path = build_path(migration_path)
+        write_to_file(migration_code, path)
+        path
+      end
+
+      private
+
+      def absolute_path(path)
+        File.expand_path(path, __dir__)
+      end
+
+      def migration_code(data_type)
+        migration_template(absolute_path("./templates"), "create_event_store_events").result_with_hash(migration_version: migration_version, data_type: data_type)
+      end
+
+      def migration_template(template_root, name)
+        ERB.new(File.read(File.join(template_root, "#{name}_template.erb")))
+      end
+
+      def migration_version
+        "[4.2]"
+      end
+
+      def timestamp
+        Time.now.strftime("%Y%m%d%H%M%S")
+      end
+
+      def write_to_file(migration_code, path)
+        File.write(path, migration_code)
+      end
+
+      def build_path(migration_path)
+        File.join( "#{migration_path}", "#{timestamp}_create_event_store_events.rb")
+      end
+    end
+  end
+end

data/lib/ruby_event_store/active_record/generators/rails_migration_generator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+begin
+  require "rails/generators"
+rescue LoadError
+end
+
+module RubyEventStore
+  module ActiveRecord
+    class RailsMigrationGenerator < Rails::Generators::Base
+      class Error < Thor::Error
+      end
+
+      DATA_TYPES = %w[binary json jsonb].freeze
+
+      namespace "rails_event_store_active_record:migration"
+
+      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.erb", "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
+end if defined?(Rails::Generators::Base)

data/lib/ruby_event_store/active_record/generators/templates/create_event_store_events_template.erb

@@ -0,0 +1,55 @@
+# 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/ruby_event_store/active_record/index_violation_detector.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module ActiveRecord
+    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
+end

data/lib/ruby_event_store/active_record/pg_linearized_event_repository.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module ActiveRecord
+    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
+end

data/lib/ruby_event_store/active_record/railtie.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module ActiveRecord
+    Railtie = Class.new(::Rails::Railtie)
+  end
+end

data/lib/ruby_event_store/active_record/rake_task.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "ruby_event_store/active_record"
+require "active_record"
+load "ruby_event_store/active_record/tasks/migration_tasks.rake"
+
+include ActiveRecord::Tasks
+
+db_dir = ENV["DATABASE_DIR"] || './db'
+
+task :environment do
+  connection = ActiveRecord::Base.establish_connection(ENV["DATABASE_URL"])
+  DatabaseTasks.env = connection.db_config.env_name
+  DatabaseTasks.db_dir = db_dir
+  DatabaseTasks.migrations_paths = ENV["MIGRATIONS_PATH"] || File.join(db_dir, 'migrate')
+end
+
+load 'active_record/railties/databases.rake'

data/lib/ruby_event_store/active_record/tasks/migration_tasks.rake

@@ -0,0 +1,12 @@
+require_relative "../generators/migration_generator"
+
+desc "Generate migration"
+task "db:migrations:copy" do
+  data_type = ENV["DATA_TYPE"] || raise("Specify data type (binary, json, jsonb): rake db:migrations:copy DATA_TYPE=json")
+
+  path = RubyEventStore::ActiveRecord::MigrationGenerator
+           .new
+           .call(data_type, ENV["MIGRATION_PATH"] || "db/migrate")
+
+  puts "Migration file created #{path}"
+end

data/lib/ruby_event_store/active_record/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module ActiveRecord
+    VERSION = "2.7.0"
+  end
+end

data/lib/ruby_event_store/active_record/with_abstract_base_class.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module ActiveRecord
+    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
+end

data/lib/ruby_event_store/active_record/with_default_models.rb

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

data/lib/ruby_event_store/active_record.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "active_record/generators/migration_generator"
+require_relative "active_record/generators/rails_migration_generator"
+require_relative "active_record/event"
+require_relative "active_record/with_default_models"
+require_relative "active_record/with_abstract_base_class"
+require_relative "active_record/event_repository"
+require_relative "active_record/batch_enumerator"
+require_relative "active_record/event_repository_reader"
+require_relative "active_record/index_violation_detector"
+require_relative "active_record/pg_linearized_event_repository"
+require_relative "active_record/version"
+require_relative "active_record/railtie" if defined?(Rails::Engine)

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: ruby_event_store-active_record
+version: !ruby/object:Gem::Version
+  version: 2.7.0
+platform: ruby
+authors:
+- Arkency
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby_event_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.7.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'
+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:
+- README.md
+files:
+- README.md
+- lib/rails_event_store_active_record.rb
+- lib/ruby_event_store/active_record.rb
+- lib/ruby_event_store/active_record/batch_enumerator.rb
+- lib/ruby_event_store/active_record/event.rb
+- lib/ruby_event_store/active_record/event_repository.rb
+- lib/ruby_event_store/active_record/event_repository_reader.rb
+- lib/ruby_event_store/active_record/generators/migration_generator.rb
+- lib/ruby_event_store/active_record/generators/rails_migration_generator.rb
+- lib/ruby_event_store/active_record/generators/templates/create_event_store_events_template.erb
+- lib/ruby_event_store/active_record/index_violation_detector.rb
+- lib/ruby_event_store/active_record/pg_linearized_event_repository.rb
+- lib/ruby_event_store/active_record/railtie.rb
+- lib/ruby_event_store/active_record/rake_task.rb
+- lib/ruby_event_store/active_record/tasks/migration_tasks.rake
+- lib/ruby_event_store/active_record/version.rb
+- lib/ruby_event_store/active_record/with_abstract_base_class.rb
+- lib/ruby_event_store/active_record/with_default_models.rb
+homepage: https://railseventstore.org
+licenses:
+- MIT
+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
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Persistent event repository implementation for RubyEventStore based on ActiveRecord
+test_files: []