pg_eventstore 0.2.6 → 0.4.0

data/lib/pg_eventstore/subscriptions/subscriptions_manager.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'basic_runner'
+require_relative 'subscription'
+require_relative 'events_processor'
+require_relative 'subscription_handler_performance'
+require_relative 'subscription_runner'
+require_relative 'runner_state'
+require_relative 'subscriptions_set'
+require_relative 'subscription_runners_feeder'
+require_relative 'subscription_feeder'
+require_relative 'commands_handler'
+
+module PgEventstore
+  # The public Subscriptions API, available to the user.
+  class SubscriptionsManager
+    extend Forwardable
+
+    attr_reader :config
+    private :config
+
+    def_delegators :@subscription_feeder, :start, :stop, :force_lock!
+
+    # @param config [PgEventstore::Config]
+    # @param set_name [String]
+    # @param max_retries [Integer, nil] max number of retries of failed SubscriptionsSet
+    # @param retries_interval [Integer, nil] a delay between retries of failed SubscriptionsSet
+    def initialize(config:, set_name:, max_retries: nil, retries_interval: nil)
+      @config = config
+      @set_name = set_name
+      @subscription_feeder = SubscriptionFeeder.new(
+        config_name: config.name,
+        set_name: set_name,
+        max_retries: max_retries || config.subscriptions_set_max_retries,
+        retries_interval: retries_interval || config.subscriptions_set_retries_interval
+      )
+    end
+
+    # @param subscription_name [String] subscription's name
+    # @param handler [#call] subscription's handler
+    # @param options [Hash] request options
+    # @option options [Integer, Symbol] :from_position a starting subscription position
+    # @option options [Boolean] :resolve_link_tos When using projections to create new events you
+    #   can set whether the generated events are pointers to existing events. Setting this option to true tells
+    #   PgEventstore to return the original event instead a link event.
+    # @option options [Hash] :filter provide it to filter events. It works the same way as a :filter option of
+    #   {PgEventstore::Client#read} method. Filtering by both - event types and streams are available.
+    # @param middlewares [Array<Symbol>, nil] provide a list of middleware names to override a config's middlewares
+    # @param pull_interval [Integer] an interval in seconds to determine how often to query new events of the given
+    #   subscription.
+    # @param max_retries [Integer] max number of retries of failed Subscription
+    # @param retries_interval [Integer] a delay between retries of failed Subscription
+    # @param restart_terminator [#call, nil] a callable object which, when called - accepts PgEventstore::Subscription
+    #   object to determine whether restarts should be stopped(true - stops restarts, false - continues restarts)
+    # @return [void]
+    def subscribe(subscription_name, handler:, options: {}, middlewares: nil,
+                  pull_interval: config.subscription_pull_interval,
+                  max_retries: config.subscription_max_retries,
+                  retries_interval: config.subscription_retries_interval,
+                  restart_terminator: config.subscription_restart_terminator)
+      subscription = Subscription.using_connection(config.name).new(
+        set: @set_name, name: subscription_name, options: options, chunk_query_interval: pull_interval,
+        max_restarts_number: max_retries, time_between_restarts: retries_interval
+      )
+      runner = SubscriptionRunner.new(
+        stats: SubscriptionHandlerPerformance.new,
+        events_processor: EventsProcessor.new(create_event_handler(middlewares, handler)),
+        subscription: subscription,
+        restart_terminator: restart_terminator
+      )
+
+      @subscription_feeder.add(runner)
+      true
+    end
+
+    # @return [Array<PgEventstore::Subscription>]
+    def subscriptions
+      @subscription_feeder.read_only_subscriptions
+    end
+
+    # @return [PgEventstore::SubscriptionsSet, nil]
+    def subscriptions_set
+      @subscription_feeder.read_only_subscriptions_set
+    end
+
+    private
+
+    # @param middlewares [Array<Symbol>, nil]
+    # @param handler [#call]
+    # @return [Proc]
+    def create_event_handler(middlewares, handler)
+      deserializer = EventDeserializer.new(select_middlewares(middlewares), config.event_class_resolver)
+      ->(raw_event) { handler.call(deserializer.deserialize(raw_event)) }
+    end
+
+    # @param middlewares [Array, nil]
+    # @return [Array<Object<#serialize, #deserialize>>]
+    def select_middlewares(middlewares = nil)
+      return config.middlewares.values unless middlewares
+
+      config.middlewares.slice(*middlewares).values
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/subscriptions_set.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # Defines ruby's representation of subscriptions_set record.
+  class SubscriptionsSet
+    include Extensions::UsingConnectionExtension
+    include Extensions::OptionsExtension
+
+    class << self
+      # @param attrs [Hash]
+      # @return [PgEventstore::SubscriptionsSet]
+      def create(attrs)
+        new(**subscriptions_set_queries.create(attrs))
+      end
+
+      private
+
+      # @return [PgEventstore::SubscriptionsSetQueries]
+      def subscriptions_set_queries
+        SubscriptionsSetQueries.new(connection)
+      end
+    end
+
+    # @!attribute id
+    #   @return [String] UUIDv4. It is used to lock the Subscription by updating Subscription#locked_by attribute
+    attribute(:id)
+    # @!attribute name
+    #   @return [String] name of the set
+    attribute(:name)
+    # @!attribute state
+    #   @return [String]
+    attribute(:state)
+    # @!attribute restart_count
+    #   @return [Integer] the number of SubscriptionsSet's restarts after its failure
+    attribute(:restart_count)
+    # @!attribute max_restarts_number
+    #   @return [Integer] maximum number of times the SubscriptionsSet can be restarted
+    attribute(:max_restarts_number)
+    # @!attribute time_between_restarts
+    #   @return [Integer] interval in seconds between retries of failed SubscriptionsSet
+    attribute(:time_between_restarts)
+    # @!attribute last_restarted_at
+    #   @return [Time, nil] last time the SubscriptionsSet was restarted
+    attribute(:last_restarted_at)
+    # @!attribute last_error
+    #   @return [Hash{'class' => String, 'message' => String, 'backtrace' => Array<String>}, nil] the information about
+    #     last error caused when pulling Subscriptions events.
+    attribute(:last_error)
+    # @!attribute last_error_occurred_at
+    #   @return [Time, nil] the time when the last error occurred
+    attribute(:last_error_occurred_at)
+    # @!attribute created_at
+    #   @return [Time]
+    attribute(:created_at)
+    # @!attribute updated_at
+    #   @return [Time]
+    attribute(:updated_at)
+
+    # @param attrs [Hash]
+    # @return [Hash]
+    def assign_attributes(attrs)
+      attrs.each do |attr, value|
+        public_send("#{attr}=", value)
+      end
+    end
+
+    # @param attrs [Hash]
+    # @return [Hash]
+    def update(attrs)
+      assign_attributes(subscriptions_set_queries.update(id, attrs))
+    end
+
+    # @return [void]
+    def delete
+      subscriptions_set_queries.delete(id)
+    end
+
+    # Dup the current object without assigned connection
+    # @return [PgEventstore::SubscriptionsSet]
+    def dup
+      SubscriptionsSet.new(**Utils.deep_dup(options_hash))
+    end
+
+    # @return [PgEventstore::SubscriptionsSet]
+    def reload
+      assign_attributes(subscriptions_set_queries.find!(id))
+      self
+    end
+
+    private
+
+    # @return [PgEventstore::SubscriptionsSetQueries]
+    def subscriptions_set_queries
+      SubscriptionsSetQueries.new(self.class.connection)
+    end
+  end
+end

