pg_eventstore 0.3.0 → 0.4.0

data/lib/pg_eventstore/{pg_result_deserializer.rb → event_deserializer.rb}

@@ -2,7 +2,7 @@
 
 module PgEventstore
   # @!visibility private
-  class PgResultDeserializer
+  class EventDeserializer
     attr_reader :middlewares, :event_class_resolver
 
     # @param middlewares [Array<Object<#deserialize, #serialize>>]
@@ -14,29 +14,21 @@ module PgEventstore
 
     # @param pg_result [PG::Result]
     # @return [Array<PgEventstore::Event>]
-    def deserialize(pg_result)
-      pg_result.map(&method(:_deserialize))
+    def deserialize_pg_result(pg_result)
+      pg_result.map(&method(:deserialize))
     end
-    alias deserialize_many deserialize
 
     # @param pg_result [PG::Result]
     # @return [PgEventstore::Event, nil]
-    def deserialize_one(pg_result)
+    def deserialize_one_pg_result(pg_result)
       return if pg_result.ntuples.zero?
 
-      _deserialize(pg_result.first)
+      deserialize(pg_result.first)
     end
 
-    # @return [PgEventstore::PgResultDeserializer]
-    def without_middlewares
-      self.class.new([], event_class_resolver)
-    end
-
-    private
-
     # @param attrs [Hash]
     # @return [PgEventstore::Event]
-    def _deserialize(attrs)
+    def deserialize(attrs)
       event = event_class_resolver.call(attrs['type']).new(**attrs.transform_keys(&:to_sym))
       middlewares.each do |middleware|
         middleware.deserialize(event)
@@ -44,5 +36,10 @@ module PgEventstore
       event.stream = PgEventstore::Stream.new(**attrs['stream'].transform_keys(&:to_sym)) if attrs.key?('stream')
       event
     end
+
+    # @return [PgEventstore::EventDeserializer]
+    def without_middlewares
+      self.class.new([], event_class_resolver)
+    end
   end
 end

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

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/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,12 @@ 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|
         conn.exec_params(*exec_params)
       end
-      deserializer.deserialize_many(pg_result)
+      deserializer.deserialize_pg_result(pg_result)
     end
 
     # @param stream [PgEventstore::Stream] persisted stream
@@ -42,14 +40,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|
         conn.exec_params(sql, [*attributes.values, event.type])
       end
-      deserializer.without_middlewares.deserialize_one(pg_result).tap do |persisted_event|
+      deserializer.without_middlewares.deserialize_one_pg_result(pg_result).tap do |persisted_event|
         persisted_event.stream = stream
       end
     end
@@ -66,25 +64,6 @@ module PgEventstore
       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(', ')
-    end
-
     # @return [PgEventstore::EventTypeQueries]
     def event_type_queries
       EventTypeQueries.new(connection)

data/lib/pg_eventstore/queries/event_type_queries.rb

@@ -46,5 +46,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/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

