pg_eventstore 0.10.2 → 1.0.0.rc1

data/lib/pg_eventstore/web/application.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module PgEventstore
+  module Web
+    class Application < Sinatra::Base
+      set :static_cache_control, [:private, max_age: 86400]
+      set :environment, -> { (ENV['RACK_ENV'] || ENV['RAILS_ENV'] || ENV['APP_ENV'])&.to_sym || :development }
+      set :logging, -> { environment == :development || environment == :test }
+      set :erb, layout: :'layouts/application'
+      set :sessions, true
+      set :session_secret, ENV.fetch('SECRET_KEY_BASE') { SecureRandom.hex(64) }
+
+      helpers(Paginator::Helpers, Subscriptions::Helpers) do
+        # @return [Array<Hash>, nil]
+        def streams_filter
+          params in { filter: { streams: Array => streams } }
+          streams&.select { _1 in { context: String, stream_name: String, stream_id: String } }&.map do
+            Hash[_1.reject { |_, value| value == '' }].transform_keys(&:to_sym)
+          end&.reject { _1.empty? }
+        end
+
+        # @return [Array<String>, nil]
+        def events_filter
+          params in { filter: { events: Array => events } }
+          events&.select { _1.is_a?(String) && _1 != '' }
+        end
+
+        # @return [Symbol]
+        def current_config
+          PgEventstore.available_configs.include?(session[:current_config]) ? session[:current_config] : :default
+        end
+
+        # @return [PgEventstore::Connection]
+        def connection
+          PgEventstore.connection(current_config)
+        end
+
+        # @param collection [PgEventstore::Paginator::BaseCollection]
+        # @return [void]
+        def paginated_json_response(collection)
+          halt 200, {
+            results: collection.collection,
+            pagination: { more: !collection.next_page_starting_id.nil?, starting_id: collection.next_page_starting_id }
+          }.to_json
+        end
+
+        # @param fallback_url [String]
+        # @return [String]
+        def redirect_back_url(fallback_url:)
+          return fallback_url if request.referer.to_s.empty?
+
+          "#{request.referer}#{params[:hash]}"
+        end
+      end
+
+      get '/' do
+        @collection = Paginator::EventsCollection.new(
+          current_config,
+          starting_id: params[:starting_id]&.to_i,
+          per_page: Paginator::EventsCollection::PER_PAGE[params[:per_page]],
+          order: Paginator::EventsCollection::SQL_DIRECTIONS[params[:order]],
+          options: { filter: { event_types: events_filter, streams: streams_filter } }
+        )
+
+        if request.xhr?
+          content_type 'application/json'
+          halt 200, {
+            events: erb(:'home/partials/events', { layout: false }, { events: @collection.collection }),
+            total_count: total_count(@collection.total_count),
+            pagination: erb(:'home/partials/pagination_links', { layout: false }, { collection: @collection })
+          }.to_json
+        else
+          erb :'home/dashboard'
+        end
+      end
+
+      get '/subscriptions' do
+        @set_collection = Subscriptions::SetCollection.new(connection)
+        @current_set = params[:set_name] || @set_collection.names.first
+        @association = Subscriptions::SubscriptionsToSetAssociation.new(
+          subscriptions_set: Subscriptions::SubscriptionsSet.new(connection, @current_set).subscriptions_set,
+          subscriptions: Subscriptions::Subscriptions.new(connection, @current_set).subscriptions
+        )
+        erb :'subscriptions/index'
+      end
+
+      post '/change_config' do
+        config = params[:config]&.to_sym
+        config = :default unless PgEventstore.available_configs.include?(config)
+        session[:current_config] = config
+        redirect(url('/'))
+      end
+
+      get '/stream_contexts_filtering', provides: :json do
+        collection = Paginator::StreamContextsCollection.new(
+          current_config,
+          starting_id: params[:starting_id],
+          per_page: Paginator::StreamContextsCollection::PER_PAGE,
+          order: :asc,
+          options: { query: params[:term] }
+        )
+        paginated_json_response(collection)
+      end
+
+      get '/stream_names_filtering', provides: :json do
+        collection = Paginator::StreamNamesCollection.new(
+          current_config,
+          starting_id: params[:starting_id],
+          per_page: Paginator::StreamNamesCollection::PER_PAGE,
+          order: :asc,
+          options: { query: params[:term], context: params[:context] }
+        )
+        paginated_json_response(collection)
+      end
+
+      get '/stream_ids_filtering', provides: :json do
+        collection = Paginator::StreamIdsCollection.new(
+          current_config,
+          starting_id: params[:starting_id],
+          per_page: Paginator::StreamIdsCollection::PER_PAGE,
+          order: :asc,
+          options: { query: params[:term], context: params[:context], stream_name: params[:stream_name] }
+        )
+        paginated_json_response(collection)
+      end
+
+      get '/event_types_filtering', provides: :json do
+        collection = Paginator::EventTypesCollection.new(
+          current_config,
+          starting_id: params[:starting_id],
+          per_page: Paginator::EventTypesCollection::PER_PAGE,
+          order: :asc,
+          options: { query: params[:term] }
+        )
+        paginated_json_response(collection)
+      end
+
+      post '/subscription_cmd/:set_id/:id/:cmd' do
+        puts SubscriptionCommandQueries.new(connection).find_or_create_by(
+          subscriptions_set_id: params[:set_id],
+          subscription_id: params[:id],
+          command_name: CommandHandlers::SubscriptionRunnersCommands::AVAILABLE_COMMANDS.fetch(params[:cmd].to_sym)
+        )
+
+        redirect redirect_back_url(fallback_url: url('/subscriptions'))
+      end
+
+      post '/subscriptions_set_cmd/:id/:cmd' do
+        SubscriptionsSetCommandQueries.new(connection).find_or_create_by(
+          subscriptions_set_id: params[:id],
+          command_name: CommandHandlers::SubscriptionFeederCommands::AVAILABLE_COMMANDS.fetch(params[:cmd].to_sym)
+        )
+
+        redirect redirect_back_url(fallback_url: url('/subscriptions'))
+      end
+
+      post '/delete_subscriptions_set/:id' do
+        SubscriptionsSetQueries.new(connection).delete(params[:id])
+
+        redirect redirect_back_url(fallback_url: url('/subscriptions'))
+      end
+
+      post '/delete_subscription/:id' do
+        SubscriptionQueries.new(connection).delete(params[:id])
+
+        redirect redirect_back_url(fallback_url: url('/subscriptions'))
+      end
+
+      post '/delete_all_subscriptions' do
+        params[:ids].each do |id|
+          SubscriptionQueries.new(connection).delete(id)
+        end
+
+        redirect redirect_back_url(fallback_url: url('/subscriptions'))
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/paginator/base_collection.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Paginator
+      class BaseCollection
+        attr_reader :config_name, :starting_id, :per_page, :order, :options
+
+        # @param config_name [Symbol]
+        # @param starting_id [String, Integer, nil]
+        # @param per_page [Integer]
+        # @param order [Symbol] :asc or :desc
+        # @param options [Hash] additional options to filter the collection
+        def initialize(config_name, starting_id:, per_page:, order:, options: {})
+          @config_name = config_name
+          @starting_id = starting_id
+          @per_page = per_page
+          @order = order
+          @options = options
+        end
+
+        # @return [Array]
+        def collection
+          raise NotImplementedError
+        end
+
+        # @return [Integer]
+        def count
+          collection.size
+        end
+
+        # @return [String, Integer, nil]
+        def next_page_starting_id
+          raise NotImplementedError
+        end
+
+        # @return [String, Integer, nil]
+        def prev_page_starting_id
+          raise NotImplementedError
+        end
+
+        # @return [Integer]
+        def total_count
+          raise NotImplementedError
+        end
+
+        private
+
+        # @return [PgEventstore::Connection]
+        def connection
+          PgEventstore.connection(config_name)
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/paginator/event_types_collection.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Paginator
+      class EventTypesCollection < BaseCollection
+        PER_PAGE = 10
+
+        # @return [Array<Hash>]
+        def collection
+          @_collection ||=
+            begin
+              sql_builder =
+                SQLBuilder.new.select('event_type').from('partitions').
+                  where('context is not null and stream_name is not null').
+                  group('event_type').order("event_type #{order}").limit(per_page)
+              sql_builder.where("event_type #{direction_operator} ?", starting_id) if starting_id
+              sql_builder.where('event_type like ?', "#{options[:query]}%")
+              connection.with do |conn|
+                conn.exec_params(*sql_builder.to_exec_params)
+              end.to_a
+            end
+        end
+
+        # @return [String, nil]
+        def next_page_starting_id
+          return unless collection.size == per_page
+
+          starting_id = collection.first['event_type']
+          sql_builder =
+            SQLBuilder.new.select('event_type').from('partitions').
+              where('context is not null and stream_name is not null').
+              where("event_type #{direction_operator} ?", starting_id).where('event_type like ?', "#{options[:query]}%").
+              group('event_type').order("event_type #{order}").limit(1).offset(per_page)
+
+          connection.with do |conn|
+            conn.exec_params(*sql_builder.to_exec_params)
+          end.to_a.dig(0, 'event_type')
+        end
+
+        private
+
+        # @return [String]
+        def direction_operator
+          order == :asc ? '>=' : '<='
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/paginator/events_collection.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Paginator
+      class EventsCollection < BaseCollection
+        SQL_DIRECTIONS = {
+          'asc' => :asc,
+          'desc' => :desc
+        }.tap do |directions|
+          directions.default = :desc
+        end.freeze
+        PER_PAGE = %w[10 20 50 100 1000].to_h { [_1, _1.to_i] }.tap do |per_page|
+          per_page.default = 10
+        end.freeze
+        # Max number of events after which we don't perform the exact count and keep the estimate count instead because of
+        # the potential performance degradation.
+        MAX_NUMBER_TO_COUNT = 10_000
+
+        # @return [Array<PgEventstore::Event>]
+        def collection
+          @_collection ||= PgEventstore.client(config_name).read(
+            PgEventstore::Stream.all_stream,
+            options: options.merge(
+              from_position: starting_id, max_count: per_page, direction: order, resolve_link_tos: true
+            ),
+            middlewares: []
+          )
+        end
+
+        # @return [Integer, nil]
+        def next_page_starting_id
+          return unless collection.size == per_page
+
+          from_position = event_global_position(collection.first)
+          sql_builder = QueryBuilders::EventsFiltering.all_stream_filtering(
+            options.merge(from_position: from_position, max_count: 1, direction: order)
+          ).to_sql_builder.unselect.select('global_position').offset(per_page)
+          global_position(sql_builder)
+        end
+
+        # @return [Integer, nil]
+        def prev_page_starting_id
+          from_position = event_global_position(collection.first) || starting_id
+          sql_builder = QueryBuilders::EventsFiltering.all_stream_filtering(
+            options.merge(from_position: from_position, max_count: per_page, direction: order == :asc ? :desc : :asc)
+          ).to_sql_builder.unselect.select('global_position').offset(1)
+          sql, params = sql_builder.to_exec_params
+          sql = "SELECT * FROM (#{sql}) events ORDER BY global_position #{order} LIMIT 1"
+          PgEventstore.connection.with  do |conn|
+            conn.exec_params(sql, params)
+          end.to_a.dig(0, 'global_position')
+        end
+
+        # @return [Integer]
+        def total_count
+          @_total_count ||=
+            begin
+              sql_builder =
+                QueryBuilders::EventsFiltering.all_stream_filtering(options).
+                  to_sql_builder.remove_limit.remove_group.remove_order
+              count = estimate_count(sql_builder)
+              return count if count > MAX_NUMBER_TO_COUNT
+
+              regular_count(sql_builder)
+            end
+        end
+
+        private
+
+        # @param event [PgEventstore::Eventg]
+        # @return [integer, nil]
+        def event_global_position(event)
+          event&.link&.global_position || event&.global_position
+        end
+
+        # @param sql_builder [PgEventstore::SQLBuilder]
+        # @return [Integer]
+        def estimate_count(sql_builder)
+          sql, params = sql_builder.to_exec_params
+          connection.with do |conn|
+            conn.exec_params("EXPLAIN #{sql}", params)
+          end.to_a.first['QUERY PLAN'].match(/rows=(\d+)/)[1].to_i
+        end
+
+        # @param sql_builder [PgEventstore::SQLBuilder]
+        # @return [Integer]
+        def regular_count(sql_builder)
+          sql_builder.unselect.select('count(*) as count_all')
+
+          connection.with do |conn|
+            conn.exec_params(*sql_builder.to_exec_params)
+          end.to_a.first['count_all']
+        end
+
+        # @return [Integer, nil]
+        def global_position(sql_builder)
+          connection.with do |conn|
+            conn.exec_params(*sql_builder.to_exec_params)
+          end.to_a.dig(0, 'global_position')
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/paginator/helpers.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Paginator
+      module Helpers
+        # @param collection [PgEventstore::Paginator::BaseCollection]
+        # @return [String]
+        def previous_page_link(collection)
+          id = collection.prev_page_starting_id
+          disabled = id ? '' : 'disabled'
+          <<~HTML
+          <li class="page-item #{disabled}">
+            <a class="page-link" href="#{build_starting_id_link(id)}" tabindex="-1">Previous</a>
+          </li>
+        HTML
+        end
+
+        # @param collection [PgEventstore::Paginator::BaseCollection]
+        # @return [String]
+        def next_page_link(collection)
+          id = collection.next_page_starting_id
+          disabled = id ? '' : 'disabled'
+          <<~HTML
+          <li class="page-item #{disabled}">
+            <a class="page-link" href="#{build_starting_id_link(id)}" tabindex="-1">Next</a>
+          </li>
+        HTML
+        end
+
+        # @return [String]
+        def first_page_link
+          path = build_path(params.slice(*(params.keys - ['starting_id'])))
+          <<~HTML
+          <li class="page-item">
+            <a class="page-link" href="#{path}" tabindex="-1">First</a>
+          </li>
+        HTML
+        end
+
+        # @param per_page [String] string representation of items per page. E.g. "10", "20", etc.
+        # @return [String]
+        def per_page_url(per_page)
+          build_path(params.merge(per_page: per_page))
+        end
+
+        # @param order [String] "asc"/"desc"
+        # @return [String]
+        def sort_url(order)
+          build_path(params.merge(order: order))
+        end
+
+        # @param number [Integer] total number of events by the current filter
+        # @return [String]
+        def total_count(number)
+          prefix =
+            if number > Paginator::EventsCollection::MAX_NUMBER_TO_COUNT
+              "Estimate count: "
+            else
+              "Total count: "
+            end
+          number = number_with_delimiter(number)
+          prefix + number
+        end
+
+        # Takes an integer and adds delimiters in there. E.g 1002341 becomes this "1,002,341"
+        # @param number [Integer]
+        # @param delimiter [String]
+        # @return [String] number with delimiters
+        def number_with_delimiter(number, delimiter: ',')
+          number = number.to_s
+          symbols_to_skip = number.size % 3
+          parts = []
+          parts.push(number[0...symbols_to_skip]) unless symbols_to_skip.zero?
+          parts.push(*number[symbols_to_skip..].scan(/\d{3}/))
+          parts.join(delimiter)
+        end
+
+        # @param event [PgEventstore::Event]
+        # @return [String]
+        def stream_path(event)
+          build_path(
+            {
+              filter: {
+                streams: [
+                  {
+                    context: event.stream.context,
+                    stream_name: event.stream.stream_name,
+                    stream_id: event.stream.stream_id
+                  }
+                ]
+              }
+            }
+          )
+
+        end
+
+        private
+
+        # @param starting_id [String, Integer, nil]
+        # @param [String, nil]
+        def build_starting_id_link(starting_id)
+          return 'javascript: void(0);' unless starting_id
+
+          build_path(params.merge(starting_id: starting_id))
+        end
+
+        # @param params [Hash, Array]
+        # @return [String]
+        def build_path(params)
+          encoded_params = Rack::Utils.build_nested_query(params)
+          return request.path if encoded_params.empty?
+
+          "#{request.path}?#{encoded_params}"
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/paginator/stream_contexts_collection.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Paginator
+      class StreamContextsCollection < BaseCollection
+        PER_PAGE = 10
+
+        # @return [Array<Hash>]
+        def collection
+          @_collection ||=
+            begin
+              sql_builder =
+                SQLBuilder.new.select('context').from('partitions').where('stream_name is null and event_type is null')
+                          .limit(per_page).order("context #{order}")
+              sql_builder.where("context #{direction_operator} ?", starting_id) if starting_id
+              sql_builder.where('context like ?', "#{options[:query]}%")
+              connection.with do |conn|
+                conn.exec_params(*sql_builder.to_exec_params)
+              end.to_a
+            end
+        end
+
+        # @return [String, nil]
+        def next_page_starting_id
+          return unless collection.size == per_page
+
+          starting_id = collection.first['context']
+          sql_builder =
+            SQLBuilder.new.select('context').from('partitions').where('stream_name is null and event_type is null').
+              where("context #{direction_operator} ?", starting_id).where('context like ?', "#{options[:query]}%").
+              limit(1).offset(per_page).order("context #{order}")
+
+          connection.with do |conn|
+            conn.exec_params(*sql_builder.to_exec_params)
+          end.to_a.dig(0, 'context')
+        end
+
+        private
+
+        # @return [String]
+        def direction_operator
+          order == :asc ? '>=' : '<='
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/paginator/stream_ids_collection.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Paginator
+      class StreamIdsCollection < BaseCollection
+        PER_PAGE = 10
+
+        # @return [Array<Hash>]
+        def collection
+          @_collection ||=
+            begin
+              sql_builder =
+                SQLBuilder.new.select('stream_id').from('events').
+                  where('context = ? and stream_name = ?', options[:context], options[:stream_name]).
+                  where('stream_id like ?', "#{options[:query]}%")
+              sql_builder.where("stream_id #{direction_operator} ?", starting_id) if starting_id
+              sql_builder.group('stream_id').limit(per_page).order("stream_id #{order}")
+              connection.with do |conn|
+                conn.exec_params(*sql_builder.to_exec_params)
+              end.to_a
+            end
+        end
+
+        # @return [String, nil]
+        def next_page_starting_id
+          return unless collection.size == per_page
+
+          starting_id = collection.first['stream_id']
+          sql_builder =
+            SQLBuilder.new.select('stream_id').from('events').
+              where("stream_id #{direction_operator} ?", starting_id).where('stream_id like ?', "#{options[:query]}%").
+              where('context = ? and stream_name = ?', options[:context], options[:stream_name]).
+              group('stream_id').limit(1).offset(per_page).order("stream_id #{order}")
+
+          connection.with do |conn|
+            conn.exec_params(*sql_builder.to_exec_params)
+          end.to_a.dig(0, 'stream_id')
+        end
+
+        private
+
+        # @return [String]
+        def direction_operator
+          order == :asc ? '>=' : '<='
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/paginator/stream_names_collection.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Paginator
+      class StreamNamesCollection < BaseCollection
+        PER_PAGE = 10
+
+        # @return [Array<Hash>]
+        def collection
+          @_collection ||=
+            begin
+              sql_builder =
+                SQLBuilder.new.select('stream_name').from('partitions').
+                  where('event_type is null and context = ?', options[:context]).
+                  where('stream_name like ?', "#{options[:query]}%")
+              sql_builder.where("stream_name #{direction_operator} ?", starting_id) if starting_id
+              sql_builder.limit(per_page).order("stream_name #{order}")
+              connection.with do |conn|
+                conn.exec_params(*sql_builder.to_exec_params)
+              end.to_a
+            end
+        end
+
+        # @return [String, nil]
+        def next_page_starting_id
+          return unless collection.size == per_page
+
+          starting_id = collection.first['stream_name']
+          sql_builder =
+            SQLBuilder.new.select('stream_name').from('partitions').
+              where("stream_name #{direction_operator} ?", starting_id).
+              where('stream_name like ?', "#{options[:query]}%").
+              where('event_type is null and context = ?', options[:context]).
+              limit(1).offset(per_page).order("stream_name #{order}")
+
+          connection.with do |conn|
+            conn.exec_params(*sql_builder.to_exec_params)
+          end.to_a.dig(0, 'stream_name')
+        end
+
+        private
+
+        # @return [String]
+        def direction_operator
+          order == :asc ? '>=' : '<='
+        end
+      end
+    end
+  end
+end