ruby_event_store-rom 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f2cadf18b1a9e4c39002fd8d23c4d2b44a96f784eb4789d1e3faa972f3353af
-  data.tar.gz: 259cdfd63aa4f52aeee63d5d1b0dbfc86f4d669f5a7794743c127d0b5f2b9767
+  metadata.gz: 578db4e9a6e68483348133d15dfee076b76a29a76ac6ae5ec6e7b94063bf7284
+  data.tar.gz: cb177a748a62f91911ace80e4c5175a5cc4cda773947eff6d855249d71a7b8e6
 SHA512:
-  metadata.gz: e42552f06a8d409406f046385e70e4296048396bbe47d126b36d90280d41d50a62293d60e9ffc86bc8f7653a93118a13e615f46f941ba1b7e8a41189ee110c98
-  data.tar.gz: 123ec9e8fafb080c5e48300b7f94c87a2c15a99bdf9cf898572767a43ffdd4ada396e87aa7621ed449df176ec0a6791954488f8fc0884dac0d711dd209ba1ab4
+  metadata.gz: b0124ece3841ae0774b5a758cf5c154d5406060dfeae4803072ad37d08ad56d0305d33a81fdbe3359e834fcc8412270e50176a39b49f3ca38ecf68283e8faa6a
+  data.tar.gz: f773ecdc66ee0ff1974ca9977ea9b003cf63b4ac8212ddfda997c8f7c13c76693c65281cf0684f35fb43290cb411b7e3b971780f6815480fb34a2c1dc871221f

data/Makefile

@@ -1,25 +1,42 @@
 GEM_VERSION  = $(shell cat ../RES_VERSION)
 GEM_NAME     = ruby_event_store-rom
 REQUIRE      = $(GEM_NAME)
-IGNORE       = RubyEventStore::ROM::EventRepository\#handle_not_found_errors \
+IGNORE       = 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::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::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::UnitOfWork\#commit!
+               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:
 

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

@@ -0,0 +1,45 @@
+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, ::ROM::Types::Strict::Time.default { Time.now }
+          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

@@ -0,0 +1,95 @@
+module RubyEventStore
+  module ROM
+    module Memory
+      module Relations
+        class StreamEntries < ::ROM::Relation[:memory]
+          schema(:stream_entries) do
+            attribute :id, ::ROM::Types::Strict::Int.meta(primary_key: true).default { RubyEventStore::ROM::Memory.fetch_next_id }
+            attribute :stream, ::ROM::Types::Strict::String
+            attribute :position, ::ROM::Types::Strict::Int.optional
+            attribute :event_id, ::ROM::Types::Strict::String.meta(foreign_key: true, relation: :events)
+            attribute :created_at, ::ROM::Types::Strict::Time.default { Time.now }
+
+            associations do
+              belongs_to :events, as: :event, foreign_key: :event_id, override: true, view: :for_stream_entries
+            end
+          end
+
+          auto_struct true
+
+          SERIALIZED_GLOBAL_STREAM_NAME = 'all'.freeze
+
+          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_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)
+            reverse, 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.restrict { |tuple| tuple[:id].public_send(operator, offset_entry_id) } if offset_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

@@ -0,0 +1,49 @@
+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
+              while changesets.size > 0
+                changeset = changesets.shift
+                relation = env.container.relations[changeset.relation.name]
+
+                case changeset
+                when ROM::Repositories::Events::Create
+                  relation.by_pk(changeset.to_a.map{ |e| e[:id] }).each do |tuple|
+                    raise TupleUniquenessError.for_event_id(tuple[:id])
+                  end
+                when ROM::Repositories::StreamEntries::Create
+                  changeset.to_a.each do |tuple|
+                    relation.send(:verify_uniquness!, tuple)
+                  end
+                else
+                  raise ArgumentError, 'Unknown changeset'
+                end
+
+                committed << [changeset, relation]
+
+                changeset.commit
+              end
+            rescue StandardError
+              committed.reverse.each do |changeset, relation|
+                relation
+                  .restrict(id: changeset.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/relations/events.rb

@@ -3,7 +3,9 @@ module RubyEventStore
     module SQL
       module Relations
         class Events < ::ROM::Relation[:sql]
-          schema(:event_store_events, as: :events, infer: true)
+          schema(:event_store_events, as: :events, infer: true) do
+            attribute :created_at, ::ROM::Types::Strict::Time.default { Time.now }
+          end
         end
       end
     end

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

@@ -4,6 +4,8 @@ module RubyEventStore
       module Relations
         class StreamEntries < ::ROM::Relation[:sql]
           schema(:event_store_events_in_streams, as: :stream_entries, infer: true) do
+            attribute :created_at, ::ROM::Types::Strict::Time.default { Time.now }
+            
             associations do
               belongs_to :events, as: :event, foreign_key: :event_id
             end
@@ -11,10 +13,6 @@ module RubyEventStore
 
           alias_method :take, :limit
     
-          def by_stream(stream)
-            where(stream: stream.name)
-          end
-    
           SERIALIZED_GLOBAL_STREAM_NAME = 'all'.freeze
 
           def by_stream(stream)
@@ -47,8 +45,6 @@ module RubyEventStore
             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)

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

