ruby_event_store-rom 0.35.0 → 0.36.0

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

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

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

@@ -2,23 +2,22 @@ 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"
-    
+        MYSQL_PKEY_ERROR    = "for key 'PRIMARY'".freeze
+        POSTGRES_PKEY_ERROR = 'event_store_events_pkey'.freeze
+        SQLITE3_PKEY_ERROR  = 'event_store_events.id'.freeze
+
+        MYSQL_INDEX_ERROR    = "for key '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?(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)
+          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

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

@@ -4,7 +4,19 @@ module RubyEventStore
       module Relations
         class Events < ::ROM::Relation[:sql]
           schema(:event_store_events, as: :events, infer: true) do
-            attribute :created_at, ::ROM::Types::Strict::Time.default { Time.now }
+            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

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

@@ -4,17 +4,21 @@ 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 }
+            attribute :created_at, RubyEventStore::ROM::Types::DateTime
 
             associations do
               belongs_to :events, as: :event, foreign_key: :event_id
             end
           end
 
-          alias_method :take, :limit
+          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
@@ -36,8 +40,8 @@ module RubyEventStore
           end
 
           DIRECTION_MAP = {
-            forward:  [:asc,  :>],
-            backward: [:desc, :<]
+            forward: %i[asc >],
+            backward: %i[desc <]
           }.freeze
 
           def ordered(direction, stream, offset_entry_id = nil)

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

@@ -1,6 +1,6 @@
 require 'ruby_event_store/rom/sql'
 
-MIGRATIONS_PATH = 'db/migrate'
+MIGRATIONS_PATH = 'db/migrate'.freeze
 
 desc 'Setup ROM EventRespository environment'
 task 'db:setup' do
@@ -10,11 +10,24 @@ end
 
 desc 'Copy RubyEventStore SQL migrations to db/migrate'
 task 'db:migrations:copy' => 'db:setup' do
+  # Optional data type for `data` and `metadata`
+  data_type = ENV['DATA_TYPE']
+
   Dir[File.join(File.dirname(__FILE__), '../../../../../../', MIGRATIONS_PATH, '/*.rb')].each do |input|
-    name = File.basename(input, '.*').sub(/\d+_/, '')
+    contents = File.read(input)
+    name     = File.basename(input, '.*').sub(/\d+_/, '')
+
+    re_data_type = /(ENV.+?DATA_TYPE.+?\|\|=\s*)['"](jsonb?|text)['"]/
+
+    if data_type && contents =~ re_data_type
+      # Search/replace this string: ENV['DATA_TYPE'] ||= 'text'
+      contents = contents.sub(re_data_type, format('\1"%<data_type>s"', data_type: data_type))
+      name    += "_with_#{data_type}"
+    end
+
     output = ROM::SQL::RakeSupport.create_migration(name, path: File.join(Dir.pwd, MIGRATIONS_PATH))
 
-    File.write output, File.read(input)
+    File.write output, contents
 
     puts "<= migration file created #{output}"
   end

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

@@ -0,0 +1,29 @@
+module RubyEventStore
+  module ROM
+    module Changesets
+      class CreateEvents < ::ROM::Changeset::Create
+        module Defaults
+          def self.included(base)
+            base.class_eval do
+              relation :events
+
+              # 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: RubyEventStore::ROM::Types::DateTime.call(nil)).merge(tuple)
+              end
+            end
+          end
+        end
+
+        include Defaults
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module RubyEventStore
+  module ROM
+    module Changesets
+      class CreateStreamEntries < ::ROM::Changeset::Create
+        module Defaults
+          def self.included(base)
+            base.class_eval do
+              relation :stream_entries
+
+              map do |tuple|
+                Hash(created_at: RubyEventStore::ROM::Types::DateTime.call(nil)).merge(tuple)
+              end
+            end
+          end
+        end
+
+        include Defaults
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module RubyEventStore
+  module ROM
+    module Changesets
+      class UpdateEvents < ::ROM::Changeset::Update
+        module Defaults
+          def self.included(base)
+            base.class_eval do
+              relation :events
+
+              # Convert to Hash
+              map(&:to_h)
+
+              map do
+                rename_keys event_id: :id
+                accept_keys %i[id data metadata event_type created_at]
+              end
+
+              map do |tuple|
+                Hash(created_at: RubyEventStore::ROM::Types::DateTime.call(nil)).merge(tuple)
+              end
+            end
+          end
+        end
+
+        include Defaults
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rom/event_repository.rb

@@ -10,7 +10,7 @@ module RubyEventStore
       def_delegators :@rom, :unit_of_work
 
       def initialize(rom: ROM.env)
-        raise ArgumentError, "Must specify rom" unless rom && rom.instance_of?(Env)
+        raise ArgumentError, 'Must specify rom' unless rom && rom.instance_of?(Env)
 
         @rom = rom
         @events = Repositories::Events.new(rom.container)
@@ -46,7 +46,7 @@ module RubyEventStore
         # Validate event IDs
         @events
           .find_nonexistent_pks(event_ids)
-          .each { |id| raise EventNotFound.new(id) }
+          .each { |id| raise EventNotFound, id }
 
         guard_for(:unique_violation) do
           unit_of_work do |changesets|
@@ -66,9 +66,7 @@ module RubyEventStore
       end
 
       def has_event?(event_id)
-        !! guard_for(:not_found, event_id, swallow: EventNotFound) do
-          @events.exist?(event_id)
-        end
+        guard_for(:not_found, event_id, swallow: EventNotFound) { @events.exist?(event_id) } || false
       end
 
       def last_stream_event(stream)
@@ -87,15 +85,27 @@ module RubyEventStore
         @events.count(specification)
       end
 
+      def update_messages(messages)
+        # Validate event IDs
+        @events
+          .find_nonexistent_pks(messages.map(&:event_id))
+          .each { |id| raise EventNotFound, id }
+
+        unit_of_work do |changesets|
+          changesets << @events.update_changeset(messages)
+        end
+      end
+
       def streams_of(event_id)
         @stream_entries.streams_of(event_id)
-          .map{|name| Stream.new(name)}
+                       .map { |name| Stream.new(name) }
       end
 
       private
 
       def normalize_to_array(events)
         return events if events.is_a?(Enumerable)
+
         [events]
       end
     end

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

@@ -6,7 +6,7 @@ module RubyEventStore
       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]

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

