ruby_event_store 2.7.0 → 2.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 812fd5359d77a05770e48775b328225aacdf815dba3bcdd3d178d12c99c37702
-  data.tar.gz: 0e559d46b60ef26c19262b6507baed2190d426a865067ad76aa39d8a25c861c5
+  metadata.gz: cc8c288c3150e4fd8817c7926d0f0291869214b21f68111cc325ed5ac4c09351
+  data.tar.gz: c7ea97aafc43dc89bd9a825a3cb2ffc029b9f8ace1f5f8ee1f11be3e3ceebca0
 SHA512:
-  metadata.gz: ab93715c45c4d08b58ff5a294e64b517ba7e0798e1518ef9affd39c884c9e648a95713da7991b6eee74b1b4ea5e938e2536033ba3e8dc262adb65197745e5f14
-  data.tar.gz: 908a2d22813f3decf421199b8ae53f2cae97fe34f150ce050c9fecefe2bfa30cd99e76c527b98386519af06aa4922dc531d89940b556151af818280f0852f0dd
+  metadata.gz: f337d1cd9e1800fc4ded518a8a8de45724ac600a54e7b94ba77eb40b900b8b5207ca1d27b469b0fc73282881a2f4f61f50bfe7e31a2a60e4d27a0c5ec5b493ba
+  data.tar.gz: 9306ba1444c202977d687a2da0ac58a375aba3b91e4d5f1f0e4cabcc1f76de1cc73eae64defb8fe9e271d10d29e32e906beaf826ac9af5abbfed47e6a34b63e7

data/lib/ruby_event_store/mappers/transformation/preserve_types.rb

@@ -4,16 +4,64 @@ module RubyEventStore
   module Mappers
     module Transformation
       class PreserveTypes
-        def initialize(type_resolver: ->(type) { type.to_s } )
-          @registered_type_serializers = {}
-          @type_resolver = type_resolver
+        def initialize(type_resolver: ->(type) { type.to_s })
+          @registry = Registry.new(type_resolver)
         end
 
-        def register(type, serializer:, deserializer:)
-          @registered_type_serializers[@type_resolver.(type)] = {
-            serializer: serializer,
-            deserializer: deserializer
-          }
+        class NullType
+          PASS_THROUGH = ->(v) { v }
+          private_constant :PASS_THROUGH
+
+          def serializer
+            PASS_THROUGH
+          end
+
+          def deserializer
+            PASS_THROUGH
+          end
+
+          def stored_type
+            DEFAULT_STORE_TYPE
+          end
+        end
+        private_constant :NullType
+
+        class RegisteredType
+          def initialize(serializer, deserializer, stored_type)
+            @serializer = serializer
+            @deserializer = deserializer
+            @stored_type = stored_type
+          end
+
+          attr_reader :serializer, :deserializer, :stored_type
+        end
+        private_constant :RegisteredType
+
+        class Registry
+          def initialize(resolver)
+            @types = {}
+            @resolver = resolver
+          end
+
+
+          NULL_TYPE = NullType.new
+          private_constant :NULL_TYPE
+
+          def add(type, serializer, deserializer, stored_type)
+            types[resolver[type]] = RegisteredType.new(serializer, deserializer, stored_type)
+          end
+
+          def of(type)
+            types.fetch(resolver[type]) { NULL_TYPE }
+          end
+
+          private
+          attr_reader :resolver, :types
+        end
+        private_constant :Registry
+
+        def register(type, serializer:, deserializer:, stored_type: DEFAULT_STORE_TYPE)
+          registry.add(type, serializer, deserializer, stored_type)
           self
         end
 
@@ -21,46 +69,49 @@ module RubyEventStore
           data = transform(record.data)
           metadata = transform(record.metadata)
           if (metadata.respond_to?(:[]=))
-            metadata[:types] = {
-              data: store_type(record.data),
-              metadata: store_type(record.metadata),
-            }
+            metadata[:types] = { data: store_type(record.data), metadata: store_type(record.metadata) }
           end
 
           Record.new(
-            event_id:   record.event_id,
+            event_id: record.event_id,
             event_type: record.event_type,
-            data:       data,
-            metadata:   metadata,
-            timestamp:  record.timestamp,
-            valid_at:   record.valid_at,
+            data: data,
+            metadata: metadata,
+            timestamp: record.timestamp,
+            valid_at: record.valid_at
           )
         end
 
         def load(record)
