rails_event_store_active_record 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47f9fb4041eeafab89312eabfbf9cada70da41480032fef06dcf3311f0e35d56
-  data.tar.gz: 79e021816506f4e49ff72e6f66f66820c9d588a30d1f3f8736d29cc478400340
+  metadata.gz: b146f907eef70a988c0949381dbf897a4f93bd7aa9e1ccf8346559c2656feb80
+  data.tar.gz: 46b6f4ce8d62b7386d72a1219a375e012bd3d15b33b16fe552cb8adee9f4f6e4
 SHA512:
-  metadata.gz: cfc072dd9e99031459dcc037cece006477f08c8b5ec014b592f579b3de403e57b7224a68691548b6e2e1b1d0d735aba841cb7a969f0d22916b8165360f4d64df
-  data.tar.gz: 440e6a1a06e37a05ec12590de43be4445314c8244d480f8a8a2ad261e5adcce05e5aa2115a9001011fcb063779ab6a74ff4e518dc0a463812bebe0eea67c50ff
+  metadata.gz: 0be237c7518c776a5ee19e8625f39966a20f255b0076839695957df0aa337c181bc7c85351afb2a1fbffdd6b0fd75fa50217482c30d1aa82437b242a32552e8d
+  data.tar.gz: 32aa1160ba4de4081357319e25012330249b6e946d0e0b558452fe41e7a30aa25e70d65faf9897ba6b7afac841c6b2ea6011117a892a272179da58b38a96bbb4

data/README.md

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

data/lib/rails_event_store_active_record/batch_enumerator.rb

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

data/lib/rails_event_store_active_record/event_repository.rb

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

data/lib/rails_event_store_active_record/event_repository_reader.rb

@@ -2,7 +2,6 @@
 
 module RailsEventStoreActiveRecord
   class EventRepositoryReader
-
     def initialize(event_klass, stream_klass, serializer)
       @event_klass = event_klass
       @stream_klass = stream_klass
@@ -38,9 +37,7 @@ module RailsEventStoreActiveRecord
     end
 
     def streams_of(event_id)
-      @stream_klass.where(event_id: event_id)
-        .pluck(:stream)
-        .map { |name| RubyEventStore::Stream.new(name) }
+      @stream_klass.where(event_id: event_id).pluck(:stream).map { |name| RubyEventStore::Stream.new(name) }
     end
 
     def position_in_stream(event_id, stream)
@@ -55,23 +52,28 @@ module RailsEventStoreActiveRecord
       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) do
-        stream
-          .offset(offset)
-          .limit(limit)
-          .map(&method(:record))
-      end
+      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 = offset_id.nil? ? stream.limit(limit) : stream.where(start_offset_condition(spec, offset_id, search_in)).limit(limit)
+        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
@@ -80,29 +82,29 @@ module RailsEventStoreActiveRecord
     def read_scope(spec)
       if spec.stream.global?
         stream = @event_klass
-        stream = stream.where(event_id: spec.with_ids)                           if spec.with_ids?
-        stream = stream.where(event_type: spec.with_types)                       if spec.with_types?
+        stream = stream.where(event_id: spec.with_ids) if spec.with_ids?
+        stream = stream.where(event_type: spec.with_types) if spec.with_types?
         stream = ordered(stream, spec)
-        stream = stream.limit(spec.limit)                                        if spec.limit?
-        stream = stream.where(start_condition_in_global_stream(spec))            if spec.start
-        stream = stream.where(stop_condition_in_global_stream(spec))             if spec.stop
-        stream = stream.where(older_than_condition(spec))          if spec.older_than
+        stream = stream.limit(spec.limit) if spec.limit?
+        stream = stream.where(start_condition_in_global_stream(spec)) if spec.start
+        stream = stream.where(stop_condition_in_global_stream(spec)) if spec.stop
+        stream = stream.where(older_than_condition(spec)) if spec.older_than
         stream = stream.where(older_than_or_equal_condition(spec)) if spec.older_than_or_equal
-        stream = stream.where(newer_than_condition(spec))          if spec.newer_than
+        stream = stream.where(newer_than_condition(spec)) if spec.newer_than
         stream = stream.where(newer_than_or_equal_condition(spec)) if spec.newer_than_or_equal
         stream.order(id: order(spec))
       else
         stream = @stream_klass.preload(:event).where(stream: spec.stream.name)
