ruby_event_store-sequel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea243993dea1905cfb81d7a15462ae7e46afdd072d81048bef2fa480cede1dda
+  data.tar.gz: b736b5c5b52a6e404a48d9faf5a348e69482ece6044402d21999b9a70d2f9252
+SHA512:
+  metadata.gz: a6765b5af6ee1bdf081285203ddfa6010e2ef510199b076add7fadbc8ec64713318af0cf822d270a6953cc5562a80082a453f8b86b2537cf2e0e3127f1837dfd
+  data.tar.gz: 40cd9e30fa7bb9390171efb3f2f53a39b62d087469e5cd842f004b1eb71cd3f497c0cc982975c33d1ecc4a0d2feb2ebebc75999aa14097614042b350d7ff4279

data/README.md

@@ -0,0 +1,7 @@
+# RubyEventStore Sequel Event Repository
+
+![RubyEventStore Sequel Event Repository](https://github.com/RailsEventStore/rails_event_store/workflows/ruby_event_store-sequel/badge.svg)
+
+A [sequel](https://sequel.jeremyevans.net) based implementation of events repository for [Ruby Event Store](https://github.com/RailsEventStore/rails_event_store). It is an alternative to the ActiveRecord `EventRepository` implementation used in `rails_event_store` gem.
+
+[Read the docs to get started.](http://railseventstore.org/docs/repository/)

data/lib/ruby_event_store/generators/templates/1_create_ruby_event_store_tables.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+::Sequel.migration do
+  up do
+    ENV["DATA_TYPE"] ||= "text"
+    data_type = ENV["DATA_TYPE"].to_sym
+    data_types = %i[text]
+    raise ArgumentError, "DATA_TYPE must be: #{data_types.join(", ")}" unless data_types.include?(data_type)
+
+    create_table :event_store_events_in_streams do
+      primary_key :id, type: :Bignum, null: false
+
+      column :stream, String, null: false
+      column :position, Integer
+      column :event_id, String, size: 36, null: false
+      column :created_at, Time, null: false, index: "index_event_store_events_in_streams_on_created_at"
+
+      index %i[stream position], unique: true, name: "index_event_store_events_in_streams_on_stream_and_position"
+      index %i[stream event_id], unique: true, name: "index_event_store_events_in_streams_on_stream_and_event_id"
+    end
+
+    create_table :event_store_events do
+      primary_key :id, type: :Bignum, null: false
+
+      column :event_id, String, size: 36, null: false
+      column :event_type, String, null: false
+      column :metadata, String, text: true
+      column :data, String, text: true, null: false
+      column :created_at, Time, null: false, index: "index_event_store_events_on_created_at"
+      column :valid_at, Time, index: "index_event_store_events_on_valid_at"
+
+      index :event_id, unique: true, name: "index_event_store_events_on_event_id"
+    end
+  end
+
+  down do
+    drop_table :event_store_events
+    drop_table :event_store_events_in_streams
+  end
+end

data/lib/ruby_event_store/generators/templates/mysql/1_create_ruby_event_store_tables.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+::Sequel.migration do
+  up do
+    ENV["DATA_TYPE"] ||= "text"
+    data_type = ENV["DATA_TYPE"].to_sym
+    data_types = %i[text]
+    raise ArgumentError, "DATA_TYPE must be: #{data_types.join(", ")}" unless data_types.include?(data_type)
+
+    create_table :event_store_events_in_streams do
+      primary_key :id, type: :Bignum, null: false
+
+      column :stream, String, null: false
+      column :position, Integer
+      column :event_id, String, size: 36, null: false
+      column :created_at,
+             Time,
+             null: false,
+             type: "DATETIME(6)",
+             index: "index_event_store_events_in_streams_on_created_at"
+
+      index %i[stream position], unique: true, name: "index_event_store_events_in_streams_on_stream_and_position"
+      index %i[stream event_id], unique: true, name: "index_event_store_events_in_streams_on_stream_and_event_id"
+    end
+
+    create_table :event_store_events do
+      primary_key :id, type: :Bignum, null: false
+
+      column :event_id, String, size: 36, null: false
+      column :event_type, String, null: false
+      column :metadata, String, text: true
+      column :data, String, text: true, null: false
+      column :created_at, Time, null: false, type: "DATETIME(6)", index: "index_event_store_events_on_created_at"
+      column :valid_at, Time, type: "DATETIME(6)", index: "index_event_store_events_on_valid_at"
+
+      index :event_id, unique: true, name: "index_event_store_events_on_event_id"
+    end
+  end
+
+  down do
+    drop_table :event_store_events
+    drop_table :event_store_events_in_streams
+  end
+end

data/lib/ruby_event_store/generators/templates/postgres/1_create_ruby_event_store_tables.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+::Sequel.migration do
+  up do
+    ENV["DATA_TYPE"] ||= "text"
+    data_type = ENV["DATA_TYPE"].to_sym
+    data_types = %i[text json jsonb]
+    raise ArgumentError, "DATA_TYPE must be: #{data_types.join(", ")}" unless data_types.include?(data_type)
+
+    create_table :event_store_events_in_streams do
+      primary_key :id, type: :Bignum, null: false
+
+      column :stream, String, null: false
+      column :position, Integer
+      column :event_id, String, null: false
+      column :created_at,
+             Time,
+             null: false,
+             type: "TIMESTAMP",
+             index: "index_event_store_events_in_streams_on_created_at"
+
+      index %i[stream position], unique: true, name: "index_event_store_events_in_streams_on_stream_and_position"
+      index %i[stream event_id], unique: true, name: "index_event_store_events_in_streams_on_stream_and_event_id"
+    end
+
+    create_table :event_store_events do
+      primary_key :id, type: :Bignum, null: false
+
+      column :event_id, String, null: false
+      column :event_type, String, null: false
+      column :metadata, data_type
+      column :data, data_type, null: false
+      column :created_at, Time, null: false, type: "TIMESTAMP", index: "index_event_store_events_on_created_at"
+      column :valid_at, Time, type: "TIMESTAMP", index: "index_event_store_events_on_valid_at"
+
+      index :event_id, unique: true, name: "index_event_store_events_on_event_id"
+    end
+  end
+
+  down do
+    drop_table :event_store_events
+    drop_table :event_store_events_in_streams
+  end
+end

data/lib/ruby_event_store/sequel/event_repository.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Sequel
+    class EventRepository
+      UPSERT_COLUMNS = %i[event_type data metadata valid_at].freeze
+
+      def initialize(sequel:, serializer:)
+        @serializer = serializer
+        @index_violation_detector = IndexViolationDetector.new("event_store_events", "event_store_events_in_streams")
+        @db = sequel
+        @db.timezone = :utc
+      end
+
+      attr_reader :index_violation_detector
+
+      def append_to_stream(records, stream, expected_version)
+        resolved_version = resolved_version(expected_version, stream)
+
+        @db.transaction do
+          records.map.with_index do |record, index|
+            serialized_record = record.serialize(@serializer)
+
+            @db[:event_store_events].insert(
+              event_id: serialized_record.event_id,
+              event_type: serialized_record.event_type,
+              data: serialized_record.data,
+              metadata: serialized_record.metadata,
+              created_at: record.timestamp,
+              valid_at: optimize_timestamp(record.valid_at, record.timestamp),
+            )
+            unless stream.global?
+              @db[:event_store_events_in_streams].insert(
+                event_id: serialized_record.event_id,
+                stream: stream.name,
+                created_at: Time.now.utc,
+                position: resolved_version ? resolved_version + index + 1 : nil,
+              )
+            end
+          end
+        end
+        self
+      rescue ::Sequel::UniqueConstraintViolation => ex
+        raise EventDuplicatedInStream if index_violation_detector.detect(ex.message)
+        raise WrongExpectedEventVersion
+      end
+
+      def link_to_stream(event_ids, stream, expected_version)
+        (
+          event_ids -
+            @db[:event_store_events]
+              .select(::Sequel[:event_store_events][:event_id])
+              .where(::Sequel[:event_store_events][:event_id] => event_ids)
+              .map { |e| e[:event_id] }
+        ).each { |id| raise EventNotFound.new(id) }
+
+        resolved_version = resolved_version(expected_version, stream)
+
+        @db.transaction do
+          event_ids.map.with_index do |event_id, index|
+            @db[:event_store_events_in_streams].insert(
+              event_id: event_id,
+              stream: stream.name,
+              created_at: Time.now.utc,
+              position: resolved_version ? resolved_version + index + 1 : nil,
+            )
+          end
+        end
+        self
+      rescue ::Sequel::UniqueConstraintViolation => ex
+        raise EventDuplicatedInStream if index_violation_detector.detect(ex.message)
+        raise WrongExpectedEventVersion
+      end
+
+      def position_in_stream(event_id, stream)
+        record =
+          @db[:event_store_events_in_streams]
+            .select(::Sequel[:event_store_events_in_streams][:position])
+            .where(
+              ::Sequel[:event_store_events_in_streams][:event_id] => event_id,
+              ::Sequel[:event_store_events_in_streams][:stream] => stream.name,
+            )
+            .first
+        raise EventNotFoundInStream.new if record.nil?
+        record[:position]
+      end
+
+      def global_position(event_id)
+        record =
+          @db[:event_store_events]
+            .select(::Sequel[:event_store_events][:id])
+            .where(::Sequel[:event_store_events][:event_id] => event_id)
+            .first
+        raise EventNotFound.new(event_id) if record.nil?
+        record[:id] - 1
+      end
+
+      def event_in_stream?(event_id, stream)
+        @db[:event_store_events_in_streams].where(event_id: event_id, stream: stream.name).any?
+      end
+
+      def delete_stream(stream)
+        @db[:event_store_events_in_streams].where(stream: stream.name).delete
+      end
+
+      def has_event?(event_id)
+        @db[:event_store_events].where(event_id: event_id).any?
+      end
+
+      def last_stream_event(stream)
+        row = @db[:event_store_events_in_streams].where(stream: stream.name).order(:position, :id).last
+        return row if row.nil?
+        event = @db[:event_store_events].where(event_id: row[:event_id]).first
+        SerializedRecord.new(
+          event_id: event[:event_id],
+          event_type: event[:event_type],
+          data: event[:data],
+          metadata: event[:metadata],
+          timestamp: event[:created_at].iso8601(TIMESTAMP_PRECISION),
+          valid_at: (event[:valid_at] || event[:created_at]).iso8601(TIMESTAMP_PRECISION),
+        ).deserialize(@serializer)
+      end
+
+      def read(specification)
+        if specification.batched?
+          stream = read_(specification)
+          batch_reader = ->(offset, limit) { stream.offset(offset).limit(limit).map(&method(:record)) }
+          RubyEventStore::BatchEnumerator.new(specification.batch_size, specification.limit, batch_reader).each
+        elsif specification.first?
+          record_ = read_(specification).first
+          record(record_) if record_
+        elsif specification.last?
+          record_ = read_(specification).last
+          record(record_) if record_
+        else
+          read_(specification).map { |h| record(h) }.each
+        end
+      end
+
+      def count(specification)
+        read_(specification).count
+      end
+
+      def update_messages(records)
+        hashes = records.map { |record| upsert_hash(record, record.serialize(@serializer)) }
+        for_update = records.map(&:event_id)
+        @db.transaction do
+          existing =
+            @db[:event_store_events]
+              .where(event_id: for_update)
+              .select(:event_id, :id, :created_at, :valid_at)
+              .reduce({}) do |acc, record|
+                acc.merge(record[:event_id] => [record[:id], record[:created_at], record[:valid_at]])
+              end
+
+          (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)
+            h[:valid_at] = existing.fetch(h.fetch(:event_id)).at(2)
+          end
+
+          if supports_on_duplicate_key_update?
+            commit_on_duplicate_key_update(hashes)
+          else
+            commit_insert_conflict_update(hashes)
+          end
+        end
+      end
+
+      def streams_of(event_id)
+        @db[:event_store_events_in_streams].where(event_id: event_id).map { |h| Stream.new(h[:stream]) }
+      end
+
+      private
+
+      def optimize_timestamp(valid_at, created_at)
+        valid_at unless valid_at.eql?(created_at)
+      end
+
+      def record(h)
+        SerializedRecord.new(
+          event_id: h[:event_id],
+          event_type: h[:event_type],
+          data: h[:data],
+          metadata: h[:metadata],
+          timestamp: h[:created_at].iso8601(TIMESTAMP_PRECISION),
+          valid_at: (h[:valid_at].nil? ? h[:created_at] : h[:valid_at]).iso8601(TIMESTAMP_PRECISION),
+        ).deserialize(@serializer)
+      end
+
+      def read_(specification)
+        specification.stream.global? ? read_from_global_stream(specification) : read_from_specific_stream(specification)
+      end
+
+      def resolved_version(expected_version, stream)
+        expected_version.resolve_for(
+          stream,
+          ->(stream) do
+            @db[:event_store_events_in_streams]
+              .select(:position)
+              .where(stream: stream.name)
+              .order(:position)
+              .last
+              &.fetch(:position)
+          end,
+        )
+      end
+
+      def read_from_specific_stream(specification)
+        dataset =
+          @db[:event_store_events]
+            .join(:event_store_events_in_streams, event_id: :event_id)
+            .select(
+              ::Sequel[:event_store_events][:event_id],
+              :event_type,
+              :data,
+              :metadata,
+              ::Sequel[:event_store_events][:created_at],
+              :valid_at,
+            )
+            .where(stream: specification.stream.name)
+            .order(::Sequel[:event_store_events_in_streams][:id])
+
+        dataset = dataset.where(event_type: specification.with_types) if specification.with_types?
+        dataset =
+          dataset.where(::Sequel[:event_store_events][:event_id] => specification.with_ids) if specification.with_ids?
+
+        if specification.start
+          condition = "event_store_events_in_streams.id #{specification.forward? ? ">" : "<"} ?"
+          dataset =
+            dataset.where(
+              ::Sequel.lit(condition, find_event_id_in_stream(specification.start, specification.stream.name)),
+            )
+        end
+
+        if specification.stop
+          condition = "event_store_events_in_streams.id #{specification.forward? ? "<" : ">"} ?"
+          dataset =
+            dataset.where(
+              ::Sequel.lit(condition, find_event_id_in_stream(specification.stop, specification.stream.name)),
+            )
+        end
+
+        if specification.older_than
+          dataset = dataset.where(::Sequel.lit("#{time_comparison_field(specification)} < ?", specification.older_than))
+        end
+
+        if specification.older_than_or_equal
+          dataset =
+            dataset.where(
+              ::Sequel.lit("#{time_comparison_field(specification)} <= ?", specification.older_than_or_equal),
+            )
+        end
+
+        if specification.newer_than
+          dataset = dataset.where(::Sequel.lit("#{time_comparison_field(specification)} > ?", specification.newer_than))
+        end
+
+        if specification.newer_than_or_equal
+          dataset =
+            dataset.where(
+              ::Sequel.lit("#{time_comparison_field(specification)} >= ?", specification.newer_than_or_equal),
+            )
+        end
+
+        dataset = dataset.order(::Sequel[:event_store_events][:created_at]) if specification.time_sort_by_as_at?
+        dataset = dataset.order(::Sequel.lit(coalesced_date)) if specification.time_sort_by_as_of?
+        dataset = dataset.limit(specification.limit) if specification.limit?
+        dataset = dataset.order(::Sequel[:event_store_events_in_streams][:id]).reverse if specification.backward?
+
+        dataset
+      end
+
+      def find_event_id_in_stream(specification_event_id, specification_stream_name)
+        event =
+          @db[:event_store_events_in_streams]
+            .select(:id)
+            .where(event_id: specification_event_id, stream: specification_stream_name)
+            .first
+        raise EventNotFound.new(specification_event_id) unless event
+
+        event[:id]
+      end
+
+      def find_event_id_globally(specification_event_id)
+        event = @db[:event_store_events].select(:id).where(event_id: specification_event_id).first
+        raise EventNotFound.new(specification_event_id) unless event
+
+        event[:id]
+      end
+
+      def read_from_global_stream(specification)
+        dataset =
+          @db[:event_store_events].select(
+            ::Sequel[:event_store_events][:event_id],
+            ::Sequel[:event_store_events][:event_type],
+            ::Sequel[:event_store_events][:data],
+            ::Sequel[:event_store_events][:metadata],
+            ::Sequel[:event_store_events][:created_at],
+            ::Sequel[:event_store_events][:valid_at],
+          ).order(:id)
+
+        dataset = dataset.where(event_type: specification.with_types) if specification.with_types?
+        dataset = dataset.where(event_id: specification.with_ids) if specification.with_ids?
+
+        if specification.start
+          id = find_event_id_globally(specification.start)
+          condition = "event_store_events.id #{specification.forward? ? ">" : "<"} ?"
+
+          dataset = dataset.where(::Sequel.lit(condition, id))
+        end
+
+        if specification.stop
+          id = find_event_id_globally(specification.stop)
+          condition = "event_store_events.id #{specification.forward? ? "<" : ">"} ?"
+
+          dataset = dataset.where(::Sequel.lit(condition, id))
+        end
+
+        if specification.older_than
+          dataset = dataset.where(::Sequel.lit("#{time_comparison_field(specification)} < ?", specification.older_than))
+        end
+
+        if specification.older_than_or_equal
+          dataset =
+            dataset.where(
+              ::Sequel.lit("#{time_comparison_field(specification)} <= ?", specification.older_than_or_equal),
+            )
+        end
+
+        if specification.newer_than
+          dataset = dataset.where(::Sequel.lit("#{time_comparison_field(specification)} > ?", specification.newer_than))
+        end
+
+        if specification.newer_than_or_equal
+          dataset =
+            dataset.where(
+              ::Sequel.lit("#{time_comparison_field(specification)} >= ?", specification.newer_than_or_equal),
+            )
+        end
+
+        dataset = dataset.order(::Sequel[:event_store_events][:created_at]) if specification.time_sort_by_as_at?
+        dataset = dataset.order(::Sequel.lit(coalesced_date)) if specification.time_sort_by_as_of?
+        dataset = dataset.limit(specification.limit) if specification.limit?
+        dataset = dataset.order(::Sequel[:event_store_events][:id]) unless specification.time_sort_by
+        dataset = dataset.reverse if specification.backward?
+
+        dataset
+      end
+
+      def coalesced_date
+        "COALESCE(event_store_events.valid_at, event_store_events.created_at)"
+      end
+
+      def time_comparison_field(specification)
+        specification.time_sort_by_as_of? ? coalesced_date : "event_store_events.created_at"
+      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 supports_on_duplicate_key_update?
+        @db.adapter_scheme =~ /mysql/
+      end
+
+      def commit_on_duplicate_key_update(hashes)
+        @db[:event_store_events].on_duplicate_key_update(*UPSERT_COLUMNS).multi_insert(hashes)
+      end
+
+      def commit_insert_conflict_update(hashes)
+        @db[:event_store_events].insert_conflict(
+          target: :event_id,
+          update: UPSERT_COLUMNS.each_with_object({}) { |column, memo| memo[column] = ::Sequel[:excluded][column] },
+        ).multi_insert(hashes)
+      end
+    end
+  end
+end

data/lib/ruby_event_store/sequel/index_violation_detector.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Sequel
+    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/sequel/version.rb

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

data/lib/ruby_event_store/sequel.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "ruby_event_store"
+require "sequel"
+
+require_relative "sequel/index_violation_detector"
+require_relative "sequel/event_repository"

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: ruby_event_store-sequel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Arkency
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: ruby_event_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Implementation of events repository based on Sequel for Ruby Event Store
+email:
+- dev@arkency.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/ruby_event_store/generators/templates/1_create_ruby_event_store_tables.rb
+- lib/ruby_event_store/generators/templates/mysql/1_create_ruby_event_store_tables.rb
+- lib/ruby_event_store/generators/templates/postgres/1_create_ruby_event_store_tables.rb
+- lib/ruby_event_store/sequel.rb
+- lib/ruby_event_store/sequel/event_repository.rb
+- lib/ruby_event_store/sequel/index_violation_detector.rb
+- lib/ruby_event_store/sequel/version.rb
+homepage: https://railseventstore.org
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://railseventstore.org
+  changelog_uri: https://github.com/RailsEventStore/rails_event_store/blob/master/contrib/ruby_event_store-sequel/CHANGELOG.md
+  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'
+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.6.8
+specification_version: 4
+summary: Sequel-based event repository for Ruby Event Store
+test_files: []