ruby_event_store-rom 0.28.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: daa7bf0e1b646617b35f359cbef1a2160c486cd72cef8e6865f38bd2d6bc8dbf
+  data.tar.gz: 7262de3e82f5e5ed7de6955a4d4973ba1f04dc8b877c74b38b7f804867d26479
+SHA512:
+  metadata.gz: 5ec50cdeb365d38b2420af3736fa994c40670a6a703677fb1348dd3c1e26909407b2d04376d43e156428e989aca08a7d508411625589efee0b5f39224c04506f
+  data.tar.gz: e25e06dcd18b2a4f071d89804ac7a68d1cb7275457f8114ddc22a8af9e0a42aa858833e50c3f81a0e69294913692a9357fd7b914e8e3f7aa014c3510cdbe65c6

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+Further changes can be tracked at [releases page](https://github.com/RailsEventStore/rails_event_store/releases).
+
+### 0.1.0 (03.04.2018)
+
+* Implemented ROM SQL adapter
+* Add `rom-sql` 2.4.0 dependency
+* Add `rom-repository` 2.0.2 dependency
+* Add `rom-changeset` 1.0.2 dependency
+* Add `sequel` 4.49 dependency

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'ruby_event_store', path: '../ruby_event_store'

data/Makefile

@@ -0,0 +1,78 @@
+GEM_VERSION  = $(shell cat ../RES_VERSION)
+GEM_NAME     = ruby_event_store-rom
+REQUIRE      = $(GEM_NAME)
+IGNORE       = RubyEventStore::ROM::EventRepository\#handle_not_found_errors \
+               RubyEventStore::ROM::EventRepository\#handle_unique_violation_errors \
+               RubyEventStore::ROM::EventRepository\#has_event? \
+               RubyEventStore::ROM::EventRepository\#last_stream_event \
+               RubyEventStore::ROM::Repositories::Events\#find_nonexistent_pks \
+               RubyEventStore::ROM::Env\#handle_error \
+               RubyEventStore::ROM::Env\#initialize \
+               RubyEventStore::ROM::Env\#register_error_handler \
+               RubyEventStore::ROM::Env\#register_unit_of_work_options \
+               RubyEventStore::ROM::Env\#transaction \
+               RubyEventStore::ROM::UnitOfWork\#call \
+               RubyEventStore::ROM::UnitOfWork\#commit! \
+               RubyEventStore::ROM::SQL::Relations::StreamEntries\#normalize_stream_name \
+               RubyEventStore::ROM::SQL::IndexViolationDetector\#detect \
+               RubyEventStore::ROM::SQL::SpecHelper\#load_gateway_schema \
+               RubyEventStore::ROM::SQL::SpecHelper\#establish_gateway_connection \
+               RubyEventStore::ROM::SQL::SpecHelper\#drop_gateway_schema \
+               RubyEventStore::ROM::SQL::SpecHelper\#close_gateway_connection \
+               RubyEventStore::ROM::SQL::UnitOfWork\#commit!
+SUBJECT      ?= RubyEventStore::ROM*
+DATABASE_URL ?= sqlite::memory:
+
+install: ## Install gem dependencies
+	@echo "Installing gem dependencies"
+	@bundle install
+
+remove-lock:
+	@echo "Removing resolved dependency versions"
+	-rm Gemfile.lock
+
+reinstall: remove-lock install ## Removing resolved dependency versions
+
+test: ## Run unit tests
+	@echo "Running unit tests"
+	@bundle exec rspec
+
+test-fast: ## Run unit tests with --fail-fast
+	@echo "Running unit tests with --fail-fast"
+	@bundle exec rspec --fail-fast --order defined --backtrace
+
+mutate: test ## Run mutation tests
+	@echo "Running mutation tests"
+	@DATABASE_URL=$(DATABASE_URL) bundle exec mutant --include lib \
+		$(addprefix --require ,$(REQUIRE)) \
+		$(addprefix --ignore-subject ,$(IGNORE)) \
+		--use rspec "$(SUBJECT)"
+
+mutate-fast: ## Run mutation tests with --fail-fast
+	@echo "Running mutation tests with --fail-fast"
+	@DATABASE_URL=$(DATABASE_URL) bundle exec mutant --include lib \
+		$(addprefix --require ,$(REQUIRE)) \
+		$(addprefix --ignore-subject ,$(IGNORE)) \
+		--fail-fast \
+		--use rspec "$(SUBJECT)"
+
+build:
+	@echo "Building gem package"
+	@gem build -V $(GEM_NAME).gemspec
+	@mkdir -p pkg/
+	@mv $(GEM_NAME)-$(GEM_VERSION).gem pkg/
+
+push:
+	@echo "Pushing package to RubyGems"
+	@gem push -k dev_arkency pkg/$(GEM_NAME)-$(GEM_VERSION).gem
+
+clean:
+	@echo "Removing previously built package"
+	-rm pkg/$(GEM_NAME)-$(GEM_VERSION).gem
+
+help:
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+.PHONY: help
+.DEFAULT_GOAL := help
+

data/README.md

@@ -0,0 +1,9 @@
+# RubyEventStore ROM Event Repository
+
+A Ruby Object Model (ROM) implementation of events repository for [Ruby Event Store](https://github.com/RailsEventStore/rails_event_store).
+
+This version of the ROM adapter supports [rom-sql](https://github.com/rom-rb/rom-sql) at this time. 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/)
+
+_Additonal backing stores via ROM are being tracked here: [#299](https://github.com/RailsEventStore/rails_event_store/issues/299)._

data/Rakefile

@@ -0,0 +1,20 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'ruby_event_store/rom/adapters/sql/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: [:ci]
+
+desc "Run CI tasks"
+task ci: [:spec]
+
+begin
+  require "rubocop/rake_task"
+
+  Rake::Task[:default].enhance [:rubocop]
+
+  RuboCop::RakeTask.new do |task|
+    task.options << "--display-cop-names"
+  end
+rescue LoadError
+end

data/db/migrate/20180327044629_create_ruby_event_store_tables.rb

@@ -0,0 +1,45 @@
+require 'rom/sql'
+
+::ROM::SQL.migration do
+  change do
+    postgres = database_type =~ /postgres/
+    sqlite   = database_type =~ /sqlite/
+    
+    run 'CREATE EXTENSION IF NOT EXISTS pgcrypto;' if postgres
+
+    create_table? :event_store_events_in_streams do
+      primary_key :id, type: :Bignum, null: false
+
+      column :stream, String, null: false
+      column :position, Integer
+
+      if postgres
+        column :event_id, :uuid, null: false
+      else
+        column :event_id, String, size: 36, null: false
+      end
+
+      column :created_at, DateTime, 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
+      if postgres
+        column :id, :uuid, default: Sequel.function(:gen_random_uuid), primary_key: true
+      else
+        column :id, String, size: 36, null: false, primary_key: true
+      end
+
+      column :event_type, String, null: false
+      column :metadata, String, text: true
+      column :data, String, text: true, null: false
+      column :created_at, DateTime, null: false, index: 'index_event_store_events_on_created_at'
+
+      if sqlite # TODO: Is this relevant without ActiveRecord?
+        index :id, unique: true
+      end
+    end
+  end
+end

data/lib/ruby_event_store-rom.rb

@@ -0,0 +1 @@
+require 'ruby_event_store/rom'

data/lib/ruby_event_store/rom.rb

@@ -0,0 +1,107 @@
+require 'rom-changeset'
+require 'rom-mapper'
+require 'rom-repository'
+require 'ruby_event_store'
+require 'ruby_event_store/rom/event_repository'
+require 'ruby_event_store/rom/tuple_uniqueness_error'
+require 'ruby_event_store/rom/unit_of_work'
+require 'ruby_event_store/rom/version'
+
+module RubyEventStore
+  module ROM
+    class Env
+      attr_accessor :container
+  
+      def initialize(container)
+        @container = container
+  
+        container.register(:unique_violation_error_handlers, Set.new)
+        container.register(:not_found_error_handlers, Set.new)
+        container.register(:logger, Logger.new(STDOUT).tap { |logger| logger.level = Logger::WARN })
+      end
+
+      def logger
+        container[:logger]
+      end
+
+      def transaction(&block)
+        options = container[:unit_of_work_options].dup
+        options.delete(:class){UnitOfWork}.new(rom: self).call(**options, &block)
+      end
+
+      def register_unit_of_work_options(options)
+        container.register(:unit_of_work_options, options)
+      end
+  
+      def register_error_handler(type, handler)
+        container[:"#{type}_error_handlers"] << handler
+      end
+  
+      def handle_error(type, ex, *args)
+        container[:"#{type}_error_handlers"].each{ |h| h.call(ex, *args) }
+        raise ex
+      end
+    end
+
+    class << self
+      # Set to a default instance
+      attr_accessor :env
+  
+      def configure(adapter_name, database_uri = ENV['DATABASE_URL'], &block)
+        if adapter_name.is_a?(::ROM::Configuration)
+          # Call config block manually
+          Env.new ::ROM.container(adapter_name.tap(&block), &block)
+        elsif database_uri.nil?
+          raise ArgumentError.new('Missing database URI argument or DATABASE_URL environment variable')
+        else
+          Env.new ::ROM.container(adapter_name, database_uri, &block)
+        end
+      end
+  
+      def setup(*args, &block)
+        configure(*args) do |config|
+          setup_defaults(config)
+          block.call(config) if block
+        end.tap(&method(:configure_defaults))
+      end
+
+    private
+      
+      def setup_defaults(config)
+        require_relative 'rom/repositories/stream_entries'
+        require_relative 'rom/repositories/events'
+        
+        config.register_mapper(ROM::Mappers::EventToSerializedRecord)
+        config.register_mapper(ROM::Mappers::StreamEntryToSerializedRecord)
+
+        find_adapters(config.environment.gateways).each do |adapter|
+          adapter.setup(config)
+        end
+      end
+
+      def configure_defaults(env)
+        env.register_error_handler :not_found, -> (ex, event_id) {
+          case ex
+          when ::ROM::TupleCountMismatchError
+            raise EventNotFound.new(event_id)
+          end
+        }
+
+        find_adapters(env.container.gateways).each do |adapter|
+          adapter.configure(env)
+        end
+      end
+
+      def find_adapters(gateways)
+        # Setup for each kind of gateway class
+        gateways.values.map(&:class).uniq.map do |klass|
+          constant = klass.name.split('::')[1].to_sym
+
+          next unless RubyEventStore::ROM.constants.include?(constant)
+
+          RubyEventStore::ROM.const_get(constant)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/adapters/sql/index_violation_detector.rb

@@ -0,0 +1,26 @@
+module RubyEventStore
+  module ROM
+    module SQL
+      class IndexViolationDetector
+    
+        MYSQL_PKEY_ERROR    = "for key 'PRIMARY'"
+        POSTGRES_PKEY_ERROR = "event_store_events_pkey"
+        SQLITE3_PKEY_ERROR  = "event_store_events.id"
+    
+        MYSQL_INDEX_ERROR    = "for key 'index_event_store_events_in_streams_on_stream_and_event_id'"
+        POSTGRES_INDEX_ERROR = "Key (stream, event_id)"
+        SQLITE3_INDEX_ERROR  = "event_store_events_in_streams.stream, event_store_events_in_streams.event_id"
+    
+        def detect(message)
+          message.include?(MYSQL_PKEY_ERROR)     ||
+          message.include?(POSTGRES_PKEY_ERROR)  ||
+          message.include?(SQLITE3_PKEY_ERROR)   ||
+    
+          message.include?(MYSQL_INDEX_ERROR)    ||
+          message.include?(POSTGRES_INDEX_ERROR) ||
+          message.include?(SQLITE3_INDEX_ERROR)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/adapters/sql/rake_task.rb

@@ -0,0 +1,3 @@
+require 'rom/sql/rake_task'
+require 'ruby_event_store/rom/sql'
+load 'ruby_event_store/rom/adapters/sql/tasks/migration_tasks.rake'

data/lib/ruby_event_store/rom/adapters/sql/relations/events.rb

@@ -0,0 +1,11 @@
+module RubyEventStore
+  module ROM
+    module SQL
+      module Relations
+        class Events < ::ROM::Relation[:sql]
+          schema(:event_store_events, as: :events, infer: true)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/adapters/sql/relations/stream_entries.rb

@@ -0,0 +1,61 @@
+module RubyEventStore
+  module ROM
+    module SQL
+      module Relations
+        class StreamEntries < ::ROM::Relation[:sql]
+          schema(:event_store_events_in_streams, as: :stream_entries, infer: true) do
+            associations do
+              belongs_to :events, as: :event, foreign_key: :event_id
+            end
+          end
+
+          alias_method :take, :limit
+    
+          def by_stream(stream)
+            where(stream: stream.name)
+          end
+    
+          SERIALIZED_GLOBAL_STREAM_NAME = 'all'.freeze
+
+          def by_stream(stream)
+            where(stream: normalize_stream_name(stream))
+          end
+
+          def by_stream_and_event_id(stream, event_id)
+            where(stream: normalize_stream_name(stream), event_id: event_id).one!
+          end
+  
+          def max_position(stream)
+            by_stream(stream).select(:position).order(Sequel.desc(:position)).first
+          end
+  
+          DIRECTION_MAP = {
+            forward:  [:asc,  :>],
+            backward: [:desc, :<]
+          }.freeze
+  
+          def ordered(direction, stream, offset_entry_id = nil)
+            order, operator = DIRECTION_MAP[direction]
+  
+            raise ArgumentError, 'Direction must be :forward or :backward' if order.nil?
+  
+            order_columns = %i[position id]
+            order_columns.delete(:position) if stream.global?
+            
+            query = by_stream(stream)
+            query = query.where { id.public_send(operator, offset_entry_id) } if offset_entry_id
+            query.order { |r| order_columns.map { |c| r[:stream_entries][c].public_send(order) } }
+          end
+          
+          alias_method :take, :limit
+
+          private
+  
+          def normalize_stream_name(stream)
+            stream.global? ? SERIALIZED_GLOBAL_STREAM_NAME : stream.name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/adapters/sql/tasks/migration_tasks.rake

@@ -0,0 +1,18 @@
+require 'ruby_event_store/rom/sql'
+
+desc 'Setup ROM EventRespository environment'
+task 'db:setup' do
+  ROM::SQL::RakeSupport.env = ::RubyEventStore::ROM.configure(:sql).container
+end
+
+desc "Copy RubyEventStore SQL migrations to db/migrate"
+task 'db:copy_migrations' => 'db:setup' do
+  Dir[File.join(File.dirname(__FILE__), '../../../../../../db/migrate/*.rb')].each do |input|
+    name = File.basename(input, '.*').sub(/\d+_/, '')
+    output = ROM::SQL::RakeSupport.create_migration(name)
+
+    File.write output, File.read(input)
+
+    puts "<= migration file created #{output}"
+  end
+end

data/lib/ruby_event_store/rom/adapters/sql/unit_of_work.rb

@@ -0,0 +1,37 @@
+module RubyEventStore
+  module ROM
+    module SQL
+      class UnitOfWork < ROM::UnitOfWork
+        def commit!(gateway, changesets, **options)
+          # Committing changesets concurrently causes MySQL deadlocks
+          # which are not caught and retried by Sequel's built-in
+          # :retry_on option. This appears to be a result of how ROM
+          # handles exceptions which don't bubble up so that Sequel
+          # can retry transactions with the :retry_on option when there's
+          # a deadlock.
+          #
+          # This is exacerbated by the fact that changesets insert multiple
+          # tuples with individual INSERT statements because ROM specifies
+          # to Sequel to return a list of primary keys created. The likelihood
+          # of a deadlock is reduced with batched INSERT statements.
+          #
+          # For this reason we need to manually insert changeset records to avoid
+          # MySQL deadlocks or to allow Sequel to retry transactions
+          # when the :retry_on option is specified.
+          options.merge!(
+            retry_on: Sequel::SerializationFailure,
+            before_retry: -> (num, ex) {
+              env.logger.warn("RETRY TRANSACTION [#{self.class.name} => #{ex.class.name}] #{ex.message}")
+            }
+          )
+  
+          gateway.transaction(options) do
+            changesets.each do |changeset|
+              changeset.relation.multi_insert(changeset.to_a)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/event_repository.rb

@@ -0,0 +1,91 @@
+require 'ruby_event_store/rom/unit_of_work'
+
+module RubyEventStore
+  module ROM
+    class EventRepository
+      def initialize(rom: ROM.env)
+        @rom = rom
+        @events = Repositories::Events.new(rom.container)
+        @stream_entries = Repositories::StreamEntries.new(rom.container)
+      end
+
+      def append_to_stream(events, stream, expected_version)
+        events = normalize_to_array(events)
+        event_ids = events.map(&:event_id)
+
+        @rom.transaction do |changesets|
+          # Create changesets inside transaction because
+          # we want to find the last position (a.k.a. version)
+          # again if the transaction is retried due to a
+          # deadlock in MySQL
+          changesets << @events.create_changeset(events)
+          changesets << @stream_entries.create_changeset(event_ids, stream, expected_version, global_stream: true)
+        end
+
+        self
+      rescue => ex
+        @rom.handle_error(:unique_violation, ex)
+      end
+
+      def link_to_stream(event_ids, stream, expected_version)
+        event_ids = normalize_to_array(event_ids)
+        nonexistent_ids = @events.find_nonexistent_pks(event_ids)
+
+        nonexistent_ids.each { |id| raise EventNotFound.new(id) }
+
+        @stream_entries.create_changeset(event_ids, stream, expected_version).commit
+
+        self
+      rescue => ex
+        @rom.handle_error(:unique_violation, ex)
+      end
+
+      def delete_stream(stream)
+        @stream_entries.delete(stream)
+      end
+
+      def has_event?(event_id)
+        @events.exist?(event_id)
+      rescue => ex
+        begin
+          @rom.handle_error(:not_found, ex, event_id)
+        rescue EventNotFound
+          false
+        end
+      end
+
+      def last_stream_event(stream)
+        Specification.new(self)
+          .stream(stream.name)
+          .limit(1)
+          .backward
+          .each
+          .first
+      end
+
+      def read_event(event_id)
+        @events.by_id(event_id)
+      rescue => ex
+        @rom.handle_error(:not_found, ex, event_id)
+      end
+
+      def read(specification)
+        raise ReservedInternalName if specification.stream_name.eql?(@stream_entries.stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME)
+
+        @events.read(
+          specification.direction,
+          specification.stream,
+          from: specification.start,
+          limit: (specification.count if specification.limit?)
+        )
+      end
+
+      private
+
+      def normalize_to_array(events)
+        return events if events.is_a?(Enumerable)
+        [events]
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/mappers/event_to_serialized_record.rb

@@ -0,0 +1,18 @@
+require 'rom/transformer'
+
+module RubyEventStore
+  module ROM
+    module Mappers
+      class EventToSerializedRecord < ::ROM::Transformer
+        relation :events
+        register_as :event_to_serialized_record
+      
+        map_array do
+          rename_keys id: :event_id
+          accept_keys %i[event_id data metadata event_type]
+          constructor_inject RubyEventStore::SerializedRecord
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/mappers/stream_entry_to_serialized_record.rb

@@ -0,0 +1,18 @@
+require 'rom/transformer'
+
+module RubyEventStore
+  module ROM
+    module Mappers
+      class StreamEntryToSerializedRecord < ::ROM::Transformer
+        relation :stream_entries
+        register_as :stream_entry_to_serialized_record
+      
+        map_array do
+          unwrap :event, %i[data metadata event_type]
+          accept_keys %i[event_id data metadata event_type]
+          constructor_inject RubyEventStore::SerializedRecord
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/repositories/events.rb

@@ -0,0 +1,53 @@
+require_relative '../mappers/event_to_serialized_record'
+
+module RubyEventStore
+  module ROM
+    module Repositories
+      class Events < ::ROM::Repository[:events]
+        class Create < ::ROM::Changeset::Create
+          # Convert to Hash
+          map(&:to_h)
+
+          map do
+            rename_keys event_id: :id
+            accept_keys %i[id data metadata event_type]
+          end
+
+          map do |tuple|
+            Hash(created_at: Time.now).merge(tuple)
+          end
+        end
+
+        def create_changeset(serialized_records)
+          events.changeset(Create, serialized_records)
+        end
+
+        def find_nonexistent_pks(event_ids)
+          return event_ids unless event_ids.any?
+          event_ids - events.by_pk(event_ids).pluck(:id)
+        end
+
+        def exist?(event_id)
+          events.by_pk(event_id).exist?
+        end
+  
+        def by_id(event_id)
+          events.map_with(:event_to_serialized_record).by_pk(event_id).one!
+        end
+
+        def read(direction, stream, from:, limit:)
+          unless from.equal?(:head)
+            offset_entry_id = stream_entries.by_stream_and_event_id(stream, from).fetch(:id)
+          end
+          
+          stream_entries
+            .ordered(direction, stream, offset_entry_id)
+            .take(limit)
+            .combine(:event)
+            .map_with(:stream_entry_to_serialized_record) # Add `auto_struct: false` for Memory adapter
+            .each
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/repositories/stream_entries.rb

@@ -0,0 +1,48 @@
+require_relative '../mappers/stream_entry_to_serialized_record'
+
+module RubyEventStore
+  module ROM
+    module Repositories
+      class StreamEntries < ::ROM::Repository[:stream_entries]
+        class Create < ::ROM::Changeset::Create
+          map do |tuple|
+            Hash(created_at: Time.now).merge(tuple)
+          end
+        end
+
+        POSITION_SHIFT = 1.freeze
+
+        def create_changeset(event_ids, stream, expected_version, global_stream: nil)
+          resolved_version = expected_version.resolve_for(stream, ->(_stream) {
+            (stream_entries.max_position(stream) || {})[:position]
+          })
+
+          tuples = []
+
+          event_ids.each_with_index do |event_id, index|
+            tuples << {
+              stream: stream.name,
+              position: resolved_version && resolved_version + index + POSITION_SHIFT,
+              event_id: event_id
+            } unless stream.global?
+
+            tuples << {
+              stream: stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME,
+              event_id: event_id
+            } if global_stream
+          end
+
+          stream_entries.changeset(Create, tuples)
+        end
+
+        def delete(stream)
+          delete_changeset(stream).commit
+        end
+
+        def delete_changeset(stream)
+          stream_entries.by_stream(stream).changeset(:delete)
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/sql.rb

@@ -0,0 +1,81 @@
+require 'rom/sql'
+require 'ruby_event_store/rom'
+require_relative 'adapters/sql/index_violation_detector'
+require_relative 'adapters/sql/unit_of_work'
+require_relative 'adapters/sql/relations/events'
+require_relative 'adapters/sql/relations/stream_entries'
+
+module RubyEventStore
+  module ROM
+    module SQL
+      class << self
+        def setup(config)
+          config.register_relation Relations::Events
+          config.register_relation Relations::StreamEntries
+        end
+
+        def configure(env)
+          # See: https://github.com/jeremyevans/sequel/blob/master/doc/transactions.rdoc
+          env.register_unit_of_work_options(
+            class: UnitOfWork,
+            savepoint: true
+          )
+
+          env.register_error_handler :unique_violation, -> ex {
+            case ex
+            when ::ROM::SQL::UniqueConstraintError, Sequel::UniqueConstraintViolation
+              raise EventDuplicatedInStream if IndexViolationDetector.new.detect(ex.message)
+              raise WrongExpectedEventVersion
+            end
+          }
+
+          env.register_error_handler :not_found, -> (ex, event_id) {
+            case ex
+            when ::ROM::TupleCountMismatchError
+              raise EventNotFound.new(event_id)
+            when Sequel::DatabaseError
+              raise ex unless ex.message =~ /PG::InvalidTextRepresentation.*uuid/
+              raise EventNotFound.new(event_id)
+            end
+          }
+        end
+      end
+
+      class SpecHelper
+        attr_reader :env
+        
+        def initialize(rom: ROM.env)
+          @env = rom
+        end
+
+        def gateway
+          env.container.gateways.fetch(:default)
+        end
+
+        def establish_gateway_connection
+          # Manually preconnect because disconnecting and reconnecting
+          # seems to lose the "preconnect concurrently" setting
+          gateway.connection.pool.send(:preconnect, true)
+        end
+
+        def load_gateway_schema
+          gateway.run_migrations
+        end
+
+        def drop_gateway_schema
+          gateway.connection.drop_table?('event_store_events')
+          gateway.connection.drop_table?('event_store_events_in_streams')
+          gateway.connection.drop_table?('schema_migrations')
+        end
+
+        # See: https://github.com/rom-rb/rom-sql/blob/master/spec/shared/database_setup.rb
+        def close_gateway_connection
+          gateway.connection.disconnect
+          # Prevent the auto-reconnect when the test completed
+          # This will save from hardly reproducible connection run outs
+          gateway.connection.pool.available_connections.freeze
+        end
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/tuple_uniqueness_error.rb

@@ -0,0 +1,6 @@
+module RubyEventStore
+  module ROM
+    class TupleUniquenessError < StandardError
+    end
+  end
+end

data/lib/ruby_event_store/rom/unit_of_work.rb

@@ -0,0 +1,23 @@
+module RubyEventStore
+  module ROM
+    class UnitOfWork
+      attr_reader :env
+
+      def initialize(rom: ROM.env)
+        @env = rom
+      end
+
+      def call(**options)
+        gateway = @env.container.gateways.fetch(options.delete(:gateway){:default})
+
+        yield(changesets = [])
+
+        commit!(gateway, changesets, options)
+      end
+
+      def commit!(gateway, changesets, **options)
+        gateway.transaction(options) { changesets.each(&:commit) }
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/version.rb

@@ -0,0 +1,5 @@
+module RubyEventStore
+  module ROM
+    VERSION = "0.28.0"
+  end
+end

data/ruby_event_store-rom.gemspec

@@ -0,0 +1,44 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_event_store/rom/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ruby_event_store-rom'
+  spec.version       = RubyEventStore::ROM::VERSION
+  spec.licenses      = ['MIT']
+  spec.authors       = ['Joel Van Horn']
+  spec.email         = ['joel@joelvanhorn.com']
+
+  spec.summary       = %q{ROM events repository for Ruby Event Store}
+  spec.description   = %q{Implementation of events repository based on ROM for Ruby 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_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.6'
+  spec.add_development_dependency 'sqlite3', '1.3.13'
+  spec.add_development_dependency 'pg', '0.21'
+  spec.add_development_dependency 'mysql2', '0.4.10'
+  spec.add_development_dependency 'mutant-rspec', '~> 0.8.14'
+  spec.add_development_dependency 'fakefs', '~> 0.11.2'
+  spec.add_development_dependency 'childprocess'
+  spec.add_development_dependency 'google-protobuf', '~> 3.5.1.2'
+
+  spec.add_dependency 'ruby_event_store', '= 0.28.0'
+  spec.add_dependency 'sequel', '>= 4.49'
+  spec.add_dependency 'rom-sql', '~> 2.4'
+  spec.add_dependency 'rom-repository', '~> 2.0'
+  spec.add_dependency 'rom-changeset', '~> 1.0'
+end

metadata

@@ -0,0 +1,282 @@
+--- !ruby/object:Gem::Specification
+name: ruby_event_store-rom
+version: !ruby/object:Gem::Version
+  version: 0.28.0
+platform: ruby
+authors:
+- Joel Van Horn
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-05-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.13
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.13
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.10
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.10
+- !ruby/object:Gem::Dependency
+  name: mutant-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.14
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.14
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: google-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.1.2
+- !ruby/object:Gem::Dependency
+  name: ruby_event_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.28.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.28.0
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.49'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.49'
+- !ruby/object:Gem::Dependency
+  name: rom-sql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rom-repository
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rom-changeset
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Implementation of events repository based on ROM for Ruby Event Store'
+email:
+- joel@joelvanhorn.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- Makefile
+- README.md
+- Rakefile
+- db/migrate/20180327044629_create_ruby_event_store_tables.rb
+- lib/ruby_event_store-rom.rb
+- lib/ruby_event_store/rom.rb
+- lib/ruby_event_store/rom/adapters/sql/index_violation_detector.rb
+- lib/ruby_event_store/rom/adapters/sql/rake_task.rb
+- lib/ruby_event_store/rom/adapters/sql/relations/events.rb
+- lib/ruby_event_store/rom/adapters/sql/relations/stream_entries.rb
+- lib/ruby_event_store/rom/adapters/sql/tasks/migration_tasks.rake
+- lib/ruby_event_store/rom/adapters/sql/unit_of_work.rb
+- lib/ruby_event_store/rom/event_repository.rb
+- lib/ruby_event_store/rom/mappers/event_to_serialized_record.rb
+- lib/ruby_event_store/rom/mappers/stream_entry_to_serialized_record.rb
+- lib/ruby_event_store/rom/repositories/events.rb
+- lib/ruby_event_store/rom/repositories/stream_entries.rb
+- lib/ruby_event_store/rom/sql.rb
+- lib/ruby_event_store/rom/tuple_uniqueness_error.rb
+- lib/ruby_event_store/rom/unit_of_work.rb
+- lib/ruby_event_store/rom/version.rb
+- ruby_event_store-rom.gemspec
+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
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: ROM events repository for Ruby Event Store
+test_files: []