ruby_event_store-rom 1.3.1 → 2.1.0

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

@@ -1,52 +1,46 @@
 # frozen_string_literal: true
 
-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]
-        def create_changeset(serialized_records)
-          events.create_changeset(serialized_records)
+        def create_changeset(records)
+          events.create_changeset(records)
         end
 
-        def update_changeset(serialized_records)
-          events.update_changeset(serialized_records)
+        def update_changeset(records)
+          events.update_changeset(records)
         end
 
         def find_nonexistent_pks(event_ids)
           return event_ids unless event_ids.any?
 
-          event_ids - events.by_pk(event_ids).pluck(:id)
+          event_ids - events.by_event_id(event_ids).pluck(:event_id)
         end
 
         def exist?(event_id)
-          events.by_pk(event_id).exist?
-        end
-
-        def by_id(event_id)
-          events.map_with(:event_to_serialized_record).by_pk(event_id).one!
+          events.by_event_id(event_id).exist?
         end
 
-        def last_stream_event(stream)
+        def last_stream_event(stream, serializer)
           query = stream_entries.ordered(:backward, stream)
-          query = query_builder(query, limit: 1)
+          query = query.combine(:event)
+          query = query.map_with(:stream_entry_to_serialized_record, auto_struct: false)
+          query = query_builder(serializer, query, limit: 1)
           query.first
         end
 
-        def read(specification)
+        def read(specification, serializer)
           query = read_scope(specification)
 
           if specification.batched?
             BatchEnumerator.new(
               specification.batch_size,
               specification.limit,
-              ->(offset, limit) { query_builder(query, offset: offset, limit: limit).to_ary }
+              ->(offset, limit) { query_builder(serializer, query, offset: offset, limit: limit).to_ary }
             ).each
           else
-            query = query_builder(query, limit: (specification.limit if specification.limit?))
+            query = query_builder(serializer, query, limit: (specification.limit if specification.limit?))
             if !specification.start && !specification.stop
               specification.first? || specification.last? ? query.first : query.each
             elsif specification.last?
@@ -59,35 +53,66 @@ module RubyEventStore
 
         def count(specification)
           query = read_scope(specification)
-          query = query.take(specification.limit) if specification.limit?
+          query = query.limit(specification.limit) if specification.limit?
           query.count
         end
 
+        def global_position(event_id)
+          record = events.by_event_id(event_id).one
+          raise EventNotFound.new(event_id) if record.nil?
+          record.id - 1
+        end
+
         protected
 
         def read_scope(specification)
-          offset_entry_id = stream_entries.by_stream_and_event_id(specification.stream, specification.start).fetch(:id) if specification.start
-          stop_entry_id = stream_entries.by_stream_and_event_id(specification.stream, specification.stop).fetch(:id) if specification.stop
-
           direction = specification.forward? ? :forward : :backward
 
           if specification.last? && !specification.start && !specification.stop
             direction = specification.forward? ? :backward : :forward
           end
 
-          query = stream_entries.ordered(direction, specification.stream, offset_entry_id, stop_entry_id)
+          if specification.stream.global?
+            offset_entry_id = events.by_event_id(specification.start).one!.fetch(:id) if specification.start
+            stop_entry_id = events.by_event_id(specification.stop).one!.fetch(:id) if specification.stop
+
+            query = events.ordered(direction, offset_entry_id, stop_entry_id, specification.time_sort_by)
+            query = query.map_with(:event_to_serialized_record, auto_struct: false)
+          else
+            offset_entry_id =
+              stream_entries
+                .by_stream_and_event_id(specification.stream, specification.start)
+                .fetch(:id) if specification.start
+            stop_entry_id =
+              stream_entries
+                .by_stream_and_event_id(specification.stream, specification.stop)
+                .fetch(:id) if specification.stop
+
+            query =
+              stream_entries.ordered(
+                direction,
+                specification.stream,
+                offset_entry_id,
+                stop_entry_id,
+                specification.time_sort_by
+              )
+            query = query.combine(:event)
+            query = query.map_with(:stream_entry_to_serialized_record, auto_struct: false)
+          end
+
           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 = query.older_than(specification.older_than) if specification.older_than