-          types = record.metadata.delete(:types) rescue nil
+          types =
+            begin
+              record.metadata.delete(:types)
+            rescue StandardError
+              nil
+            end
           data_types = types&.fetch(:data, nil)
           metadata_types = types&.fetch(:metadata, nil)
           data = data_types ? restore_type(record.data, data_types) : record.data
           metadata = metadata_types ? restore_type(record.metadata, metadata_types) : record.metadata
 
           Record.new(
-            event_id:   record.event_id,
+            event_id: record.event_id,
             event_type: record.event_type,
-            data:       data,
-            metadata:   metadata,
-            timestamp:  record.timestamp,
-            valid_at:   record.valid_at,
+            data: data,
+            metadata: metadata,
+            timestamp: record.timestamp,
+            valid_at: record.valid_at
           )
         end
 
+        DEFAULT_STORE_TYPE = ->(argument) { argument.class.name }
+        private_constant :DEFAULT_STORE_TYPE
+
         private
-        PASS_THROUGH = ->(v) { v }
+        attr_reader :registry
 
         def transform_hash(argument)
-          argument.each_with_object({}) do |(key, value), hash|
-            hash[transform(key)] = transform(value)
-          end
+          argument.each_with_object({}) { |(key, value), hash| hash[transform(key)] = transform(value) }
         end
 
         def transform(argument)
@@ -68,9 +119,9 @@ module RubyEventStore
           when Hash
             transform_hash(argument)
           when Array
-            argument.map{|i| transform(i)}
+            argument.map { |i| transform(i) }
           else
-            serializer_of(argument.class).call(argument)
+            registry.of(argument.class).serializer[argument]
           end
         end
 
@@ -85,15 +136,15 @@ module RubyEventStore
           when Hash
             store_types(argument)
           when Array
-            argument.map{|i| store_type(i)}
+            argument.map { |i| store_type(i) }
           else
-            argument.class.name
+            registry.of(argument.class).stored_type[argument]
           end
         end
 
         def restore_types(argument, types)
           argument.each_with_object({}) do |(key, value), hash|
-            key_type, value_type = types.fetch(key.to_sym)
+            key_type, value_type = types.fetch(key.to_sym) { types.fetch(key.to_s) }
             restored_key = restore_type(key, key_type)
             hash[restored_key] = restore_type(value, value_type)
           end
@@ -104,19 +155,11 @@ module RubyEventStore
           when Hash
             restore_types(argument, type)
           when Array
-            argument.each_with_index.map{|a,idx| restore_type(a, type.fetch(idx))}
+            argument.each_with_index.map { |a, idx| restore_type(a, type.fetch(idx)) }
           else
-            deserializer_of(type).call(argument)
+            registry.of(type).deserializer[argument]
           end
         end
-
-        def serializer_of(type)
-          @registered_type_serializers.dig(@type_resolver.(type), :serializer) || PASS_THROUGH
-        end
-
-        def deserializer_of(type)
-          @registered_type_serializers.dig(type, :deserializer) || PASS_THROUGH
-        end
       end
     end
   end

data/lib/ruby_event_store/specification_result.rb

@@ -223,6 +223,22 @@ module RubyEventStore
       attributes.read_as.equal?(:all)
     end
 
+    # Read strategy. True if results will be sorted by timestamp
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def time_sort_by_as_at?
+      time_sort_by.equal?(:as_at)
+    end
+
+    # Read strategy. True if results will be sorted by valid_at
+    # {http://railseventstore.org/docs/read/ Find out more}.
+    #
+    # @return [Boolean]
+    def time_sort_by_as_of?
+      time_sort_by.equal?(:as_of)
+    end
+
     # Clone [SpecificationResult]
     # If block is given cloned attributes might be modified.
     #

data/lib/ruby_event_store/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyEventStore
-  VERSION = "2.7.0"
+  VERSION = "2.8.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.8.1
 platform: ruby
 authors:
 - Arkency
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-19 00:00:00.000000000 Z
+date: 2023-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby