com.wsscode.pathom3.connect.runner — com.wsscode/pathom3 2023.01.24-alpha

add-taken-path! clj/s

(add-taken-path! {:com.wsscode.pathom3.connect.runner/keys [node-run-stats*]}
                 {:com.wsscode.pathom3.connect.planner/keys [node-id]}
                 taken-path-id)

all-requires-ready? clj/s

(all-requires-ready? env {:com.wsscode.pathom3.connect.planner/keys [expects]})

Check if all requirements from the node are present in the current entity.

assoc-end-plan-stats clj/s

(assoc-end-plan-stats {:com.wsscode.pathom3.connect.planner/keys [graph]
                       :as env})

attribute-error-resolver clj/s

(attribute-error-resolver)

batch-group-input-groups clj/s

(batch-group-input-groups batch-items)

batch-group-inputs clj/s

(batch-group-inputs batch-items)

batch-hold-token clj/s

(batch-hold-token env cache? op-name node cache-store input-data params)

cache-batch-item clj/s

(cache-batch-item
  {env' :com.wsscode.pathom3.connect.runner/env
   :com.wsscode.pathom3.connect.runner/keys [node-resolver-input]
   :com.wsscode.pathom3.connect.operation/keys [cache? cache-store]
   :as batch-item}
  batch-op
  response)

cache-key clj/s

(cache-key env input-data op-name params)

check-entity-requires! clj/s

(check-entity-requires! {:com.wsscode.pathom3.connect.planner/keys [graph]
                         :com.wsscode.pathom3.path/keys [path]
                         :as env})

