ok using data-spec now and it's working

home stretch - I now combine routers for performance, but now it's mixing all the swagger routes together

so I have ["/v1/" blah] and ["/v2/" blah] and I want to generate different swagger.json's

you can scope the swagger docs.

just a sec.

cool

pretty excited to get this live

https://metosin.github.io/reitit/ring/swagger.html#multiple-swagger-apis

so, you can add a :id to swagger-apis, one endpoint can belong to multiple apis too. Cool to get a real-life use case for this, just added it because it was easy to do it.

[["/v1"
  {:swagger {:id ::v1}}
  v1-routes common-routes
  ["/swagger.json" ...]
  ["/swagger-ui/*" ...]]

 ["/v2"
  {:swagger {:id ::v2}}
  v2-routes common-routes
  ["/swagger.json" ...]
  ["/swagger-ui/*" ...]]]

is there a way for a child to dissoc/ignore middleware a parent sets?

@kanwei use meta-merge meta-data like`:replace` or :displace on the middleware vector to ignore whatever the parents have set. Here are some pointers for it: https://metosin.github.io/reitit/basics/route_data.html#nested-route-data

also, the middleware can decide not to mount on certain endpoints, using their :compile lifecycle functions.

for example, one can safely add coercion etc. middleware to the root, it will only attach itself to routes that have :coercion and :parameters or :responses defined.

cool i'll check it out

also I'm still a bit confused about the vector syntax

can I refactor this?

we lean on`:compile` on projects a lot, one can add data like :roles #{:admin} to route data and have a middleware mount just to those endpoints.

(def v2-routes
  (reitit/router
    [["/api/v2"
      {:swagger    {:id ::v2}
       :middleware [wrap-api-account
                    wrap-api-validate]}
      private-search-routes]
     ["/api/v2"
      {:swagger {:id ::v2}}
      public-search-routes]
     ["/api/v2/swagger.json"
      {:get {:no-doc  true
             :swagger {:id   ::v2
                       :info {:version     "2.0"
                              :title       "X"
                              :description "X"
                              :contact     {:name  "X"
                                            :email "x"}}}
             :handler (swagger/create-swagger-handler)
             }}]]
    {:data {:coercion   reitit.coercion.spec/coercion
            :middleware [coercion/coerce-response-middleware
                         coercion/coerce-request-middleware
                         ]}}))

so I'm trying to put some middleware on some routes

can I rewrite this so that I only have to use :swagger {:id ::v2} once instead of 3x

the vector syntax still trips me up because I'm not sure how the options maps are applied

in the example, you have 3 separate routes. each has it’s own route data.

you can nest the path fragments, and the data can be shared. so:

[["/api/v2" {:middleware [wrap-x]}]
 ["/api/v2/swagger.json" {:middleware [wrap-x]}]
 ["/api/v2/ping" {:middleware [wrap-x]}]]

can be written as:

[["/api/v2"
  {:middleware [wrap-x]}
  ["/swagger.json"]
  ["/ping"]]]

here the two routes are under the top-level route fragment and the route data gets merged from there (root->leafs)

you can think it like hiccup & html.

what would this do?

[["/api/v2"
  {:middleware [wrap-x]}
  ["/swagger.json"]
  {:middleware [wrap-y]}
  ["/ping"]]]

does a map only work in the first position after the path?

yes

like attributes for html elements

(ns user
  (:require [reitit.core :as r]))

(-> (r/router
      ["/api"
       {:middleware [:api]}
       ["/v2"
        {:middleware [:v2]}
        ["/ping"]
        ["/pong"]]])
    (r/routes))
;[["/api/v2/ping" {:middleware [:api :v2]}]
; ["/api/v2/pong" {:middleware [:api :v2]}]]

internally, the routes are flattented and the data gets merged using the meta-merge rules

(-> (r/router
      ["/api"
       {:middleware [:api]}
       ["/v2"
        {:middleware [:v2]}
        ["/ping"]
        ["/pong"
         {:middleware ^:replace [:pong]}]]])
    (r/routes))
;[["/api/v2/ping" {:middleware [:api :v2]}]
; ["/api/v2/pong" {:middleware [:pong]}]]

ok that makes more sense

we are about to do a swagger-like tool, but for reitit, with visualization of the merged route structure to help development

or more like re-frame-10x

so one of my routers has a {:conflicts nil} defined

in my top function I merge routes with merge-routers like the example says

but I had to override the merge with {:conflicts nil}

(defn merge-routers [& routers]
  (reitit-core/router
    (apply merge (map reitit-core/routes routers))
    (assoc (apply merge (map reitit-core/options routers))
      :conflicts nil)))

is that expected?

(reitit/ring-handler
                (merge-routers controller/main-website-routes ; <---- has conflicts
                               register-routes <---- no conflicts
                               ...))

I would have assumed that you could just do a normal merge of a quarantine router (controller/main-website-routes) and a regular router without having to do another {:conflicts nil}

hope that made sense

merge works from left to right, the options are just maps, and the last one wins.

the defult value is reitit.core/throw-on-conflicts!.

btw, the route fragment can be empty, too. this allows route-data to be attached without adding anything to the path. like :<> in reagent. This is a big win over compojure & others.

(-> (r/router
      ["" {:no-doc true}
       ["/ping"]
       ["/pong"]])
    (r/routes))
;[["/ping" {:no-doc true}]
; ["/pong" {:no-doc true}]]

[["/api/v2"
      {:swagger {:id ::v2}}
      [private-search-routes {:middleware [wrap-api-account
                                           wrap-api-validate]}]
      [public-search-routes]]]

the private-search-routes isn't getting middleware wrapped

any way to make it work like this, or do I have to put it in another ["/api/v2"] sibling?

the private-search-routes is most likely a vector, the data can only be after a path string. the empty fragment helps here:

[["/api/v2"
  {:swagger {:id ::v2}}
  ["" {:middleware [wrap-api-account wrap-api-validate]}
   private-search-routes]
  public-search-routes]]

or if that’s a common pattern, you can refactor that out into a function:

(defn wrap-api [routes]
  ["" {:middleware [wrap-api-account wrap-api-validate]}
   routes])

[["/api/v2"
  {:swagger {:id ::v2}}
  (wrap-api private-search-routes)
  public-search-routes]]

ah

yeah that makes sense

i have to really just think about it as a huge tree