data/lib/pg_eventstore/tasks/setup.rake

@@ -32,7 +32,7 @@ namespace :pg_eventstore do
         conn.exec('SELECT number FROM migrations ORDER BY number DESC LIMIT 1').to_a.dig(0, 'number') || -1
 
       Dir.chdir migration_files_root do
-        Dir["*.{sql,rb}"].sort.each do |f_name|
+        Dir["*.{sql,rb}"].sort_by { |f_name| f_name.split('_').first.to_i }.each do |f_name|
           number = File.basename(f_name).split('_')[0].to_i
           next if latest_migration >= number
 

data/lib/pg_eventstore/utils.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class Utils
+    class << self
+      # Deep transforms keys of a given Hash
+      # @param object [Object]
+      # @return [Object] a hash with transformed keys
+      def deep_transform_keys(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[yield(key)] = deep_transform_keys(value, &block)
+          end
+        when Array
+          object.map { |e| deep_transform_keys(e, &block) }
+        else
+          object
+        end
+      end
+
+      # Deep dup Array or Hash
+      # @param object [Object]
+      # @return [Object]
+      def deep_dup(object)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[deep_dup(key)] = deep_dup(value)
+          end
+        when Array
+          object.map { |e| deep_dup(e) }
+        else
+          object.dup
+        end
+      end
+
+      # Converts array to the string containing SQL positional variables
+      # @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
+
+      # Transforms exception instance into a hash
+      # @param error [StandardError]
+      # @return [Hash]
+      def error_info(error)
+        {
+          class: error.class,
+          message: error.message,
+          backtrace: error.backtrace
+        }
+      end
+
+      # @param str [String]
+      # @return [String]
+      def underscore_str(str)
+        str = str.dup
+        str[0] = str[0].downcase
+        str.gsub!(/[A-Z]/) { |letter| '_' + letter.downcase }
+        str
+      end
+    end
+  end
+end

data/lib/pg_eventstore/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgEventstore
-  VERSION = "0.2.6"
+  VERSION = "0.4.0"
 end

data/lib/pg_eventstore.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
 require_relative 'pg_eventstore/version'
+require_relative 'pg_eventstore/utils'
+require_relative 'pg_eventstore/callbacks'
 require_relative 'pg_eventstore/extensions/options_extension'
+require_relative 'pg_eventstore/extensions/callbacks_extension'
+require_relative 'pg_eventstore/extensions/using_connection_extension'
 require_relative 'pg_eventstore/event_class_resolver'
 require_relative 'pg_eventstore/config'
 require_relative 'pg_eventstore/event'
-require_relative 'pg_eventstore/sql_builder'
 require_relative 'pg_eventstore/stream'
 require_relative 'pg_eventstore/client'
 require_relative 'pg_eventstore/connection'
 require_relative 'pg_eventstore/errors'
 require_relative 'pg_eventstore/middleware'
+require_relative 'pg_eventstore/subscriptions/subscriptions_manager'
 
 module PgEventstore
   class << self
@@ -58,6 +62,20 @@ module PgEventstore
       end
     end
 
+    # @param config_name [Symbol]
+    # @param subscription_set [String]
+    # @param max_retries [Integer, nil] max number of retries of failed SubscriptionsSet
+    # @param retries_interval [Integer, nil] a delay between retries of failed SubscriptionsSet
+    # @return [PgEventstore::SubscriptionManager]
+    def subscriptions_manager(config_name = :default, subscription_set:, max_retries: nil, retries_interval: nil)
+      SubscriptionsManager.new(
+        config: config(config_name),
+        set_name: subscription_set,
+        max_retries: max_retries,
+        retries_interval: retries_interval
+      )
+    end
+
     # @param name [Symbol]
     # @return [PgEventstore::Client]
     def client(name = :default)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_eventstore
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.4.0
 platform: ruby
 authors:
 - Ivan Dzyzenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-20 00:00:00.000000000 Z
+date: 2024-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -54,6 +54,9 @@ files:
 - db/initial/primary_and_foreign_keys.sql
 - db/initial/tables.sql
 - db/migrations/0_improve_all_stream_indexes.sql
+- db/migrations/10_create_subscription_commands.sql
+- db/migrations/11_create_subscriptions_set_commands.sql
+- db/migrations/12_improve_events_indexes.sql
 - db/migrations/1_improve_specific_stream_indexes.sql
 - db/migrations/2_adjust_global_position_index.sql
 - db/migrations/3_extract_type_into_separate_table.sql
@@ -62,14 +65,17 @@ files:
 - db/migrations/6_change_events_event_type_id_null_constraint.sql
 - db/migrations/7_change_events_type_constraint.sql
 - db/migrations/8_drop_events_type.sql
+- db/migrations/9_create_subscriptions.sql
 - docs/appending_events.md
 - docs/configuration.md
 - docs/events_and_streams.md
 - docs/multiple_commands.md
 - docs/reading_events.md
+- docs/subscriptions.md
 - docs/writing_middleware.md
 - lib/pg_eventstore.rb
 - lib/pg_eventstore/abstract_command.rb
+- lib/pg_eventstore/callbacks.rb
 - lib/pg_eventstore/client.rb
 - lib/pg_eventstore/commands.rb
 - lib/pg_eventstore/commands/append.rb
@@ -80,20 +86,41 @@ files:
 - lib/pg_eventstore/errors.rb
 - lib/pg_eventstore/event.rb
 - lib/pg_eventstore/event_class_resolver.rb
+- lib/pg_eventstore/event_deserializer.rb
 - lib/pg_eventstore/event_serializer.rb
+- lib/pg_eventstore/extensions/callbacks_extension.rb
 - lib/pg_eventstore/extensions/options_extension.rb
+- lib/pg_eventstore/extensions/using_connection_extension.rb
 - lib/pg_eventstore/middleware.rb
-- lib/pg_eventstore/pg_result_deserializer.rb
+- lib/pg_eventstore/pg_connection.rb
 - lib/pg_eventstore/queries.rb
 - lib/pg_eventstore/queries/event_queries.rb
 - lib/pg_eventstore/queries/event_type_queries.rb
 - lib/pg_eventstore/queries/stream_queries.rb
+- lib/pg_eventstore/queries/subscription_command_queries.rb
+- lib/pg_eventstore/queries/subscription_queries.rb
+- lib/pg_eventstore/queries/subscriptions_set_command_queries.rb
+- lib/pg_eventstore/queries/subscriptions_set_queries.rb
 - lib/pg_eventstore/queries/transaction_queries.rb
 - lib/pg_eventstore/query_builders/events_filtering_query.rb
 - lib/pg_eventstore/rspec/has_option_matcher.rb
 - lib/pg_eventstore/sql_builder.rb
 - lib/pg_eventstore/stream.rb
+- lib/pg_eventstore/subscriptions/basic_runner.rb
+- lib/pg_eventstore/subscriptions/command_handlers/subscription_feeder_commands.rb
+- lib/pg_eventstore/subscriptions/command_handlers/subscription_runners_commands.rb
+- lib/pg_eventstore/subscriptions/commands_handler.rb
+- lib/pg_eventstore/subscriptions/events_processor.rb
+- lib/pg_eventstore/subscriptions/runner_state.rb
+- lib/pg_eventstore/subscriptions/subscription.rb
+- lib/pg_eventstore/subscriptions/subscription_feeder.rb
+- lib/pg_eventstore/subscriptions/subscription_handler_performance.rb
+- lib/pg_eventstore/subscriptions/subscription_runner.rb
+- lib/pg_eventstore/subscriptions/subscription_runners_feeder.rb
+- lib/pg_eventstore/subscriptions/subscriptions_manager.rb
+- lib/pg_eventstore/subscriptions/subscriptions_set.rb
 - lib/pg_eventstore/tasks/setup.rake
+- lib/pg_eventstore/utils.rb
 - lib/pg_eventstore/version.rb
 - pg_eventstore.gemspec
 homepage: https://github.com/yousty/pg_eventstore
@@ -119,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key: 
 specification_version: 4
 summary: EventStore implementation using PostgreSQL