Verify if entity contains all required keys from graph index-ast. This is shallow check (don't visit nested entities).

choose-cache-store clj/s

(choose-cache-store env cache-store)

combine-inputs-with-responses clj/s

(combine-inputs-with-responses input-groups inputs responses)

For batch we group the items with the same inputs so the resolver only needs to have each input once. This function is a helper to side the input batch items with the distinct list of responses.

default-choose-path clj/s

(default-choose-path env or-node node-ids)

enhance-dynamic-input clj/s

(enhance-dynamic-input {:com.wsscode.pathom3.connect.operation/keys
                          [dynamic-resolver?]}
                       node
                       input-data)

entry-ast clj/s

(entry-ast graph k)

Get AST entry and pulls recursive query when needed.

fail-fast clj/s

(fail-fast {:com.wsscode.pathom3.error/keys [lenient-mode?]} error)

fail-or-error clj/s

(fail-or-error or-node errors)

handle-or-error clj/s

(handle-or-error env or-node res)

include-meta-stats clj/s

(include-meta-stats result
                    {:com.wsscode.pathom3.connect.runner/keys [omit-run-stats?]
                     :or {omit-run-stats? false}
                     :as env})

invoke-batch-block clj/s

(invoke-batch-block resolver batch-env batch-op input-groups inputs)

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.

invoke-resolver-with-plugins clj/s

(invoke-resolver-with-plugins resolver env input-data)

mark-batch-block-errors clj/s

(mark-batch-block-errors err env batch-op input-groups inputs)

mark-batch-errors clj/s

(mark-batch-errors error env batch-op batch-items)

mark-node-error clj/s

(mark-node-error {:com.wsscode.pathom3.connect.runner/keys [node-run-stats*]
                  :as env}
                 {:com.wsscode.pathom3.connect.planner/keys [node-id]}
                 error)

mark-node-error-with-plugins clj/s

(mark-node-error-with-plugins env node e)

merge-entity-data clj/s

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

Specialized merge versions that work on entity data.

merge-entity-to-root-data clj/s

(merge-entity-to-root-data env env' node)

merge-mutation-stats! clj/s

(merge-mutation-stats! {:com.wsscode.pathom3.connect.runner/keys
                          [node-run-stats*]}
                       {:com.wsscode.pathom3.connect.operation/keys [op-name]}
                       data)

merge-node-stats! clj/s

(merge-node-stats! {:com.wsscode.pathom3.connect.runner/keys [node-run-stats*]}
                   {:com.wsscode.pathom3.connect.planner/keys [node-id]}
                   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.

missing-maybe-in-pending-batch? clj/s

(missing-maybe-in-pending-batch? {:com.wsscode.pathom3.path/keys [path] :as env}
                                 input)

Check if there is any pending batching in the sub-path of the current input.

During the serial execution, a nested input process may be halted waiting to run after the all entities pass. In this case we need to also halt the execution to wait for that dependent input batch to run before moving on to process this node.

node-weight clj/s

(node-weight {:com.wsscode.pathom3.connect.planner/keys [graph]
              :com.wsscode.pathom3.connect.runner/keys [resolver-weights*]
              :as env}
             node-id)

Sums up the weight of a node and its successors

normalize-ast-recursive-query clj/s

(normalize-ast-recursive-query {:keys [query] :as ast} graph k)

or-expected-optional? clj/s

(or-expected-optional? {:com.wsscode.pathom3.connect.planner/keys [graph]}
                       or-node)

placeholder-merge-entity clj/s

(placeholder-merge-entity {:com.wsscode.pathom3.connect.planner/keys [graph]
                           :com.wsscode.pathom3.connect.runner/keys
                             [source-entity]})

Create an entity to process the placeholder demands. This consider if the placeholder has params, params in placeholders means that you want some specific data at that point.

plan-and-run! clj/s

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

priority-sort clj/s

(priority-sort {:com.wsscode.pathom3.connect.planner/keys [graph] :as env}
               or-node
               node-ids)

Find the node path with the highest priority to run. Returns a set of the candidates with the same priority level.

process-attr-subquery clj/s

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

process-attr-subquery-ast clj/s

(process-attr-subquery-ast graph k)

process-attr-subquery-key clj/s

(process-attr-subquery-key k)

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

(process-map-container? ast v)

Check if the map should be processed as a map-container, this means the sub-query should apply to the map values instead of the map itself.

This can be dictated by adding the ::pcr/map-container? meta data on the value, or requested by the query as part of the param.

process-map-subquery clj/s

(process-map-subquery env ast m)

process-map-subquery-data clj/s

(process-map-subquery-data 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)

processor-error? clj/s

(processor-error? err)

processor-exception clj/s

(processor-exception env err)

report-resolver-error clj/s

(report-resolver-error {:com.wsscode.pathom3.path/keys [path]
                        :com.wsscode.pathom3.error/keys [lenient-mode?]
                        :as env}
                       {:com.wsscode.pathom3.connect.operation/keys [op-name]
                        :as node}
                       error)

report-resolver-io-stats clj/s

(report-resolver-io-stats {:com.wsscode.pathom3.connect.runner/keys
                             [omit-run-stats-resolver-io?]}
                          input-data
                          result)

resolver-already-ran? clj/s

(resolver-already-ran? {:com.wsscode.pathom3.connect.runner/keys
                          [node-run-stats*]}
                       {:com.wsscode.pathom3.connect.planner/keys [node-id]})

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

(run-batches! env)

run-batches-pending! clj/s

(run-batches-pending! env)

run-batches-waiting! clj/s

(run-batches-waiting! env)

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

(run-graph-done! env)

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-graph-with-plugins clj/s

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

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! {:com.wsscode.pathom3.connect.planner/keys [graph]
               :com.wsscode.pathom3.connect.runner/keys [choose-path]
               :or {choose-path default-choose-path}
               :as env}
              {:com.wsscode.pathom3.connect.planner/keys [run-or] :as or-node})

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})

runnable-graph? clj/s

(runnable-graph? graph)

Quick check to see if the graph has something to run. In the false case we can skip the running section.

setup-root-env clj/s

(setup-root-env env)

setup-runner-env clj/s

(setup-runner-env env entity-tree* cache-type)

sort-waiting-by-depth clj/s

(sort-waiting-by-depth waits)

special-resolver-signal? clj/s

(special-resolver-signal? response)

union-key-on-data? clj/s

(union-key-on-data? {:keys [union-key]} m)

user-demand-completed? clj/s

(user-demand-completed? env)

valid-resolver-response? clj/s

(valid-resolver-response? x)

validate-response! clj/s

(validate-response! env
                    {:com.wsscode.pathom3.connect.operation/keys [op-name]
                     :as node}
                    response)

wait-batch-check clj/s

(wait-batch-check env node entity input input+opts op-name input-data)

wait-batch-response clj/s

(wait-batch-response env node)

warn-batch-unsupported clj/s

(warn-batch-unsupported env op-name)

weight-sort clj/s

(weight-sort {:com.wsscode.pathom3.connect.runner/keys [resolver-weights*]
              :as env}
             _or-node
             candidates)

Sorts nodes based on the weight of their paths. The weight is calculated every time a resolver runs.

with-resolver-cache clj/s

(with-resolver-cache env)

(with-resolver-cache env cache*)