ruby_event_store-rom 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48f28d42768890a56d1b3b7656acdc5ac79c3cfe268292eccfbebc629a039c3d
-  data.tar.gz: ac9401345cbbfe5181822e94f87af9d0dfdabfa85b961665d66fd49f0a47a589
+  metadata.gz: 0346bda57c2f37b5dd9f545f51d980fef10af52630613aa4741f48aa57d3e8eb
+  data.tar.gz: 2e451dd750e028ee9f8a3182e65721c7e3c569a1ac283f9e25cb66e92ac89fac
 SHA512:
-  metadata.gz: f30117d5b3a3fb046bacc5c13c5c83fb9ea115647eb906bd3649a5cb1b2d8cce9b4e36f9508224c4b4a32f65ca97d4edc803572049f8dfd27e248424c0995900
-  data.tar.gz: b9e646749e2631f476f27afcf33033cd73e3488d19b408f04b8694436099a643e3a2474c6525f646f94dc4b924f42e057a8036e81e77077569df65d5d3130ccc
+  metadata.gz: b4f057692be3234140fdc0102cc66af4280e1a9b83ecaff362d6a18c644fd7df5ed089dd85e3f62d10ee871d5c41fc1a1660cc96aff08d81f728554c65563070
+  data.tar.gz: 3eda5e842ca678da3039b04458f910021ba5639c286c8d5c0eee9c4ccfa2a10d4da3f2c4d534e7e6e65f3dd94d5e26385353b63eba36953b4bcf507e18af9785

data/README.md

@@ -7,4 +7,3 @@ A Ruby Object Model (ROM) implementation of events repository for [Ruby Event St
 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/)
-

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

@@ -9,8 +9,8 @@ module RubyEventStore
         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 }
+          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
 

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

@@ -6,12 +6,8 @@ module RubyEventStore
       class CreateStreamEntries < ::ROM::Changeset::Create
         relation :stream_entries
 
-        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
+        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

@@ -9,8 +9,8 @@ module RubyEventStore
         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 }
+          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
 
@@ -31,12 +31,13 @@ module RubyEventStore
         end
 
         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)
+          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

data/lib/ruby_event_store/rom/event_repository.rb

@@ -4,24 +4,25 @@ module RubyEventStore
   module ROM
     class EventRepository
       def initialize(rom:, serializer:)
-        @serializer     = serializer
-        @events         = Repositories::Events.new(rom)
+        @serializer = serializer
+        @events = Repositories::Events.new(rom)
         @stream_entries = Repositories::StreamEntries.new(rom)
-        @unit_of_work   = UnitOfWork.new(rom.gateways.fetch(:default))
+        @unit_of_work = UnitOfWork.new(rom.gateways.fetch(:default))
       end
 
       def append_to_stream(records, stream, expected_version)
         serialized_records = records.map { |record| record.serialize(@serializer) }
-        event_ids          = records.map(&:event_id)
+        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)
-            )
+            changesets <<
+              @stream_entries.create_changeset(
+                event_ids,
+                stream,
+                @stream_entries.resolve_version(stream, expected_version)
+              )
           end
         end
 
@@ -33,11 +34,12 @@ module RubyEventStore
 
         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)
-            )
+            changesets <<
+              @stream_entries.create_changeset(
+                event_ids,
+                stream,
+                @stream_entries.resolve_version(stream, expected_version)
+              )
           end
         end
 
@@ -52,6 +54,10 @@ module RubyEventStore
         @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
@@ -85,17 +91,13 @@ module RubyEventStore
       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 }
+        @events.find_nonexistent_pks(event_ids).each { |id| raise EventNotFound, id }
       end
 
       def handle_unique_violation

data/lib/ruby_event_store/rom/index_violation_detector.rb

@@ -3,26 +3,22 @@
 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
+      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
+      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
+      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
+      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)
+        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

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

@@ -7,12 +7,16 @@ module RubyEventStore
         relation :events
         register_as :event_to_serialized_record
 
-        map_array do
+        map do
           map_value :created_at, ->(time) { time.iso8601(TIMESTAMP_PRECISION) }
-          map_value :valid_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
+          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

@@ -7,13 +7,17 @@ module RubyEventStore
         relation :stream_entries
         register_as :stream_entry_to_serialized_record
 
-        map_array do
+        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) }
+          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
+          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

@@ -2,4 +2,4 @@
 
 require "rom/sql/rake_task"
 require "ruby_event_store/rom"
-load    "ruby_event_store/rom/tasks/migration_tasks.rake"
+load "ruby_event_store/rom/tasks/migration_tasks.rake"

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

@@ -6,18 +6,18 @@ module RubyEventStore
       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 :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
