Batch fallback for paths that can't update

deps.edn

@@ -4,9 +4,11 @@
  :deps
  {com.fulcrologic/guardrails {:mvn/version "1.1.3"}
   com.wsscode/cljc-misc      {:mvn/version "2021.01.21"}
+  com.wsscode/log            {:git/url "https://github.com/wilkerlucio/log"
+                              :sha     "1ac61009b3a57d5d09515ca823556bbe440c292d"}
   org.clojure/core.async     {:mvn/version "1.3.610"}
   funcool/promesa            {:mvn/version "6.0.0"}
-  edn-query-language/eql     {:mvn/version "1.0.0"}
+  edn-query-language/eql     {:mvn/version "1.0.2"}
   potemkin/potemkin          {:mvn/version "0.4.5"}}
 
  :aliases

src/main/com/wsscode/pathom3/connect/runner.cljc

@@ -2,6 +2,7 @@
   (:require
     [clojure.spec.alpha :as s]
     [com.fulcrologic.guardrails.core :refer [<- => >def >defn >fdef ? |]]
+    [com.wsscode.log :as l]
     [com.wsscode.misc.coll :as coll]
     [com.wsscode.misc.refs :as refs]
     [com.wsscode.misc.time :as time]
@@ -93,6 +94,12 @@
   "Query used to start the process. Not always available."
   vector?)
 
+(>def ::disable-batch?
+  "Flag to tell the runner that it can't use batch. This happens when navigating for
+  example into a set, in which Pathom can't determine which was the original item
+  for replacement."
+  boolean?)
+
 (>def ::wrap-batch-resolver-error fn?)
 (>def ::wrap-merge-attribute fn?)
 (>def ::wrap-mutate fn?)
@@ -201,7 +208,13 @@
 
         (or (sequential? v)
             (set? v))
-        (process-sequence-subquery env ast v)
+        (process-sequence-subquery
+          (cond-> env
+            ; no batch in sequences that are not vectors because we can't reach those
+            ; paths for updating later
+            (not (vector? v))
+            (assoc ::disable-batch? true))
+          ast v)
 
         :else
         v)
@@ -317,6 +330,39 @@
                  ::pcp/node        node
                  ::nested-waiting? true}})
 
+(defn- invoke-resolver-cached
+  [env cache? op-name resolver cache-store input-data params]
+  (if cache?
+    (p.cache/cached cache-store env
+      [op-name input-data params]
+      #(pco.prot/-resolve resolver env input-data))
+
+    (pco.prot/-resolve resolver env input-data)))
+
+(defn warn-batch-disabled [env op-name]
+  (l/warn ::event-batch-disabled
+          {::p.path/path (::p.path/path env)
+           ::pco/op-name op-name}))
+
+(defn- invoke-resolver-cached-batch
+  [env cache? op-name resolver cache-store input-data params]
+  (warn-batch-disabled env op-name)
+  (if cache?
+    (p.cache/cached cache-store env
+      [op-name input-data params]
+      #(first (pco.prot/-resolve resolver env [input-data])))
+
+    (first (pco.prot/-resolve resolver env [input-data]))))
+
+(defn batch-hold-token
+  [env cache? op-name node cache-store input-data]
+  {::batch-hold {::pco/op-name         op-name
+                 ::pcp/node            node
+                 ::pco/cache?          cache?
+                 ::pco/cache-store     cache-store
+                 ::node-resolver-input input-data
+                 ::env                 env}})
+
 (defn invoke-resolver-from-node
   "Evaluates a resolver using node information.
 
@@ -350,20 +396,14 @@
                               batch?
                               (if-let [x (find @resolver-cache* [op-name input-data params])]
                                 (val x)
-                                {::batch-hold {::pco/op-name         op-name
-                                               ::pcp/node            node
-                                               ::pco/cache?          cache?
-                                               ::pco/cache-store     cache-store
-                                               ::node-resolver-input input-data
-                                               ::env                 env}})
-
-                              cache?
-                              (p.cache/cached cache-store env
-                                [op-name input-data params]
-                                #(pco.prot/-resolve resolver env input-data))
+                                (if (::disable-batch? env)
+                                  (invoke-resolver-cached-batch
+                                    env cache? op-name resolver cache-store input-data params)
+                                  (batch-hold-token env cache? op-name node cache-store input-data)))
 
                               :else
-                              (pco.prot/-resolve resolver env input-data)))
+                              (invoke-resolver-cached
+                                env cache? op-name resolver cache-store input-data params)))
                           (catch #?(:clj Throwable :cljs :default) e
                             (mark-resolver-error-with-plugins env node e)
                             ::node-error))

