I guess you are using lenient mode right? because on strict mode, any fail will fail everything

Are you referring to Pathom3?

ah, yes

In which case I’m still on P2

Is there a way to do this on P2?

can you make a working example so we can talk over? with a full example, what happens, and what you would like to happen

I do have a working example, which is my current project but it’s bit bulky. Let me put up a small example with some resolvers.

Ok I’m not on my home PC atm so I can’t create a project fast enough. I do have some code to show you what I have.

Here is the first resolver of interest: https://github.com/aratare-jp/shinsetsu/blob/main/src/clj/shinsetsu/resolvers/tab.clj#L31

pretty simple, it gets the user id then retrieves all the tabs from such user

later on in my app flow, I need to fetch all the bookmarks within some tab, so I have another resolver for this: https://github.com/aratare-jp/shinsetsu/blob/main/src/clj/shinsetsu/resolvers/bookmark.clj#L29

there are 2 types of tabs, one protected and one public (unprotected)

imma ignore the public

for protected tab, I need to submit a password to fetch all the bookmarks within such tab

so if I submit the wrong password, you’d expect an error saying it’s the wrong password

but currently if I fetch a tab on some of its fields, and join with the bookmarks, when the password is incorrect only :tab/bookmarks will have a reader-error

all the other tab fields will resolve normally

I want to have the all-or-nothing behaviour of P3 where if I can’t fetch the bookmarks due to wrong password, an error is returned instead

previously I could achieve this by using mutations, i.e. fetch-tabs and fetch-bookmarks.

if you have multiple tabs, you want to fail all the tabs, or just the tabs which the user is not allowed to access?

all of them

a way to solve this via query design is to change your query to allow for a layer controlling the access, like: [{:user/tabs [{:tab/allowed-tab [{:tab/bookmarks [:bookmark/id]}]}]}]

this way, you can fail at :tab/allowed-tab, and them both bookmarks and all the siblings will not attempt to run

this is how I would do it in this case

interesting. I haven’t thought of that.

you can make what you want by having a plugin wrapping around the entity process, but feels flacky, would require some very specific code (like checking for a presence of bookmarks on the result) and add unescessary overhead (since it would have to check every entity)

so I would go with :tab/allowed-tab 🙂

> you can make what you want Are you referring to the custom error?

yeah, making everything fail given a specific circumstance in the result

but would be ugly, hehe

I’ll give allowed-tab a go. Also I tried :fail-fast? and it did give me what I wanted, i.e. error thrown -> back track all the way to the top. But where can I catch the exception thrown?

I'm not sure if fail-fast will work as expected in this case

its intended to be used at the root, so errors are thrown immediatly (mostly useful for development environments, to see error earlier)

yep which fits perfectly into my usecase interestingly

from the snippet I found on Pathom docs

(parser {::p/fail-fast? true}
        [{:go [:key {:nest [:trigger-error :other]}
               :trigger-error]}])
; => CompilerException clojure.lang.ExceptionInfo: Error triggered {:foo "bar"}, ...

I want that exception but even with a try-catch around the parser it just does the dont-mind-me-im-just-passing-by move on me didn’t get caught for some reason 😅

not sure if I get what you saying now, if you wrap on a try/catch you can't get this exception?

I think I replicated the issue, see if looks like what you see:

(ns test.demo-fail-sublings
  (:require [com.wsscode.pathom.core :as p]
            [com.wsscode.pathom.connect :as pc]))

(pc/defresolver user-tabs []
  {:user/tabs
   [{:tab/id          1
     :tab/accessible? true}
    {:tab/id          2
     :tab/accessible? false}]})

(pc/defresolver bookmarks [{:tab/keys [id accessible?]}]
  {:tab/bookmarks
   (if accessible?
     [{:bookmark/id id}]
     (throw (ex-info "Fail here" {})))})

(pc/defresolver tab-stuff [{:tab/keys [id]}]
  {:tab/name (str "Tab " id)})

(def registry
  [user-tabs
   bookmarks
   tab-stuff])

