pg_eventstore 0.3.0 → 0.5.0

data/lib/pg_eventstore/extensions/callbacks_extension.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Extensions
+    # Integrates PgEventstore::Calbacks into your object. Example usage:
+    #   class MyAwesomeClass
+    #     include CallbacksExtension
+    #   end
+    # Now you have {#define_callback} public method to define callbacks outside your class' object, and you can use
+    # _#callbacks_ private method to run callbacks inside your class' object. You can also use _.has_callbacks_
+    # public class method to wrap the desired method into {Callbacks#run_callbacks}. Example:
+    #   class MyAwesomeClass
+    #     include PgEventstore::Extensions::CallbacksExtension
+    #
+    #     def initialize(foo)
+    #       @foo = foo
+    #     end
+    #
+    #     def do_something
+    #       puts "I did something useful: #{@foo.inspect}!"
+    #     end
+    #     has_callbacks :something_happened, :do_something
+    #
+    #     def do_something_else
+    #       callbacks.run_callbacks(:something_else_happened) do
+    #         puts "I did something else!"
+    #       end
+    #     end
+    #   end
+    #
+    #   obj = MyAwesomeClass.new(:foo)
+    #   obj.define_callback(
+    #     :something_happened, :before, proc { puts "In before callback of :something_happened." }
+    #   )
+    #   obj.define_callback(
+    #     :something_else_happened, :before, proc { puts "In before callback of :something_else_happened." }
+    #   )
+    #   obj.do_something
+    #   obj.do_something_else
+    # Outputs:
+    #   In before callback of :something_happened.
+    #   I did something useful: :foo!
+    #   In before callback of :something_else_happened.
+    #   I did something else!
+    module CallbacksExtension
+      def self.included(klass)
+        klass.extend(ClassMethods)
+        klass.prepend(InitCallbacks)
+        klass.class_eval do
+          attr_reader :callbacks
+          private :callbacks
+        end
+      end
+
+      def define_callback(...)
+        callbacks.define_callback(...)
+      end
+
+      # @!visibility private
+      module InitCallbacks
+        def initialize(...)
+          @callbacks = Callbacks.new
+          super
+        end
+      end
+
+      # @!visibility private
+      module ClassMethods
+        # Wraps method with Callbacks#run_callbacks. This allows you to define callbacks by the given action
+        # @param action [String, Symbol]
+        # @param method_name [Symbol]
+        # @return [void]
+        def has_callbacks(action, method_name)
+          visibility_method = visibility_method(method_name)
+          m = Module.new do
+            define_method(method_name) do |*args, **kwargs, &blk|
+              callbacks.run_callbacks(action) { super(*args, **kwargs, &blk) }
+            end
+            send visibility_method, method_name
+          end
+          prepend m
+        end
+
+        private
+
+        def visibility_method(method_name)
+          return :public if public_method_defined?(method_name)
+          return :protected if protected_method_defined?(method_name)
+
+          :private
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/extensions/options_extension.rb

@@ -7,38 +7,40 @@ module PgEventstore
     # A very simple extension that implements a DSL for adding attr_accessors with default values,
     # and assigning their values during object initialization.
     # Example. Let's say you frequently do something like this:
-    # ```ruby
-    # class SomeClass
-    #   attr_accessor :attr1, :attr2, :attr3, :attr4
+    #   class SomeClass
+    #     attr_accessor :attr1, :attr2, :attr3, :attr4
     #
-    #   def initialize(opts = {})
-    #     @attr1 = opts[:attr1] || 'Attr 1 value'
-    #     @attr2 = opts[:attr2] || 'Attr 2 value'
-    #     @attr3 = opts[:attr3] || do_some_calc
-    #     @attr4 = opts[:attr4]
-    #   end
+    #     def initialize(opts = {})
+    #       @attr1 = opts[:attr1] || 'Attr 1 value'
+    #       @attr2 = opts[:attr2] || 'Attr 2 value'
+    #       @attr3 = opts[:attr3] || do_some_calc
+    #       @attr4 = opts[:attr4]
+    #     end
     #
-    #   def do_some_calc
+    #     def do_some_calc
+    #       "Some calculations"
+    #     end
     #   end
-    # end
     #
-    # SomeClass.new(attr1: 'hihi', attr4: 'byebye')
-    # ```
+    #   SomeClass.new(attr1: 'hihi', attr4: 'byebye')
     #
     # You can replace the code above using the OptionsExtension:
-    # ```ruby
-    # class SomeClass
-    #   include PgEventstore::Extensions::OptionsExtension
+    #   class SomeClass
+    #     include PgEventstore::Extensions::OptionsExtension
+    #
+    #     option(:attr1) { 'Attr 1 value' }
+    #     option(:attr2) { 'Attr 2 value' }
+    #     option(:attr3) { do_some_calc }
+    #     option(:attr4)
     #
