form-state.clj

(defn ref->ident
  "Sometimes references on the client are actual idents and sometimes they are
  nested maps, this function attempts to return an ident regardless."
  [x]
  (cond
    (eql/ident? x) x
    (map? x) (some #(and (= "id" (name (first %))) (into [] %)) x)
    :else nil))

(defn delta->datomic-txn
  "Takes in a normalized form delta, usually from client, and turns in
  into a datomic transaction."
  [delta]
  (mapcat (fn [[[id-k id] entity-diff]]
            (conj
              (mapcat (fn [[k diff]]
                        (let [{:keys [before after]} diff]
                          (cond
                            (ref->ident after) (if (nil? after)
                                                 [[:db/retract (str id) k (ref->ident before)]]
                                                 [[:ucv.fn/add-ident (str id) k (ref->ident after)]])

                            (and (sequential? after) (every? ref->ident after))
                            (let [before   (into #{}
                                             (comp (map ref->ident) (remove nil?))
                                             before)
                                  after    (into #{}
                                             (comp (map ref->ident) (remove nil?))
                                             after)
                                  retracts (set/difference before after)
                                  adds     (set/difference after before)
                                  eid      (str id)]
                              (vec
                                (concat
                                  (for [r retracts] [:db/retract eid k r])
                                  (for [a adds] [:ucv.fn/add-ident eid k a]))))

                            :else (if (nil? after)
                                    [[:db/retract (str id) k before]]
                                    [[:db/add (str id) k after]]))))
                entity-diff)
              {id-k id :db/id (str id)}))
    delta))