@@ -1,15 +1,18 @@
 require 'ruby_event_store/rom/sql'
 
+MIGRATIONS_PATH = 'db/migrate'
+
 desc 'Setup ROM EventRespository environment'
 task 'db:setup' do
+  Dir.chdir(Dir.pwd)
   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|
+desc 'Copy RubyEventStore SQL migrations to db/migrate'
+task 'db:migrations:copy' => 'db:setup' do
+  Dir[File.join(File.dirname(__FILE__), '../../../../../../', MIGRATIONS_PATH, '/*.rb')].each do |input|
     name = File.basename(input, '.*').sub(/\d+_/, '')
-    output = ROM::SQL::RakeSupport.create_migration(name)
+    output = ROM::SQL::RakeSupport.create_migration(name, path: File.join(Dir.pwd, MIGRATIONS_PATH))
 
     File.write output, File.read(input)
 

data/lib/ruby_event_store/rom/event_repository.rb

@@ -1,9 +1,17 @@
 require 'ruby_event_store/rom/unit_of_work'
+require 'forwardable'
 
 module RubyEventStore
   module ROM
     class EventRepository
+      extend Forwardable
+
+      def_delegator :@rom, :handle_error, :guard_for
+      def_delegators :@rom, :unit_of_work
+
       def initialize(rom: ROM.env)
+        raise ArgumentError, "Must specify rom" unless rom && rom.instance_of?(Env)
+        
         @rom = rom
         @events = Repositories::Events.new(rom.container)
         @stream_entries = Repositories::StreamEntries.new(rom.container)
@@ -13,31 +21,44 @@ module RubyEventStore
         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)
+        guard_for(:unique_violation) do
+          unit_of_work 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,
+              @stream_entries.resolve_version(stream, expected_version),
+              global_stream: true
+            )
+          end
         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
+        # Validate event IDs
+        @events
+          .find_nonexistent_pks(event_ids)
+          .each { |id| raise EventNotFound.new(id) }
+
+        guard_for(:unique_violation) do
+          unit_of_work do |changesets|
+            changesets << @stream_entries.create_changeset(
+              event_ids,
+              stream,
+              @stream_entries.resolve_version(stream, expected_version)
+            )
+          end
+        end
 
         self
-      rescue => ex
-        @rom.handle_error(:unique_violation, ex)
       end
 
       def delete_stream(stream)
@@ -45,12 +66,8 @@ module RubyEventStore
       end
 
       def has_event?(event_id)
-        @events.exist?(event_id)
-      rescue => ex
-        begin
-          @rom.handle_error(:not_found, ex, event_id)
-        rescue EventNotFound
-          false
+        !! guard_for(:not_found, event_id, swallow: EventNotFound) do
+          @events.exist?(event_id)
         end
       end
 
@@ -65,9 +82,9 @@ module RubyEventStore
       end
 
       def read_event(event_id)
-        @events.by_id(event_id)
-      rescue => ex
-        @rom.handle_error(:not_found, ex, event_id)
+        guard_for(:not_found, event_id) do
+          @events.by_id(event_id)
+        end
       end
 
       def read(specification)

data/lib/ruby_event_store/rom/memory.rb

@@ -0,0 +1,68 @@
+require 'ruby_event_store/rom'
+require 'rom/memory'
+require_relative 'adapters/memory/unit_of_work'
+require_relative 'adapters/memory/relations/events'
+require_relative 'adapters/memory/relations/stream_entries'
+
+module RubyEventStore
+  module ROM
+    module Memory
+      class << self
+        def fetch_next_id
+          @last_id ||= 0
+          @mutex ||= Mutex.new
+          @mutex.synchronize { @last_id += 1 }
+        end
+
+        def setup(config)
+          config.register_relation Relations::Events
+          config.register_relation Relations::StreamEntries
+        end
+
+        def configure(env)
+          env.register_unit_of_work_options(class: UnitOfWork)
+
+          env.register_error_handler :unique_violation, -> ex {
+            case ex
+            when TupleUniquenessError
+              raise EventDuplicatedInStream if ex.message =~ /event_id/
+              raise WrongExpectedEventVersion
+            end
+          }
+        end
+      end
+
+      class SpecHelper
+        attr_reader :env
+        attr_reader :connection_pool_size, :close_pool_connection
+        
+        def initialize
+          @connection_pool_size = 5
+          @env = ROM.setup(:memory)
+        end
+
+        def run_lifecycle
+          yield
+        ensure
+          drop_gateway_schema
+        end
+
+        def gateway
+          env.container.gateways.fetch(:default)
+        end
+
+        def drop_gateway_schema
+          gateway.connection.data.values.each { |v| v.data.clear }
+        end
+      
+        def close_gateway_connection
+          gateway.disconnect
+        end
+
+        def has_connection_pooling?
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -47,7 +47,7 @@ module RubyEventStore
                 .offset(offset)
                 .take(limit)
                 .combine(:event)
-                .map_with(:stream_entry_to_serialized_record) # Add `auto_struct: false` for Memory adapter
+                .map_with(:stream_entry_to_serialized_record, auto_struct: false)
                 .to_ary
             end
             BatchEnumerator.new(batch_size, limit || Float::INFINITY, reader).each