-    #   option(:attr1) { 'Attr 1 value' }
-    #   option(:attr2) { 'Attr 2 value' }
-    #   option(:attr3) { do_some_calc }
-    #   option(:attr4)
-    # end
+    #     def do_some_calc
+    #       "Some calculations"
+    #     end
+    #   end
     #
-    # SomeClass.new(attr1: 'hihi', attr4: 'byebye')
-    # ```
+    #   SomeClass.new(attr1: 'hihi', attr4: 'byebye')
     module OptionsExtension
+      # @!visibility private
       module ClassMethods
         # @param opt_name [Symbol] option name
         # @param blk [Proc] provide define value using block. It will be later evaluated in the
@@ -48,7 +50,11 @@ module PgEventstore
           self.options = (options + Set.new([opt_name])).freeze
           warn_already_defined(opt_name)
           warn_already_defined(:"#{opt_name}=")
-          attr_writer opt_name
+          define_method "#{opt_name}=" do |value|
+            readonly_error(opt_name) if readonly?(opt_name)
+
+            instance_variable_set(:"@#{opt_name}", value)
+          end
 
           define_method opt_name do
             result = instance_variable_get(:"@#{opt_name}")
@@ -75,6 +81,8 @@ module PgEventstore
         end
       end
 
+      ReadonlyAttributeError = Class.new(StandardError)
+
       def self.included(klass)
         klass.singleton_class.attr_accessor(:options)
         klass.options = Set.new.freeze
@@ -82,11 +90,8 @@ module PgEventstore
       end
 
       def initialize(**options)
-        self.class.options.each do |option|
-          # init default values of options
-          value = options.key?(option) ? options[option] : public_send(option)
-          public_send("#{option}=", value)
-        end
+        @readonly = Set.new
+        init_default_values(options)
       end
 
       # Construct a hash from options, where key is the option's name and the value is option's
@@ -98,6 +103,41 @@ module PgEventstore
         end
       end
       alias attributes_hash options_hash
+
+      # @param opt_name [Symbol]
+      # @return [Boolean]
+      def readonly!(opt_name)
+        return false unless self.class.options.include?(opt_name)
+
+        @readonly.add(opt_name)
+        true
+      end
+
+      # @param opt_name [Symbol]
+      # @return [Boolean]
+      def readonly?(opt_name)
+        @readonly.include?(opt_name)
+      end
+
+      private
+
+      # @param opt_name [Symbol]
+      # @raise [PgEventstore::Extensions::OptionsExtension::ReadOnlyError]
+      def readonly_error(opt_name)
+        raise(
+          ReadonlyAttributeError, "#{opt_name.inspect} attribute was marked as read only. You can no longer modify it."
+        )
+      end
+
+      # @param options [Hash]
+      # @return [void]
+      def init_default_values(options)
+        self.class.options.each do |option|
+          # init default values of options
+          value = options.key?(option) ? options[option] : public_send(option)
+          public_send("#{option}=", value)
+        end
+      end
     end
   end
 end

data/lib/pg_eventstore/extensions/using_connection_extension.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Extensions
+    # Extension that implements creating of a subclass of the class it is used in. The point of creating a subclass is
+    # to bound it to the specific connection. This way the specific connection will be available within tha class and
+    # all its instances without affecting on the original class.
+    # @!visibility private
+    module UsingConnectionExtension
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def connection
+          raise("No connection was set. Are you trying to manipulate #{name} outside of its lifecycle?")
+        end
+
+        # @param config_name [Symbol]
+        # @return [Class<PgEventstore::Subscription>]
+        def using_connection(config_name)
+          original_class = self
+          Class.new(original_class).tap do |klass|
+            klass.define_singleton_method(:connection) { PgEventstore.connection(config_name) }
+            klass.class_eval do
+              [:to_s, :inspect, :name].each do |m|
+                define_singleton_method(m, &original_class.method(m))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/pg_connection.rb

@@ -19,11 +19,28 @@ module PgEventstore
 
       sql = sql.gsub(/\$\d+/).each do |matched|
         value = params[matched[1..].to_i - 1]
-
-        value = type_map_for_queries[value.class]&.encode(value) || value
-        value.is_a?(String) ? "'#{value}'" : value
+        value = encode_value(value)
+        normalize_value(value)
       end unless params&.empty?
       PgEventstore.logger.debug(sql)
     end
