Liking cljdoc? Tell your friends :D

com.wsscode.pathom.connect


addclj/s

(add indexes sym)
(add indexes sym sym-data)
source

add-mutationclj/s

(add-mutation indexes sym data)
source

all-async-readersclj/s

source

all-parallel-readersclj/s

source

all-readersclj/s

source

all-values-valid?clj/s

(all-values-valid? m input)
source

async-pick-resolverclj/s

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

async-readerclj/s

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

atom-withclj/s

(atom-with spec)
source

batch-resolverclj/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).

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).
sourceraw docstring

call-resolverclj/s

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

call-resolver*clj/s

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

compute-pathsclj/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).

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).
sourceraw docstring

compute-paths*clj/s

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

connect-pluginclj/s

source

connect-resolversclj/s

source

create-thread-poolclj

(create-thread-pool thread-count ch)
source

data->shapeclj/s

(data->shape data)

Helper function to transform a data into an output shape.

Helper function to transform a data into an output shape.
sourceraw docstring

decrease-path-costsclj/s

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

default-resolver-dispatchclj/s

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

discover-attrsclj/s

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

group-input-indexesclj/s

(group-input-indexes inputs)
source

ident-readerclj/s

(ident-reader env)

Reader for idents on connect, this reader will make a join to the ident making the context have that ident key and value. For example the ident [:user/id 123] will make a join to a context {:user/id 123}. This reader will continue if connect doesn't have a path to respond to that ident.

This reader also supports params to add more context besides the entity value. To use that send the :pathom/context param with the join, as in:

[{([:user/id 123] {:pathom/context {:user/foo "bar"}}) [:user/name]}]

In the previous case, the context will be the merge between the identity and the context, {:user/id 123 :user/foo "bar"} in this case.

Reader for idents on connect, this reader will make a join to the ident making the
context have that ident key and value. For example the ident [:user/id 123] will make
a join to a context {:user/id 123}. This reader will continue if connect doesn't have
a path to respond to that ident.

This reader also supports params to add more context besides the entity value. To use
that send the `:pathom/context` param with the join, as in:

[{([:user/id 123] {:pathom/context {:user/foo "bar"}})
  [:user/name]}]

In the previous case, the context will be the merge between the identity and the
context, {:user/id 123 :user/foo "bar"} in this case.
sourceraw docstring

index-mergerclj/smultimethod

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

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

index-readerclj/s

source

indexed-identclj/s

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

indexes-resolverclj/s

source

merge-indexesclj/s

(merge-indexes ia ib)
source

merge-ioclj/s

(merge-io a b)

Merge ::index-io maps.

Merge ::index-io maps.
sourceraw docstring

merge-oirclj/s

(merge-oir a b)

Merge ::index-oir maps.

Merge ::index-oir maps.
sourceraw docstring

mutateclj/s

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

mutate-asyncclj/s

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

mutation-dataclj/s

(mutation-data env-or-indexes sym)

Get mutation map information in env from the resolver sym.

Get mutation map information in env from the resolver sym.
sourceraw docstring

mutation-dispatchclj/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.

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.
sourceraw docstring

mutation-factoryclj/s

(mutation-factory mm idx)
source

open-ident-readerclj/s

(open-ident-reader env)

Like ident-reader, but ident key doesn't have to be in the index, this will respond to any ident join. Also supports extra context with :pathom/context param.

Like ident-reader, but ident key doesn't have to be in the index, this will respond
to any ident join. Also supports extra context with :pathom/context param.
sourceraw docstring

output->providesclj/s

(output->provides output)
source

parallel-batchclj/s

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

parallel-batch-errorclj/s

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

parallel-readerclj/s

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

path-costclj/s

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

pick-resolverclj/s

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

plan->providesclj/s

(plan->provides env plan)
source

plan->resolversclj/s

(plan->resolvers plan)
source

readerclj/s

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

reader-compute-planclj/s

(reader-compute-plan env failed-resolvers)
source

registerclj/s

(register {:com.wsscode.pathom.connect/keys [defresolver defmutation]}
          resolver-or-resolvers)
source

reprocess-indexclj/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

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
sourceraw docstring

resolve-planclj/s

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

resolver->outputclj/s

(resolver->output env resolver-sym)
source

resolver-dataclj/s

(resolver-data env-or-indexes sym)

Get resolver map information in env from the resolver sym.

Get resolver map information in env from the resolver sym.
sourceraw docstring

resolver-dispatchclj/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.

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

resolver-factoryclj/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.

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.
sourceraw docstring

resolver-weights-resolverclj/s

source

sort-resolversclj/s

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

split-good-bad-keysclj/s

(split-good-bad-keys entity)
source

step-weightclj/s

(step-weight value new-value)
source

update-resolver-weightclj/s

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

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close