mt/strip-extra-keys-transformer fails on :and and :or schemas

[kyleerhabor]

Hello, I'm trying to use a transformation to format a request map. Say I have a map like this:

;; Basic Ring map. Many keys have been removed since they're not essential to this demonstration.
{:protocol "HTTP/1.1"
 :remote-addr "127.0.0.1"
 :route {:schema [:map
                  [:body-params [:and
                                 [:map
                                  [:media/title :string]
                                  [:media/description :string]]
                                 [:or
                                  [:map
                                   [:film/likable? :boolean]]
                                  [:map
                                   [:book/likable? :boolean]]]]]]}
 :body-params {:media/title "..."
               :media/description "..."
               :book/likable? true
               :film/likable? true
               :random/attr "blah"}}

For most requests, I'm able to use this function to minimize the map:

(defn decode-request
  "Decodes a request via its schema. Currently strips undeclared keys."
  [request]
  (m/decode (:schema (:route request)) request mt/strip-extra-keys-transformer))

When I apply it to the request map above, I'd expect the following result:

{:body-params {:media/title "..."
               :media/description "..."
               :book/likable? true
               :film/likable? true}}

However, it doesn't return that. Instead, it results in this:

{:body-params {:media/title "..."
               :media/description "..."}}

In my problem domain, a Media is a base structure with other structures building on top of it, such as a Film or Book (as seen in the schema). Since there's currently no support for relations, I've made use of :and and :or, but it seems that the transformation only cares about the first map schema (so nothing in the :or). Is there any way I could get around this?

[kyleerhabor]

I was able to partially solve my problem:

(defn mapj-marker [type]
  (if (= :and type)
    identity ; No need to make the keys required. Gives the caller more freedom.
    mu/optional-keys))

(defn mapj [schema]
  (let [type (m/type schema)
        entries (m/children schema)]
    (if (and (#{:and :or} type) (every? (comp (partial = :map) m/type) entries))
      (let [mark (mapj-marker type)]
        (reduce #(mu/merge (mark %1) (mark %2)) :map entries))
      schema)))

(defn walk-mapj [schema]
  (m/walk schema (m/schema-walker mapj)))

mapj flattens :ands and :ors into :maps, with :ors being marked :optional true:

(def S [:and
        [:map [:media/title :string] [:media/description :string]]
        [:or [:map [:film/likable? :boolean]] [:map [:book/likable? :boolean]]]])

(walk-mapj S)
;; [:map
;;  [:media/title :string]
;;  [:media/description :string]
;;  [:film/likable? {:optional true} :boolean]
;;  [:book/likable? {:optional true} :boolean]]

For my problem domain, I need to make sure only one of the :ors match (which currently doesn't work), but this answer may be useful for other people.