ruby_event_store-rom 1.2.1 → 2.0.0

data/CHANGELOG.md

@@ -1,9 +0,0 @@
-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

@@ -1,12 +0,0 @@
-source 'https://rubygems.org'
-git_source(:github) { |repo| "https://github.com/#{repo}.git" }
-gemspec
-
-eval_gemfile File.expand_path('../support/bundler/Gemfile.shared', __dir__)
-
-gem 'childprocess'
-gem 'fakefs', '~> 0.11.2'
-gem 'mysql2', '>= 0.5.3'
-gem 'pg', '>= 1.2.2'
-gem 'ruby_event_store', path: '../ruby_event_store'
-gem 'sqlite3', '1.3.13'

data/Makefile

@@ -1,57 +0,0 @@
-GEM_VERSION  = $(shell cat ../RES_VERSION)
-GEM_NAME     = ruby_event_store-rom
-REQUIRE      = $(GEM_NAME)
-IGNORE       = RubyEventStore::ROM.setup \
-               RubyEventStore::ROM.setup_defaults \
-               RubyEventStore::ROM.configure \
-               RubyEventStore::ROM.configure_defaults \
-               RubyEventStore::ROM.find_adapters \
-               RubyEventStore::ROM::TupleUniquenessError.for_event_id \
-               RubyEventStore::ROM::TupleUniquenessError.for_stream_and_position \
-               RubyEventStore::ROM::EventRepository\#initialize \
-               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::Repositories::StreamEntries\#create_changeset \
-               RubyEventStore::ROM::Changesets::CreateStreamEntries::Defaults.included \
-               RubyEventStore::ROM::Changesets::CreateEvents::Defaults.included \
-               RubyEventStore::ROM::Changesets::UpdateEvents::Defaults.included \
-               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\#unit_of_work \
-               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\#initialize \
-               RubyEventStore::ROM::SQL::SpecHelper\#has_connection_pooling? \
-               RubyEventStore::ROM::SQL::SpecHelper\#close_pool_connection \
-               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::SpecHelper\#run_lifecycle \
-               RubyEventStore::ROM::SQL::UnitOfWork\#commit! \
-               RubyEventStore::ROM::Memory::SpecHelper\#initialize \
-               RubyEventStore::ROM::Memory::SpecHelper\#close_pool_connection \
-               RubyEventStore::ROM::Memory::SpecHelper\#load_gateway_schema \
-               RubyEventStore::ROM::Memory::SpecHelper\#establish_gateway_connection \
-               RubyEventStore::ROM::Memory::SpecHelper\#drop_gateway_schema \
-               RubyEventStore::ROM::Memory::SpecHelper\#close_gateway_connection \
-               RubyEventStore::ROM::Memory::SpecHelper\#run_lifecycle \
-               RubyEventStore::ROM::Memory::UnitOfWork\#commit! \
-               RubyEventStore::ROM::Memory::Relations::Events\#verify_uniquness! \
-               RubyEventStore::ROM::Memory::Relations::StreamEntries\#verify_uniquness! \
-               RubyEventStore::ROM::Memory::Relations::StreamEntries\#normalize_stream_name
-SUBJECT      ?= RubyEventStore::ROM*
-DATABASE_URL ?= sqlite::memory:
-
-include ../support/make/install.mk
-include ../support/make/test.mk
-include ../support/make/mutant.mk
-include ../support/make/gem.mk
-include ../support/make/help.mk

data/Rakefile

@@ -1,20 +0,0 @@
-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

@@ -1,54 +0,0 @@
-require 'rom/sql'
-
-::ROM::SQL.migration do
-  change do
-    postgres = database_type =~ /postgres/
-
-    # set when copying migrations
-    # or when running tests
-    ENV['DATA_TYPE'] ||= 'text'
-    data_type = ENV['DATA_TYPE'].to_sym
-    data_types = postgres ? %i[text json jsonb] : %i[text]
-    raise ArgumentError, "DATA_TYPE must be: #{data_types.join(', ')}" unless data_types.include?(data_type)
-
-    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
-
-      if data_type =~ /json/
-        column :metadata, data_type
-        column :data, data_type, null: false
-      else
-        column :metadata, String, text: true
-        column :data, String, text: true, null: false
-      end
-
-      column :created_at, DateTime, null: false, index: 'index_event_store_events_on_created_at'
-    end
-  end
-end

