com.wsscode.pathom.connect — com.wsscode/pathom 2.1.0

add clj/s

(add indexes sym)

(add indexes sym sym-data)

add-mutation clj/s

(add-mutation indexes sym data)

all-async-readers clj/s

all-readers clj/s

all-values-valid? clj/s

(all-values-valid? m input)

async-pick-resolver clj/s

(async-pick-resolver
  {:com.wsscode.pathom.connect/keys [indexes dependency-track] :as env})

async-reader clj/s

(async-reader {:com.wsscode.pathom.connect/keys [indexes]
               :as env
               :com.wsscode.pathom.core/keys [processing-sequence]})

batch-resolver clj/s

(batch-resolver single-fn multi-fn)

Return a resolver that will dispatch to single-fn when the input is a single value, and multi-fn when multiple inputs are provided (on batch cases).

break-values clj/s

call-resolver clj/s

(call-resolver {:com.wsscode.pathom.connect/keys [resolver-dispatch]
                :or {resolver-dispatch default-resolver-dispatch}
                :as env}
               entity)

data->shape clj/s

(data->shape data)

Helper function to transform a data into an output shape.

default-resolver-dispatch clj/s

(default-resolver-dispatch {{:com.wsscode.pathom.connect/keys [sym]
                             :as resolver}
                              :com.wsscode.pathom.connect/resolver-data
                            :as env}
                           entity)

discover-attrs clj/s

(discover-attrs {:com.wsscode.pathom.connect/keys [index-io cache] :as index}
                ctx)

ident-reader clj/s

(ident-reader env)

index-merger clj/s multimethod

This is an extensible gateway so you can define different strategies for merging different kinds of indexes.

index-reader clj/s

indexed-ident clj/s

(indexed-ident {:com.wsscode.pathom.connect/keys [indexes] :as env})

merge-indexes clj/s

(merge-indexes ia ib)

merge-io clj/s

(merge-io a b)

Merge ::index-io maps.

merge-oir clj/s

(merge-oir a b)

Merge ::index-oir maps.

mutate clj/s

(mutate {:com.wsscode.pathom.connect/keys [indexes mutate-dispatch
                                           mutation-join-globals]
         :keys [query]
         :or {mutation-join-globals []}
         :as env}
        sym'
        input)

mutate-async clj/s

(mutate-async {:com.wsscode.pathom.connect/keys [indexes mutate-dispatch
                                                 mutation-join-globals]
               :keys [query]
               :or {mutation-join-globals []}
               :as env}
              sym'
              input)

mutation-data clj/s

(mutation-data env-or-indexes sym)

Get mutation map information in env from the resolver sym.

mutation-dispatch clj/s

(mutation-dispatch env _)

Helper method that extract key from ast symbol from env. It's recommended to use as a dispatch method for creating multi-methods for mutation dispatch.

mutation-factory clj/s

(mutation-factory mm idx)

pick-resolver clj/s

(pick-resolver {:com.wsscode.pathom.connect/keys [indexes dependency-track]
                :as env})

reader clj/s

(reader {:com.wsscode.pathom.connect/keys [indexes]
         :as env
         :com.wsscode.pathom.core/keys [processing-sequence]})

reprocess-index clj/s

(reprocess-index {:com.wsscode.pathom.connect/keys [index-resolvers]})

This will use the ::index-resolvers to re-build the index. You might need that if in development you changed some definitions and got in a dirty state somehow

resolver-data clj/s

(resolver-data env-or-indexes sym)

Get resolver map information in env from the resolver sym.

resolver-dispatch clj/s

(resolver-dispatch env)

(resolver-dispatch env _)

Helper method that extract resolver symbol from env. It's recommended to use as a dispatch method for creating multi-methods for resolver dispatch.

resolver-factory clj/s

(resolver-factory mm idx)

Given multi-method mm and index atom idx, returns a function with the given signature: [sym config f], the function will be add to the mm and will be indexed using config as the config params for connect/add.

sort-resolvers clj/s

(sort-resolvers {:com.wsscode.pathom.core/keys [request-cache]} resolvers e)