what do you mean return lookups?

I end up with stubs that look like

{:db/id 1}

Okay I still don’t understand. What do you mean you get stub but want lookup? What do you mean by lookup? You get these from where?

Maybe I’m using the wrong term. What I mean by lookup is a vector where the first element is a keyword for a unique identity attribute, and the second element is the value to find. Here is a contrived example where I run into this is. I first pull an entity, and then later want to pull a related entity by ref attribute.

(def schema
  {:guid {:db/unique :db.unique/identity}
   :child {:db/valueType :db.type/ref}})

(let [lookup [:guid some-guid]
      parent (d/pull db '[*] lookup)
      parent-child (:child parent)
      child (d/pull db '[*] (:db/id child-parent))])

(defn pull-parents []
  (d/q '[:find (pull ?e '[*])
         :where [?e :child _]]
       db))

(def pull-child [parent]
  (d/pull db '[* {:child ...}] (:db/id parent)))

(d/transact conn [{:child [:guid (:guid child))}}])

Ok I think I see

So sometimes you use your own “external” id that needs to be paired with attribute

and sometimes you have entity id

rule of thumb is not to expose entity ids to external systems, even to your own api

so use them in code but if you have better id stored as attribute too then rely on those when talking over module boundaries

Maybe my problem is that I don’t have clear module boundaries. By that do literally mean clojure namespaces or do you mean some abstract module boundary?

abstract

like api

but all in all, just be mindful and maybe have var naming scheme so you remember what is what

I sometimes also not sure if function should accept entity or db + eid

have not figured out rule of thumb there

Got it, I think my question may ultimately boil down to that in the end as well :thinking_face:

or maybe you are talking about that datascript functions should accept {:db/id …} maps where they expect eid or lookup?

I am not sure whether that idea is good or bad

at least what we have now is simple (but not super easy)

For what it’s worth, my vote would be no. I wrote a quick function that would basically check the inputs and find the best value for a given key and fall back to db/id. I found it incredibly difficult to understand what shape my data was in at any given function call.

That’s my feeling to

Thanks again for the insights! 🙏

I just discovered why I got so confused. There is an error when trying to transact a nested entity that is also unique. I setup a schema that has one attribute that is a plain old ref and one that is a ref that is also unique.

(def conn (d/create-conn {:unique-ref {:db/valueType :db.type/ref
                                       :db/unique :db.unique/identity}
                          :just-a-ref {:db/valueType :db.type/ref}}))

(d/transact! conn [{:just-a-ref {:foo 1}}])
{:db-before
 #datascript/DB {:schema
                 {:unique-ref
                  #:db{:valueType :db.type/ref, :unique :db.unique/identity},
                  :just-a-ref #:db{:valueType :db.type/ref}},
                 :datoms []},
 :db-after
 #datascript/DB {:schema
                 {:unique-ref
                  #:db{:valueType :db.type/ref, :unique :db.unique/identity},
                  :just-a-ref #:db{:valueType :db.type/ref}},
                 :datoms [[1 :just-a-ref 2 536870913] [2 :foo 1 536870913]]},
 :tx-data
 [#datascript/Datom [2 :foo 1 536870913 true]
  #datascript/Datom [1 :just-a-ref 2 536870913 true]],
 :tempids {1 1, 2 2, :db/current-tx 536870913},
 :tx-meta nil}

(d/transact! conn [{:unique-ref {:foo 1}}])
; Execution error (ExceptionInfo) at datascript.db/entid (db.cljc:1204).
; Expected number or lookup ref for entity id, got {:foo 1}

(serialization via datascript-transit)

If you can turn that into an issue with code example I might look into it

Sounds like a check is needed somewhere

I'll look into that 👍

https://github.com/tonsky/datascript/issues/463