@@ -34,26 +34,39 @@ module RubyEventStore
           where(event_type: types)
         end
 
-        def newer_than(time)
-          where { |r| r.events[:created_at] > time.localtime }
+        def newer_than(time, time_sort_by)
+          if time_sort_by == :as_of
+            where { |r| string::coalesce(r.events[:valid_at], r.events[:created_at]) > time.localtime }
+          else
+            where { |r| r.events[:created_at] > time.localtime }
+          end
         end
 
-        def newer_than_or_equal(time)
-          where { |r| r.events[:created_at] >= time.localtime }
+        def newer_than_or_equal(time, time_sort_by)
+          if time_sort_by == :as_of
+            where { |r| string::coalesce(r.events[:valid_at], r.events[:created_at]) >= time.localtime }
+          else
+            where { |r| r.events[:created_at] >= time.localtime }
+          end
         end
 
-        def older_than(time)
-          where { |r| r.events[:created_at] < time.localtime }
+        def older_than(time, time_sort_by)
+          if time_sort_by == :as_of
+            where { |r| string::coalesce(r.events[:valid_at], r.events[:created_at]) < time.localtime }
+          else
+            where { |r| r.events[:created_at] < time.localtime }
+          end
         end
 
-        def older_than_or_equal(time)
-          where { |r| r.events[:created_at] <= time.localtime }
+        def older_than_or_equal(time, time_sort_by)
+          if time_sort_by == :as_of
+            where { |r| string::coalesce(r.events[:valid_at], r.events[:created_at]) <= time.localtime }
+          else
+            where { |r| r.events[:created_at] <= time.localtime }
+          end
         end
 
-        DIRECTION_MAP = {
-          forward: %i[asc > <],
-          backward: %i[desc < >]
-        }.freeze
+        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]

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

@@ -7,13 +7,9 @@ module RubyEventStore
         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
+          associations { belongs_to :events, as: :event, foreign_key: :event_id }
         end
 
-        alias take limit
-
         def create_changeset(tuples)
           changeset(ROM::Changesets::CreateStreamEntries, tuples)
         end
@@ -27,7 +23,7 @@ module RubyEventStore
         end
 
         def by_event_type(types)
-          join(:events).where(event_type: types)
+          join_events.where(event_type: types)
         end
 
         def by_stream_and_event_id(stream, event_id)
@@ -38,33 +34,46 @@ module RubyEventStore
           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 }
+        def newer_than(time, time_sort_by)
+          if time_sort_by == :as_of
+            join_events.where { |r| string::coalesce(r.events[:valid_at], r.events[:created_at]) > time.localtime }
+          else
+            join_events.where { |r| r.events[:created_at] > time.localtime }
+          end
         end
 
-        def newer_than_or_equal(time)
-          join(:events).where { |r| r.events[:created_at] >= time.localtime }
+        def newer_than_or_equal(time, time_sort_by)
+          if time_sort_by == :as_of
+            join_events.where { |r| string::coalesce(r.events[:valid_at], r.events[:created_at]) >= time.localtime }
+          else
+            join_events.where { |r| r.events[:created_at] >= time.localtime }
+          end
         end
 
-        def older_than(time)
-          join(:events).where { |r| r.events[:created_at] < time.localtime }
+        def older_than(time, time_sort_by)
+          if time_sort_by == :as_of
+            join_events.where { |r| string::coalesce(r.events[:valid_at], r.events[:created_at]) < time.localtime }
+          else
+            join_events.where { |r| r.events[:created_at] < time.localtime }
+          end
         end
 
-        def older_than_or_equal(time)
-          join(:events).where { |r| r.events[:created_at] <= time.localtime }
+        def older_than_or_equal(time, time_sort_by)
+          if time_sort_by == :as_of
+            join_events.where { |r| string::coalesce(r.events[:valid_at], r.events[:created_at]) <= time.localtime }
+          else
+            join_events.where { |r| r.events[:created_at] <= time.localtime }
+          end
         end
 
-        DIRECTION_MAP = {
-          forward: %i[asc > <],
-          backward: %i[desc < >]
-        }.freeze
+        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  = []
+          event_order_columns = []
           stream_order_columns = %i[id]
 
           case time_sort_by
@@ -81,7 +90,15 @@ module RubyEventStore
           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) } }
+            query.join_events.order { |r| event_order_columns.map { |c| r.events[c].public_send(order) } }
+          end
+        end
+
+        def join_events
+          if dataset.opts[:join]&.map(&:table)&.include?(events.dataset.first_source_table)
+            self
+          else
+            join(:events)
           end
         end
       end

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

@@ -53,7 +53,7 @@ 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
 
@@ -65,6 +65,20 @@ module RubyEventStore
 
         protected
 
