ruby_event_store-browser 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b419e20de9010f16d9592f1a715216f2c4c74d54c8412be3a99ed9af265ac30
-  data.tar.gz: 4335f6b699e72f9af66a72a62f3b42c97879611bc149bab757d4655eeb02e6d7
+  metadata.gz: 5c34bdfb8bf1ac7bd5ee801add4be05d53e9698f9e62b7dd55ba822ab5210b10
+  data.tar.gz: 03ff99bad816c753b0b69554e19233467842ff74d0df7e21e1a36645550b9336
 SHA512:
-  metadata.gz: 7282139e311fa44799a4a7f125ecf137d026b65cc255ec6808886a8af19d01c803af3b6d211850c902672a7b49750aa00b76770072d04b1fb271fd66c9cab687
-  data.tar.gz: 77281b49763b1d6633062c2635a61b63e087007eae1299746b5a74b25d767ad27e2452439ebe4f32cab1e42bd7380f04f6ed8bbfac69ea1b93e4bcf3a6885dc2
+  metadata.gz: 851f7a67f73ac05f96b6ac76ce73690783eed6bc71b830b2740a6b529fb4f47396ba2e7490f969648c9fede5c54a975f7e39c94fe6f4231c09f8b803456a7af9
+  data.tar.gz: 7a9c17aa335a429247c81561ee301d26af132952b52113a0c439a2b5afbfc5b1c38b77a5154b768b75727f55dfdd8ef1592f3fab840760dde5982e137e31bef0

data/README.md

@@ -6,4 +6,4 @@ Find out more at [https://railseventstore.org](https://railseventstore.org/)
 
 ## UI Dev mode
 
-`make install clean dev` will auto-compile JS/CSS from ELM in the background and also serve standalone browser on http://localhost:9393
+`make build` compiles the CSS with Tailwind and vendors the pinned Stimulus runtime. `make dev` serves the standalone browser seeded with some events on http://localhost:9393

data/lib/ruby_event_store/browser/app.rb

@@ -2,7 +2,7 @@
 
 require_relative "../browser"
 require "rack"
-require "erb"
+require "uri"
 require "json"
 
 module RubyEventStore
@@ -14,37 +14,42 @@ module RubyEventStore
         path: nil,
         api_url: nil,
         environment: nil,
-        related_streams_query: DEFAULT_RELATED_STREAMS_QUERY
+        related_streams_query: DEFAULT_RELATED_STREAMS_QUERY,
+        extensions: [],
+        views_root: nil
       )
         warn(<<~WARN) if environment
-        Passing :environment to RubyEventStore::Browser::App.for is deprecated. 
+          Passing :environment to RubyEventStore::Browser::App.for is deprecated.
 
-        This option is no-op, has no effect and will be removed in next major release.
-      WARN
+          This option is no-op, has no effect and will be removed in next major release.
+        WARN
         warn(<<~WARN) if host
-        Passing :host to RubyEventStore::Browser::App.for is deprecated. 
+          Passing :host to RubyEventStore::Browser::App.for is deprecated.
 
-        This option will be removed in next major release. 
-        
-        Host and mount points are correctly recognized from Rack environment 
-        and this option is redundant.
-      WARN
+          This option will be removed in next major release.
+
+          Host and mount points are correctly recognized from Rack environment
+          and this option is redundant.
+        WARN
         warn(<<~WARN) if path
-        Passing :path to RubyEventStore::Browser::App.for is deprecated. 
+          Passing :path to RubyEventStore::Browser::App.for is deprecated.
+
+          This option will be removed in next major release.
 
-        This option will be removed in next major release. 
+          Host and mount points are correctly recognized from Rack environment
+          and this option is redundant.
+        WARN
+        warn(<<~WARN) if api_url
+          Passing :api_url to RubyEventStore::Browser::App.for is deprecated.
 
-        Host and mount points are correctly recognized from Rack environment 
-        and this option is redundant.
-      WARN
+          This option is no-op and will be removed in next major release.
+        WARN
 
         Rack::Builder.new do
           use Rack::Static,
               urls:
                 %w[
-                  bootstrap.js
-                  ruby_event_store_browser.css
-                  ruby_event_store_browser.js
+                  stimulus-3.2.2.js
                   android-chrome-192x192.png
                   android-chrome-512x512.png
                   apple-touch-icon.png
@@ -57,109 +62,208 @@ module RubyEventStore
                   mstile-310x150.png
                   mstile-310x310.png
                   safari-pinned-tab.svg
-                ].map { |f| ["/#{f}", f] }.to_h,
+                  ruby_event_store_browser.js
+                  ruby_event_store_browser.css
+                ].map { |f| ["/#{f}", f] }.to_h.merge(
+                  "/#{BROWSER_JS}"  => "ruby_event_store_browser.js",
+                  "/#{BROWSER_CSS}" => "ruby_event_store_browser.css",
+                ),
               root: "#{__dir__}/../../../public"
