com.wsscode.pathom.connect — com.wsscode/pathom 2.2.0-beta3

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-parallel-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).

call-resolver clj/s

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

call-resolver* clj/s

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

compute-paths clj/s

(compute-paths index-oir keys bad-keys attr)

This function will return a set of possible paths given a set of available keys to reach some attribute. You also send a set of bad keys, bad keys mean information you cannot use (maybe they already got an error, or you known will not be available).

compute-paths* clj/s

(compute-paths* index-oir keys bad-keys attr pending)

create-thread-pool clj

(create-thread-pool thread-count ch)

data->shape clj/s

(data->shape data)

Helper function to transform a data into an output shape.

decrease-path-costs clj/s

(decrease-path-costs {:com.wsscode.pathom.connect/keys
                        [resolver-weights resolver-weight-decrease-amount]
                      :or {resolver-weight-decrease-amount 1}}
                     plan)

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)

output->provides clj/s

(output->provides output)

parallel-batch clj/s

(parallel-batch {:com.wsscode.pathom.core/keys [processing-sequence] :as env})

parallel-batch-error clj/s

(parallel-batch-error {:com.wsscode.pathom.core/keys [processing-sequence]
                       :as env}
                      e)

parallel-reader clj/s

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

path-cost clj/s

(path-cost {:com.wsscode.pathom.connect/keys [resolver-weights]
            :com.wsscode.pathom.core/keys [request-cache]
            :as env}
           path)

pick-resolver clj/s

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

plan->provides clj/s

(plan->provides env plan)

plan->resolvers clj/s

(plan->resolvers plan)

reader clj/s

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

reader-compute-plan clj/s

(reader-compute-plan env failed-resolvers)

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

resolve-plan clj/s

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

resolver->output clj/s

(resolver->output env resolver-sym)

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)

split-good-bad-keys clj/s

(split-good-bad-keys entity)

step-weight clj/s

(step-weight value new-value)

update-resolver-weight clj/s

(update-resolver-weight {:com.wsscode.pathom.connect/keys [resolver-weights]}
                        resolver
                        &
                        args)