+          query = query.older_than_or_equal(specification.older_than_or_equal) if specification.older_than_or_equal
+          query = query.newer_than(specification.newer_than) if specification.newer_than
+          query = query.newer_than_or_equal(specification.newer_than_or_equal) if specification.newer_than_or_equal
           query
         end
 
-        def query_builder(query, offset: nil, limit: nil)
+        def query_builder(serializer, query, offset: nil, limit: nil)
           query = query.offset(offset) if offset
-          query = query.take(limit)    if limit
-
-          query
-            .combine(:event)
-            .map_with(:stream_entry_to_serialized_record, auto_struct: false)
+          query = query.limit(limit) if limit
+          query.to_a.map { |serialized_record| serialized_record.deserialize(serializer) }
         end
       end
     end

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

@@ -1,15 +1,12 @@
 # frozen_string_literal: true
 
-require_relative '../mappers/stream_entry_to_serialized_record'
-require_relative '../changesets/create_stream_entries'
-
 module RubyEventStore
   module ROM
     module Repositories
       class StreamEntries < ::ROM::Repository[:stream_entries]
         POSITION_SHIFT = 1
 
-        def create_changeset(event_ids, stream, resolved_version, global_stream: nil)
+        def create_changeset(event_ids, stream, resolved_version)
           tuples = []
 
           event_ids.each_with_index do |event_id, index|
@@ -20,14 +17,6 @@ module RubyEventStore
                 event_id: event_id
               }
             end
-
-            next unless global_stream
-
-            tuples << {
-              stream: stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME,
-              position: nil,
-              event_id: event_id
-            }
           end
 
           stream_entries.create_changeset(tuples)
@@ -38,14 +27,24 @@ module RubyEventStore
         end
 
         def resolve_version(stream, expected_version)
-          expected_version.resolve_for(stream, lambda { |_stream|
-            (stream_entries.max_position(stream) || {})[:position]
-          })
+          expected_version.resolve_for(
+            stream,
+            lambda { |_stream| (stream_entries.max_position(stream) || {})[:position] }
+          )
         end
 
         def streams_of(event_id)
           stream_entries.by_event_id(event_id).map { |e| e[:stream] }
-                        .reject { |s| s == stream_entries.class::SERIALIZED_GLOBAL_STREAM_NAME }
+        end
+
+        def position_in_stream(event_id, stream)
+          record = stream_entries.by_stream(stream).by_event_id(event_id).one
+          raise EventNotFoundInStream if record.nil?
+          record.position
+        end
+
+        def event_in_stream?(event_id, stream)
+          stream_entries.by_stream(stream).by_event_id(event_id).exist?
         end
       end
     end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "ruby_event_store/rom"
+
+MIGRATIONS_PATH = "db/migrate".freeze
+
+desc "Setup ROM EventRespository environment"
+task "db:setup" do
+  Dir.chdir(Dir.pwd)
+  ROM::SQL::RakeSupport.env = ::RubyEventStore::ROM.rom_container(:sql, ENV["DATABASE_URL"])
+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|
+    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)
+
+    File.write output, contents
+
+    puts "<= migration file created #{output}"
+  end
+end

data/lib/ruby_event_store/rom/types.rb

@@ -3,22 +3,24 @@
 module RubyEventStore
   module ROM
     module Types
-      DateTime = ::ROM::Types::DateTime
-                 .constructor do |value|
-                   case value
-                   when nil
-                     Dry::Core::Constants::Undefined
-                   when ::String
-                     ::DateTime.iso8601(value)
-                   else
-                     value
-                   end
-                 end
-                 .default { ::DateTime.now.new_offset(0) }
+      DateTime =
+        ::ROM::Types::DateTime
+          .constructor do |value|
+            case value
+            when nil
+              Dry::Core::Constants::Undefined
+            when ::String
+              ::DateTime.iso8601(value)
+            else
+              value
+            end
+          end
+          .default { ::DateTime.now.new_offset(0) }
 