+          extensions.each_with_index do |extension, index|
+            mappings = App.extension_asset_mappings(extension, index)
+            use Rack::Static, urls: mappings, root: extension.assets_root unless mappings.empty?
+          end
           run App.new(
                 event_store_locator: event_store_locator,
                 related_streams_query: related_streams_query,
                 host: host,
                 root_path: path,
-                api_url: api_url,
+                extensions: extensions,
+                views_root: views_root,
               )
         end
       end
 
-      def initialize(event_store_locator:, related_streams_query:, host:, root_path:, api_url:)
+      def self.extension_asset_mappings(extension, index)
+        return {} unless extension.respond_to?(:assets_root)
+
+        Dir
+          .glob("**/*", base: extension.assets_root)
+          .to_h { |relative_path| ["/extension_assets/#{index}/#{relative_path}", relative_path] }
+      end
+
+      def initialize(event_store_locator:, related_streams_query:, host:, root_path:, extensions: [], views_root: nil)
         @event_store_locator = event_store_locator
         @related_streams_query = related_streams_query
-        @routing = Urls.from_configuration(host, root_path, api_url)
+        @extensions = extensions
+        @views_root = views_root
+        @routing = Urls.from_configuration(host, root_path)
       end
 
       def call(env)
+        request = Rack::Request.new(env)
         router = Router.new(routing)
-        router.add_route("GET", "/api/events/:event_id") do |params|
-          json GetEvent.new(event_store: event_store, event_id: params.fetch("event_id"))
+
+        router.add_route("GET", "/") do |_, urls|
+          [302, { "location" => urls.stream_url(SERIALIZED_GLOBAL_STREAM_NAME) }, []]
         end
-        router.add_route("GET", "/api/streams/:stream_name") do |params, urls|
-          json GetStream.new(
-                 stream_name: params.fetch("stream_name"),
-                 routing: urls,
-                 related_streams_query: related_streams_query,
-               )
+
+        router.add_route("GET", "/streams/:stream_name") do |params, urls|
+          stream_name = params.fetch("stream_name")
+          reader = GetEventsFromStream.new(event_store: event_store, stream_name: stream_name, page: params["page"])
+          layout.render(
+            "streams/show",
+            urls: urls,
+            stream_name: stream_name,
+            title: "Stream #{stream_name}",
+            events: reader.events,
+            pagination:
+              reader.pagination.transform_values { |cursor| urls.stream_page_url(stream_name, cursor, reader.count) },
+            related_streams: related_streams_query.call(stream_name),
+            extension_links: stream_extension_links(stream_name, urls),
+          )
         end
-        router.add_route("GET", "/api/streams/:stream_name/relationships/events") do |params, urls|
-          json GetEventsFromStream.new(
-                 event_store: event_store,
-                 routing: urls,
-                 stream_name: params.fetch("stream_name"),
-                 page: params["page"],
-               )
+
+        router.add_route("GET", "/events/:event_id") do |params, urls|
+          event = event_store.read.event!(params.fetch("event_id"))
+          metadata = format_event_metadata(event)
+          parent_event =
+            event_store.read.event(event.metadata.fetch(:causation_id)) if event.metadata.key?(:causation_id)
+
+          layout.render(
+            "events/show",
+            urls: urls,
+            event: event,
+            title: "Event #{event.event_id}",
+            metadata: metadata,
+            streams: event_store.streams_of(event.event_id).map(&:name).sort,
+            parent_event: parent_event,
+            caused_by: event_store.read.stream("$by_causation_id_#{event.event_id}").backward.limit(PAGE_SIZE).to_a,
+            extension_links: event_extension_links(event, urls),
+          )
         end
 
