fix visitor for joins with collections of maps

README.md

@@ -66,7 +66,7 @@ used to transform the data in a depth-first, post-order traversal (just like
    :items {}})
 
 (defn fullname
-  [{:keys [given-name surname] :as person}]
+  [_db {:keys [given-name surname] :as person}]
   (str given-name " " surname))
 
 (def query [{:people ^{:visitor fullname} [:given-name :surname]}])
@@ -118,7 +118,7 @@ It does not provide arbitrary logic like SQL or Datalog.
 
 **Entity map**: a Clojure map which contains information that uniquely identifies
 the domain entity it is about. E.g. `{:person/id 1234 :person/name "Bill"
-:person/age 67}` could be uniquely identified by it's `:person/id` key. By 
+:person/age 67}` could be uniquely identified by it's `:person/id` key. By
 default, any map which contains a key which `(= "id" (name key))` is true, is an
 entity map and can be normalized using `pyramid.core/db`.
 

src/pyramid/pull.cljc

@@ -220,21 +220,23 @@
                                     [(:children parent)
                                      parent]))
           k' (comp k #(vector (:key node) %))
-          k' (if-let [visitor (-> node :query meta :visitor)]
-              #(k' (visitor db %))
-              k')
+          node-visitor (if-let [visitor (some-> node :query meta :visitor)]
+                         (fn [x]
+                           (visitor db x))
+                         identity)
           union-child? (and (= 1 (count (:children node)))
                             (= :union (:type (first (:children node)))))]
       (cond
         (map? data)
         ;; handle union, which might have a visitor
         (if (and union-child? (map? data))
-          #(visit k' db (first (:children node))
+          #(visit (comp k' node-visitor)
+                  db (first (:children node))
                   {:data data
                    :parent new-parent
                    :entities entities})
           (cc/into
-           k'
+           (comp k' node-visitor)
            (with-meta {} (:meta node))
            (comp
             (cc/map (fn [k x]
@@ -257,14 +259,16 @@
          ;; f
          (fn [k datum]
            (if union-child?
-             #(visit (comp k (fn [x]
-                               (with-meta x (:meta node))))
+             #(visit (comp k
+                           node-visitor
+                           (fn [x]
+                             (with-meta x (:meta node))))
                      db (first children)
                      {:data datum
                       :parent new-parent
                       :entities entities})
              (cc/into
-              k
+              (comp k node-visitor)
               (with-meta (empty datum) (:meta node))
               (comp
                (cc/map (fn [k x]
@@ -282,14 +286,16 @@
                        (cc/map
                         (fn [k datum]
                           (if union-child?
-                            #(visit (comp k (fn [x]
-                                              (with-meta x (:meta node))))
+                            #(visit (comp k
+                                          node-visitor
+                                          (fn [x]
+                                            (with-meta x (:meta node))))
                                     db (first children)
                                     {:data datum
                                      :parent new-parent
                                      :entities entities})
                             (cc/into
-                             k
+                             (comp k node-visitor)
                              (with-meta (empty datum) (:meta node))
                              (comp
                               (cc/map (fn [k x]

test/pyramid/pull_test.cljc

@@ -77,9 +77,8 @@
     (let [query [{:foo (visit [:bar :baz])}]
           data {:foo [{:bar 123 :baz 456}
                       {:bar 789 :baz "qux"}]}]
-      (is (= {:foo (->Visited
-                    [:bar :baz]
-                    [{:bar 123 :baz 456} {:bar 789 :baz "qux"}])}
+      (is (= {:foo [(->Visited [:bar :baz] {:bar 123 :baz 456})
+                    (->Visited [:bar :baz] {:bar 789 :baz "qux"})]}
              (:data (trampoline p/pull-report data query)))
           "multiple items")))
   (testing "nested join"
@@ -93,14 +92,16 @@
     (let [query [{:foo (visit [{:bar (visit [:baz])}])}]
           data {:foo [{:bar {:baz 123}}
                       {:bar {:baz 456}}]}]
-      (is (= {:foo (->Visited
-                    [{:bar (visit [:baz])}]
-                    [{:bar (->Visited
+      (is (= {:foo [(->Visited
+                     [{:bar [:baz]}]
+                     {:bar (->Visited
                             [:baz]
-                            {:baz 123})}
+                            {:baz 123})})
+                    (->Visited
+                     [{:bar [:baz]}]
                      {:bar (->Visited
                             [:baz]
-                            {:baz 456})}])}
+                            {:baz 456})})]}
              (:data (trampoline p/pull-report data query))))))
   (testing "union"
     (let [query [{:foo (visit