ruby_event_store-rom 1.3.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 301643330ee509f7bb50b8eaab0c25ae261f57fbaeb8e6482c0c5e08e963aa6a
-  data.tar.gz: fb44e5a4cea7fb9fc1ddcc2d20b3e9f2e1ca31f4d55d3d12385ddc3c5ceb7ed9
+  metadata.gz: 3af23fb98d5ccf4b0730bfd4da1dfea36b511d5b7d00e82158daaa7ed3ba6979
+  data.tar.gz: 741f05db9dc98c607888e5a3a07a8289a3d02094e8deecfcf48da150d6388954
 SHA512:
-  metadata.gz: d0678314a60a994e96459db4016d5f5d3b5282a2bef564e1f77ed038d47640882739aa5190913aca160707ca8e63c68ac8597419199c1cea8fdf0e0bcf4e605a
-  data.tar.gz: b5b4749ffc9e53e85f9eba739777b23340bd8e628cb3d10a204cf42c33876ea0989a7dc58674b2912ac8dd0c936672c0fef5c5c2992dc70225788d746fadd4f4
+  metadata.gz: f6846ccb455e16a59fe7a3e655f912f77998af55527d7e0c49278f52454d3d283e9113b70d7fff4289268dc13018d3b0ab4e0dcb774767a313078c8081e7d7fa
+  data.tar.gz: b02ae36dbe6641fda9bb4005821f220954f1ff09672736f2f895963ba0fa366442b1aa21100fee0b20663d9b718d5f66f2a28461419caf1b45c6589cefd92bc3

data/README.md

@@ -1,9 +1,9 @@
 # RubyEventStore ROM Event Repository
 
+![RubyEventStore ROM Event Repository](https://github.com/RailsEventStore/rails_event_store/workflows/ruby_event_store-rom/badge.svg)
+
 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/lib/ruby_event_store/rom/changesets/create_events.rb

@@ -4,27 +4,19 @@ module RubyEventStore
   module ROM
     module Changesets
       class CreateEvents < ::ROM::Changeset::Create
-        module Defaults
-          def self.included(base)
-            base.class_eval do
-              relation :events
+        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
+        map(&:to_h)
+        map do
+          rename_keys timestamp: :created_at
+          map_value :created_at, ->(time) { Time.iso8601(time).localtime }
+          map_value :valid_at, ->(time) { Time.iso8601(time).localtime }
+          accept_keys %i[event_id data metadata event_type created_at valid_at]
         end
 
-        include Defaults
+        def commit
+          relation.multi_insert(to_a)
+        end
       end
     end
   end

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

@@ -4,19 +4,10 @@ module RubyEventStore
   module ROM
     module Changesets
       class CreateStreamEntries < ::ROM::Changeset::Create
-        module Defaults
-          def self.included(base)
-            base.class_eval do
-              relation :stream_entries
+        relation :stream_entries
 
-              map do |tuple|
-                Hash(created_at: RubyEventStore::ROM::Types::DateTime.call(nil)).merge(tuple)
-              end
-            end
-          end
-        end
-
-        include Defaults
+        map { |tuple| Hash(created_at: RubyEventStore::ROM::Types::DateTime.call(nil)).merge(tuple) }
+        map { map_value :created_at, ->(datetime) { datetime.to_time.localtime } }
       end
     end
   end

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

@@ -4,27 +4,41 @@ 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
+        relation :events
+
+        map(&:to_h)
+        map do
+          rename_keys timestamp: :created_at
+          map_value :created_at, ->(time) { Time.iso8601(time).localtime }
+          map_value :valid_at, ->(time) { Time.iso8601(time).localtime }
+          accept_keys %i[event_id data metadata event_type created_at valid_at]
+        end
+
+        UPSERT_COLUMNS = %i[event_type data metadata valid_at].freeze
+
+        def commit
+          supports_on_duplicate_key_update? ? commit_on_duplicate_key_update : commit_insert_conflict_update
+        end
+
+        private
+
+        def supports_on_duplicate_key_update?
+          relation.dataset.db.adapter_scheme =~ /mysql/
         end
 
-        include Defaults
+        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(
+              target: :event_id,
+              update: UPSERT_COLUMNS.each_with_object({}) { |column, memo| memo[column] = Sequel[:excluded][column] }
+            )
+            .multi_insert(to_a)
+        end
       end
     end
   end

data/lib/ruby_event_store/rom/event_repository.rb

@@ -1,41 +1,28 @@
 # frozen_string_literal: true
 
-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.rom_container)
-        @stream_entries = Repositories::StreamEntries.new(rom.rom_container)
+      def initialize(rom:, serializer:)
+        @serializer = serializer
+        @events = Repositories::Events.new(rom)
+        @stream_entries = Repositories::StreamEntries.new(rom)
+        @unit_of_work = UnitOfWork.new(rom.gateways.fetch(:default))
       end
 