-        %w[/ /events/:event_id /streams/:stream_name].each do |starting_route|
-          router.add_route("GET", starting_route) do |_, urls|
-            erb bootstrap_html,
-                browser_js_src: urls.browser_js_url,
-                browser_css_src: urls.browser_css_url,
-                bootstrap_js_src: urls.bootstrap_js_url,
-                initial_data: {
-                  rootUrl: urls.app_url,
-                  apiUrl: urls.api_url,
-                  resVersion: res_version,
-                }
-          end
+        router.add_route("GET", "/swimlane") do |params, urls|
+          stream_names, sort = swimlane_params(params)
+          reader = GetEventsFromStreams.new(event_store: event_store, stream_names: stream_names, sort: sort)
+          missing_stream_names = reader.missing_stream_names
+          stream_names -= missing_stream_names
+          layout.render(
+            "swimlane/show",
+            urls: urls,
+            stream_names: stream_names,
+            missing_stream_names: missing_stream_names,
+            title: "Swimlane #{stream_names.join(', ')}",
+            events: reader.events,
+            sort: sort,
+            more_url: (urls.swimlane_more_url(stream_names, reader.next_cursor, sort) if reader.more?),
+          )
         end
-        router.handle(Rack::Request.new(env))
-      rescue EventNotFound, Router::NoMatch
-        not_found
+
+        router.add_route("GET", "/swimlane/more") do |params, urls|
+          stream_names, sort = swimlane_params(params)
+          reader =
+            GetEventsFromStreams.new(
+              event_store: event_store,
+              stream_names: stream_names,
+              cursor: params["cursor"],
+              sort: sort,
+            )
+          json(
+            html:
+              layout.render_partial("swimlane/_rows", urls: urls, stream_names: stream_names, events: reader.events, sort: sort),
+            more_url: (urls.swimlane_more_url(stream_names, reader.next_cursor, sort) if reader.more?),
+          )
+        end
+
+        extensions
+          .select { |extension| extension.respond_to?(:register_routes) }
+          .each { |extension| extension.register_routes(router, extension_context(extension)) }
+
+        router.handle(request)
+      rescue EventNotFound
+        layout.not_found(routing.with_request(request), message: "There's no event with given ID")
+      rescue Router::NoMatch
+        layout.not_found(routing.with_request(request), message: "Page not found")
       end
 
       private
 
-      attr_reader :event_store_locator, :related_streams_query, :routing
+      attr_reader :event_store_locator, :related_streams_query, :routing, :extensions, :views_root
 
       def event_store
         event_store_locator.call
       end
 
-      def bootstrap_html
-        <<~HTML
-        <!DOCTYPE html>
-        <html>
-          <head>
-            <title>RubyEventStore::Browser</title>
-            <link type="text/css" rel="stylesheet" href="<%= browser_css_src %>">
-            <meta name="ruby-event-store-browser-settings" content="<%= Rack::Utils.escape_html(JSON.dump(initial_data)) %>">
-            <meta name="robots" content="noindex, nofollow">
-            <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">
-            <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">
-            <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">
-            <link rel="mask-icon" href="/safari-pinned-tab.svg" color="#5bbad5">
-            <meta name="msapplication-TileColor" content="#da532c">
-            <meta name="theme-color" content="#ffffff">
-          </head>
-          <body>
-            <script type="text/javascript" src="<%= browser_js_src %>"></script>
-            <script type="text/javascript" src="<%= bootstrap_js_src %>"></script>
-          </body>
-        </html>
-        HTML
-      end
-
-      def not_found
-        [404, {}, []]
+      def extension_context(extension)
+        ExtensionContext.new(event_store, extension_layout(extension))
       end
 
-      def json(body)
-        [200, { "content-type" => "application/vnd.api+json" }, [JSON.dump(body.to_h)]]
+      def extension_layout(extension)
+        extension.respond_to?(:views_root) ? layout.with_views_root(extension.views_root) : layout
       end
 
-      def erb(template, **locals)
-        [200, { "content-type" => "text/html;charset=utf-8" }, [ERB.new(template).result_with_hash(locals)]]
+      def layout
+        Layout.new(
+          method(:extension_stylesheets),
+          method(:extension_scripts),
+          method(:extension_nav_links),
+          views_roots: [views_root].compact,
+        )
+      end
+
+      def stream_extension_links(stream_name, urls)
+        extensions
+          .select { |extension| extension.respond_to?(:stream_links) }
+          .flat_map { |extension| extension.stream_links(stream_name, urls) }
+      end
+
+      def event_extension_links(event, urls)
+        extensions
+          .select { |extension| extension.respond_to?(:event_links) }
+          .flat_map { |extension| extension.event_links(event, urls) }
+      end
+
+      def extension_nav_links(urls)
+        extensions
+          .select { |extension| extension.respond_to?(:nav_links) }
+          .flat_map { |extension| extension.nav_links(urls) }
+      end
+
+      def extension_stylesheets(urls)
+        extension_asset_urls(urls, ".css")
+      end
+
+      def extension_scripts(urls)
+        extension_asset_urls(urls, ".js")
+      end
+
+      def extension_asset_urls(urls, extname)
+        extensions.each_with_index.flat_map do |extension, index|
+          App
+            .extension_asset_mappings(extension, index)
+            .keys
+            .select { |path| File.extname(path) == extname }
+            .map { |path| "#{urls.app_url}#{path}" }
+        end
+      end
+
+      def format_event_metadata(event)
+        event.metadata.to_h.tap do |metadata|
+          %i[timestamp valid_at].each do |key|
+            metadata[key] = metadata.fetch(key).iso8601(RubyEventStore::TIMESTAMP_PRECISION) if metadata.key?(key)
+          end
+        end
+      end
+
+      def json(body)
+        [200, { "content-type" => "application/json" }, [JSON.generate(body)]]
       end
 
