ruby_event_store-rom 1.2.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fbad65ea5711e53b4647d47f04c6e22f3ef894d0754ab87e7b046b1db92c03c
-  data.tar.gz: 07ac32244a81e624dbc01bcfec01f4a4eabbf1d6699b260c5b7d5917ba59448e
+  metadata.gz: 48f28d42768890a56d1b3b7656acdc5ac79c3cfe268292eccfbebc629a039c3d
+  data.tar.gz: ac9401345cbbfe5181822e94f87af9d0dfdabfa85b961665d66fd49f0a47a589
 SHA512:
-  metadata.gz: 12f8616fdbe35f69b5c55030d21e9263cf1587896162a4570a28869a4ac464deb1f6707a971d3f9a656a2fddba4352adc2041e65596555b922b42f5b62aa6d20
-  data.tar.gz: d8548c345aa648ee1ed2215131b21053e20b70eb3412884e4be0e23dd00c685b463206d5db542bcd1d3ed2d09ad090d0a3ab71499a5802beef2323d627edf5f1
+  metadata.gz: f30117d5b3a3fb046bacc5c13c5c83fb9ea115647eb906bd3649a5cb1b2d8cce9b4e36f9508224c4b4a32f65ca97d4edc803572049f8dfd27e248424c0995900
+  data.tar.gz: b9e646749e2631f476f27afcf33033cd73e3488d19b408f04b8694436099a643e3a2474c6525f646f94dc4b924f42e057a8036e81e77077569df65d5d3130ccc

data/README.md

@@ -1,9 +1,10 @@
 # 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,14 @@ 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
+        map do |tuple|
+          Hash(created_at: RubyEventStore::ROM::Types::DateTime.call(nil)).merge(tuple)
+        end
+        map do
+          map_value :created_at, ->(datetime) { datetime.to_time.localtime }
         end
-
-        include Defaults
       end
     end
   end

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

@@ -4,27 +4,40 @@ 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
+
+        def commit_on_duplicate_key_update
+          relation.dataset.on_duplicate_key_update(*UPSERT_COLUMNS).multi_insert(to_a)
         end
 
-        include Defaults
+        def commit_insert_conflict_update
+          relation.dataset.insert_conflict(
+            target: :event_id,
+            update: UPSERT_COLUMNS.each_with_object({}) do |column, memo|
+              memo[column] = Sequel[:excluded][column]
+            end
+          ).multi_insert(to_a)
+        end
       end
     end
   end

data/lib/ruby_event_store/rom/event_repository.rb

@@ -1,40 +1,26 @@
 # 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)
+      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),
-              global_stream: true
+              @stream_entries.resolve_version(stream, expected_version)
             )
           end
         end
@@ -43,15 +29,10 @@ module RubyEventStore
       end
 
       def link_to_stream(event_ids, stream, expected_version)
-        event_ids = Array(event_ids)
+        validate_event_ids(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|
+        handle_unique_violation do
+          @unit_of_work.call do |changesets|
             changesets << @stream_entries.create_changeset(
               event_ids,
               stream,
@@ -63,44 +44,65 @@ module RubyEventStore
         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 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,29 @@
+# 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
@@ -10,8 +8,10 @@ module RubyEventStore
         register_as :event_to_serialized_record
 
         map_array do
-          rename_keys id: :event_id
-          accept_keys %i[event_id data metadata event_type]
+          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]
           constructor_inject RubyEventStore::SerializedRecord
         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
@@ -10,8 +8,11 @@ module RubyEventStore
         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]
+          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]
           constructor_inject RubyEventStore::SerializedRecord
         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,81 @@
+# 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
+
+        alias take limit
+
+        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,90 @@
+# 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 do
+            belongs_to :events, as: :event, foreign_key: :event_id
+          end
+        end
+
+        alias take limit
+
+        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