ruby_event_store-browser 2.4.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df8e9b50395fcb93bc771370a2d27c6cb668753f8f0d9d7784f4ef56a4b17545
-  data.tar.gz: 318dca02e6b96941d0375a3748385d5b48e494318b0e12a50c7dd70ee4ee4445
+  metadata.gz: 6d8751953fbf8d113ab312cf8bb35f847d5ac5d71dc1ad868263b900b6659801
+  data.tar.gz: 3ac9153d0e7f0b6f1310e8aa2bed3e25d81361a53bc043b21ebf48615ec69dbe
 SHA512:
-  metadata.gz: 963db3c296db6dfdb4d24630a9060dc7379f6fc8f93dfb7858b903568de7f7e71bcca47e817b45eecab75c6cb870181d02cb4f66adbfad4814cc67c650e5fe20
-  data.tar.gz: 782d3ccf1aee4a51ba1a1864ad6bfd94b8c2adbce01818ebba5f8df808224ed7ecadd111dd7696726431ab1c14dc7b13c38a8a2ec8273b122965f2ae074ccaa0
+  metadata.gz: 2d18795af4c24ad82c42b9214964387884e1a5c525509a8f559b11679e5d222cfb60ac75daab7d17dbc0fb840f63edea3a9cc5d6c17be0ee1e501b5deae21322
+  data.tar.gz: 97b5d401e981d3dfbc17c3ddaf8b80436ec18acd39aafdf679e004460d056da2201599cae84bf19ec3d6fa149f2e44d02a4dca915a20960008337ddc5e0c9528

data/lib/ruby_event_store/browser/app.rb

@@ -1,109 +1,144 @@
 # frozen_string_literal: true
 
 require_relative "../browser"
-require "sinatra/base"
+require "rack"
+require "erb"
+require "json"
 
 module RubyEventStore
   module Browser
-    class App < Sinatra::Base
+    class App
       def self.for(
         event_store_locator:,
         host: nil,
         path: nil,
         api_url: nil,
-        environment: :production,
+        environment: nil,
         related_streams_query: DEFAULT_RELATED_STREAMS_QUERY
       )
-        self.tap do |app|
-          app.settings.instance_exec do
-            set :event_store_locator, event_store_locator
-            set :related_streams_query, -> { related_streams_query }
-            set :host, host
-            set :root_path, path
-            set :api_url, api_url
-            set :environment, environment
-            set :public_folder, "#{__dir__}/../../../public"
-          end
+        warn(<<~WARN) if environment
+          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
+        warn(<<~WARN) if host
+          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
+        warn(<<~WARN) if path
+          Passing :path 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
+
+        Rack::Builder.new do
+          use Rack::Static,
+              urls: {
+                "/ruby_event_store_browser.js" => "ruby_event_store_browser.js",
+                "/ruby_event_store_browser.css" => "ruby_event_store_browser.css",
+                "/bootstrap.js" => "bootstrap.js"
+              },
+              root: "#{__dir__}/../../../public"
+          run App.new(
+                event_store_locator: event_store_locator,
+                related_streams_query: related_streams_query,
+                host: host,
+                root_path: path,
+                api_url: api_url
+              )
         end
       end
 
-      configure do
-        set :host, nil
-        set :root_path, nil
-        set :api_url, nil
-        set :event_store_locator, -> {  }
-        set :related_streams_query, nil
-        set :protection, except: :path_traversal
-
-        mime_type :json, "application/vnd.api+json"
+      def initialize(event_store_locator:, related_streams_query:, host:, root_path:, api_url:)
+        @event_store_locator = event_store_locator
+        @related_streams_query = related_streams_query
+        @routing = Urls.from_configuration(host, root_path, api_url)
       end
 
-      get "/api/events/:id" do
-        begin
-          json Event.new(event_store: settings.event_store_locator, params: symbolized_params)
-        rescue RubyEventStore::EventNotFound
-          404
+      def call(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"))
+        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
+               )
+        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"]
+               )
+        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
         end
+        router.handle(Rack::Request.new(env))
+      rescue EventNotFound, Router::NoMatch
+        not_found
       end
 
-      get "/api/streams/:id" do
-        json GetStream.new(
-               stream_name: params[:id],
-               routing: routing,
-               related_streams_query: settings.related_streams_query
-             )
-      end
+      private
+
+      attr_reader :event_store_locator, :related_streams_query, :routing
 