-      def append_to_stream(events, stream, expected_version)
-        events = Array(events)
-        event_ids = events.map(&:event_id)
-
-        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
-            )
+      def append_to_stream(records, stream, expected_version)
+        serialized_records = records.map { |record| record.serialize(@serializer) }
+        event_ids = records.map(&:event_id)
+
+        handle_unique_violation do
+          @unit_of_work.call do |changesets|
+            changesets << @events.create_changeset(serialized_records)
+            changesets <<
+              @stream_entries.create_changeset(
+                event_ids,
+                stream,
+                @stream_entries.resolve_version(stream, expected_version)
+              )
           end
         end
 
@@ -43,64 +30,81 @@ module RubyEventStore
       end
 
       def link_to_stream(event_ids, stream, expected_version)
-        event_ids = Array(event_ids)
-
-        # Validate event IDs
-        @events
-          .find_nonexistent_pks(event_ids)
-          .each { |id| raise EventNotFound, 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)
-            )
+        validate_event_ids(event_ids)
+
+        handle_unique_violation do
+          @unit_of_work.call do |changesets|
+            changesets <<
+              @stream_entries.create_changeset(
+                event_ids,
+                stream,
+                @stream_entries.resolve_version(stream, expected_version)
+              )
           end
         end
 
         self
       end
 
+      def position_in_stream(event_id, stream)
+        @stream_entries.position_in_stream(event_id, stream)
+      end
+
+      def global_position(event_id)
+        @events.global_position(event_id)
+      end
+
+      def event_in_stream?(event_id, stream)
+        @stream_entries.event_in_stream?(event_id, stream)
+      end
+
       def delete_stream(stream)
         @stream_entries.delete(stream)
       end
 
       def has_event?(event_id)
-        guard_for(:not_found, event_id, swallow: EventNotFound) { @events.exist?(event_id) } || false
+        @events.exist?(event_id)
+      rescue Sequel::DatabaseError => doh
+        raise doh unless doh.message =~ /PG::InvalidTextRepresentation.*uuid/
+        false
       end
 
       def last_stream_event(stream)
-        @events.last_stream_event(stream)
+        @events.last_stream_event(stream, @serializer)
       end
 
       def read(specification)
-        raise ReservedInternalName if specification.stream.name.eql?(@stream_entries.stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME)
-
-        @events.read(specification)
+        @events.read(specification, @serializer)
       end
 
       def count(specification)
-        raise ReservedInternalName if specification.stream.name.eql?(@stream_entries.stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME)
-
         @events.count(specification)
       end
 
-      def update_messages(messages)
-        # Validate event IDs
-        @events
-          .find_nonexistent_pks(messages.map(&:event_id))
-          .each { |id| raise EventNotFound, id }
+      def update_messages(records)
+        validate_event_ids(records.map(&:event_id))
 
-        unit_of_work do |changesets|
-          changesets << @events.update_changeset(messages)
+        @unit_of_work.call do |changesets|
+          serialized_records = records.map { |record| record.serialize(@serializer) }
+          changesets << @events.update_changeset(serialized_records)
         end
       end
 
       def streams_of(event_id)
-        @stream_entries.streams_of(event_id)
-                       .map { |name| Stream.new(name) }
+        @stream_entries.streams_of(event_id).map { |name| Stream.new(name) }
+      end
+
+      private
+
+      def validate_event_ids(event_ids)
+        @events.find_nonexistent_pks(event_ids).each { |id| raise EventNotFound, id }
+      end
+
+      def handle_unique_violation
+        yield
+      rescue ::ROM::SQL::UniqueConstraintError, Sequel::UniqueConstraintViolation => doh
+        raise ::RubyEventStore::EventDuplicatedInStream if IndexViolationDetector.new.detect(doh.message)
+        raise ::RubyEventStore::WrongExpectedEventVersion
       end
     end
   end

data/lib/ruby_event_store/rom/index_violation_detector.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module ROM
+    class IndexViolationDetector
+      MYSQL5_PKEY_ERROR = "for key 'index_event_store_events_on_event_id'".freeze
+      MYSQL8_PKEY_ERROR = "for key 'event_store_events.index_event_store_events_on_event_id'".freeze
+      POSTGRES_PKEY_ERROR = "Key (event_id)".freeze
+      SQLITE3_PKEY_ERROR = "event_store_events.event_id".freeze
+
+      MYSQL5_INDEX_ERROR = "for key 'index_event_store_events_in_streams_on_stream_and_event_id'".freeze
+      MYSQL8_INDEX_ERROR =
+        "for key 'event_store_events_in_streams.index_event_store_events_in_streams_on_stream_and_event_id'".freeze
+      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

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'rom/transformer'
-
 module RubyEventStore
   module ROM
     module Mappers
@@ -9,10 +7,16 @@ module RubyEventStore
         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
+        map do
+          map_value :created_at, ->(time) { time.iso8601(TIMESTAMP_PRECISION) }
+          map_value :valid_at, ->(time) { time.iso8601(TIMESTAMP_PRECISION) }
+          rename_keys created_at: :timestamp
+          accept_keys %i[event_id data metadata event_type timestamp valid_at]
+          create_serialized_record
+        end
+
+        def create_serialized_record(attributes)
+          RubyEventStore::SerializedRecord.new(**attributes)
         end
       end
     end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'rom/transformer'