data/lib/pg_eventstore/queries/subscription_queries.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class SubscriptionQueries
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @param attrs [Hash]
+    # @return [Hash]
+    def find_or_create_by(attrs)
+      transaction_queries.transaction do
+        find_by(attrs) || create(attrs)
+      end
+    end
+
+    # @param attrs [Hash]
+    # @return [Hash, nil]
+    def find_by(attrs)
+      builder = SQLBuilder.new.select('*').from('subscriptions')
+      attrs.each do |attr, val|
+        builder.where("#{attr} = ?", val)
+      end
+
+      pg_result = connection.with do |conn|
+        conn.exec_params(*builder.to_exec_params)
+      end
+      return if pg_result.ntuples.zero?
+
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @param id [Integer]
+    # @return [Hash]
+    # @raise [PgEventstore::RecordNotFound]
+    def find!(id)
+      find_by(id: id) || raise(RecordNotFound.new("subscriptions", id))
+    end
+
+    # @param attrs [Hash]
+    # @return [Hash]
+    def create(attrs)
+      sql = <<~SQL
+        INSERT INTO subscriptions (#{attrs.keys.join(', ')}) 
+          VALUES (#{Utils.positional_vars(attrs.values)}) 
+          RETURNING *
+      SQL
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, attrs.values)
+      end
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @param id [Integer]
+    # @param attrs [Hash]
+    def update(id, attrs)
+      attrs = { updated_at: Time.now.utc }.merge(attrs)
+      attrs_sql = attrs.keys.map.with_index(1) do |attr, index|
+        "#{attr} = $#{index}"
+      end.join(', ')
+      sql =
+        "UPDATE subscriptions SET #{attrs_sql} WHERE id = $#{attrs.keys.size + 1} RETURNING *"
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, [*attrs.values, id])
+      end
+      raise(RecordNotFound.new("subscriptions", id)) if pg_result.ntuples.zero?
+
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @param query_options [Array<Array<Integer, Hash>>] array of runner ids and query options
+    # @return [Array<Hash>] array of raw events
+    def subscriptions_events(query_options)
+      return [] if query_options.empty?
+
+      final_builder = union_builders(query_options.map { |id, opts| query_builder(id, opts) })
+      connection.with do |conn|
+        conn.exec_params(*final_builder.to_exec_params)
+      end.to_a
+    end
+
+    # @param id [Integer] subscription's id
+    # @param lock_id [String] UUIDv4 id of the subscriptions set which reserves the subscription
+    # @param force [Boolean] whether to lock the subscription despite on #locked_by value
+    # @return [String] UUIDv4 lock id
+    # @raise [SubscriptionAlreadyLockedError] in case the Subscription is already locked
+    def lock!(id, lock_id, force = false)
+      transaction_queries.transaction do
+        attrs = find!(id)
+        if attrs[:locked_by] && !force
+          raise SubscriptionAlreadyLockedError.new(attrs[:set], attrs[:name], attrs[:locked_by])
+        end
+        connection.with do |conn|
+          conn.exec_params('UPDATE subscriptions SET locked_by = $1 WHERE id = $2', [lock_id, id])
+        end
+      end
+      lock_id
+    end
+
+    # @param id [Integer] subscription's id
+    # @param lock_id [String] UUIDv4 id of the set which reserved the subscription after itself
+    # @return [void]
+    # @raise [SubscriptionUnlockError] in case the Subscription is locked by some SubscriptionsSet, other than the one,
+    #   persisted in memory
+    def unlock!(id, lock_id)
+      transaction_queries.transaction do
+        attrs = find!(id)
+        # Normally this should never happen as locking/unlocking happens within the same process. This is done only for
+        # the matter of consistency.
+        unless attrs[:locked_by] == lock_id
+          raise SubscriptionUnlockError.new(attrs[:set], attrs[:name], lock_id, attrs[:locked_by])
+        end
+        connection.with do |conn|
+          conn.exec_params('UPDATE subscriptions SET locked_by = $1 WHERE id = $2', [nil, id])
+        end
+      end
+    end
+
+    private
+
+    # @param id [Integer] runner id
+    # @param options [Hash] query options
+    # @return [PgEventstore::SQLBuilder]
+    def query_builder(id, options)
+      builder = PgEventstore::QueryBuilders::EventsFiltering.subscriptions_events_filtering(
+        event_type_queries.include_event_types_ids(options)
+      ).to_sql_builder
+      builder.select("#{id} as runner_id")
+    end
+
+    # @param builders [Array<PgEventstore::SQLBuilder>]
+    # @return [PgEventstore::SQLBuilder]
+    def union_builders(builders)
+      builders[1..].each_with_object(builders[0]) do |builder, first_builder|
+        first_builder.union(builder)
+      end
+    end
+
+    # @return [PgEventstore::TransactionQueries]
+    def transaction_queries
+      TransactionQueries.new(connection)
+    end
+
+    # @return [PgEventstore::EventTypeQueries]
+    def event_type_queries
+      EventTypeQueries.new(connection)
+    end
+
+    # @param hash [Hash]
+    # @return [Hash]
+    def deserialize(hash)
+      hash.transform_keys(&:to_sym)
+    end
+  end
+end

data/lib/pg_eventstore/queries/subscriptions_set_command_queries.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class SubscriptionsSetCommandQueries
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @param subscriptions_set_id [Integer]
+    # @param command_name [String]
+    # @return [Hash, nil]
+    def find_by(subscriptions_set_id:, command_name:)
+      sql_builder =
+        SQLBuilder.new.
+          select('*').
+          from('subscriptions_set_commands').
+          where('subscriptions_set_id = ? AND name = ?', subscriptions_set_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 subscriptions_set_id [Integer]
+    # @param command_name [String]
+    # @return [Hash]
+    def create_by(subscriptions_set_id:, command_name:)
+      sql = <<~SQL
+        INSERT INTO subscriptions_set_commands (name, subscriptions_set_id) 
+          VALUES ($1, $2)
+          RETURNING *
+      SQL
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, [command_name, subscriptions_set_id])
+      end
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @param subscriptions_set_id [Integer]
+    # @return [Array<Hash>]
+    def find_commands(subscriptions_set_id)
+      sql_builder =
+        SQLBuilder.new.select('*').
+          from('subscriptions_set_commands').
+          where("subscriptions_set_id = ?", subscriptions_set_id).
+          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 subscriptions_set_commands WHERE id = $1', [id])
+      end
+    end
+
+    private
+
+    # @param hash [Hash]
+    # @return [Hash]
+    def deserialize(hash)
+      hash.transform_keys(&:to_sym)
+    end
+  end
+end