-      SerializedRecordSerializer = ::ROM::Types::String
       # detects if the value is a Sequel::Postgres::JSONHash or Sequel::Postgres::JSONBHash
-      SerializedRecordDeserializer = ::ROM::Types::String.constructor { |v| v.class.name.upcase.include?('JSON') ? JSON.dump(v) : v }
+      RecordDeserializer =
+        ::ROM::Types::String.constructor { |v| v.class.name.upcase.include?("JSON") ? JSON.dump(v) : v }
+      RecordSerializer = ::ROM::Types::String
     end
   end
 end

data/lib/ruby_event_store/rom/unit_of_work.rb

@@ -3,22 +3,37 @@
 module RubyEventStore
   module ROM
     class UnitOfWork
-      attr_reader :env
-
-      def initialize(rom: ROM.env)
-        @env = rom
+      def initialize(gateway)
+        @gateway = gateway
       end
 
-      def call(**options)
-        gateway = @env.rom_container.gateways.fetch(options.delete(:gateway) { :default })
-
+      def call
         yield(changesets = [])
-
-        commit!(gateway, changesets, **options)
-      end
-
-      def commit!(gateway, changesets, **options)
-        gateway.transaction(options) { changesets.each(&:commit) }
+        @gateway.transaction(
+          savepoint: true,
+          # See: https://github.com/jeremyevans/sequel/blob/master/doc/transactions.rdoc
+          #
+          # Committing changesets concurrently causes MySQL deadlocks
+          # which are not caught and retried by Sequel's built-in
+          # :retry_on option. This appears to be a result of how ROM
+          # handles exceptions which don't bubble up so that Sequel
+          # can retry transactions with the :retry_on option when there's
+          # a deadlock.
+          #
+          # This is exacerbated by the fact that changesets insert multiple
+          # tuples with individual INSERT statements because ROM specifies
+          # to Sequel to return a list of primary keys created. The likelihood
+          # of a deadlock is reduced with batched INSERT statements.
+          #
+          # For this reason we need to manually insert changeset records to avoid
+          # MySQL deadlocks or to allow Sequel to retry transactions
+          # when the :retry_on option is specified.
+          retry_on: Sequel::SerializationFailure,
+          before_retry:
+            lambda do |_num, ex|
+              env.logger.warn("RETRY TRANSACTION [#{self.class.name} => #{ex.class.name}] #{ex.message}")
+            end
+        ) { changesets.each(&:commit) }
       end
     end
   end

data/lib/ruby_event_store/rom/version.rb

@@ -2,6 +2,6 @@
 
 module RubyEventStore
   module ROM
-    VERSION = "1.3.1"
+    VERSION = "2.1.0"
   end
 end

data/lib/ruby_event_store/rom.rb

@@ -1,116 +1,41 @@
 # frozen_string_literal: true
 
-require 'rom-changeset'
-require 'rom-repository'
-require 'ruby_event_store'
-require 'ruby_event_store/rom/types'
-require 'ruby_event_store/rom/event_repository'
-require 'ruby_event_store/rom/changesets/create_events'
-require 'ruby_event_store/rom/changesets/update_events'
-require 'ruby_event_store/rom/changesets/create_stream_entries'
-require 'ruby_event_store/rom/tuple_uniqueness_error'
-require 'ruby_event_store/rom/unit_of_work'
-require 'ruby_event_store/rom/version'
+require "ruby_event_store"
+require "rom"
+require "rom/sql"
+require "rom/transformer"
+
+require_relative "rom/changesets/create_events"
+require_relative "rom/changesets/create_stream_entries"
+require_relative "rom/changesets/update_events"
+require_relative "rom/event_repository"
+require_relative "rom/index_violation_detector"
+require_relative "rom/mappers/event_to_serialized_record"
+require_relative "rom/mappers/stream_entry_to_serialized_record"
+require_relative "rom/relations/events"
+require_relative "rom/relations/stream_entries"
+require_relative "rom/repositories/events"
+require_relative "rom/repositories/stream_entries"
+require_relative "rom/types"
+require_relative "rom/unit_of_work"
 
 module RubyEventStore
   module ROM
