@danielcompton we do this a lot

(:import [yada.resource Resource])

`(defn add-interceptors [t] (postwalk (fn [x] (cond-> x (instance? Resource x) (assoc :interceptor-chain (concat [(fn [ctx] (assoc ctx :db @db))] (yada/interceptor-chain nil))))) t))`

(waiting for slack to process the same in a code block)

hope this helps

3 backticks @malcolmsparks 🙂

(defn add-interceptors [t]
  (postwalk
   (fn [x]
     (cond-> x (instance? Resource x)
             (assoc :interceptor-chain (concat [(fn [ctx] (assoc ctx :db @db))]
                                               (yada/interceptor-chain nil)))))
   t))

(defn update-resources [routes f & args]
  (postwalk
    (fn [x]
      (if (instance? Resource x)
        (resource (apply f x args))
        x))
    routes))

this is what we do, I think it's taken from a very early version of yada 🙂

@stijn - your version has the advantage that resources will be re-validated, which is very useful

@vinnyataide hi - the problem is that you're not creating a yada resource - you need

(y/resource {})

(y/handler (y/resource {}))

As a technical point, you only need

(y/resource)

reason is, that yada resources satisfy bidi's bidi.ring.Ring protocol which means that bidi knows how to route Ring requests to them directly

the implementation of this actually simply wraps the resource in a yada handler

one advantage of using naked resources in your bidi routing tree is to make it easier to treat them as pure data and post-process them, as @danielcompton is asking about

Thanks!

great!