Fixing strip-extra-keys-transformer for recursive map encoding

metosin · Sep 26, 2023 · d02168f · d02168f
1 parent e7ed7b0
commit d02168f
Show file tree

Hide file tree

Showing 2 changed files with 34 additions and 9 deletions.
diff --git a/src/malli/transform.cljc b/src/malli/transform.cljc
@@ -381,16 +381,18 @@
                                                    (if (and (map? x) (not default-schema))
                                                      (reduce-kv (fn [acc k _] (if-not (ks k) (dissoc acc k) acc)) x x)
                                                      x))))))}
-         strip-map-of {:compile (fn [schema options]
-                                  (let [entry-schema (m/into-schema :tuple nil (m/children schema) options)
-                                        valid? (m/validator entry-schema options)]
-                                    {:leave (fn [x] (reduce (fn [acc entry]
+         strip-map-of (fn [stage]
+                        {:compile (fn [schema options]
+                                    (let [entry-schema (m/into-schema :tuple nil (m/children schema) options)
+                                          valid?       (m/validator entry-schema options)]
+                                      {stage (fn [x]
+                                              (reduce (fn [acc entry]
                                                               (if (valid? entry)
                                                                 (apply assoc acc entry)
-                                                                acc)) (empty x) x))}))}]
+                                                                acc)) (empty x) x))}))})]
      (transformer
-      {:decoders {:map strip-map, :map-of strip-map-of}
-       :encoders {:map strip-map, :map-of strip-map-of}}))))
+       {:decoders {:map strip-map, :map-of (strip-map-of :leave)}
+        :encoders {:map strip-map, :map-of (strip-map-of :enter)}}))))
 
 (defn key-transformer [{:keys [decode encode types] :or {types #{:map}}}]
   (let [transform (fn [f stage] (when f {stage (-transform-map-keys f)}))]

diff --git a/test/malli/transform_test.cljc b/test/malli/transform_test.cljc
@@ -414,10 +414,33 @@
       (is (= {:x :kikka} (m/decode [:map [:x keyword?]] {:x "kikka", :y "kukka"} strict-json-transformer))))
     (testing "encode"
       (is (= "kikka" (m/encode keyword? :kikka strict-json-transformer)))
-      (is (= {:x "kikka"} (m/encode [:map [:x keyword?]] {:x :kikka, :y :kukka} strict-json-transformer)))))
+      (is (= {:x "kikka"} (m/encode [:map [:x keyword?]] {:x :kikka, :y :kukka} strict-json-transformer)))
+
+      (testing "nested map encode"
+        (is (= {:x {:a {:b {}}}}
+               (m/encode [:map
+                          [:x [:map
+                               [:a [:map [:b [:map]]]]]]]
+                         {:x          {:a {:b {}
+                                           :c {}}}
+                          :additional 1}
+                         strict-json-transformer))))
+
+      (testing "recursive map encode"
+        (is (= {:x {"a" {"b" {}}}}
+               (m/encode [:map {:registry {::kw-map [:map-of :keyword [:ref ::kw-map]]}}
+                          [:x [:ref ::kw-map]]]
+
+                         {:x          {:a {:b {}
+                                           ;; TODO: Additional invalid param invalidates the recursive map
+                                           ;;"c" {}
+                                           }}
+                          :additional 1}
+                         strict-json-transformer
+                         ))))))
 
   (let [transformer (mt/transformer
-                     (mt/key-transformer
+                      (mt/key-transformer
                       {:decode #(-> % (subs 4) keyword)
                        :encode #(->> % name (str "key_"))})
                      (mt/string-transformer)