@@ -56,7 +56,7 @@ module RubyEventStore
               .ordered(direction, stream, offset_entry_id)
               .take(limit)
               .combine(:event)
-              .map_with(:stream_entry_to_serialized_record) # Add `auto_struct: false` for Memory adapter
+              .map_with(:stream_entry_to_serialized_record, auto_struct: false)
               .each
           end
         end

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

@@ -12,22 +12,19 @@ module RubyEventStore
 
         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]
-          })
-
+        def create_changeset(event_ids, stream, resolved_version, global_stream: nil)
           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?
+             } unless stream.global?
 
-            tuples << {
+             tuples << {
               stream: stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME,
+              position: nil,
               event_id: event_id
             } if global_stream
           end
@@ -36,11 +33,13 @@ module RubyEventStore
         end
 
         def delete(stream)
-          delete_changeset(stream).commit
+          stream_entries.by_stream(stream).command(:delete).call
         end
 
-        def delete_changeset(stream)
-          stream_entries.by_stream(stream).changeset(:delete)
+        def resolve_version(stream, expected_version)
+          expected_version.resolve_for(stream, ->(_stream) {
+            (stream_entries.max_position(stream) || {})[:position]
+          })
         end
       end
     end

data/lib/ruby_event_store/rom/sql.rb

@@ -1,5 +1,5 @@
-require 'rom/sql'
 require 'ruby_event_store/rom'
+require 'rom/sql'
 require_relative 'adapters/sql/index_violation_detector'
 require_relative 'adapters/sql/unit_of_work'
 require_relative 'adapters/sql/relations/events'
@@ -44,14 +44,50 @@ module RubyEventStore
       class SpecHelper
         attr_reader :env
         
-        def initialize(rom: ROM.env)
-          @env = rom
+        def initialize(database_uri = ENV['DATABASE_URL'])
+          config = ::ROM::Configuration.new(
+            :sql,
+            database_uri,
+            max_connections: database_uri =~ /sqlite/ ? 1 : 5,
+            preconnect: :concurrently,
+            # sql_mode: %w[NO_AUTO_VALUE_ON_ZERO STRICT_ALL_TABLES]
+          )
+          # $stdout.sync = true
+          # config.default.use_logger Logger.new(STDOUT)
+          # config.default.connection.pool.send(:preconnect, true)
+          config.default.run_migrations
+    
+          @env = ROM.setup(config)
+        end
+        
+        def run_lifecycle
+          establish_gateway_connection
+          load_gateway_schema
+
+          yield
+        ensure
+          drop_gateway_schema
+          close_gateway_connection
         end
 
         def gateway
           env.container.gateways.fetch(:default)
         end
 
+        def has_connection_pooling?
+          !gateway.connection.database_type.eql?(:sqlite)
+        end
+
+        def connection_pool_size
+          gateway.connection.pool.size
+        end
+
+        def close_pool_connection
+          gateway.connection.pool.disconnect
+        end
+
+      protected
+
         def establish_gateway_connection
           # Manually preconnect because disconnecting and reconnecting
           # seems to lose the "preconnect concurrently" setting

data/lib/ruby_event_store/rom/tuple_uniqueness_error.rb

@@ -1,6 +1,19 @@
 module RubyEventStore
   module ROM
     class TupleUniquenessError < StandardError
+      class << self
+        def for_event_id(event_id)
+          new "Uniquness violated for event_id (#{event_id.inspect})"
+        end
+
+        def for_stream_and_event_id(stream_name, event_id)
+          new "Uniquness violated for stream (#{stream_name.inspect}) and event_id (#{event_id.inspect})"
+        end
+
+        def for_stream_and_position(stream_name, position)
+          new "Uniquness violated for stream (#{stream_name.inspect}) and position (#{position.inspect})"
+        end
+      end
     end
   end
 end

data/lib/ruby_event_store/rom/version.rb

@@ -1,5 +1,5 @@
 module RubyEventStore
   module ROM
-    VERSION = "0.30.0"
+    VERSION = "0.31.0"
   end
 end

data/lib/ruby_event_store/rom.rb

@@ -24,7 +24,7 @@ module RubyEventStore
         container[:logger]
       end
 
-      def transaction(&block)
+      def unit_of_work(&block)
         options = container[:unit_of_work_options].dup
         options.delete(:class){UnitOfWork}.new(rom: self).call(**options, &block)
       end
@@ -37,9 +37,15 @@ module RubyEventStore
         container[:"#{type}_error_handlers"] << handler
       end
   
-      def handle_error(type, ex, *args)
-        container[:"#{type}_error_handlers"].each{ |h| h.call(ex, *args) }
-        raise ex
+      def handle_error(type, *args, swallow: [])
+        yield
+      rescue => ex
+        begin
+          container[:"#{type}_error_handlers"].each{ |h| h.call(ex, *args) }
+          raise ex
+        rescue *swallow
+          # swallow
+        end
       end
     end
 
@@ -51,8 +57,6 @@ module RubyEventStore
         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