-      def res_version
-        RubyEventStore::VERSION
+      def swimlane_params(params)
+        stream_names = Array(params["streams"]).reject { |name| name.nil? || name.empty? }.uniq
+        sort = ("as_of" if params["sort"] == "as_of")
+        [stream_names, sort]
       end
     end
   end

data/lib/ruby_event_store/browser/extension_context.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Browser
+    class ExtensionContext
+      attr_reader :event_store
+
+      def initialize(event_store, layout)
+        @event_store = event_store
+        @layout = layout
+      end
+
+      def render(template, urls:, title: nil, **locals)
+        @layout.render(template, urls: urls, title: title, **locals)
+      end
+
+      def not_found(urls, message: "Page not found")
+        @layout.not_found(urls, message: message)
+      end
+    end
+  end
+end

data/lib/ruby_event_store/browser/get_events_from_stream.rb

@@ -2,115 +2,72 @@
 
 module RubyEventStore
   module Browser
-    class GetEventsFromStream
-      HEAD = Object.new
-
-      def initialize(event_store:, routing:, stream_name:, page:)
-        @event_store = event_store
-        @routing = routing
-        @stream_name = stream_name
-        @page = page || {}
-      end
-
-      def to_h
-        { data: events.map { |e| JsonApiEvent.new(e, nil).to_h }, links: links }
-      end
-
-      private
-
-      attr_reader :event_store, :routing, :stream_name, :page
+    GetEventsFromStream =
+      Struct.new(:event_store, :stream_name, :page, keyword_init: true) do
+        def initialize(event_store:, stream_name:, page:)
+          super(event_store: event_store, stream_name: stream_name, page: page || {})
+        end
 
-      def events
-        @events ||=
-          case direction
-          when :forward
-            events_forward(position).reverse
-          when :backward
-            events_backward(position)
-          end
-      end
+        def events
+          @events ||=
+            case direction
+            when :forward
+              read(event_store.read, position).reverse
+            when :backward
+              read(event_store.read.backward, position)
+            end
+        end
 
-      def links
-        @links ||=
+        def pagination
+          found = events
           {}.tap do |h|
-            if prev_event?
-              h[:prev] = prev_page_link(events.first.event_id)
-              h[:first] = first_page_link
+            if prev_event?(found)
+              h[:prev] = { position: found.first.event_id, direction: :forward }
+              h[:first] = { position: :head, direction: :backward }
             end
 
-            if next_event?
-              h[:next] = next_page_link(events.last.event_id)
-              h[:last] = last_page_link
+            if next_event?(found)
+              h[:next] = { position: found.last.event_id, direction: :backward }
+              h[:last] = { position: :head, direction: :forward }
             end
           end
-      end
-
-      def events_forward(position)
-        spec = event_store.read.limit(count)
-        spec = spec.stream(stream_name) unless stream_name.eql?(SERIALIZED_GLOBAL_STREAM_NAME)
-        spec = spec.from(position) unless position.equal?(HEAD)
-        spec.to_a
-      end
-
-      def events_backward(position)
-        spec = event_store.read.limit(count).backward
-        spec = spec.stream(stream_name) unless stream_name.eql?(SERIALIZED_GLOBAL_STREAM_NAME)
-        spec = spec.from(position) unless position.equal?(HEAD)
-        spec.to_a
-      end
-
-      def next_event?
-        return if events.empty?
-        events_backward(events.last.event_id).any?
-      end
-
-      def prev_event?
-        return if events.empty?
-        events_forward(events.first.event_id).any?
-      end
+        end
 
-      def prev_page_link(event_id)
-        routing.paginated_events_from_stream_url(id: stream_name, position: event_id, direction: :forward, count: count)
-      end
+        def count
+          Integer(page["count"] || PAGE_SIZE)
+        end
 