@@ -6,7 +6,7 @@ module RubyEventStore
       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]

data/lib/ruby_event_store/rom/memory.rb

@@ -3,6 +3,9 @@ require 'rom/memory'
 require_relative 'adapters/memory/unit_of_work'
 require_relative 'adapters/memory/relations/events'
 require_relative 'adapters/memory/relations/stream_entries'
+require_relative 'adapters/memory/changesets/create_events'
+require_relative 'adapters/memory/changesets/update_events'
+require_relative 'adapters/memory/changesets/create_stream_entries'
 
 module RubyEventStore
   module ROM
@@ -22,10 +25,11 @@ module RubyEventStore
         def configure(env)
           env.register_unit_of_work_options(class: UnitOfWork)
 
-          env.register_error_handler :unique_violation, -> ex {
+          env.register_error_handler :unique_violation, lambda { |ex|
             case ex
             when TupleUniquenessError
               raise EventDuplicatedInStream if ex.message =~ /event_id/
+
               raise WrongExpectedEventVersion
             end
           }
@@ -35,7 +39,7 @@ module RubyEventStore
       class SpecHelper
         attr_reader :env
         attr_reader :connection_pool_size, :close_pool_connection
-        
+
         def initialize
           @connection_pool_size = 5
           @env = ROM.setup(:memory)
@@ -54,14 +58,22 @@ module RubyEventStore
         def drop_gateway_schema
           gateway.connection.data.values.each { |v| v.data.clear }
         end
-      
+
         def close_gateway_connection
           gateway.disconnect
         end
 
+        def gateway_type?(name)
+          name == :memory
+        end
+
         def has_connection_pooling?
           true
         end
+
+        def supports_upsert?
+          true
+        end
       end
     end
   end

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

@@ -1,29 +1,22 @@
 require_relative '../mappers/event_to_serialized_record'
+require_relative '../changesets/create_events'
+require_relative '../changesets/update_events'
 
 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
+        def create_changeset(serialized_records)
+          events.create_changeset(serialized_records)
         end
 
-        def create_changeset(serialized_records)
-          events.changeset(Create, serialized_records)
+        def update_changeset(serialized_records)
+          events.update_changeset(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
 
@@ -45,21 +38,19 @@ module RubyEventStore
           query = read_scope(specification)
 
           if specification.batched?
-            reader = ->(offset, limit) do
-              query_builder(query, offset: offset, limit: limit).to_ary
-            end
-            BatchEnumerator.new(specification.batch_size, specification.limit, reader).each
+            BatchEnumerator.new(
+              specification.batch_size,
+              specification.limit,
+              ->(offset, limit) { query_builder(query, offset: offset, limit: limit).to_ary }
+            ).each
           else
-            limit = specification.limit if specification.limit?
-            query = query_builder(query, limit: limit)
+            query = query_builder(query, limit: (specification.limit if specification.limit?))
             if specification.head?
               specification.first? || specification.last? ? query.first : query.each
+            elsif specification.last?
+              query.to_ary.last
             else
-              if specification.last?
-                query.to_ary.last
-              else
-                specification.first? ? query.first : query.each
-              end
+              specification.first? ? query.first : query.each
             end
           end
         end
@@ -70,12 +61,10 @@ module RubyEventStore
           query.count
         end
 
-      protected
+        protected
 
         def read_scope(specification)
-          unless specification.head?
-            offset_entry_id = stream_entries.by_stream_and_event_id(specification.stream, specification.start).fetch(:id)
-          end
+          offset_entry_id = stream_entries.by_stream_and_event_id(specification.stream, specification.start).fetch(:id) unless specification.head?
 
           direction = specification.forward? ? :forward : :backward
 
@@ -84,7 +73,6 @@ module RubyEventStore
           end
 
           query = stream_entries.ordered(direction, specification.stream, offset_entry_id)
-
           query = query.by_event_id(specification.with_ids) if specification.with_ids
           query = query.by_event_type(specification.with_types) if specification.with_types?
           query