-
 module RubyEventStore
   module ROM
     module Mappers
@@ -9,10 +7,17 @@ module RubyEventStore
         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
+        map do
+          unwrap :event, %i[event_id data metadata event_type created_at valid_at]
+          map_value :created_at, ->(time) { time.iso8601(TIMESTAMP_PRECISION) }
+          map_value :valid_at, ->(time) { time.iso8601(TIMESTAMP_PRECISION) }
+          rename_keys created_at: :timestamp
+          accept_keys %i[event_id data metadata event_type timestamp valid_at]
+          create_serialized_record
+        end
+
+        def create_serialized_record(attributes)
+          RubyEventStore::SerializedRecord.new(**attributes)
         end
       end
     end

data/lib/ruby_event_store/rom/rake_task.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "rom/sql/rake_task"
+require "ruby_event_store/rom"
+load "ruby_event_store/rom/tasks/migration_tasks.rake"

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module ROM
+    module Relations
+      class Events < ::ROM::Relation[:sql]
+        schema(:event_store_events, as: :events, infer: true) do
+          attribute :event_id, ::ROM::Types::String
+          attribute :data,
+                    RubyEventStore::ROM::Types::RecordSerializer,
+                    read: RubyEventStore::ROM::Types::RecordDeserializer
+          attribute :metadata,
+                    RubyEventStore::ROM::Types::RecordSerializer,
+                    read: RubyEventStore::ROM::Types::RecordDeserializer
+          attribute :created_at, RubyEventStore::ROM::Types::DateTime
+          attribute :valid_at, RubyEventStore::ROM::Types::DateTime
+
+          primary_key :event_id
+        end
+
+        def create_changeset(tuples)
+          events.changeset(Changesets::CreateEvents, tuples)
+        end
+
+        def update_changeset(tuples)
+          events.changeset(Changesets::UpdateEvents, tuples)
+        end
+
+        def by_event_id(event_id)
+          where(event_id: event_id)
+        end
+
+        def by_event_type(types)
+          where(event_type: types)
+        end
+
+        def newer_than(time)
+          where { |r| r.events[:created_at] > time.localtime }
+        end
+
+        def newer_than_or_equal(time)
+          where { |r| r.events[:created_at] >= time.localtime }
+        end
+
+        def older_than(time)
+          where { |r| r.events[:created_at] < time.localtime }
+        end
+
+        def older_than_or_equal(time)
+          where { |r| r.events[:created_at] <= time.localtime }
+        end
+
+        DIRECTION_MAP = { forward: %i[asc > <], backward: %i[desc < >] }.freeze
+
+        def ordered(direction, offset_entry_id = nil, stop_entry_id = nil, time_sort_by = nil)
+          order, operator_offset, operator_stop = DIRECTION_MAP[direction]
+
+          raise ArgumentError, "Direction must be :forward or :backward" if order.nil?
+
+          event_order_columns = [:id]
+
+          case time_sort_by
+          when :as_at
+            event_order_columns.unshift :created_at
+          when :as_of
+            event_order_columns.unshift :valid_at
+          end
+
+          query = self
+          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(*event_order_columns.map { |c| events[c].public_send(order) })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module ROM
+    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 { belongs_to :events, as: :event, foreign_key: :event_id }
+        end
+
+        def create_changeset(tuples)
+          changeset(ROM::Changesets::CreateStreamEntries, tuples)
+        end
+
+        def by_stream(stream)
+          where(stream: stream.name)
+        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: stream.name, event_id: event_id).one!
+        end
+
+        def max_position(stream)
+          by_stream(stream).select(:position).order(Sequel.desc(:position)).first
+        end
+
+        def newer_than(time)
+          join(:events).where { |r| r.events[:created_at] > time.localtime }
+        end
+
+        def newer_than_or_equal(time)
+          join(:events).where { |r| r.events[:created_at] >= time.localtime }
+        end
+
+        def older_than(time)
+          join(:events).where { |r| r.events[:created_at] < time.localtime }
+        end
+
+        def older_than_or_equal(time)
+          join(:events).where { |r| r.events[:created_at] <= time.localtime }
+        end
+
+        DIRECTION_MAP = { forward: %i[asc > <], backward: %i[desc < >] }.freeze
+
+        def ordered(direction, stream, offset_entry_id = nil, stop_entry_id = nil, time_sort_by = nil)
+          order, operator_offset, operator_stop = DIRECTION_MAP[direction]
+
+          raise ArgumentError, "Direction must be :forward or :backward" if order.nil?
+
+          event_order_columns = []
+          stream_order_columns = %i[id]
+
+          case time_sort_by
+          when :as_at
+            event_order_columns.unshift :created_at
+          when :as_of
+            event_order_columns.unshift :valid_at
+          end
+
+          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
+
+          if event_order_columns.empty?
+            query.order { |r| stream_order_columns.map { |c| r[:stream_entries][c].public_send(order) } }
+          else
+            query.join(:events).order { |r| event_order_columns.map { |c| r.events[c].public_send(order) } }
+          end
+        end
+      end
+    end
+  end
+end