+        def find_event_id_in_stream(specification_event_id, specification_stream_name)
+          stream_entries
+            .by_stream_and_event_id(specification_stream_name, specification_event_id)
+            .fetch(:id)
+        rescue ::ROM::TupleCountMismatchError
+          raise EventNotFound.new(specification_event_id)
+        end
+
+        def find_event_id_globally(specification_event_id)
+          events.by_event_id(specification_event_id).one!.fetch(:id)
+        rescue ::ROM::TupleCountMismatchError
+          raise EventNotFound.new(specification_event_id)
+        end
+
         def read_scope(specification)
           direction = specification.forward? ? :forward : :backward
 
@@ -73,35 +87,40 @@ module RubyEventStore
           end
 
           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
+            offset_entry_id = find_event_id_globally(specification.start) if specification.start
+            stop_entry_id = find_event_id_globally(specification.stop) 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)
+            offset_entry_id = find_event_id_in_stream(specification.start, specification.stream) if specification.start
+            stop_entry_id = find_event_id_in_stream(specification.stop, specification.stream) 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 = 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, specification.time_sort_by) if specification.older_than
+          query = query.older_than_or_equal(specification.older_than_or_equal, specification.time_sort_by) if specification.older_than_or_equal
+          query = query.newer_than(specification.newer_than, specification.time_sort_by) if specification.newer_than
+          query = query.newer_than_or_equal(specification.newer_than_or_equal, specification.time_sort_by) if specification.newer_than_or_equal
           query
         end
 
         def query_builder(serializer, query, offset: nil, limit: nil)
           query = query.offset(offset) if offset
-          query = query.take(limit)    if limit
-          query
-            .to_a
-            .map { |serialized_record| serialized_record.deserialize(serializer) }
+          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

@@ -27,9 +27,10 @@ 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)
@@ -41,6 +42,10 @@ module RubyEventStore
           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
   end

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

@@ -7,7 +7,7 @@ MIGRATIONS_PATH = "db/migrate".freeze
 desc "Setup ROM EventRespository environment"
 task "db:setup" do
   Dir.chdir(Dir.pwd)
-  ROM::SQL::RakeSupport.env = ::RubyEventStore::ROM.configure(:sql).rom_container
+  ROM::SQL::RakeSupport.env = ::RubyEventStore::ROM.rom_container(:sql, ENV["DATABASE_URL"])
 end
 
 desc "Copy RubyEventStore SQL migrations to db/migrate"
@@ -15,19 +15,19 @@ 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|
+  Dir[File.join(File.dirname(__FILE__), "../../../../", MIGRATIONS_PATH, "/*.rb")].each do |input|
     contents = File.read(input)
-    name     = File.basename(input, ".*").sub(/\d+_/, "")
+    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}"
+      name += "_with_#{data_type}"
     end
 
-    output = ROM::SQL::RakeSupport.create_migration(name, path: File.join(Dir.pwd, MIGRATIONS_PATH))
+    output = ROM::SQL::RakeSupport.create_migration(name)
 
     File.write output, contents
 

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) }
 
       # detects if the value is a Sequel::Postgres::JSONHash or Sequel::Postgres::JSONBHash
-      RecordDeserializer = ::ROM::Types::String.constructor { |v| v.class.name.upcase.include?("JSON") ? JSON.dump(v) : v }
-      RecordSerializer   = ::ROM::Types::String
+      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

@@ -29,12 +29,11 @@ module RubyEventStore
           # MySQL deadlocks or to allow Sequel to retry transactions
           # when the :retry_on option is specified.
           retry_on: Sequel::SerializationFailure,
-          before_retry: lambda { |_num, ex|
-            env.logger.warn("RETRY TRANSACTION [#{self.class.name} => #{ex.class.name}] #{ex.message}")
-          }
-        ) do
-          changesets.each(&:commit)
-        end
+          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 = "2.0.0"
+    VERSION = "2.2.0"
   end
 end

data/lib/ruby_event_store/rom.rb

@@ -24,15 +24,13 @@ module RubyEventStore
     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_mapper Mappers::StreamEntryToSerializedRecord
+          rom.register_mapper Mappers::EventToSerializedRecord
           rom.register_relation Relations::Events
           rom.register_relation Relations::StreamEntries
         end
       end
 
-      private
-
       def rom_container(adapter_name, database_uri, &block)
         if adapter_name.is_a?(::ROM::Configuration)
           ::ROM.container(adapter_name.tap(&block), &block)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store-rom
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Joel Van Horn
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-30 00:00:00.000000000 Z
+date: 2023-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-container
@@ -162,6 +162,7 @@ metadata:
   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:
@@ -170,14 +171,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.4.17
 signing_key:
 specification_version: 4
 summary: ROM events repository for Ruby Event Store