+
+    def encode_value(value)
+      encoder = type_map_for_queries[value.class]
+      return type_map_for_queries.send(encoder, value).encode(value) if encoder.is_a?(Symbol)
+
+      type_map_for_queries[value.class]&.encode(value) || value
+    end
+
+    def normalize_value(value)
+      case value
+      when String
+        "'#{value}'"
+      when NilClass
+        'NULL'
+      else
+        value
+      end
+    end
   end
 end

data/lib/pg_eventstore/queries/event_queries.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'pg_eventstore/query_builders/events_filtering_query'
-
 module PgEventstore
   # @!visibility private
   class EventQueries
@@ -10,7 +8,7 @@ module PgEventstore
 
     # @param connection [PgEventstore::Connection]
     # @param serializer [PgEventstore::EventSerializer]
-    # @param deserializer [PgEventstore::PgResultDeserializer]
+    # @param deserializer [PgEventstore::EventDeserializer]
     def initialize(connection, serializer, deserializer)
       @connection = connection
       @serializer = serializer
@@ -22,12 +20,13 @@ module PgEventstore
     # @param options [Hash]
     # @return [Array<PgEventstore::Event>]
     def stream_events(stream, options)
-      options = include_event_types_ids(options)
+      options = event_type_queries.include_event_types_ids(options)
       exec_params = events_filtering(stream, options).to_exec_params
-      pg_result = connection.with do |conn|
+      raw_events = connection.with do |conn|
         conn.exec_params(*exec_params)
-      end
-      deserializer.deserialize_many(pg_result)
+      end.to_a
+      preloader.preload_related_objects(raw_events)
+      deserializer.deserialize_many(raw_events)
     end
 
     # @param stream [PgEventstore::Stream] persisted stream
