pg_eventstore 0.3.0 → 0.5.0

data/lib/pg_eventstore/queries/subscription_queries.rb

@@ -0,0 +1,166 @@
+# 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) })
+      raw_events = connection.with do |conn|
+        conn.exec_params(*final_builder.to_exec_params)
+      end.to_a
+      preloader.preload_related_objects(raw_events)
+    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
+
+    # @return [PgEventstore::Preloader]
+    def preloader
+      Preloader.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

data/lib/pg_eventstore/queries/subscriptions_set_queries.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class SubscriptionsSetQueries
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @param attrs [Hash]
+    # @return [Array<Hash>]
+    def find_all(attrs)
+      builder = SQLBuilder.new.select('*').from('subscriptions_set')
+      attrs.each do |attr, val|
+        builder.where("#{attr} = ?", val)
+      end
+
+      pg_result = connection.with do |conn|
+        conn.exec_params(*builder.to_exec_params)
+      end
+      pg_result.to_a.map(&method(:deserialize))
+    end
+
+    # The same as #find_all, but returns first result
+    # @return [Hash, nil]
+    def find_by(...)
+      find_all(...).first
+    end
+
+    # @param id [String] UUIDv4
+    # @return [Hash]
+    # @raise [PgEventstore::RecordNotFound]
+    def find!(id)
+      find_by(id: id) || raise(RecordNotFound.new("subscriptions_set", id))
+    end
+
+    # @param attrs [Hash]
+    # @return [Hash]
+    def create(attrs)
+      sql = <<~SQL
+        INSERT INTO subscriptions_set (#{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 [String] UUIDv4
+    # @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 = <<~SQL
+        UPDATE subscriptions_set SET #{attrs_sql} WHERE id = $#{attrs.keys.size + 1} RETURNING *
+      SQL
+      pg_result = connection.with do |conn|
+        conn.exec_params(sql, [*attrs.values, id])
+      end
+      raise(RecordNotFound.new("subscriptions_set", id)) if pg_result.ntuples.zero?
+
+      deserialize(pg_result.to_a.first)
+    end
+
+    # @return id [Integer]
+    # @return [void]
+    def delete(id)
+      connection.with do |conn|
+        conn.exec_params('DELETE FROM subscriptions_set 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.rb

@@ -1,9 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'sql_builder'
+require_relative 'query_builders/events_filtering_query'
 require_relative 'queries/transaction_queries'
 require_relative 'queries/event_queries'
 require_relative 'queries/stream_queries'
 require_relative 'queries/event_type_queries'
+require_relative 'queries/subscription_queries'
+require_relative 'queries/subscriptions_set_queries'
+require_relative 'queries/subscription_command_queries'
+require_relative 'queries/subscriptions_set_command_queries'
+require_relative 'queries/preloader'
 
 module PgEventstore
   # @!visibility private

data/lib/pg_eventstore/query_builders/events_filtering_query.rb

@@ -4,8 +4,7 @@ module PgEventstore
   module QueryBuilders
     # @!visibility private
     class EventsFiltering
-      DEFAULT_OFFSET = 0
-      DEFAULT_LIMIT = 1000
+      DEFAULT_LIMIT = 1_000
       SQL_DIRECTIONS = {
         'asc' => 'ASC',
         'desc' => 'DESC',
@@ -16,17 +15,22 @@ module PgEventstore
       }.tap do |directions|
         directions.default = 'ASC'
       end.freeze
+      SUBSCRIPTIONS_OPTIONS = %i[from_position resolve_link_tos filter max_count].freeze
 
       class << self
         # @param options [Hash]
-        # @param offset [Integer]
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
-        def all_stream_filtering(options, offset: 0)
+        def subscriptions_events_filtering(options)
+          all_stream_filtering(options.slice(*SUBSCRIPTIONS_OPTIONS))
+        end
+
+        # @param options [Hash]
+        # @return [PgEventstore::QueryBuilders::EventsFiltering]
+        def all_stream_filtering(options)
           event_filter = new
           options in { filter: { event_type_ids: Array => event_type_ids } }
           event_filter.add_event_types(event_type_ids)
           event_filter.add_limit(options[:max_count])
-          event_filter.add_offset(offset)
           event_filter.resolve_links(options[:resolve_link_tos])
           options in { filter: { streams: Array => streams } }
           streams&.each { |attrs| event_filter.add_stream_attrs(**attrs) }
@@ -37,14 +41,12 @@ module PgEventstore
 
         # @param stream [PgEventstore::Stream]
         # @param options [Hash]
-        # @param offset [Integer]
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
-        def specific_stream_filtering(stream, options, offset: 0)
+        def specific_stream_filtering(stream, options)
           event_filter = new
           options in { filter: { event_type_ids: Array => event_type_ids } }
           event_filter.add_event_types(event_type_ids)
           event_filter.add_limit(options[:max_count])
-          event_filter.add_offset(offset)
           event_filter.resolve_links(options[:resolve_link_tos])
           event_filter.add_stream(stream)
           event_filter.add_revision(options[:from_revision], options[:direction])
@@ -57,13 +59,10 @@ module PgEventstore
         @sql_builder =
           SQLBuilder.new.
             select('events.*').
-            select('row_to_json(streams.*) as stream').
-            select('event_types.type as type').
             from('events').
             join('JOIN streams ON streams.id = events.stream_id').
             join('JOIN event_types ON event_types.id = events.event_type_id').
-            limit(DEFAULT_LIMIT).
-            offset(DEFAULT_OFFSET)
+            limit(DEFAULT_LIMIT)
       end
 
       # @param context [String, nil]
@@ -96,7 +95,7 @@ module PgEventstore
         sql = event_type_ids.size.times.map do
           "?"
         end.join(", ")
-        @sql_builder.where("event_types.id IN (#{sql})", *event_type_ids)
+        @sql_builder.where("events.event_type_id IN (#{sql})", *event_type_ids)
       end
 
       # @param revision [Integer, nil]
@@ -137,14 +136,6 @@ module PgEventstore
         @sql_builder.limit(limit)
       end
 
-      # @param offset [Integer, nil]
-      # @return [void]
-      def add_offset(offset)
-        return unless offset
-
-        @sql_builder.offset(offset)
-      end
-
       # @param should_resolve [Boolean]
       # @return [void]
       def resolve_links(should_resolve)
@@ -153,10 +144,14 @@ module PgEventstore
         @sql_builder.
           unselect.
           select("(COALESCE(original_events.*, events.*)).*").
-          select('row_to_json(streams.*) as stream').
           join("LEFT JOIN events original_events ON original_events.id = events.link_id")
       end
 
+      # @return [PgEventstore::SQLBuilder]
+      def to_sql_builder
+        @sql_builder
+      end
+
       # @return [Array]
       def to_exec_params
         @sql_builder.to_exec_params

data/lib/pg_eventstore/sql_builder.rb

@@ -13,6 +13,8 @@ module PgEventstore
       @limit_value = nil
       @offset_value = nil
       @positional_values = []
+      @positional_values_size = 0
+      @union_values = []
     end
 
     # @param sql [String]
@@ -32,8 +34,7 @@ module PgEventstore
     # @param arguments [Array] positional values
     # @return self
     def where(sql, *arguments)
-      sql = extract_positional_args(sql, *arguments)
-      @where_values['AND'].push("(#{sql})")
+      @where_values['AND'].push([sql, arguments])
       self
     end
 
@@ -41,8 +42,7 @@ module PgEventstore
     # @param arguments [Object] positional values
     # @return self
     def where_or(sql, *arguments)
-      sql = extract_positional_args(sql, *arguments)
-      @where_values['OR'].push("(#{sql})")
+      @where_values['OR'].push([sql, arguments])
       self
     end
 
@@ -57,7 +57,7 @@ module PgEventstore
     # @param arguments [Object]
     # @return self
     def join(sql, *arguments)
-      @join_values.push(extract_positional_args(sql, *arguments))
+      @join_values.push([sql, arguments])
       self
     end
 
@@ -82,7 +82,34 @@ module PgEventstore
       self
     end
 
+    # @param another_builder [PgEventstore::SQLBuilder]
+    # @return [self]
+    def union(another_builder)
+      @union_values.push(another_builder)
+      self
+    end
+
     def to_exec_params
+      return [single_query_sql, @positional_values] if @union_values.empty?
+
+      [union_query_sql, @positional_values]
+    end
+
+    protected
+
+    # @return [Array<Object>] sql positional values
+    def positional_values
+      @positional_values
+    end
+
+    def positional_values_size=(val)
+      @positional_values_size = val
+    end
+
+    private
+
+    # @return [String]
+    def single_query_sql
       where_sql = [where_sql('OR'), where_sql('AND')].reject(&:empty?).map { |sql| "(#{sql})" }.join(' AND ')
       sql = "SELECT #{select_sql} FROM #{@from_value}"
       sql += " #{join_sql}" unless @join_values.empty?
@@ -90,10 +117,22 @@ module PgEventstore
       sql += " ORDER BY #{order_sql}" unless @order_values.empty?
       sql += " LIMIT #{@limit_value}" if @limit_value
       sql += " OFFSET #{@offset_value}" if @offset_value
-      [sql, @positional_values]
+      sql
     end
 
-    private
+    # @return [String]
+    def union_query_sql
+      sql = single_query_sql
+      union_parts = ["(#{sql})"]
+      union_parts += @union_values.map do |builder|
+        builder.positional_values_size = @positional_values_size
+        builder_sql, values = builder.to_exec_params
+        @positional_values.push(*values)
+        @positional_values_size += values.size
+        "(#{builder_sql})"
+      end
+      union_parts.join(' UNION ALL ')
+    end
 
     # @return [String]
     def select_sql
@@ -103,12 +142,14 @@ module PgEventstore
     # @param join_pattern [String] "OR"/"AND"
     # @return [String]
     def where_sql(join_pattern)
-      @where_values[join_pattern].join(" #{join_pattern} ")
+      @where_values[join_pattern].map do |sql, args|
+        "(#{extract_positional_args(sql, *args)})"
+      end.join(" #{join_pattern} ")
     end
 
     # @return [String]
     def join_sql
-      @join_values.join(" ")
+      @join_values.map { |sql, args| extract_positional_args(sql, *args) }.join(" ")
     end
 
     # @return [String]
@@ -116,10 +157,13 @@ module PgEventstore
       @order_values.join(', ')
     end
 
+    # Replaces "?" signs in the given string with positional variables and memorize positional values they refer to.
+    # @return [String]
     def extract_positional_args(sql, *arguments)
       sql.gsub("?").each_with_index do |_, index|
         @positional_values.push(arguments[index])
-        "$#{@positional_values.size}"
+        @positional_values_size += 1
+        "$#{@positional_values_size}"
       end
     end
   end

data/lib/pg_eventstore/stream.rb

@@ -18,7 +18,8 @@ module PgEventstore
       end
     end
 
-    attr_reader :context, :stream_name, :stream_id, :id, :stream_revision
+    attr_reader :context, :stream_name, :stream_id, :id
+    attr_accessor :stream_revision
 
     # @param context [String]
     # @param stream_name [String]