fix: handle reitit route denormalization

Co-authored-By: Ryan Schmukler <rschmukler@gmail.com>

Fixes an issue where we didn't handle denormalized route syntax in
reitit.

Closes #17

Author: charlot-shaw

src/hyper/routes.clj

@@ -3,16 +3,21 @@
 
    Pure functions for looking up route metadata by name, resolving
    titles/head content, and reading the current routes (supporting
-   live-reloading via Var indirection).")
+   live-reloading via Var indirection)."
+  (:require [reitit.core :as reitit]))
 
 (defn index-routes
-  "Build a {route-name → route-data} map from a routes vector for O(1) lookups."
+  "Build a {route-name → route-data} map from a routes vector for O(1) lookups.
+   Handles both flat and arbitrarily-nested reitit-style route trees by compiling
+   a temporary router and reading back the flattened routes."
   [routes]
-  (into {}
-        (keep (fn [[_path data]]
-                (when-let [n (:name data)]
-                  [n data])))
-        routes))
+  (if (seq routes)
+    (into {}
+          (keep (fn [[_path data]]
+                  (when-let [n (:name data)]
+                    [n data])))
+          (-> routes reitit/router reitit/routes))
+    {}))
 
 (defn find-render-fn
   "Find the :get handler for a named route."

src/hyper/server.clj

@@ -427,20 +427,21 @@
    compiles the reitit router, and updates app-state with the current routes and router.
    Returns the compiled Ring handler (without outer middleware)."
   [user-routes app-state* page-wrapper system-routes]
-  (let [wrapped-routes (mapv (fn [[path route-data]]
+  (let [flat-routes    (-> user-routes reitit/router reitit/routes)
+        wrapped-routes (mapv (fn [[path route-data]]
                                (if (and (:get route-data) (not (:hyper/disabled? route-data)))
                                  [path (update route-data :get (fn [handler] (page-wrapper handler)))]
                                  [path route-data]))
-                             user-routes)
+                             flat-routes)
         all-routes     (concat system-routes wrapped-routes)
         router         (ring/router all-routes
                                     {:conflicts nil
                                      :data      {:coercion   malli/coercion
                                                  :middleware [ring-coercion/coerce-request-middleware]}})]
-    ;; Store routes and router in app-state for access during actions/renders/navigation
+    ;; Store the flattened routes and router in app-state for access during actions/renders/navigation
     (swap! app-state* assoc
            :router router
-           :routes user-routes)
+           :routes flat-routes)
     (ring/ring-handler router (ring/create-default-handler))))
 
 (defn- wrap-static

test/hyper/routes_test.clj

@@ -13,6 +13,19 @@
    ["/users/:id" {:name :user-profile
                   :get  (fn [_] [:div "User"])}]])
 
+(def denormalized-sample-routes
+  [[""
+    ["/"
+     ["" {:name  :home
+          :get   (fn [_] [:div "Home"])
+          :title "Home"}]]
+    ["/about"
+     ["" {:name  :about
+          :get   (fn [_] [:div "About"])
+          :title (fn [_req] "About Us")}]]
+    ["/users/:id" {:name :user-profile
+                   :get  (fn [_] [:div "User"])}]]])
+
 (deftest index-routes-test
   (testing "builds name->data map"
     (let [idx (routes/index-routes sample-routes)]
@@ -30,7 +43,20 @@
 
   (testing "returns empty map for empty routes"
     (is (= {} (routes/index-routes [])))
-    (is (= {} (routes/index-routes nil)))))
+    (is (= {} (routes/index-routes nil))))
+
+  (testing "handles nested/denormalized reitit-style route trees"
+    (let [idx (routes/index-routes denormalized-sample-routes)]
+      (is (= 3 (count idx)))
+      (is (contains? idx :home))
+      (is (contains? idx :about))
+      (is (contains? idx :user-profile))))
+
+  (testing "nested routes preserve route data"
+    (let [idx (routes/index-routes denormalized-sample-routes)]
+      (is (= "Home" (:title (idx :home))))
+      (is (fn? (:title (idx :about))))
+      (is (fn? (:get (idx :home)))))))
 
 (deftest find-render-fn-test
   (let [idx (routes/index-routes sample-routes)]

test/hyper/server_test.clj

@@ -232,6 +232,73 @@
       (is (= 302 (:status unauthed)))
       (is (= "/login" (get-in unauthed [:headers "Location"]))))))
 
+(deftest test-create-handler-with-denormalized-routes
+  (testing "Denormalized (nested) routes are served and receive hyper context"
+    (let [received-req (atom nil)
+          app-state*   (atom (state/init-state))
+          routes       [[""
+                         ["/"
+                          ["" {:name :home
+                               :get  (fn [req]
+                                       (reset! received-req req)
+                                       [:div "Home"])}]]
+                         ["/about"
+                          ["" {:name  :about
+                               :get   (fn [_] [:div "About"])
+                               :title "About Us"}]]
+                         ["/users/:id" {:name :user-profile
+                                        :get  (fn [_] [:div "User"])}]]]
+          handler      (server/create-handler routes app-state*)
+          response     (handler {:uri "/" :request-method :get})]
+      (is (= 200 (:status response))
+          "Nested home route should be served")
+      (is (.contains (:body response) "Home"))
+      (is (some? @received-req)
+          "Handler should have been called")
+      (is (string? (:hyper/session-id @received-req))
+          "Request should carry :hyper/session-id")
+      (is (string? (:hyper/tab-id @received-req))
+          "Request should carry :hyper/tab-id")
+      (is (= app-state* (:hyper/app-state @received-req))
+          "Request should carry :hyper/app-state")))
+
+  (testing "All sibling routes in a denormalized tree are reachable"
+    (let [app-state* (atom (state/init-state))
+          routes     [[""
+                       ["/"
+                        ["" {:name :home
+                             :get  (fn [_] [:div "Home"])}]]
+                       ["/about"
+                        ["" {:name  :about
+                             :get   (fn [_] [:div "About"])
+                             :title "About Us"}]]
+                       ["/users/:id" {:name :user-profile
+                                      :get  (fn [_] [:div "User"])}]]]
+          handler    (server/create-handler routes app-state*)]
+      (is (= 200 (:status (handler {:uri "/about" :request-method :get}))))
+      (is (.contains (:body (handler {:uri "/about" :request-method :get})) "About"))
+      (is (= 200 (:status (handler {:uri "/users/42" :request-method :get}))))
+      (is (.contains (:body (handler {:uri "/users/42" :request-method :get})) "User"))))
+
+  (testing "Denormalized routes are indexed correctly in app-state"
+    (let [app-state* (atom (state/init-state))
+          routes     [[""
+                       ["/"
+                        ["" {:name :home
+                             :get  (fn [_] [:div "Home"])}]]
+                       ["/about"
+                        ["" {:name  :about
+                             :get   (fn [_] [:div "About"])
+                             :title "About Us"}]]
+                       ["/users/:id" {:name :user-profile
+                                      :get  (fn [_] [:div "User"])}]]]
+          _handler   (server/create-handler routes app-state*)
+          route-idx  (routes/live-route-index app-state*)]
+      (is (contains? route-idx :home))
+      (is (contains? route-idx :about))
+      (is (contains? route-idx :user-profile))
+      (is (= "About Us" (routes/find-route-title route-idx :about))))))
+
 (deftest test-create-handler-with-hyper-disabled
   (testing "render fn can disable endpoint wrapping"
     (let [app-state*  (atom (state/init-state))