@@ -42,14 +41,14 @@ module PgEventstore
 
       sql = <<~SQL
         INSERT INTO events (#{attributes.keys.join(', ')}) 
-          VALUES (#{positional_vars(attributes.values)}) 
+          VALUES (#{Utils.positional_vars(attributes.values)}) 
           RETURNING *, $#{attributes.values.size + 1} as type
       SQL
 
-      pg_result = connection.with do |conn|
+      raw_event = connection.with do |conn|
         conn.exec_params(sql, [*attributes.values, event.type])
-      end
-      deserializer.without_middlewares.deserialize_one(pg_result).tap do |persisted_event|
+      end.to_a.first
+      deserializer.without_middlewares.deserialize(raw_event).tap do |persisted_event|
         persisted_event.stream = stream
       end
     end
@@ -58,36 +57,21 @@ module PgEventstore
 
     # @param stream [PgEventstore::Stream]
     # @param options [Hash]
-    # @param offset [Integer]
     # @return [PgEventstore::EventsFilteringQuery]
-    def events_filtering(stream, options, offset: 0)
-      return QueryBuilders::EventsFiltering.all_stream_filtering(options, offset: offset) if stream.all_stream?
+    def events_filtering(stream, options)
+      return QueryBuilders::EventsFiltering.all_stream_filtering(options) if stream.all_stream?
 
-      QueryBuilders::EventsFiltering.specific_stream_filtering(stream, options, offset: offset)
-    end
-
-    # Replaces filter by event type strings with filter by event type ids
-    # @param options [Hash]
-    # @return [Hash]
-    def include_event_types_ids(options)
-      options in { filter: { event_types: Array => event_types } }
-      return options unless event_types
-
-      filter = options[:filter].dup
-      filter[:event_type_ids] = event_type_queries.find_event_types(event_types).uniq
-      filter.delete(:event_types)
-      options.merge(filter: filter)
-    end
-
-    # @param array [Array]
-    # @return [String] positional variables, based on array size. Example: "$1, $2, $3"
-    def positional_vars(array)
-      array.size.times.map { |t| "$#{t + 1}" }.join(', ')
+      QueryBuilders::EventsFiltering.specific_stream_filtering(stream, options)
     end
 
     # @return [PgEventstore::EventTypeQueries]
     def event_type_queries
       EventTypeQueries.new(connection)
     end
+
+    # @return [PgEventstore::Preloader]
+    def preloader
+      Preloader.new(connection)
+    end
   end
 end

data/lib/pg_eventstore/queries/event_type_queries.rb

@@ -33,6 +33,17 @@ module PgEventstore
       end.to_a.dig(0, 'id')
     end
 
+    # @param ids [Array<Integer>]
+    # @return [Array<Hash>]
+    def find_by_ids(ids)
+      return [] if ids.empty?
+
+      builder = SQLBuilder.new.from('event_types').where('id = ANY(?)', ids.uniq)
+      connection.with do |conn|
+        conn.exec_params(*builder.to_exec_params)
+      end.to_a
+    end
+
     # @param types [Array<String>]
     # @return [Array<Integer, nil>]
     def find_event_types(types)
@@ -46,5 +57,18 @@ module PgEventstore
         SQL
       end.to_a.map { |attrs| attrs['id'] }
     end
+
+    # Replaces filter by event type strings with filter by event type ids
+    # @param options [Hash]
+    # @return [Hash]
+    def include_event_types_ids(options)
+      options in { filter: { event_types: Array => event_types } }
+      return options unless event_types
+
+      options = Utils.deep_dup(options)
+      options[:filter][:event_type_ids] = find_event_types(event_types).uniq
+      options[:filter].delete(:event_types)
+      options
+    end
   end
 end

data/lib/pg_eventstore/queries/preloader.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class Preloader
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @param raw_events [Array<Hash>]
+    # @return [Array<Hash>]
+    def preload_related_objects(raw_events)
+      streams = stream_queries.find_by_ids(raw_events.map { _1['stream_id'] }).to_h { [_1['id'], _1] }
+      types = event_type_queries.find_by_ids(raw_events.map { _1['event_type_id'] }).to_h { [_1['id'], _1] }
+      raw_events.each do |event|
+        event['stream'] = streams[event['stream_id']]
+        event['type'] = types[event['event_type_id']]['type']
+      end
+    end
+
+    private
+
+    # @return [PgEventstore::EventTypeQueries]
+    def event_type_queries
+      EventTypeQueries.new(connection)
+    end
+
+    # @return [PgEventstore::StreamQueries]
+    def stream_queries
+      StreamQueries.new(connection)
+    end
+  end
+end

data/lib/pg_eventstore/queries/stream_queries.rb

@@ -26,6 +26,17 @@ module PgEventstore
       deserialize(pg_result) if pg_result.ntuples == 1
     end
 
+    # @param ids [Array<Integer>]
+    # @return [Array<Hash>]
+    def find_by_ids(ids)
+      return [] if ids.empty?
+
+      builder = SQLBuilder.new.from('streams').where('id = ANY(?)', ids.uniq.sort)
+      connection.with do |conn|
+        conn.exec_params(*builder.to_exec_params)
+      end.to_a
+    end
+
     # @param stream [PgEventstore::Stream]
     # @return [PgEventstore::RawStream] persisted stream
     def create_stream(stream)
@@ -44,13 +55,15 @@ module PgEventstore
     end
 
     # @param stream [PgEventstore::Stream] persisted stream
-    # @return [void]
+    # @return [PgEventstore::Stream]
     def update_stream_revision(stream, revision)
       connection.with do |conn|
         conn.exec_params(<<~SQL, [revision, stream.id])
           UPDATE streams SET stream_revision = $1 WHERE id = $2
         SQL
       end
+      stream.stream_revision = revision
+      stream
     end
 
     private

data/lib/pg_eventstore/queries/subscription_command_queries.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class SubscriptionCommandQueries
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @param subscription_id [Integer]
+    # @param command_name [String]
+    # @return [Hash, nil]
+    def find_by(subscription_id:, command_name:)
+      sql_builder =
+        SQLBuilder.new.
+          select('*').
+          from('subscription_commands').
+          where('subscription_id = ? AND name = ?', subscription_id, command_name)
+      pg_result = connection.with do |conn|
+        conn.exec_params(*sql_builder.to_exec_params)
+      end
+      return if pg_result.ntuples.zero?
+
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @param subscription_id [Integer]
+    # @param command_name [String]
+    # @return [Hash]
+    def create_by(subscription_id:, command_name:)
+      sql = <<~SQL
+        INSERT INTO subscription_commands (name, subscription_id) 
+          VALUES ($1, $2)
+          RETURNING *
+      SQL
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, [command_name, subscription_id])
+      end
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @param subscription_ids [Array<Integer>]
+    # @return [Array<Hash>]
+    def find_commands(subscription_ids)
+      return [] if subscription_ids.empty?
+
+      sql = subscription_ids.size.times.map do
+        "?"
+      end.join(", ")
+      sql_builder =
+        SQLBuilder.new.select('*').
+          from('subscription_commands').
+          where("subscription_id IN (#{sql})", *subscription_ids).
+          order('id ASC')
+      pg_result = connection.with do |conn|
+        conn.exec_params(*sql_builder.to_exec_params)
+      end
+      pg_result.to_a.map(&method(:deserialize))
+    end
+
+    # @param id [Integer]
+    # @return [void]
+    def delete(id)
+      connection.with do |conn|
+        conn.exec_params('DELETE FROM subscription_commands WHERE id = $1', [id])
+      end
+    end
+
+    private
+
+    # @param hash [Hash]
+    # @return [Hash]
+    def deserialize(hash)
+      hash.transform_keys(&:to_sym)
+    end
+  end
+end