-      def next_page_link(event_id)
-        routing.paginated_events_from_stream_url(
-          id: stream_name,
-          position: event_id,
-          direction: :backward,
-          count: count,
-        )
-      end
+        private
 
-      def first_page_link
-        routing.paginated_events_from_stream_url(id: stream_name, position: :head, direction: :backward, count: count)
-      end
+        def read(reader, position)
+          spec = reader.limit(count)
+          spec = spec.stream(stream_name) unless stream_name.eql?(SERIALIZED_GLOBAL_STREAM_NAME)
+          spec = spec.from(position) if position
+          spec.to_a
+        end
 
-      def last_page_link
-        routing.paginated_events_from_stream_url(id: stream_name, position: :head, direction: :forward, count: count)
-      end
+        def next_event?(found)
+          return if found.empty?
+          read(event_store.read.backward, found.last.event_id).any?
+        end
 
-      def count
-        Integer(page["count"] || PAGE_SIZE)
-      end
+        def prev_event?(found)
+          return if found.empty?
+          read(event_store.read, found.first.event_id).any?
+        end
 
-      def direction
-        case page["direction"]
-        when "forward"
-          :forward
-        else
-          :backward
+        def direction
+          case page["direction"]
+          when "forward"
+            :forward
+          else
+            :backward
+          end
         end
-      end
 
-      def position
-        case page["position"]
-        when "head", nil
-          HEAD
-        else
-          page.fetch("position")
+        def position
+          page["position"] unless page["position"].nil? || page["position"] == "head"
         end
       end
-    end
   end
 end

data/lib/ruby_event_store/browser/get_events_from_streams.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Browser
+    class GetEventsFromStreams
+      def initialize(event_store:, stream_names:, cursor: nil, sort: nil, count: PAGE_SIZE)
+        @event_store = event_store
+        @stream_names = stream_names
+        @cursor = cursor
+        @sort = sort
+        @count = count
+      end
+
+      def events
+        @events ||= build_page
+      end
+
+      def more?
+        events
+        @more
+      end
+
+      def missing_stream_names
+        (stream_names - [SERIALIZED_GLOBAL_STREAM_NAME]).select { |name| chunks.fetch(name).empty? }
+      end
+
+      def next_cursor
+        events.last && time_of(events.last.last).iso8601(TIMESTAMP_PRECISION)
+      end
+
+      private
+
+      attr_reader :event_store, :stream_names, :cursor, :sort, :count
+
+      def build_page
+        rows = stream_names.flat_map { |name| chunks.fetch(name).map { |event| [name, event] } }
+        @more = full_chunks.any?
+        return group(rows) unless @more
+
+        boundary = full_chunks.map { |name| time_of(chunks.fetch(name).last) }.max
+        page_rows = rows.select { |_, event| time_of(event) >= boundary }
+        group(page_rows + drained_rows(boundary))
+      end
+
+      def chunks
+        @chunks ||= stream_names.to_h { |name| [name, read_chunk(name)] }
+      end
+
+      def read_chunk(name)
+        scope = time_sorted(stream_scope(name)).backward.limit(count)
+        scope = scope.older_than(cursor_time) if cursor_time
+        scope.to_a
+      end
+
+      def full_chunks
+        stream_names.select { |name| chunks.fetch(name).size == count }
+      end
+
+      def drained_rows(boundary)
+        full_chunks
+          .select { |name| time_of(chunks.fetch(name).last) == boundary }
+          .flat_map { |name| drain(name, boundary).map { |event| [name, event] } }
+      end
+
+      def drain(name, boundary)
+        time_sorted(stream_scope(name)).between(boundary..boundary)
+      end
+
+      def stream_scope(name)
+        name == SERIALIZED_GLOBAL_STREAM_NAME ? event_store.read : event_store.read.stream(name)
+      end
+
+      def group(rows)
+        rows
+          .group_by(&:last)
+          .map { |event, list| [list.map(&:first).uniq, event] }
+          .sort_by { |_, event| [time_of(event), event.event_id] }
+          .reverse
+      end
+
+      def time_sorted(scope)
+        as_of? ? scope.as_of : scope.as_at
+      end
+
+      def time_of(event)
+        event.metadata.fetch(as_of? ? :valid_at : :timestamp)
+      end
+
+      def as_of?
+        sort == "as_of"
+      end
+
+      def cursor_time
+        @cursor_time ||= cursor && Time.iso8601(cursor)
+      end
+    end
+  end
+end