src/main/com/wsscode/pathom3/connect/runner/async.cljc

@@ -17,6 +17,7 @@
     [com.wsscode.pathom3.format.shape-descriptor :as pfsd]
     [com.wsscode.pathom3.path :as p.path]
     [com.wsscode.pathom3.plugin :as p.plugin]
+    [com.wsscode.promesa.macros :refer [clet]]
     [promesa.core :as p]))
 
 (declare run-node! run-graph!)
@@ -80,7 +81,13 @@
 
         (or (sequential? v)
             (set? v))
-        (process-sequence-subquery env ast v)
+        (process-sequence-subquery
+          (cond-> env
+            ; no batch in sequences that are not vectors because we can't reach those
+            ; paths for updating later
+            (not (vector? v))
+            (assoc ::pcr/disable-batch? true))
+          ast v)
 
         :else
         v)
@@ -133,6 +140,39 @@
   (if run-next
     (run-node! env (pcp/get-node graph run-next))))
 
+(defn- invoke-resolver-cached
+  [env cache? op-name resolver cache-store input-data params]
+  (if cache?
+    (p.cache/cached cache-store env
+      [op-name input-data params]
+      #(try
+         (pco.prot/-resolve resolver env input-data)
+         (catch #?(:clj Throwable :cljs :default) e
+           (p/rejected e))))
+
+    (try
+      (pco.prot/-resolve resolver env input-data)
+      (catch #?(:clj Throwable :cljs :default) e
+        (p/rejected e)))))
+
+(defn- invoke-resolver-cached-batch
+  [env cache? op-name resolver cache-store input-data params]
+  (pcr/warn-batch-disabled env op-name)
+  (if cache?
+    (p.cache/cached cache-store env
+      [op-name input-data params]
+      #(try
+         (clet [res (pco.prot/-resolve resolver env [input-data])]
+           (first res))
+         (catch #?(:clj Throwable :cljs :default) e
+           (p/rejected e))))
+
+    (try
+      (clet [res (pco.prot/-resolve resolver env [input-data])]
+        (first res))
+      (catch #?(:clj Throwable :cljs :default) e
+        (p/rejected e)))))
+
 (defn invoke-resolver-from-node
   "Evaluates a resolver using node information.
 
@@ -165,24 +205,14 @@
                                 batch?
                                 (if-let [x (find @resolver-cache* [op-name input-data params])]
                                   (val x)
-                                  {::pcr/batch-hold {::pco/op-name             op-name
-                                                     ::pcp/node                node
-                                                     ::pco/cache?              cache?
-                                                     ::pco/cache-store         cache-store
-                                                     ::pcr/node-resolver-input input-data
-                                                     ::pcr/env                 env}})
-
-                                cache?
-                                (p.cache/cached cache-store env
-                                  [op-name input-data params]
-                                  #(try
-                                     (pco.prot/-resolve resolver env input-data)
-                                     (catch #?(:clj Throwable :cljs :default) e e)))
+                                  (if (::pcr/disable-batch? env)
+                                    (invoke-resolver-cached-batch
+                                      env cache? op-name resolver cache-store input-data params)
+                                    (pcr/batch-hold-token env cache? op-name node cache-store input-data)))
 
                                 :else
-                                (try
-                                  (pco.prot/-resolve resolver env input-data)
-                                  (catch #?(:clj Throwable :cljs :default) e e))))
+                                (invoke-resolver-cached
+                                  env cache? op-name resolver cache-store input-data params)))
                             (p/catch
                               (fn [error]
                                 (pcr/mark-resolver-error-with-plugins env node error)

src/main/com/wsscode/pathom3/path.cljc

@@ -12,7 +12,7 @@
         :index nat-int?
         :call symbol?))
 
-(>def ::path (s/coll-of ::path-entry :kind vector?))
+(>def ::path (s/nilable (s/coll-of ::path-entry :kind vector?)))
 
 (>defn append-path
   [env path-entry]

test/com/wsscode/pathom3/connect/runner_test.cljc

@@ -953,7 +953,21 @@
       #_(is (= (meta res)
                {})))
 
-    (testing "partial error")))
+    (testing "partial error"))
+
+  (testing "uses batch resolver as single resolver when running under a path that batch wont work"
+    (is (graph-response?
+          (pci/register
+            [batch-fetch])
+          {:list
+           #{{:id 1}
+             {:id 2}
+             {:id 3}}}
+          [{:list [:v]}]
+          {:list
+           #{{:id 1 :v 10}
+             {:id 2 :v 20}
+             {:id 3 :v 30}}}))))
 
 (deftest run-graph!-run-stats
   (is (graph-response?