Added datafy/pull and datafy/pull-many version.

They work as pull/pull-many but return maps that impement the datafy/nav dance.

Author: IamDrowsy

src/datascript/datafy.cljc

@@ -0,0 +1,74 @@
+(ns datascript.datafy
+  (:require [clojure.core.protocols :as cp]
+            [datascript.pull-api :as dp]
+            [clojure.string :as str]))
+
+(declare datafy-entity)
+(declare datafy-entity-seq)
+
+(defn- attr<->rattr [attr]
+  (keyword (namespace attr)
+           (if (str/starts-with? (name attr) "_")
+             (subs (name attr) 1)
+             (str "_" (name attr)))))
+
+(defn- pull-pattern [ref-rattrs]
+  (into ["*"] ref-rattrs))
+
+
+(defn- navize-entity [db-val entity]
+  (let [ref-attrs (:db.type/ref (:rschema db-val))
+        ref-rattrs (set (map attr<->rattr ref-attrs))
+        many-attrs (:db.cardinality/many (:rschema db-val))
+        pull-pattern (into ["*"] ref-rattrs)]
+    (with-meta entity
+               {`cp/nav (fn [coll k v]
+                          (cond
+                            (or (and (many-attrs k) (ref-attrs k))
+                                (ref-rattrs k))
+                            (datafy-entity-seq db-val
+                                               (dp/pull-many db-val pull-pattern (mapv :db/id v)))
+                            (ref-attrs k)
+                            (datafy-entity db-val (dp/pull db-val pull-pattern (:db/id v)))
+                            :else v))})))
+
+(defn- navize-entity-seq [db-val entities]
+  (with-meta entities
+             {`cp/nav (fn [coll k v]
+                        (datafy-entity db-val v))}))
+
+(defn- datafy-entity [db-val entity]
+  (with-meta entity
+             {`cp/datafy (fn [entity]
+                           (navize-entity db-val entity))}))
+
+(defn- datafy-entity-seq [db-val entities]
+  (with-meta entities
+             {`cp/datafy (fn [entities] (navize-entity-seq db-val entities))}))
+
+(defn pull
+  "Same as `datascript.core/pull` but the returned map implements `datafy/nav` (See [https://clojure.github.io/clojure/clojure.datafy-api.html](https://clojure.github.io/clojure/clojure.datafy-api.html).
+
+  This can be used to navigate through the database following ref fields.
+
+  Usage:
+  ```
+  (pull db [:ref, :name] 1)
+  ; => {:db/id 1,
+  ;     :name \"Child\",
+  ;     :ref {:db/id 2}}
+  (nav (datafy (pull db [:ref, :name] 1))
+       :ref
+       {:db/id 2})
+  ; => {:db/id 2,
+  ;     :name \"Parent\",
+  ;     :_ref {:db/id 1}}
+  ```
+  "
+  [db selector eid]
+  (datafy-entity db (dp/pull db selector eid)))
+
+(defn pull-many
+  "Same as [[pull]] but accepts sequence of ids and returns sequence of maps that implements `datafy/nav`."
+  [db selector eids]
+  (datafy-entity-seq db (dp/pull-many db selector eids)))

test/datascript/test/datafy.cljc

@@ -0,0 +1,40 @@
+(ns datascript.test.datafy
+  (:require
+    #?(:cljs [cljs.test    :as t :refer-macros [is are deftest testing]]
+       :clj  [clojure.test :as t :refer        [is are deftest testing]])
+    [datascript.datafy :as datafy]
+    [datascript.core :as d]
+    [clojure.core.protocols :as cp]))
+
+(defn- test-db []
+  (let [schema {:ref {:db/valueType :db.type/ref}
+                :namespace/ref {:db/valueType :db.type/ref}
+                :many/ref {:db/valueType :db.type/ref
+                           :db/cardinality :db.cardinality/many}}
+        db (-> (d/empty-db schema)
+               (d/db-with [{:db/id 1 :name "Parent1"}
+                           {:db/id 2 :name "Child1" :ref 1 :namespace/ref 1}
+                           {:db/id 3 :name "GrandChild1" :ref 2 :namespace/ref 2}
+                           {:db/id 4 :name "Master" :many/ref [1 2 3]}]))]
+    db))
+
+(defn- nav [coll k]
+  (cp/nav coll k (coll k)))
+
+(defn d+n
+  "Helper function to datafy/navigate for a path"
+  [coll [k & ks]]
+  (if (nil? k)
+    coll
+    (d+n (nav (cp/datafy coll) k)
+         ks)))
+
+(deftest test-navigation
+  (let [db (test-db)
+        entity (datafy/pull db [:ref :namespace/ref :many/_ref] 3)]
+    (is (= 2 (:db/id (d+n entity [:ref]))))
+    (is (= 2 (:db/id (d+n entity [:namespace/ref]))))
+    (is (= 1 (:db/id (d+n entity [:ref :namespace/ref]))))
+    (is (= 3 (:db/id (d+n entity [:namespace/ref :ref :_ref 0 :namespace/_ref 0]))))
+    (is (= #{1 2 3} (set (map :db/id (d+n entity [:many/_ref 0 :many/ref])))))))
+