Liking cljdoc? Tell your friends :D

com.wsscode.pathom3.connect.runner.parallel

WARN: this part of the library is under experimentation process, the design, interface and performance characteristics might change.

WARN: this part of the library is under experimentation process, the design, interface
and performance characteristics might change.
raw docstring

create-batch-processorclj/s

(create-batch-processor {:com.wsscode.pathom3.connect.runner.parallel/keys
                           [batch-hold-delay-ms batch-hold-flush-threshold]
                         :as env})
source

delayed-processclj/s

(delayed-process f debounce-window-ms)
(delayed-process f debounce-window-ms flush-threshold)
source

get-batch-processclj/s

(get-batch-process
  {:com.wsscode.pathom3.connect.runner.parallel/keys [async-batches*] :as env}
  batch-split)
source

invoke-async-batchclj/s

(invoke-async-batch env cache? op-name node cache-store input-data params)
source

invoke-mutation!clj/s

(invoke-mutation! env {:keys [key] :as ast})

Run mutation from AST.

Run mutation from AST.
sourceraw docstring

invoke-resolver-from-nodeclj/s

(invoke-resolver-from-node env
                           {:com.wsscode.pathom3.connect.operation/keys
                              [op-name]
                            :com.wsscode.pathom3.connect.planner/keys [input]
                            :as node})

Evaluates a resolver using node information.

When this function runs the resolver, if filters the data to only include the keys mentioned by the resolver input. This is important to ensure that the resolver is not using some key that came accidentally due to execution order, that would lead to brittle executions.

Evaluates a resolver using node information.

When this function runs the resolver, if filters the data to only include the keys
mentioned by the resolver input. This is important to ensure that the resolver is
not using some key that came accidentally due to execution order, that would lead to
brittle executions.
sourceraw docstring

merge-entity-dataclj/s

(merge-entity-data env entity new-data)

Specialized merge versions that work on entity data.

Specialized merge versions that work on entity data.
sourceraw docstring

merge-resolver-response!clj/s

(merge-resolver-response! env response)

This function gets the map returned from the resolver and merge the data in the current cache-tree.

This function gets the map returned from the resolver and merge the data in the
current cache-tree.
sourceraw docstring

plan-and-run!clj/s

(plan-and-run! env ast-or-graph entity-tree*)
source

process-attr-subqueryclj/s

(process-attr-subquery {:com.wsscode.pathom3.connect.planner/keys [graph]
                        :as env}
                       entity
                       k
                       v)
source

process-idents!clj/s

(process-idents! env idents)

Process the idents from the Graph, this will add the ident data into the child.

If there is ident data already, it gets merged with the ident value.

Process the idents from the Graph, this will add the ident data into the child.

If there is ident data already, it gets merged with the ident value.
sourceraw docstring

process-map-container-subqueryclj/s

(process-map-container-subquery env ast m)

Build a new map where the values are replaced with the map process of the subquery.

Build a new map where the values are replaced with the map process of the subquery.
sourceraw docstring

process-map-subqueryclj/s

(process-map-subquery env ast m)
source

process-mutations!clj/s

(process-mutations! {:com.wsscode.pathom3.connect.planner/keys [graph] :as env})

Runs the mutations gathered by the planner.

Runs the mutations gathered by the planner.
sourceraw docstring

process-sequence-subqueryclj/s

(process-sequence-subquery env ast s)
source

run-and-node!clj/s

(run-and-node! {:com.wsscode.pathom3.connect.planner/keys [graph] :as env}
               {:com.wsscode.pathom3.connect.planner/keys [run-and]
                :as and-node})

Given an AND node, runs every attached node, then runs the attached next.

Given an AND node, runs every attached node, then runs the attached next.
sourceraw docstring

run-async-batches!clj/s

(run-async-batches! env batch-items)
source

run-foreign-mutationclj/s

(run-foreign-mutation env {:keys [key] :as ast})
source

run-graph!clj/s

(run-graph! env ast-or-graph entity-tree*)

Plan and execute a request, given an environment (with indexes), the request AST and the entity-tree*.

Plan and execute a request, given an environment (with indexes), the request AST
and the entity-tree*.
sourceraw docstring

run-graph!*clj/s

(run-graph!* {:com.wsscode.pathom3.connect.planner/keys [graph] :as env})

Run the root node of the graph. As resolvers run, the result will be add to the entity cache tree.

Run the root node of the graph. As resolvers run, the result will be add to the
entity cache tree.
sourceraw docstring

run-graph-entity-doneclj/s

(run-graph-entity-done env)
source

run-graph-impl!clj/s

(run-graph-impl! env ast-or-graph entity-tree*)
source

run-next-node!clj/s

(run-next-node! {:com.wsscode.pathom3.connect.planner/keys [graph] :as env}
                {:com.wsscode.pathom3.connect.planner/keys [run-next]})

Runs the next node associated with the node, in case it exists.

Runs the next node associated with the node, in case it exists.
sourceraw docstring

run-node!clj/s

(run-node! env node)

Run a node from the compute graph. This will start the processing on the sent node and them will run everything that's connected to this node as sequences of it.

The result is going to build up at ::p.ent/cache-tree*, after the run is concluded the output will be there.

Run a node from the compute graph. This will start the processing on the sent node
and them will run everything that's connected to this node as sequences of it.

The result is going to build up at ::p.ent/cache-tree*, after the run is concluded
the output will be there.
sourceraw docstring

run-or-node!clj/s

(run-or-node! env
              {:com.wsscode.pathom3.connect.planner/keys [run-or] :as or-node})
source

run-or-node!*clj/s

(run-or-node!* {:com.wsscode.pathom3.connect.planner/keys [graph]
                :com.wsscode.pathom3.connect.runner/keys [choose-path]
                :or {choose-path pcr/default-choose-path}
                :as env}
               or-node
               nodes
               errors)
source

run-resolver-node!clj/s

(run-resolver-node! env node)

This function evaluates the resolver associated with the node.

First it checks if the expected results from the resolver are already available. In case they are, the resolver call is skipped.

This function evaluates the resolver associated with the node.

First it checks if the expected results from the resolver are already available. In
case they are, the resolver call is skipped.
sourceraw docstring

run-root-node!clj/s

(run-root-node! {:com.wsscode.pathom3.connect.planner/keys [graph] :as env})
source

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

× close