data/db/migrate/20181026152045_index_by_event_type.rb

@@ -1,9 +0,0 @@
-require 'rom/sql'
-
-::ROM::SQL.migration do
-  change do
-    alter_table(:event_store_events) do
-      add_index :event_type
-    end
-  end
-end

data/lib/ruby_event_store/rom/adapters/memory/changesets/create_events.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module Memory
-      module Changesets
-        class CreateEvents < ROM::Changesets::CreateEvents
-          def commit
-            relation.by_pk(to_a.map { |e| e[:id] }).each do |tuple|
-              raise TupleUniquenessError.for_event_id(tuple[:id])
-            end
-
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_event_store/rom/adapters/memory/changesets/create_stream_entries.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module Memory
-      module Changesets
-        class CreateStreamEntries < ROM::Changesets::CreateStreamEntries
-          def commit
-            to_a.each do |tuple|
-              relation.send(:verify_uniquness!, tuple)
-            end
-
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_event_store/rom/adapters/memory/changesets/update_events.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module Memory
-      module Changesets
-        class UpdateEvents < ROM::Changesets::UpdateEvents
-          def commit
-            to_a.each do |params|
-              attributes = command.input[params].to_h.delete_if { |k, v| k == :created_at && v.nil? }
-              relation.by_pk(params.fetch(:id)).dataset.map { |tuple| tuple.update(attributes) }
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module Memory
-      module Relations
-        class Events < ::ROM::Relation[:memory]
-          schema(:events) do
-            attribute :id, ::ROM::Types::Strict::String.meta(primary_key: true)
-            attribute :event_type, ::ROM::Types::Strict::String
-            attribute :metadata, ::ROM::Types::Strict::String.optional
-            attribute :data, ::ROM::Types::Strict::String
-            attribute :created_at, RubyEventStore::ROM::Types::DateTime
-          end
-
-          def create_changeset(tuples)
-            events.changeset(Changesets::CreateEvents, tuples)
-          end
-
-          def update_changeset(tuples)
-            events.changeset(Changesets::UpdateEvents, tuples)
-          end
-
-          def insert(tuple)
-            verify_uniquness!(tuple)
-            super
-          end
-
-          def for_stream_entries(_assoc, stream_entries)
-            restrict(id: stream_entries.map { |e| e[:event_id] })
-          end
-
-          def by_pk(id)
-            restrict(id: id)
-          end
-
-          def exist?
-            one?
-          end
-
-          def pluck(name)
-            map { |e| e[name] }
-          end
-
-          private
-
-          def verify_uniquness!(tuple)
-            return unless by_pk(tuple[:id]).exist?
-
-            raise TupleUniquenessError.for_event_id(tuple[:id])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module Memory
-      module Relations
-        class StreamEntries < ::ROM::Relation[:memory]
-          schema(:stream_entries) do
-            attribute(:id, ::ROM::Types::Strict::Integer.meta(primary_key: true).default { RubyEventStore::ROM::Memory.fetch_next_id })
-            attribute :stream, ::ROM::Types::Strict::String
-            attribute :position, ::ROM::Types::Strict::Integer.optional
-            attribute :event_id, ::ROM::Types::Strict::String.meta(foreign_key: true, relation: :events)
-            attribute :created_at, RubyEventStore::ROM::Types::DateTime
-
-            associations do
-              belongs_to :events, as: :event, foreign_key: :event_id, override: true, view: :for_stream_entries
-            end
-          end
-
-          def for_events(events)
-            restrict(event_id: events.map { |e| e[:id] })
-          end
-
-          auto_struct true
-
-          SERIALIZED_GLOBAL_STREAM_NAME = 'all'.freeze
-
-          def create_changeset(tuples)
-            changeset(Changesets::CreateStreamEntries, tuples)
-          end
-
-          def offset(num)
-            num.zero? ? self : new(dataset.slice(num..-1) || [])
-          end
-
-          def take(num)
-            num.nil? ? self : super
-          end
-
-          def insert(tuple)
-            verify_uniquness!(tuple)
-            super
-          end
-
-          def delete(tuple)
-            super tuple.to_h
-          end
-
-          def by_stream(stream)
-            restrict(stream: normalize_stream_name(stream))
-          end
-
-          def by_event_id(event_id)
-            restrict(event_id: event_id)
-          end
-
-          def by_event_type(types)
-            for_events(events.restrict(event_type: Array(types)))
-          end
-
-          def by_stream_and_event_id(stream, event_id)
-            restrict(stream: normalize_stream_name(stream), event_id: event_id).one!
-          end
-
-          def max_position(stream)
-            new(by_stream(stream).order(:position).dataset.reverse).project(:position).take(1).one
-          end
-
-          DIRECTION_MAP = {
-            forward: [false, :>, :<],
-            backward: [true, :<, :>]
-          }.freeze
-
-          def ordered(direction, stream, offset_entry_id = nil, stop_entry_id = nil)
-            reverse, operator_offset, operator_stop = 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.restrict { |tuple| tuple[:id].public_send(operator_offset, offset_entry_id) } if offset_entry_id
-            query = query.restrict { |tuple| tuple[:id].public_send(operator_stop, stop_entry_id) } if stop_entry_id
-            query = query.order(*order_columns)
-            query = new(query.dataset.reverse) if reverse
-
-            query
-          end
-
-          private
-
-          # Verifies uniqueness of [stream, event_id] and [stream, position]
-          def verify_uniquness!(tuple)
-            stream = tuple[:stream]
-            attrs = %i[position event_id]
-            attrs.delete(:position) if Stream.new(stream).global?
-
-            attrs.each do |key|
-              next if key == :position && tuple[key].nil?
-              next if restrict(:stream => stream, key => tuple.fetch(key)).none?
-
-              raise TupleUniquenessError.public_send(:"for_stream_and_#{key}", stream, tuple.fetch(key))
-            end
-          end
-
-          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/memory/unit_of_work.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module Memory
-      class UnitOfWork < ROM::UnitOfWork
-        def self.mutex
-          @mutex ||= Mutex.new
-        end
-
-        def commit!(_gateway, changesets, **_options)
-          self.class.mutex.synchronize do
-            committed = []
-
-            begin
-              until changesets.empty?
-                changeset = changesets.shift
-                relation = env.rom_container.relations[changeset.relation.name]
-
-                committed << [changeset, relation]
-
-                changeset.commit
-              end
-            rescue StandardError
-              committed.reverse_each do |c, r|
-                r.restrict(id: c.to_a.map { |e| e[:id] }).command(:delete, result: :many).call
-              end
-
-              raise
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_event_store/rom/adapters/sql/changesets/create_events.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module SQL
-      module Changesets
-        class CreateEvents < ROM::Changesets::CreateEvents
-          def commit
-            relation.multi_insert(to_a)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_event_store/rom/adapters/sql/changesets/update_events.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module SQL
-      module Changesets
-        class UpdateEvents < ::ROM::Changeset::Create
-          include ROM::Changesets::UpdateEvents::Defaults
-
-          UPSERT_COLUMNS = %i[event_type data metadata created_at].freeze
-
-          def commit
-            if SQL.supports_on_duplicate_key_update?(relation.dataset.db)
-              commit_on_duplicate_key_update
-            elsif SQL.supports_insert_conflict_update?(relation.dataset.db)
-              commit_insert_conflict_update
-            else
-              raise "Database doesn't support upserts: #{relation.dataset.db.adapter_scheme}"
-            end
-          end
-
-          private
-
-          def commit_on_duplicate_key_update
-            relation.dataset.on_duplicate_key_update(*UPSERT_COLUMNS).multi_insert(to_a)
-          end
-
-          def commit_insert_conflict_update
-            relation.dataset.insert_conflict(
-              # constraint: 'index_name',
-              target: :id,
-              update: UPSERT_COLUMNS.each_with_object({}) do |column, memo|
-                memo[column] = Sequel[:excluded][column]
-              end
-            ).multi_insert(to_a)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module SQL
-      class IndexViolationDetector
-        MYSQL5_PKEY_ERROR   = "for key 'PRIMARY'".freeze
-        MYSQL8_PKEY_ERROR   = "for key 'event_store_events.PRIMARY'".freeze
-        POSTGRES_PKEY_ERROR = 'event_store_events_pkey'.freeze
-        SQLITE3_PKEY_ERROR  = 'event_store_events.id'.freeze
-
-        MYSQL5_INDEX_ERROR   = "for key 'index_event_store_events_in_streams_on_stream_and_event_id'".freeze
-        MYSQL8_INDEX_ERROR   = "for key 'event_store_events_in_streams.index_event_store_events_in_streams_on_stream_and_event_id'".freeze
-        POSTGRES_INDEX_ERROR = 'Key (stream, event_id)'.freeze
-        SQLITE3_INDEX_ERROR  = 'event_store_events_in_streams.stream, event_store_events_in_streams.event_id'.freeze
-
-        def detect(message)
-          message.include?(MYSQL5_PKEY_ERROR) ||
-            message.include?(MYSQL8_PKEY_ERROR) ||
-            message.include?(POSTGRES_PKEY_ERROR)  ||
-            message.include?(SQLITE3_PKEY_ERROR)   ||
-
-            message.include?(MYSQL5_INDEX_ERROR)    ||
-            message.include?(MYSQL8_INDEX_ERROR)    ||
-            message.include?(POSTGRES_INDEX_ERROR) ||
-            message.include?(SQLITE3_INDEX_ERROR)
-        end
-      end
-    end
-  end
-end

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

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module RubyEventStore
-  module ROM
-    module SQL
-      module Relations
-        class Events < ::ROM::Relation[:sql]
-          schema(:event_store_events, as: :events, infer: true) do
-            attribute :data, RubyEventStore::ROM::Types::SerializedRecordSerializer,
-                      read: RubyEventStore::ROM::Types::SerializedRecordDeserializer
-            attribute :metadata, RubyEventStore::ROM::Types::SerializedRecordSerializer,
-                      read: RubyEventStore::ROM::Types::SerializedRecordDeserializer
-            attribute :created_at, RubyEventStore::ROM::Types::DateTime
-          end
-
-          def create_changeset(tuples)
-            events.changeset(Changesets::CreateEvents, tuples)
-          end
-
-          def update_changeset(tuples)
-            events.changeset(Changesets::UpdateEvents, tuples)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-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
-            attribute :created_at, RubyEventStore::ROM::Types::DateTime
-
-            associations do
-              belongs_to :events, as: :event, foreign_key: :event_id
-            end
-          end
-
-          alias take limit
-
-          SERIALIZED_GLOBAL_STREAM_NAME = 'all'.freeze
-
-          def create_changeset(tuples)
-            changeset(ROM::Changesets::CreateStreamEntries, tuples)
-          end
-
-          def by_stream(stream)
-            where(stream: normalize_stream_name(stream))
-          end
-
-          def by_event_id(event_id)
-            where(event_id: event_id)
-          end
-
-          def by_event_type(types)
-            join(:events).where(event_type: types)
-          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: %i[asc > <],
-            backward: %i[desc < >]
-          }.freeze
-
-          def ordered(direction, stream, offset_entry_id = nil, stop_entry_id = nil)
-            order, operator_offset, operator_stop = 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, offset_entry_id) } if offset_entry_id
-            query = query.where { id.public_send(operator_stop, stop_entry_id) } if stop_entry_id
-            query.order { |r| order_columns.map { |c| r[:stream_entries][c].public_send(order) } }
-          end
-
-          private
-
-          def normalize_stream_name(stream)
-            stream.global? ? SERIALIZED_GLOBAL_STREAM_NAME : stream.name
-          end
-        end
-      end
-    end
-  end
-end