-    class Env
-      include Dry::Container::Mixin
-
-      attr_accessor :rom_container
-
-      def initialize(rom_container)
-        @rom_container = rom_container
-
-        register(:unique_violation_error_handlers, Set.new)
-        register(:not_found_error_handlers, Set.new)
-        register(:logger, Logger.new(STDOUT).tap { |logger| logger.level = Logger::WARN })
-      end
-
-      def logger
-        resolve(:logger)
-      end
-
-      def unit_of_work(&block)
-        options = resolve(:unit_of_work_options).dup
-        options.delete(:class) { UnitOfWork }.new(rom: self).call(**options, &block)
-      end
-
-      def register_unit_of_work_options(options)
-        register(:unit_of_work_options, options)
-      end
-
-      def register_error_handler(type, handler)
-        resolve(:"#{type}_error_handlers") << handler
-      end
-
-      def handle_error(type, *args, swallow: [])
-        yield
-      rescue StandardError => e
-        begin
-          resolve(:"#{type}_error_handlers").each { |h| h.call(e, *args) }
-          raise e
-        rescue *swallow
-          # swallow
+    class << self
+      def setup(adapter_name, database_uri = ENV["DATABASE_URL"])
+        rom_container(adapter_name, database_uri) do |rom|
+          rom.register_mapper Mappers::StreamEntryToSerializedRecord
+          rom.register_mapper Mappers::EventToSerializedRecord
+          rom.register_relation Relations::Events
+          rom.register_relation Relations::StreamEntries
         end
       end
-    end
-
-    class << self
-      # Set to a default instance
-      attr_accessor :env
 
-      def configure(adapter_name, database_uri = ENV['DATABASE_URL'], &block)
+      def rom_container(adapter_name, database_uri, &block)
         if adapter_name.is_a?(::ROM::Configuration)
-          # Call config block manually
-          Env.new ::ROM.container(adapter_name.tap(&block), &block)
+          ::ROM.container(adapter_name.tap(&block), &block)
         else
-          Env.new ::ROM.container(adapter_name, database_uri, &block)
-        end
-      end
-
-      def setup(*args, &block)
-        configure(*args) do |config|
-          setup_defaults(config)
-          yield(config) if block
-        end.tap(&method(:configure_defaults))
-      end
-
-      private
-
-      def setup_defaults(config)
-        require_relative 'rom/repositories/stream_entries'
-        require_relative 'rom/repositories/events'
-
-        config.register_mapper(ROM::Mappers::EventToSerializedRecord)
-        config.register_mapper(ROM::Mappers::StreamEntryToSerializedRecord)
-
-        find_adapters(config.environment.gateways).each do |adapter|
-          adapter.setup(config)
-        end
-      end
-
-      def configure_defaults(env)
-        env.register_error_handler :not_found, lambda { |ex, event_id|
-          case ex
-          when ::ROM::TupleCountMismatchError
-            raise EventNotFound, event_id
-          end
-        }
-
-        find_adapters(env.rom_container.gateways).each do |adapter|
-          adapter.configure(env)
-        end
-      end
-
-      def find_adapters(gateways)
-        # Setup for each kind of gateway class
-        gateways.values.map(&:class).uniq.map do |klass|
-          constant = klass.name.split('::')[1].to_sym
-
-          next unless RubyEventStore::ROM.constants.include?(constant)
-
-          RubyEventStore::ROM.const_get(constant)
+          ::ROM.container(adapter_name, database_uri, &block)
         end
       end
     end

data/lib/ruby_event_store-rom.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-require 'ruby_event_store/rom'
+require "ruby_event_store/rom"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store-rom
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Joel Van Horn
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2021-01-05 00:00:00.000000000 Z
+date: 2023-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-container
@@ -95,92 +95,74 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: ruby_event_store
+  name: sequel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.1
+        version: 5.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.1
+        version: 5.11.0
 - !ruby/object:Gem::Dependency
-  name: sequel
+  name: ruby_event_store
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.11.0
+        version: 2.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.11.0
-description: Implementation of events repository based on ROM for Ruby Event Store'
-email:
-- joel@joelvanhorn.com
+        version: 2.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Implementation of events repository based on ROM for Ruby Event Store
+email: joel@joelvanhorn.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
 files:
-- ".rubocop.yml"
-- ".rubocop_todo.yml"
-- CHANGELOG.md
-- Gemfile
-- Makefile
 - README.md
-- Rakefile
-- db/migrate/20180327044629_create_ruby_event_store_tables.rb
-- db/migrate/20181026152045_index_by_event_type.rb
 - lib/ruby_event_store-rom.rb
 - lib/ruby_event_store/rom.rb
-- lib/ruby_event_store/rom/adapters/memory/changesets/create_events.rb
-- lib/ruby_event_store/rom/adapters/memory/changesets/create_stream_entries.rb
-- lib/ruby_event_store/rom/adapters/memory/changesets/update_events.rb
-- lib/ruby_event_store/rom/adapters/memory/relations/events.rb
-- lib/ruby_event_store/rom/adapters/memory/relations/stream_entries.rb
-- lib/ruby_event_store/rom/adapters/memory/unit_of_work.rb
-- lib/ruby_event_store/rom/adapters/sql/changesets/create_events.rb
-- lib/ruby_event_store/rom/adapters/sql/changesets/update_events.rb
-- lib/ruby_event_store/rom/adapters/sql/index_violation_detector.rb
-- lib/ruby_event_store/rom/adapters/sql/rake_task.rb
-- lib/ruby_event_store/rom/adapters/sql/relations/events.rb
-- lib/ruby_event_store/rom/adapters/sql/relations/stream_entries.rb
-- lib/ruby_event_store/rom/adapters/sql/tasks/migration_tasks.rake
 - lib/ruby_event_store/rom/changesets/create_events.rb
 - lib/ruby_event_store/rom/changesets/create_stream_entries.rb
 - lib/ruby_event_store/rom/changesets/update_events.rb
 - lib/ruby_event_store/rom/event_repository.rb
+- lib/ruby_event_store/rom/index_violation_detector.rb
 - lib/ruby_event_store/rom/mappers/event_to_serialized_record.rb
 - lib/ruby_event_store/rom/mappers/stream_entry_to_serialized_record.rb
-- lib/ruby_event_store/rom/memory.rb
+- lib/ruby_event_store/rom/rake_task.rb
+- lib/ruby_event_store/rom/relations/events.rb
+- lib/ruby_event_store/rom/relations/stream_entries.rb
 - lib/ruby_event_store/rom/repositories/events.rb
 - lib/ruby_event_store/rom/repositories/stream_entries.rb
-- lib/ruby_event_store/rom/sql.rb
-- lib/ruby_event_store/rom/tuple_uniqueness_error.rb
+- lib/ruby_event_store/rom/tasks/migration_tasks.rake
 - lib/ruby_event_store/rom/types.rb
 - lib/ruby_event_store/rom/unit_of_work.rb
 - lib/ruby_event_store/rom/version.rb
-- lib/ruby_event_store/spec/rom/event_repository_lint.rb
-- lib/ruby_event_store/spec/rom/relations/events_lint.rb
-- lib/ruby_event_store/spec/rom/relations/stream_entries_lint.rb
-- lib/ruby_event_store/spec/rom/spec_helper_lint.rb
-- lib/ruby_event_store/spec/rom/unit_of_work_lint.rb
-- ruby_event_store-rom.gemspec
 homepage: https://railseventstore.org
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://railseventstore.org/
-  changelog_uri: https://github.com/RailsEventStore/rails_event_store/releases
+  homepage_uri: https://railseventstore.org
+  changelog_uri: https://github.com/RailsEventStore/rails_event_store/blob/master/contrib/ruby_event_store-rom/CHANGELOG.md
   source_code_uri: https://github.com/RailsEventStore/rails_event_store
   bug_tracker_uri: https://github.com/RailsEventStore/rails_event_store/issues
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -189,14 +171,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: ROM events repository for Ruby Event Store

data/.rubocop.yml

@@ -1 +0,0 @@
-inherit_from: .rubocop_todo.yml