change implementation to extend type Entity instead of providing new pull/pull-many

Author: IamDrowsy

src/datascript/datafy.cljc

@@ -1,74 +1,42 @@
 (ns datascript.datafy
   (:require [clojure.core.protocols :as cp]
             [datascript.pull-api :as dp]
-            [clojure.string :as str]))
+            [datascript.db :as db]
+            [datascript.impl.entity :as e]))
 
-(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]
+(defn- navize-pulled-entity [db-val pulled-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
+        ref-rattrs (set (map db/reverse-ref ref-attrs))
+        many-attrs (:db.cardinality/many (:rschema db-val))]
+    (with-meta pulled-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)))
+                            (datafy-entity-seq db-val v)
                             (ref-attrs k)
-                            (datafy-entity db-val (dp/pull db-val pull-pattern (:db/id v)))
+                            (e/entity db-val (:db/id v))
                             :else v))})))
 
-(defn- navize-entity-seq [db-val entities]
+(defn- navize-pulled-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))}))
+                        (e/entity db-val (:db/id v)))}))
 
 (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)))
+             {`cp/datafy (fn [entities] (navize-pulled-entity-seq db-val entities))}))
+
+(extend-protocol cp/Datafiable
+  datascript.impl.entity.Entity
+  (datafy [this]
+    (let [db (.-db this)
+          ref-attrs (:db.type/ref (:rschema db))
+          ref-rattrs (set (map db/reverse-ref ref-attrs))
+          pull-pattern (into ["*"] ref-rattrs)]
+      (navize-pulled-entity db (dp/pull db pull-pattern (:db/id this))))))

test/datascript/test/datafy.cljc

@@ -1,10 +1,11 @@
 (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]])
+    #?(: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]))
+    [clojure.core.protocols :as cp]
+    [datascript.impl.entity :as e]))
 
 (defn- test-db []
   (let [schema {:ref {:db/valueType :db.type/ref}
@@ -31,7 +32,7 @@
 
 (deftest test-navigation
   (let [db (test-db)
-        entity (datafy/pull db [:ref :namespace/ref :many/_ref] 3)]
+        entity (e/entity db 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]))))