(def parser
  (p/parser
    {::p/env     {::p/reader               [p/map-reader
                                            pc/reader2
                                            pc/open-ident-reader
                                            p/env-placeholder-reader]
                  ::p/placeholder-prefixes #{">"}}
     ::p/mutate  pc/mutate
     ::p/plugins [(pc/connect-plugin {::pc/register registry})
                  p/error-handler-plugin
                  p/trace-plugin]}))

(comment
  (parser {}
    [{:user/tabs
      [{:tab/bookmarks
        [:bookmark/id]}
       :tab/name]}])
  ; =>
  ; {:user/tabs [{:tab/bookmarks [{:bookmark/id 1}], :tab/name "Tab 1"}
  ;             {:tab/bookmarks :com.wsscode.pathom.core/reader-error, :tab/name "Tab 2"}],
  ; :com.wsscode.pathom.core/errors {[:user/tabs 1 :tab/bookmarks] "class clojure.lang.ExceptionInfo: Fail here - {}"}}
  )

Yep it’s perfect.

solution using :tab/accessible:

(ns test.demo-fail-sublings
  (:require [com.wsscode.pathom.core :as p]
            [com.wsscode.pathom.connect :as pc]))

(pc/defresolver user-tabs []
  {:user/tabs
   [{:tab/id          1
     :tab/accessible? true}
    {:tab/id          2
     :tab/accessible? false}]})

(pc/defresolver bookmarks [{:tab/keys [id accessible?]}]
  {:tab/bookmarks
   (if accessible?
     [{:bookmark/id id}]
     (throw (ex-info "Fail here" {})))})

(pc/defresolver tab-accessible [env {:tab/keys [accessible?]}]
  {::pc/input #{:tab/id :tab/accessible?}}
  {:tab/accessible
   (if accessible?
     (p/entity env)
     (throw (ex-info "Fail here" {})))})

(pc/defresolver tab-stuff [{:tab/keys [id]}]
  {:tab/name (str "Tab " id)})

(def registry
  [user-tabs
   bookmarks
   tab-stuff
   tab-accessible])

(def parser
  (p/parser
    {::p/env     {::p/reader               [p/map-reader
                                            pc/reader2
                                            pc/open-ident-reader
                                            p/env-placeholder-reader]
                  ::p/placeholder-prefixes #{">"}}
     ::p/mutate  pc/mutate
     ::p/plugins [(pc/connect-plugin {::pc/register registry})
                  p/error-handler-plugin
                  p/trace-plugin]}))

(comment
  (parser {}
    [{:user/tabs
      [{:tab/accessible
        [{:tab/bookmarks
          [:bookmark/id]}
         :tab/name]}]}])
  ; =>
  ; {:user/tabs [{:tab/accessible {:tab/bookmarks [{:bookmark/id 1}], :tab/name "Tab 1"}}
  ;              {:tab/accessible :com.wsscode.pathom.core/reader-error}],
  ; :com.wsscode.pathom.core/errors {[:user/tabs 1 :tab/accessible] "class clojure.lang.ExceptionInfo: Fail here - {}"}}
  )

OK will give it a go. May be i’ve been approaching this problem from a completely wrong angle all along.

😅

this is all very novel stuff, we are all still figuring it out 😅

no books on information modelling though attributes out there, yet 😛

👍:skin-tone-3:

This problem has made me want to migrate to P3 all the more 😅

I don't think it would solve this one for you, because strict mode will break the whole query all the time, like fail-fast in this sense

no way to apply this strictness to a sub-part

So for this project I’m looking for absolute all-or-nothing

If one part fails, nothing gets returned except an error

then what about:

(parser {::p/fail-fast? true}
    [{:user/tabs
      [{:tab/bookmarks
        [:bookmark/id]}
       :tab/name]}])
Execution error (ExceptionInfo) at test.demo-fail-sublings/bookmarks (demo_fail_sublings.clj:16).
Fail here

what reader are you using?

give me a sec

[pc/open-ident-reader p/map-reader pc/reader2 pc/index-reader]

so the fail-fast should work

what dont-mind-me-im-just-passing-by move on me means?

(try
   (parser {::p/fail-fast? true}
     [{:user/tabs
       [{:tab/bookmarks
         [:bookmark/id]}
        :tab/name]}])
   (catch Throwable ex
     (println "Gotcha" (ex-message ex))))
Gotcha Fail here
=> nil

Yep it does work as expected, but when I put the try-catch around it, the catch part didn’t get fired somehow. That’s what I meant.

Perhaps I had some wanky code in there at the time

Imma try it again.

full demo with catch:

(ns test.demo-fail-sublings
  (:require [com.wsscode.pathom.core :as p]
            [com.wsscode.pathom.connect :as pc]))

(pc/defresolver user-tabs []
  {:user/tabs
   [{:tab/id          1
     :tab/accessible? true}
    {:tab/id          2
     :tab/accessible? false}]})

(pc/defresolver bookmarks [{:tab/keys [id accessible?]}]
  {:tab/bookmarks
   (if accessible?
     [{:bookmark/id id}]
     (throw (ex-info "Fail here" {})))})

(pc/defresolver tab-stuff [{:tab/keys [id]}]
  {:tab/name (str "Tab " id)})

(def registry
  [user-tabs
   bookmarks
   tab-stuff])

(def parser
  (p/parser
    {::p/env     {::p/reader               [p/map-reader
                                            pc/reader2
                                            pc/open-ident-reader
                                            p/env-placeholder-reader]
                  ::p/placeholder-prefixes #{">"}}
     ::p/mutate  pc/mutate
     ::p/plugins [(pc/connect-plugin {::pc/register registry})
                  p/error-handler-plugin
                  p/trace-plugin
                  {::p/wrap-parser
                   (fn [parser]
                     (fn [env tx]
                       (tap> tx)
                       (parser env tx)))}]}))

(comment
  (try
   (parser {::p/fail-fast? true}
     [{:user/tabs
       [{:tab/bookmarks
         [:bookmark/id]}
        :tab/name]}])
   (catch Throwable ex
     (println "Gotcha" (ex-message ex))))
  ; Gotcha Fail here
  ; => nil
  )

cause not being able to catch sounds strange

Then I definitely had some wanky code

I’m glad this is just me messing up all along 😅

Thanks for the extensive help @wilkerlucio Will definitely try both of them 🙂

have fun 🙂

fun is mandatory 😛