-      get "/api/streams/:id/relationships/events" do
-        json GetEventsFromStream.new(
-               event_store: settings.event_store_locator,
-               params: symbolized_params,
-               routing: routing
-             )
+      def event_store
+        event_store_locator.call
       end
 
-      get %r{/(events/.*|streams/.*)?} do
-        erb "
-          <!DOCTYPE html>
-          <html>
-            <head>
-              <title>RubyEventStore::Browser</title>
-              <meta name=\"ruby-event-store-browser-settings\" content='<%= browser_settings %>'>
-            </head>
-            <body>
-              <script type=\"text/javascript\" src=\"<%= path %>/ruby_event_store_browser.js\"></script>
-              <script type=\"text/javascript\" src=\"<%= path %>/bootstrap.js\"></script>
-            </body>
-          </html>
-        ",
-            locals: {
-              path: settings.root_path || request.script_name
-            }
+      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)) %>">
+          </head>
+          <body>
+            <script type="text/javascript" src="<%= browser_js_src %>"></script>
+            <script type="text/javascript" src="<%= bootstrap_js_src %>"></script>
+          </body>
+        </html>
+        HTML
       end
 
-      helpers do
-        def symbolized_params
-          params.each_with_object({}) { |(k, v), h| v.nil? ? next : h[k.to_sym] = v }
-        end
+      def not_found
+        [404, {}, []]
+      end
 
-        def routing
-          Routing.new(settings.host || request.base_url, settings.root_path || request.script_name)
-        end
+      def json(body)
+        [200, { "Content-Type" => "application/vnd.api+json" }, [JSON.dump(body.to_h)]]
+      end
 
-        def browser_settings
-          JSON.dump(
-            {
-              rootUrl: routing.root_url,
-              apiUrl: settings.api_url || routing.api_url,
-              resVersion: RubyEventStore::VERSION
-            }
-          )
-        end
+      def erb(template, **locals)
+        [200, { "Content-Type" => "text/html;charset=utf-8" }, [ERB.new(template).result_with_hash(locals)]]
+      end
 
-        def json(data)
-          content_type :json
-          JSON.dump data.as_json
-        end
+      def res_version
+        RubyEventStore::VERSION
       end
     end
   end

data/lib/ruby_event_store/browser/{event.rb → get_event.rb}

@@ -2,18 +2,20 @@
 
 module RubyEventStore
   module Browser
-    class Event
-      attr_reader :event_store, :params
-
-      def initialize(event_store:, params:)
+    class GetEvent
+      def initialize(event_store:, event_id:)
         @event_store = event_store
-        @params = params
+        @event_id = event_id
       end
 
-      def as_json
+      def to_h
         { data: JsonApiEvent.new(event, parent_event_id).to_h }
       end
 
+      private
+
+      attr_reader :event_store, :event_id
+
       def event
         @event ||= event_store.read.event!(event_id)
       end
@@ -21,10 +23,6 @@ module RubyEventStore
       def parent_event_id
         event_store.read.event(event.metadata.fetch(:causation_id))&.event_id if event.metadata.has_key?(:causation_id)
       end
-
-      def event_id
-        params.fetch(:id)
-      end
     end
   end
 end

data/lib/ruby_event_store/browser/get_events_from_stream.rb

@@ -5,18 +5,21 @@ module RubyEventStore
     class GetEventsFromStream
       HEAD = Object.new
 
-      attr_reader :event_store, :params, :routing
-
-      def initialize(event_store:, params:, routing:)
+      def initialize(event_store:, routing:, stream_name:, page:)
         @event_store = event_store
-        @params = params
         @routing = routing
+        @stream_name = stream_name
+        @page = page || {}
       end
 
-      def as_json
+      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
+
       def events
         @events ||=
           case direction
@@ -88,11 +91,11 @@ module RubyEventStore
       end
 
       def count
-        Integer(pagination_param[:count] || PAGE_SIZE)
+        Integer(page["count"] || PAGE_SIZE)
       end
 
       def direction
-        case pagination_param[:direction]
+        case page["direction"]
         when "forward"
           :forward
         else
@@ -101,21 +104,13 @@ module RubyEventStore
       end
 
       def position
-        case pagination_param[:position]
+        case page["position"]
         when "head", nil
           HEAD
         else
-          pagination_param.fetch(:position)
+          page.fetch("position")
         end
       end
-
-      def stream_name
-        params.fetch(:id)
-      end
-
-      def pagination_param
-        params[:page] || {}
-      end
     end
   end
 end

