com.wsscode.pathom3.connect.runner.parallel — com.wsscode/pathom3 2021.10.20-alpha

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

create-batch-processor clj/s

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

delayed-process clj/s

(delayed-process f debounce-window-ms)

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

get-batch-process clj/s

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

invoke-async-batch clj/s

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

invoke-mutation! clj/s

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

Run mutation from AST.

invoke-resolver-from-node clj/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.

merge-entity-data clj/s

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

Specialized merge versions that work on entity data.

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.

plan-and-run! clj/s

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

process-attr-subquery clj/s

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

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-map-container-subquery clj/s

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

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

process-map-subquery clj/s

(process-map-subquery env ast m)

process-mutations! clj/s

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

Runs the mutations gathered by the planner.

process-sequence-subquery clj/s

(process-sequence-subquery env ast s)

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.

run-async-batches! clj/s

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

run-foreign-mutation clj/s

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

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*.

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-graph-entity-done clj/s

(run-graph-entity-done env)

run-graph-impl! clj/s

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

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.

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-or-node! clj/s

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

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)

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.

run-root-node! clj/s

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