are you sure they don’t try resolve when the inputs just have nil values? that’s different from absence

Pretty sure. I put logging in the resolver, and the input to the resolver is missing one of the values entirely even though the inputs has it listed.

I am trying to put together the simplest thing that replicates the effect so far. The actual example has lots of interconnected resolvers...

I just noticed that the resolvers follow the 'correct' path that I expected it to, one that provides the missing field. But it only does this on the first resolution. The correct path is fairly slow, so I wonder if the path weighting algorithm is trying to get around resolving the slow resolver.

Alright, I looked up how the weighting works. After noticing that "If a resolver call throws an exception, double it’s weight", I decided to change my resolver to throw an exception if any of the inputs are missing.

This fixed the behavior, as pathom is now correctly falling back to the other path on failure, as well as discouraging the problem path somewhat.

Here's the query I'd like to work https://github.com/bgrabow/clojure-game-geek/blob/6866af5668a520907809993592b2761fc8b733e4/src/clojure_game_geek/pathom/parser.clj#L26

I want to look up all the designer names for a given board game ID. Right now I'm getting a reader-error:

(a/<!! (parser {:database {:data (-> (io/resource "cgg-data.edn")
                                     slurp
                                     edn/read-string
                                     atom)}}
               [{[:board-game/id "1234"]
                 [
                  {:board-game/designers [:designer/name]}]}]))
=>
{[:board-game/id "1234"] #:board-game{:designers :com.wsscode.pathom.core/reader-error},
 :com.wsscode.pathom.core/errors {[[:board-game/id "1234"] :board-game/designers] "class java.lang.IllegalArgumentException: find not supported on type: java.lang.String"}}

I can make the board game id -> designer ids jump, and I can do the designer id -> designer name jump, but I must have something hooked up wrong or I'm misunderstanding how the designer ids -> designer id jump is supposed to work:

(a/<!! (parser {:database {:data (-> (io/resource "cgg-data.edn")
                                     slurp
                                     edn/read-string
                                     atom)}}
               [{[:board-game/id "1234"]
                 [:board-game/designers]}
                {[:designer/id "200"]
                 [:designer/name]}]))
=> {[:designer/id "200"] #:designer{:name "Kris Burm"}, [:board-game/id "1234"] #:board-game{:designers ("200")}}

It looks to me like your board game resolver is returning {:board-game/designers ("200")} where it should be returning {:board-game/designers ({:designer/id "200"})}.

Yeah! That's working now, thank you! https://github.com/bgrabow/clojure-game-geek/commit/5761218b59e612e192d2fda88124bebad1c89658#diff-bdf581a0bb704397fed938b7d562328d

Is there a way I can query for the designer names without knowing about the :board-game/designers key? I.e. I know that a board game has designers who have names, but I don't want to care about the implementation details of how that path gets traversed.

Hmm, maybe I'm thinking about that wrong. If we imagine a schema where a board game has some designers who authored the game, and some other designers who advised the design, I would need to specify if I want to look up the names of the authoring designers vs looking up the names of the advising designers. So the relationship represented by :board-game/designers is a necessary part of the query specification.

Right, that is what's connecting the board game with its set of designers, and that connection has to live somewhere. There are other ways to model it, but this one seems pretty natural to me. 👍