pg_eventstore 1.6.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 337db5e3df424d6d72b3e08367a730af7c77ebfd907d38b309309e30a563e81e
-  data.tar.gz: 71c36ea38c4d756adea73939ab15e75a2b4500d17768416e0f37013160f0b696
+  metadata.gz: ac379ed7a4c1c8ca46edd8e4ec537dafd575dd50749a140d15c49c24a1ece1c1
+  data.tar.gz: c5f83c5aa8fccc6f7100172270c951fda96ca7926c7a1b6b37f90217024e3e09
 SHA512:
-  metadata.gz: 70699c2d05ddb69f64922c6e0e67d46a523b5ed2f70d9278134435a144bc002013fe0657a408a0657ccb9f0fe2d1f9cd7a1521a50e128375b1c1d8ec1e127584
-  data.tar.gz: c1125f8dc9af55a1ce1752b94a9bb3273e1153c70e726845867bb91cad9a4b407bcc63537d2bb5859bef20508ce5bfb4391ed56218a690bef2119cf1351597d7
+  metadata.gz: 6ffbe0ddbfff6207069a527c7f41693e59d00a3217f68697c851fb2582300fefc569be8035f30924a225b95522ee5ef29ec26c9c6134fe705b31f6b32d0c39a3
+  data.tar.gz: 3b1860f5f351f5ffcd56f09c557661796a98f46a49c9a9bf8945667074ad8705f7cb9998639031fe07a4a2dfb89a0bf636b1e8157a21374da869cf4e76377792

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [1.8.0]
+- Introduce default config for admin web UI. Now if you define `:admin_web_ui` config - it will be preferred over default config
+- Fix pagination of events in admin UI
+- Improve partial index for `$streams` system stream
+
+## [1.7.0]
+- Implement reading from `"$streams"` system stream
+- Disable Host authorization introduced in sinatra v4.1
+
 ## [1.6.0]
 - Introduce subscriptions CLI. Type `pg-eventstore subscriptions --help` to see available commands. The main purpose of it is to provide the single way to start/stop subscription processes. Check [Subscriptions](docs/subscriptions.md#creating-a-subscription) docs about the new way to start and keep running a subscriptions process.
 

data/README.md

@@ -53,6 +53,51 @@ Documentation chapters:
 
 The gem is shipped with its own CLI. Use `pg-eventstore --help` to find out its capabilities.
 
+## RSpec
+
+### Clean up test db
+
+The gem provides a class to clean up your `pg_eventstore` test db between tests. Example usage(in your `spec/spec_helper.rb`:
+
+```ruby
+require 'pg_eventstore/rspec/test_helpers'
+
+RSpec.configure do |config|
+  config.before do
+    PgEventstore::TestHelpers.clean_up_db
+  end
+end
+```
+
+### RSpec matcher for OptionsExtension
+
+If you would like to be able to test the functional, provided by `PgEventstore::Extensions::OptionsExtension` extension - there is a rspec matcher. Load custom matcher in you `spec_helper.rb`:
+
+```ruby
+require 'pg_eventstore/rspec/has_option_matcher'
+```
+
+Let's say you have next class:
+```ruby
+class SomeClass
+  include PgEventstore::Extensions::OptionsExtension
+
+  option(:some_opt, metadata: { foo: :bar }) { '1' }
+end
+```
+
+To test that its instance has the proper option with the proper default value and proper metadata you can use this matcher:
+```ruby
+RSpec.describe SomeClass do
+  subject { described_class.new }
+
+  # Check that :some_opt is present
+  it { is_expected.to have_option(:some_opt) }
+  # Check that :some_opt is present and has the correct default value
+  it { is_expected.to have_option(:some_opt).with_default_value('1').with_metadata(foo: :bar) }
+end
+```
+
 ## Development
 
 After checking out the repo, run:

data/db/migrations/7_support_reading_streams_system_stream.sql

@@ -0,0 +1,2 @@
+CREATE INDEX idx_events_0_stream_revision_global_position ON events USING btree (stream_revision, global_position) WHERE stream_revision = 0;
+CREATE VIEW "$streams" AS SELECT * FROM events WHERE stream_revision = 0;

data/db/migrations/8_improve_0_revision_partial_index.sql

@@ -0,0 +1,2 @@
+DROP INDEX IF EXISTS idx_events_0_stream_revision_global_position;
+CREATE INDEX idx_events_0_stream_revision_global_position ON events USING btree (global_position) WHERE stream_revision = 0;

data/docs/admin_ui.md

@@ -10,7 +10,13 @@
 
 ## Authorization
 
-Admin UI is implemented as a rack application. It doesn't have any built-in authentication/authorization mechanism - it is your responsibility to take care of it.
+Admin UI is implemented as a rack application. It doesn't have any built-in authentication/authorization mechanism - it is your responsibility to take care of it. Admin UI tries to look for `:admin_web_ui` config with a fallback to `:default` config. Thus, you can setup Admin UI-specific config, e.g. without some middlewares or so. Example:
+
+```ruby
+PgEventstore.configure(name: :admin_web_ui) do |config|
+  config.middlewares = { my_admin_ui_middleware: AdminUIMiddleware.new }
+end
+```
 
 ### Rails integration
 

data/docs/events_and_streams.md

@@ -16,7 +16,9 @@
 - `stream_revision` - Integer(optional, read only). A revision of an event inside its stream.
 - `data` - Hash(optional). Event's payload data. For example, if you have a `DescriptionChanged` event class, then you may want to have a description value in the event payload data. Example: `DescriptionChanged.new(data: { 'description' => 'Description of something', 'post_id' => SecureRandom.uuid })`
 - `metadata` - Hash(optional). Event metadata. Event meta information which is not part of an events data payload. Example: `{ published_by: publishing_user.id }`
-- `link_id` - String(UUIDv4, optional, read only). If an event is a link event (link events are pointers to other events), this attribute contains the `id` of the original event. Manually assigning this attribute has no effect. It is internally set when appending an event to the given stream or when reading events from the database.
+- `link_id` - String(UUIDv4, optional, read only). If an event is a link event (link events are pointers to other events), this attribute contains an `id` of the original event. Manually assigning this attribute has no effect. It is internally set when appending an event to the given stream or when reading events from the database.
+- `link_partition_id` - Integer(optional, read only). If an event is a link event - this attribute contains a partition `id` of original event. Manually assigning this attribute has no effect. It is internally set when appending an event to the given stream or when reading events from the database.
+- `link` - PgEventstore::Event(optional, read only). When reading from a stream using `resolve_link_tos: true`, if an event is resolved from a link - this attribute contains a `PgEventstore::Event` object which corresponds to that link. Manually assigning this attribute has no effect. It is internally set when reading events from the database.
 - `created_at` - Time(optional, read only). Database's timestamp when an event was appended to a stream. You may want to put your own timestamp into a `metadata` attribute - it may be useful when migrating between different databases. Manually assigning this attribute has no effect. It is internally set when appending an event to the given stream or when reading events from the database.
 
 Example:
@@ -40,7 +42,21 @@ PgEventstore::Stream.new(context: 'Sales', stream_name: 'Customer', stream_id: '
 PgEventstore::Stream.new(context: 'Sales', stream_name: 'Customer', stream_id: 'f37b82f2-4152-424d-ab6b-0cc6f0a53aae')
 ```
 
-There is a special stream, called the "all" stream. You can get this object by calling the`PgEventstore::Stream.all_stream` method. Read more about the "all" stream in the `Reading from the "all" stream` section of [Reading events](reading_events.md) chapter.
+### "all" stream
+
+There is a special stream, called the "all" stream. You can get this object by calling the `PgEventstore::Stream.all_stream` method. Read more about the "all" stream in the `Reading from the "all" stream` section of [Reading events](reading_events.md) chapter.
+
+### System streams
+
+System stream is a special stream, the representation of which is pre-defined by the gem. System stream object can be created in next way:
+
+```ruby
+PgEventstore::Stream.system_stream(stream_name)
+```
+
+Current list of system streams is:
+
+- `"$streams"`. Reading from this stream will return 0 revision events. This allows effectively loop through a list of streams. Read more in [Reading events](reading_events.md#streams-stream-filtering) chapter.
 
 ## Important note
 

data/docs/multiple_commands.md

@@ -44,3 +44,7 @@ old_email =
 # Sending email outside multiple block to prevent potential re-triggering of it 
 UserMailer.notify_email_changed(user.id, old_email: old_email, new_email: user.email).deliver_later
 ```
+
+## Side effect of internal implementation
+
+Please note that when publishing an event with a type as part of a `multiple` block that does not yet exist in the database, the block will run twice as the first attempt to publish will always fail due to the way `append_to_stream` is implemented. Consider this when writing expectations in your tests for example.

data/docs/reading_events.md

@@ -53,7 +53,7 @@ In case a stream with given name does not exist, a `PgEventstore::StreamNotFound
 ```ruby
 begin
   stream = PgEventstore::Stream.new(context: 'non-existing-context', stream_name: 'User', stream_id: 'f37b82f2-4152-424d-ab6b-0cc6f0a53aae')
-  PgEventstore.client.read(stream)
+  PgEventstore.client.read(stream, options: { max_count: 1 })
 rescue PgEventstore::StreamNotFoundError => e
   puts e.message # => Stream #<PgEventstore::Stream:0x01> does not exist.
   puts e.stream # => #<PgEventstore::Stream:0x01>
@@ -80,6 +80,15 @@ You can read from a specific position of the "all" stream. This is very similar
 PgEventstore.client.read(PgEventstore::Stream.all_stream, options: { from_position: 9023, direction: 'Backwards' })
 ```
 
+## Reading from "$streams" system stream
+
+`"$streams"` is a special stream which consists of events with `stream_revision == 0`. This allows you to effectively query all streams. Example:
+
+```ruby
+stream = PgEventstore::Stream.system_stream("$streams")
+PgEventstore.client.read(stream).map(&:stream) # => array of unique streams
+```
+
 ## Middlewares
 
 If you would like to skip some of your registered middlewares from processing events after they being read from a stream - you should use the `:middlewares` argument which allows you to override the list of middlewares you would like to use.
@@ -160,6 +169,12 @@ You can also mix filtering by stream's attributes and event types. The result wi
 PgEventstore.client.read(PgEventstore::Stream.all_stream, options: { filter: { streams: [{ context: 'MyAwesomeContext' }], event_types: %w[Foo Bar] } })
 ```
 
+### "$streams" stream filtering
+
+When reading from `"$streams"` same rules apply as when reading from "all" stream. For example, read all streams which have `context == "MyAwesomeContext"` and start from events with event type either `"Foo"` or `"Bar"`:
+```ruby
+PgEventstore.client.read(PgEventstore::Stream.system_stream("$streams"), options: { filter: { streams: [{ context: 'MyAwesomeContext' }], event_types: %w[Foo Bar] } })
+```
 
 ## Pagination
 

data/lib/pg_eventstore/commands/read.rb

@@ -15,7 +15,7 @@ module PgEventstore
       # @return [Array<PgEventstore::Event>]
       # @raise [PgEventstore::StreamNotFoundError]
       def call(stream, options: {})
-        queries.events.stream_revision(stream) || raise(StreamNotFoundError, stream) unless stream.all_stream?
+        queries.events.stream_revision(stream) || raise(StreamNotFoundError, stream) unless stream.system?
 
         queries.events.stream_events(stream, options)
       end

data/lib/pg_eventstore/queries/event_queries.rb

@@ -70,7 +70,7 @@ module PgEventstore
     # @param options [Hash]
     # @return [Array<PgEventstore::Event>]
     def stream_events(stream, options)
-      exec_params = events_filtering(stream, options).to_exec_params
+      exec_params = QueryBuilders::EventsFiltering.events_filtering(stream, options).to_exec_params
       raw_events = connection.with do |conn|
         conn.exec_params(*exec_params)
       end.to_a
@@ -128,15 +128,6 @@ module PgEventstore
       [sql_rows_for_insert, values]
     end
 
-    # @param stream [PgEventstore::Stream]
-    # @param options [Hash]
-    # @return [PgEventstore::EventsFiltering]
-    def events_filtering(stream, options)
-      return QueryBuilders::EventsFiltering.all_stream_filtering(options) if stream.all_stream?
-
-      QueryBuilders::EventsFiltering.specific_stream_filtering(stream, options)
-    end
-
     # @return [PgEventstore::LinksResolver]
     def links_resolver
       LinksResolver.new(connection)

data/lib/pg_eventstore/query_builders/events_filtering.rb

@@ -21,6 +21,18 @@ module PgEventstore
       SUBSCRIPTIONS_OPTIONS = %i[from_position resolve_link_tos filter max_count].freeze
 
       class << self
+        # @param stream [PgEventstore::Stream]
+        # @param options [Hash]
+        # @return [PgEventstore::EventsFiltering]
+        def events_filtering(stream, options)
+          return all_stream_filtering(options) if stream.all_stream?
+          if stream.system? && Stream::KNOWN_SYSTEM_STREAMS.include?(stream.context)
+            return system_stream_filtering(stream, options)
+          end
+
+          specific_stream_filtering(stream, options)
+        end
+
         # @param options [Hash]
         # @return [PgEventstore::QueryBuilders::EventsFiltering]
         def subscriptions_events_filtering(options)
@@ -54,6 +66,15 @@ module PgEventstore
           event_filter.add_stream_direction(options[:direction])
           event_filter
         end
+
+        # @param stream [PgEventstore::Stream] system stream
+        # @param options [Hash]
+        # @return [PgEventstore::QueryBuilders::EventsFiltering]
+        def system_stream_filtering(stream, options)
+          all_stream_filtering(options).tap do |event_filter|
+            event_filter.set_source(stream.context)
+          end
+        end
       end
 
       def initialize
@@ -139,6 +160,12 @@ module PgEventstore
         @sql_builder.to_exec_params
       end
 
+      # @param table_name [String] system stream view name
+      # @return [void]
+      def set_source(table_name)
+        @sql_builder.from(%{ "#{PG::Connection.escape(table_name)}" events })
+      end
+
       private
 
       # @param stream_attrs [Hash]

data/lib/pg_eventstore/rspec/has_option_matcher.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 # This matcher is defined to test options which are defined by using
-# EventStoreClient::Extensions::OptionsExtension option. Example:
+# PgEventstore::Extensions::OptionsExtension option. Example:
 # Let's say you have next class
 # class SomeClass
 #   include PgEventstore::Extensions::OptionsExtension
 #
-#   option(:some_opt) { '1' }
+#   option(:some_opt, metadata: { foo: :bar }) { '1' }
 # end
 #
-# To test that its instance has the proper option with the proper default value you can use this
+# To test that its instance has the proper option with the proper default value and proper metadata you can use this
 # matcher:
 # RSpec.describe SomeClass do
 #   subject { described_class.new }
@@ -17,31 +17,7 @@
 #   # Check that :some_opt is present
 #   it { is_expected.to have_option(:some_opt) }
 #   # Check that :some_opt is present and has the correct default value
-#   it { is_expected.to have_option(:some_opt).with_default_value('1') }
-# end
-#
-# If you have more complex implementation of default value of your option - you should handle it
-# customly. For example:
-# class SomeClass
-#   include PgEventstore::Extensions::OptionsExtension
-#
-#   option(:some_opt) { calc_value }
-# end
-# You could test it like so:
-# RSpec.described SomeClass do
-#   let(:instance) { described_class.new }
-#
-#   describe ':some_opt default value' do
-#     subject { instance.some_opt }
-#
-#     let(:value) { 'some val' }
-#
-#     before do
-#       allow(instance).to receive(:calc_value).and_return(value)
-#     end
-#
-#     it { is_expected.to eq(value) }
-#   end
+#   it { is_expected.to have_option(:some_opt).with_default_value('1').with_metadata(foo: :bar) }
 # end
 RSpec::Matchers.define :has_option do |option_name|
   match do |obj|

data/lib/pg_eventstore/stream.rb

@@ -8,6 +8,8 @@ module PgEventstore
     SYSTEM_STREAM_PREFIX = '$'
     # @return [Integer]
     NON_EXISTING_STREAM_REVISION = -1
+    # @return [Array<String>]
+    KNOWN_SYSTEM_STREAMS = %w[$streams].freeze
 
     class << self
       # Produces "all" stream instance. "all" stream does not represent any specific stream. Instead, it indicates that
@@ -18,6 +20,12 @@ module PgEventstore
           stream.instance_variable_set(:@all_stream, true)
         end
       end
+
+      # @param name [String]
+      # @return [PgEventstore::Stream]
+      def system_stream(name)
+        new(context: name, stream_name: '', stream_id: '')
+      end
     end
 
     # @!attribute context

data/lib/pg_eventstore/version.rb

@@ -2,5 +2,5 @@
 
 module PgEventstore
   # @return [String]
-  VERSION = "1.6.0"
+  VERSION = "1.8.0"
 end

data/lib/pg_eventstore/web/application.rb

@@ -5,10 +5,16 @@ require 'securerandom'
 module PgEventstore
   module Web
     class Application < Sinatra::Base
+      # @return [Symbol]
+      DEFAULT_ADMIN_UI_CONFIG = :admin_web_ui
+      # @return [String]
+      COOKIES_CONFIG_KEY = 'current_config'
+
       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 :host_authorization, { allow_if: ->(_env) { true } }
 
       helpers(Paginator::Helpers, Subscriptions::Helpers) do
         # @return [Array<Hash>, nil]
@@ -19,6 +25,12 @@ module PgEventstore
           end&.reject { _1.empty? }
         end
 
+        # @return [String, nil]
+        def system_stream
+          params in { filter: { system_stream: String => system_stream } }
+          system_stream if Stream::KNOWN_SYSTEM_STREAMS.include?(system_stream)
+        end
+
         # @return [Array<String>, nil]
         def events_filter
           params in { filter: { events: Array => events } }
@@ -27,12 +39,23 @@ module PgEventstore
 
         # @return [Symbol]
         def current_config
-          config = request.cookies['current_config']&.to_s&.to_sym
-          PgEventstore.available_configs.include?(config) ? config : :default
+          resolve_config_by_name(request.cookies[COOKIES_CONFIG_KEY]&.to_s&.to_sym)
+        end
+
+        # @param config_name [Symbol, nil]
+        # @return [Symbol]
+        def resolve_config_by_name(config_name)
+          existing_config = [config_name, DEFAULT_ADMIN_UI_CONFIG].find do |name|
+            PgEventstore.available_configs.include?(name)
+          end
+
+          existing_config || PgEventstore::DEFAULT_CONFIG
         end
 
+        # @param val [Object]
+        # @return [void]
         def current_config=(val)
-          response.set_cookie('current_config', { value: val.to_s, http_only: true, same_site: :lax })
+          response.set_cookie(COOKIES_CONFIG_KEY, { value: val.to_s, http_only: true, same_site: :lax })
         end
 
         # @return [PgEventstore::Connection]
@@ -40,7 +63,7 @@ module PgEventstore
           PgEventstore.connection(current_config)
         end
 
-        # @param collection [PgEventstore::Paginator::BaseCollection]
+        # @param collection [PgEventstore::Web::Paginator::BaseCollection]
         # @return [void]
         def paginated_json_response(collection)
           halt 200, {
@@ -85,7 +108,8 @@ module PgEventstore
           options: {
             filter: { event_types: events_filter, streams: streams_filter },
             resolve_link_tos: resolve_link_tos?
-          }
+          },
+          system_stream: system_stream
         )
 
         if request.xhr?
@@ -127,9 +151,7 @@ module PgEventstore
       end
 
       post '/change_config' do
-        config = params[:config]&.to_sym
-        config = :default unless PgEventstore.available_configs.include?(config)
-        self.current_config = config
+        self.current_config = resolve_config_by_name(params[:config]&.to_s&.to_sym)
         redirect(redirect_back_url(fallback_url: '/'))
       end
 

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

@@ -19,12 +19,22 @@ module PgEventstore
         #   count instead because of the potential performance degradation.
         MAX_NUMBER_TO_COUNT = 10_000
 
+        # @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
+        # @param system_stream [String, nil] a name of system stream
+        def initialize(config_name, starting_id:, per_page:, order:, options: {}, system_stream: nil)
+          super(config_name, starting_id: starting_id, per_page: per_page, order: order, options: options)
+          @stream = system_stream ? PgEventstore::Stream.system_stream(system_stream) : PgEventstore::Stream.all_stream
+        end
+
         # @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),
-            middlewares: []
+            @stream,
+            options: options.merge(from_position: starting_id, max_count: per_page, direction: order)
           )
         end
 
@@ -33,7 +43,8 @@ module PgEventstore
           return unless collection.size == per_page
 
           from_position = event_global_position(collection.first)
-          sql_builder = QueryBuilders::EventsFiltering.all_stream_filtering(
+          sql_builder = QueryBuilders::EventsFiltering.events_filtering(
+            @stream,
             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)
@@ -42,12 +53,13 @@ module PgEventstore
         # @return [Integer, nil]
         def prev_page_starting_id
           from_position = event_global_position(collection.first) || starting_id
-          sql_builder = QueryBuilders::EventsFiltering.all_stream_filtering(
+          sql_builder = QueryBuilders::EventsFiltering.events_filtering(
+            @stream,
             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|
+          connection.with  do |conn|
             conn.exec_params(sql, params)
           end.to_a.dig(0, 'global_position')
         end
@@ -57,7 +69,7 @@ module PgEventstore
           @_total_count ||=
             begin
               sql_builder =
-                QueryBuilders::EventsFiltering.all_stream_filtering(options).
+                QueryBuilders::EventsFiltering.events_filtering(@stream, options).
                   to_sql_builder.remove_limit.remove_group.remove_order
               count = estimate_count(sql_builder)
               return count if count > MAX_NUMBER_TO_COUNT
@@ -68,7 +80,7 @@ module PgEventstore
 
         private
 
-        # @param event [PgEventstore::Event]
+        # @param event [PgEventstore::Event, nil]
         # @return [Integer, nil]
         def event_global_position(event)
           event&.link&.global_position || event&.global_position

data/lib/pg_eventstore/web/public/javascripts/pg_eventstore.js

@@ -60,6 +60,13 @@ $(function(){
         });
     }
 
+    let initSystemStreamFilterAutocomplete = function($filter){
+        let $streamNameSelect = $filter.find('select');
+        $streamNameSelect.select2({
+            allowClear: true
+        });
+    }
+
     let initEventTypeFilterAutocomplete = function($filter) {
         let $eventTypeSelect = $filter.find('select');
         $eventTypeSelect.select2({
@@ -86,6 +93,8 @@ $(function(){
     let $filtersForm = $('#filters-form');
     // Stream filter template
     let streamFilterTmpl = $('#stream-filter-tmpl').text();
+    // System stream filter template
+    let systemStreamFilterTmpl = $('#system-stream-filter-tmpl').text();
     // Event type filter template
     let eventFilterTmpl = $('#event-type-filter-tmpl').text();
 
@@ -93,21 +102,34 @@ $(function(){
     $filtersForm.on('click', '.remove-filter', function(){
         $(this).parents('.form-row').remove();
     });
-    // Add stream filter button
+    // "Add stream filter" button
     $filtersForm.on('click', '.add-stream-filter', function(){
         let filtersNum = $filtersForm.find('.stream-filters').children().length + '';
         $filtersForm.find('.stream-filters').append(streamFilterTmpl.replace(/%NUM%/g, filtersNum));
         initStreamFilterAutocomplete($filtersForm.find('.stream-filters').children().last());
     });
-    // Add event type filter button
+    // "Add system stream filter" button
+    $filtersForm.on('click', '.add-system-stream-filter', function(){
+        if($filtersForm.find('.system-stream-filter').children().length > 0)
+            return;
+
+        $filtersForm.find('.system-stream-filter').append(systemStreamFilterTmpl);
+        initSystemStreamFilterAutocomplete($filtersForm.find('.system-stream-filter').children().last());
+    });
+    // "Add event type filter" button
     $filtersForm.on('click', '.add-event-filter', function(){
         $filtersForm.find('.event-filters').append(eventFilterTmpl);
         initEventTypeFilterAutocomplete($filtersForm.find('.event-filters').children().last());
     });
+
     // Init select2 for stream filters which were initially rendered
     $filtersForm.find('.stream-filters').children().each(function(){
         initStreamFilterAutocomplete($(this));
     });
+    // Init select2 for system stream filter which were initially rendered
+    $filtersForm.find('.system-stream-filter').children().each(function(){
+        initSystemStreamFilterAutocomplete($(this));
+    });
     // Init select2 for event type filters which were initially rendered
     $filtersForm.find('.event-filters').children().each(function(){
         initEventTypeFilterAutocomplete($(this));

data/lib/pg_eventstore/web/views/home/dashboard.erb

@@ -1,6 +1,9 @@
 <script type="text/html" id="stream-filter-tmpl">
   <%= erb :'home/partials/stream_filter', { layout: false }, { stream: {} } %>
 </script>
+<script type="text/html" id="system-stream-filter-tmpl">
+  <%= erb :'home/partials/system_stream_filter', { layout: false }, { stream: nil } %>
+</script>
 <script type="text/html" id="event-type-filter-tmpl">
   <%= erb :'home/partials/event_filter', { layout: false }, { event_type: '' } %>
 </script>
@@ -27,6 +30,11 @@
             <form id="filters-form" action="<%= url('/') %>" method="GET" data-parsley-validate class="form-horizontal form-label-left">
               <input type="hidden" name="per_page" value="<%= params[:per_page].to_i %>">
               <input type="hidden" name="resolve_link_tos" value="<%= resolve_link_tos? %>">
+              <div class="system-stream-filter">
+                <% if system_stream %>
+                  <%= erb :'home/partials/system_stream_filter', { layout: false }, { stream: system_stream } %>
+                <% end %>
+              </div>
               <div class="stream-filters">
                 <% streams_filter&.each do |attrs| %>
                   <%= erb :'home/partials/stream_filter', { layout: false }, { stream: attrs } %>
@@ -48,6 +56,7 @@
                       </button>
                       <div class="dropdown-menu">
                         <a class="dropdown-item add-stream-filter" href="javascript: void(0)">Add stream filter</a>
+                        <a class="dropdown-item add-system-stream-filter" href="javascript: void(0)">Add system stream filter</a>
                         <a class="dropdown-item add-event-filter" href="javascript: void(0)">Add event filter</a>
                       </div>
                     </div>

data/lib/pg_eventstore/web/views/home/partials/events.erb

@@ -6,10 +6,13 @@
     <td><%= h event.stream.stream_name %></td>
     <td><a href="<%= stream_path(event) %>"><%= event.stream.stream_id %></a></td>
     <td>
-      <%= h event.type %>
+      <p class="float-left"><%= h event.type %></p>
       <% if event.link %>
-        <i class="fa fa-link"></i>
+        <p class="float-left ml-2">
+          <i class="fa fa-link"></i>
+        </p>
       <% end %>
+      <div class="clearfix"></div>
     </td>
     <td><%= event.created_at.strftime('%F %T') %></td>
     <td><%= event.id %></td>

data/lib/pg_eventstore/web/views/home/partials/system_stream_filter.erb

@@ -0,0 +1,15 @@
+<div class="form-row align-items-center">
+  <div class="col-3">
+    <select name="filter[system_stream]" class="form-control mb-2" data-placeholder="Select system stream">
+      <option></option>
+      <% PgEventstore::Stream::KNOWN_SYSTEM_STREAMS.each do |stream_name| %>
+        <option value="<%= stream_name %>" <% if stream == stream_name %> selected <% end %>><%= stream_name %></option>
+      <% end %>
+    </select>
+  </div>
+  <div class="col-1">
+    <a class="btn btn-default remove-filter" href="javascript: void(0);">
+      <i class="fa fa-minus-circle"></i>
+    </a>
+  </div>
+</div>

data/lib/pg_eventstore/web/views/layouts/application.erb

@@ -87,7 +87,7 @@
               <div class="dropdown-menu dropdown-usermenu pull-right" aria-labelledby="navbarDropdown">
                 <% PgEventstore.available_configs.each do |config| %>
                   <form action="<%= url('/change_config') %>" method="POST">
-                    <input type="hidden" name="config" value="<%= h config %>">
+                    <input type="hidden" name="config" value="<%= h config.to_s %>">
                     <button type="submit" class="dropdown-item"><%= h config.inspect %></button>
                   </form>
                 <% end %>

data/lib/pg_eventstore.rb

@@ -18,6 +18,9 @@ require_relative 'pg_eventstore/middleware'
 require_relative 'pg_eventstore/subscriptions/subscriptions_manager'
 
 module PgEventstore
+  # @return [Symbol]
+  DEFAULT_CONFIG = :default
+
   class << self
     # @!attribute mutex
     #   @return [Thread::Mutex]
@@ -27,7 +30,7 @@ module PgEventstore
     # Creates a Config if not exists and yields it to the given block.
     # @param name [Symbol] a name to assign to a config
     # @return [Object] a result of the given block
-    def configure(name: :default)
+    def configure(name: DEFAULT_CONFIG)
       mutex.synchronize do
         @config[name] ||= Config.new(name: name)
         connection_config_was = @config[name].connection_options
@@ -48,7 +51,7 @@ module PgEventstore
 
     # @param name [Symbol]
     # @return [PgEventstore::Config]
-    def config(name = :default)
+    def config(name = DEFAULT_CONFIG)
       return @config[name] if @config[name]
 
       error_message = <<~TEXT
@@ -64,7 +67,7 @@ module PgEventstore
     # thread-safe
     # @param name [Symbol]
     # @return [PgEventstore::Connection]
-    def connection(name = :default)
+    def connection(name = DEFAULT_CONFIG)
       mutex.synchronize do
         @connection[name] ||= Connection.new(**config(name).connection_options)
       end
@@ -76,7 +79,7 @@ module PgEventstore
     # @param retries_interval [Integer, nil] a delay between retries of failed SubscriptionsSet
     # @param force_lock [Boolean] whether to force-lock subscriptions
     # @return [PgEventstore::SubscriptionsManager]
-    def subscriptions_manager(config_name = :default, subscription_set:, max_retries: nil, retries_interval: nil,
+    def subscriptions_manager(config_name = DEFAULT_CONFIG, subscription_set:, max_retries: nil, retries_interval: nil,
                               force_lock: false)
       SubscriptionsManager.new(
         config: config(config_name),
@@ -89,7 +92,7 @@ module PgEventstore
 
     # @param name [Symbol]
     # @return [PgEventstore::Client]
-    def client(name = :default)
+    def client(name = DEFAULT_CONFIG)
       Client.new(config(name))
     end
 
@@ -108,7 +111,7 @@ module PgEventstore
 
     # @return [void]
     def init_variables
-      @config = { default: Config.new(name: :default) }
+      @config = { DEFAULT_CONFIG => Config.new(name: DEFAULT_CONFIG) }
       @connection = {}
       @mutex = Thread::Mutex.new
     end

data/sig/pg_eventstore/queries/event_queries.rbs

@@ -31,11 +31,6 @@ module PgEventstore
     # _@param_ `events`
     def prepared_statements: (PgEventstore::Stream stream, ::Array[PgEventstore::Event] events) -> ::Array[(::Array[String] | ::Array[Object])]
 
-    # _@param_ `stream`
-    #
-    # _@param_ `options`
-    def events_filtering: (PgEventstore::Stream stream, ::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
-
     def links_resolver: () -> PgEventstore::LinksResolver
 
     # Returns the value of attribute connection.

data/sig/pg_eventstore/query_builders/events_filtering_query.rbs

@@ -6,6 +6,10 @@ module PgEventstore
       SQL_DIRECTIONS: Hash[String | Symbol, String]
       SUBSCRIPTIONS_OPTIONS: ::Array[Symbol]
 
+      @sql_builder: PgEventstore::SQLBuilder
+
+      def self.events_filtering: (PgEventstore::Stream stream, ::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
+      
       # _@param_ `options`
       def self.subscriptions_events_filtering: (::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
 
@@ -17,6 +21,8 @@ module PgEventstore
       # _@param_ `options`
       def self.specific_stream_filtering: (PgEventstore::Stream stream, ::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
 
+      def self.system_stream_filtering: (PgEventstore::Stream stream, Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
+
       def initialize: () -> void
 
       # _@param_ `context`

data/sig/pg_eventstore/stream.rbs

@@ -1,10 +1,13 @@
 module PgEventstore
   class Stream
+    KNOWN_SYSTEM_STREAMS: Array[String]
     SYSTEM_STREAM_PREFIX: String
     NON_EXISTING_STREAM_REVISION: Integer
 
     def self.all_stream: () -> PgEventstore::Stream
 
+    def self.system_stream: (String) -> PgEventstore::Stream
+
     # _@param_ `context`
     #
     # _@param_ `stream_name`

data/sig/pg_eventstore/web/application.rbs

@@ -0,0 +1,32 @@
+module PgEventstore
+  module Web
+    class Application
+      COOKIES_CONFIG_KEY: String
+      DEFAULT_ADMIN_UI_CONFIG: Symbol
+
+      def asset_url: (String path) -> String
+
+      def connection: -> PgEventstore::Connection
+
+      def current_config: -> Symbol
+
+      def current_config=: (untyped val) -> void
+
+      def events_filter: -> Array[String]?
+
+      def h: (String text) -> String
+
+      def paginated_json_response: (PgEventstore::Web::Paginator::BaseCollection collection) -> void
+
+      def redirect_back_url: (fallback_url: String) -> String
+
+      def resolve_config_by_name: (Symbol? config_name)-> Symbol
+
+      def resolve_link_tos?: -> bool
+
+      def streams_filter: -> Array[Hash[untyped, untyped]]?
+
+      def system_stream: -> String?
+    end
+  end
+end

data/sig/pg_eventstore/web/paginator/base_collection.rbs

@@ -2,15 +2,6 @@ module PgEventstore
   module Web
     module Paginator
       class BaseCollection
-        # _@param_ `config_name`
-        #
-        # _@param_ `starting_id`
-        #
-        # _@param_ `per_page`
-        #
-        # _@param_ `order` — :asc or :desc
-        #
-        # _@param_ `options` — additional options to filter the collection
         def initialize: (
             Symbol config_name,
             starting_id: (String | Integer)?,

data/sig/pg_eventstore/web/paginator/event_types_collection.rbs

@@ -4,6 +4,15 @@ module PgEventstore
       class EventTypesCollection < PgEventstore::Web::Paginator::BaseCollection
         PER_PAGE: Integer
 
+        def initialize: (
+            Symbol config_name,
+            starting_id: (String | Integer)?,
+            per_page: Integer,
+            order: Symbol,
+            ?options: ::Hash[untyped, untyped],
+            ?system_stream: String?
+          ) -> void
+
         def collection: () -> ::Array[::Hash[String, String]]
 
         def next_page_starting_id: () -> String?

data/sig/pg_eventstore/web/paginator/events_collection.rbs

@@ -6,6 +6,8 @@ module PgEventstore
         PER_PAGE: ::Hash[String, Integer]
         MAX_NUMBER_TO_COUNT: Integer
 
+        @stream: PgEventstore::Stream
+
         def collection: () -> ::Array[PgEventstore::Event]
 
         def next_page_starting_id: () -> Integer?
@@ -15,7 +17,7 @@ module PgEventstore
         def total_count: () -> Integer
 
         # _@param_ `event`
-        def event_global_position: (PgEventstore::Event event) -> Integer?
+        def event_global_position: (PgEventstore::Event? event) -> Integer?
 
         # _@param_ `sql_builder`
         def estimate_count: (PgEventstore::SQLBuilder sql_builder) -> Integer

data/sig/pg_eventstore.rbs

@@ -1,4 +1,6 @@
 module PgEventstore
+  DEFAULT_CONFIG: Symbol
+
   # _@param_ `name` — a name to assign to a config
   #
   # _@return_ — a result of the given block

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_eventstore
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Ivan Dzyzenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-11-12 00:00:00.000000000 Z
+date: 2025-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -77,6 +77,8 @@ files:
 - db/migrations/4_create_subscriptions_set_commands.sql
 - db/migrations/5_partitions.sql
 - db/migrations/6_add_commands_data.sql
+- db/migrations/7_support_reading_streams_system_stream.sql
+- db/migrations/8_improve_0_revision_partial_index.sql
 - docs/admin_ui.md
 - docs/appending_events.md
 - docs/configuration.md
@@ -226,6 +228,7 @@ files:
 - lib/pg_eventstore/web/views/home/partials/events.erb
 - lib/pg_eventstore/web/views/home/partials/pagination_links.erb
 - lib/pg_eventstore/web/views/home/partials/stream_filter.erb
+- lib/pg_eventstore/web/views/home/partials/system_stream_filter.erb
 - lib/pg_eventstore/web/views/layouts/application.erb
 - lib/pg_eventstore/web/views/subscriptions/index.erb
 - pg_eventstore.gemspec
@@ -331,6 +334,7 @@ files:
 - sig/pg_eventstore/subscriptions/subscriptions_set_lifecycle.rbs
 - sig/pg_eventstore/utils.rbs
 - sig/pg_eventstore/version.rbs
+- sig/pg_eventstore/web/application.rbs
 - sig/pg_eventstore/web/paginator/base_collection.rbs
 - sig/pg_eventstore/web/paginator/event_types_collection.rbs
 - sig/pg_eventstore/web/paginator/events_collection.rbs