-        stream = stream.where(event_id: spec.with_ids)                                                if spec.with_ids?
-        stream = stream.where(@event_klass.table_name => {event_type: spec.with_types}) if spec.with_types?
+        stream = stream.where(event_id: spec.with_ids) if spec.with_ids?
+        stream = stream.where(@event_klass.table_name => { event_type: spec.with_types }) if spec.with_types?
         stream = ordered(stream.joins(:event), spec)
         stream = stream.order(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.limit(spec.limit) if spec.limit?
+        stream = stream.where(start_condition(spec)) if spec.start
+        stream = stream.where(stop_condition(spec)) if spec.stop
+        stream = stream.where(older_than_condition(spec)) if spec.older_than
         stream = stream.where(older_than_or_equal_condition(spec)) if spec.older_than_or_equal
-        stream = stream.where(newer_than_condition(spec))          if spec.newer_than
+        stream = stream.where(newer_than_condition(spec)) if spec.newer_than
         stream = stream.where(newer_than_or_equal_condition(spec)) if spec.newer_than_or_equal
         stream
       end
@@ -120,37 +122,41 @@ module RailsEventStoreActiveRecord
     end
 
     def start_offset_condition(specification, record_id, search_in)
-      condition = "#{search_in}.id #{specification.forward? ? '>' : '<'} ?"
+      condition = "#{search_in}.id #{specification.forward? ? ">" : "<"} ?"
       [condition, record_id]
     end
 
     def stop_offset_condition(specification, record_id, search_in)
-      condition = "#{search_in}.id #{specification.forward? ? '<' : '>'} ?"
+      condition = "#{search_in}.id #{specification.forward? ? "<" : ">"} ?"
       [condition, record_id]
     end
 
     def start_condition(specification)
-      start_offset_condition(specification,
+      start_offset_condition(
+        specification,
         @stream_klass.find_by!(event_id: specification.start, stream: specification.stream.name),
-        @stream_klass.table_name)
+        @stream_klass.table_name
+      )
     end
 
     def stop_condition(specification)
-      stop_offset_condition(specification,
+      stop_offset_condition(
+        specification,
         @stream_klass.find_by!(event_id: specification.stop, stream: specification.stream.name),
-        @stream_klass.table_name)
+        @stream_klass.table_name
+      )
     end
 
     def start_condition_in_global_stream(specification)
-      start_offset_condition(specification,
+      start_offset_condition(
+        specification,
         @event_klass.find_by!(event_id: specification.start),
-        @event_klass.table_name)
+        @event_klass.table_name
+      )
     end
 
     def stop_condition_in_global_stream(specification)
-      stop_offset_condition(specification,
-        @event_klass.find_by!(event_id: specification.stop),
-        @event_klass.table_name)
+      stop_offset_condition(specification, @event_klass.find_by!(event_id: specification.stop), @event_klass.table_name)
     end
 
     def older_than_condition(specification)
@@ -176,14 +182,16 @@ module RailsEventStoreActiveRecord
     def record(record)
       record = record.event if @stream_klass === record
 
-      RubyEventStore::SerializedRecord.new(
-        event_id: record.event_id,
-        metadata: record.metadata,
-        data: record.data,
-        event_type: record.event_type,
-        timestamp: record.created_at.iso8601(RubyEventStore::TIMESTAMP_PRECISION),
-        valid_at: (record.valid_at || record.created_at).iso8601(RubyEventStore::TIMESTAMP_PRECISION),
-      ).deserialize(serializer)
+      RubyEventStore::SerializedRecord
+        .new(
+          event_id: record.event_id,
+          metadata: record.metadata,
+          data: record.data,
+          event_type: record.event_type,
+          timestamp: record.created_at.iso8601(RubyEventStore::TIMESTAMP_PRECISION),
+          valid_at: (record.valid_at || record.created_at).iso8601(RubyEventStore::TIMESTAMP_PRECISION)
+        )
+        .deserialize(serializer)
     end
   end
 

data/lib/rails_event_store_active_record/generators/migration_generator.rb

@@ -7,16 +7,18 @@ end
 
 module RailsEventStoreActiveRecord
   class MigrationGenerator < Rails::Generators::Base
-    class Error < Thor::Error; end
+    class Error < Thor::Error
+    end
 
-    DATA_TYPES = %w(binary json jsonb).freeze
+    DATA_TYPES = %w[binary json jsonb].freeze
 
     source_root File.expand_path(File.join(File.dirname(__FILE__), "../generators/templates"))
     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('/')})"
+      desc:
+        "Configure the data type for `data` and `meta data` fields in Postgres migration (options: #{DATA_TYPES.join("/")})"
     )
 
     def initialize(*args)
@@ -45,4 +47,4 @@ module RailsEventStoreActiveRecord
       Time.now.strftime("%Y%m%d%H%M%S")
     end
   end
-end if defined?(Rails::Generators::Base)
+end if defined?(Rails::Generators::Base)

data/lib/rails_event_store_active_record/index_violation_detector.rb

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

data/lib/rails_event_store_active_record/pg_linearized_event_repository.rb

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

data/lib/rails_event_store_active_record/version.rb

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

data/lib/rails_event_store_active_record/with_abstract_base_class.rb

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

metadata

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