data/lib/ruby_event_store/browser/get_stream.rb

@@ -7,7 +7,7 @@ module RubyEventStore
         @related_streams_query = related_streams_query
       end
 
-      def as_json
+      def to_h
         {
           data: {
             id: stream_name,

data/lib/ruby_event_store/browser/router.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module Browser
+    class Router
+      NoMatch = Class.new(StandardError)
+
+      class Route
+        NAMED_SEGMENTS_PATTERN = %r{\/([^\/]*):([^:$\/]+)}.freeze
+        private_constant :NAMED_SEGMENTS_PATTERN
+
+        def initialize(request_method, pattern, &block)
+          @request_method = request_method
+          @pattern = pattern
+          @handler = block
+        end
+
+        def match(request)
+          return unless request.request_method.eql?(request_method)
+
+          match_data = regexp.match(File.join("/", request.path_info))
+          match_data.named_captures.transform_values { |v| Rack::Utils.unescape(v) } if match_data
+        end
+
+        def call(params, urls)
+          handler[params, urls]
+        end
+
+        private
+
+        def regexp
+          /\A#{pattern.gsub(NAMED_SEGMENTS_PATTERN, '/\1(?<\2>[^$/]+)')}\Z/
+        end
+
+        attr_reader :request_method, :pattern, :handler
+      end
+
+      def initialize(urls = Urls.initial)
+        @routes = Array.new
+        @urls = urls
+      end
+
+      def add_route(request_method, pattern, &block)
+        routes << Route.new(request_method, pattern, &block)
+      end
+
+      def handle(request)
+        routes.each do |route|
+          route_params = route.match(request)
+          return route.call(request.params.merge(route_params), urls.with_request(request)) if route_params
+        end
+        raise NoMatch
+      end
+
+      private
+
+      attr_reader :routes, :urls
+    end
+  end
+end

data/lib/ruby_event_store/browser/urls.rb

@@ -0,0 +1,64 @@
+module RubyEventStore
+  module Browser
+    class Urls
+      def self.from_configuration(host, root_path, api_url = nil)
+        new(host, root_path, api_url)
+      end
+
+      def self.initial
+        new(nil, nil, nil)
+      end
+
+      def with_request(request)
+        Urls.new(host || request.base_url, root_path || request.script_name, api_url)
+      end
+
+      attr_reader :app_url, :api_url, :host, :root_path
+
+      def initialize(host, root_path, api_url)
+        @host = host
+        @root_path = root_path
+        @app_url = [host, root_path].compact.reduce(:+)
+        @api_url = api_url || ("#{app_url}/api" if app_url)
+      end
+
+      def events_url
+        "#{api_url}/events"
+      end
+
+      def streams_url
+        "#{api_url}/streams"
+      end
+
+      def paginated_events_from_stream_url(id:, position: nil, direction: nil, count: nil)
+        stream_name = Rack::Utils.escape(id)
+        query_string =
+          URI.encode_www_form(
+            { "page[position]" => position, "page[direction]" => direction, "page[count]" => count }.compact
+          )
+
+        if query_string.empty?
+          "#{api_url}/streams/#{stream_name}/relationships/events"
+        else
+          "#{api_url}/streams/#{stream_name}/relationships/events?#{query_string}"
+        end
+      end
+
+      def browser_js_url
+        "#{app_url}/ruby_event_store_browser.js"
+      end
+
+      def browser_css_url
+        "#{app_url}/ruby_event_store_browser.css"
+      end
+
+      def bootstrap_js_url
+        "#{app_url}/bootstrap.js"
+      end
+
+      def ==(o)
+        self.class.eql?(o.class) && app_url.eql?(o.app_url) && api_url.eql?(o.api_url)
+      end
+    end
+  end
+end

data/lib/ruby_event_store/browser/version.rb

@@ -2,6 +2,6 @@
 
 module RubyEventStore
   module Browser
-    VERSION = "2.4.0"
+    VERSION = "2.5.1"
   end
 end

data/lib/ruby_event_store/browser.rb

@@ -8,8 +8,9 @@ module RubyEventStore
   end
 end
 
-require_relative "browser/event"
+require_relative "browser/get_event"
 require_relative "browser/json_api_event"
 require_relative "browser/get_events_from_stream"
 require_relative "browser/get_stream"
-require_relative "browser/routing"
+require_relative "browser/urls"
+require_relative "browser/router"