                     res))})
     (throw (ex-info "Mutation not found" {:mutation sym'}))))
 
-(defn mutate-async [{::keys [indexes mutate-dispatch mutation-join-globals]
-                     :keys  [query]
-                     :or    {mutation-join-globals []}
-                     :as    env} sym' input]
+(defn mutate-async
+  "Async mutate function to integrate connect mutations to pathom parser."
+  [{::keys [indexes mutate-dispatch mutation-join-globals]
+    :keys  [query]
+    :or    {mutation-join-globals []}
+    :as    env} sym' input]
   (if-let [{::keys [sym]} (get-in indexes [::mutations sym'])]
     (let [env (assoc-in env [:ast :key] sym)]
       {:action #(go-catch

                      1)
                    1)))))

(defn pick-resolver [{::keys [indexes dependency-track]
                      :as    env}]
  (let [k (-> env :ast :key)
        e (p/entity env)]
    (if-let [attr-resolvers (get-in indexes [::index-oir k])]

  2. a mutation map
  3. a sequence with items

  The sequence version can have nested sequences, they will be recursively add.

  Examples of possible usages:

      (-> {} ; blank index
          (pc/register one-resolver) ; single resolver
          (pc/register one-mutation) ; single mutation
          (pc/register [one-resolver one-mutation]) ; sequence of resolvers/mutations
          (pc/register [[resolver1 resolver2] [resolver3 mutation]]) ; nested sequences
          (pc/register [[resolver1 resolver2] resolver-out [resolver3 mutation]]) ; all mixed
          )
  "
  [indexes item-or-items]
  (if (sequential? item-or-items)
    (reduce
