com.wsscode.pathom3.connect.planner — com.wsscode/pathom3 2023.01.31-alpha

add-branch-to-node clj/s

(add-branch-to-node graph target-node-id branch-type new-branch-node-id)

add-ident-process clj/s

(add-ident-process graph {:keys [key]})

add-node-branches clj/s

(add-node-branches graph target-node-id branch-type node-ids)

add-node-parent clj/s

(add-node-parent graph node-id node-parent-id)

add-placeholder-entry clj/s

(add-placeholder-entry graph attr)

add-resolvers-trail clj/s

(add-resolvers-trail env resolvers)

add-snapshot! clj/s

(add-snapshot! graph
               {:com.wsscode.pathom3.connect.planner/keys [snapshots*
                                                           snapshot-depth]}
               event-details)

add-unreachable-path clj/s

(add-unreachable-path graph env path)

Add attribute to unreachable list

add-warning clj/s

(add-warning graph warn)

assoc-node clj/s

(assoc-node graph node-id k v)

Set attribute k about node-id. Only assoc when node exists, otherwise its a noop.

attr-optional? clj/s

(attr-optional? {:com.wsscode.pathom3.connect.planner/keys [index-ast]}
                attribute-kw)

base-env clj/s

(base-env)

base-graph clj/s

(base-graph)

branch-node? clj/s

(branch-node? node)

Returns true when the node is a branch node type.

can-merge-sibling-resolver-nodes? clj/s

(can-merge-sibling-resolver-nodes? graph node-id1 node-id2)

combine-expects clj/s

(combine-expects na nb)

combine-foreign-ast clj/s

(combine-foreign-ast na nb)

combine-inputs clj/s

(combine-inputs na nb)

combine-run-next clj/s

(combine-run-next graph env node-ids pivot)

Combine each node in node-ids with the pivot run next, this version will use AND node to connect the run next items

combine-run-next* clj/s

(combine-run-next* graph env branch-type node-ids pivot node-defaults)

Combine run next of elements, in case both have a run-next, a branch node will be placed there connecting both next nodes.

compare-AND-children-denorm clj/s

(compare-AND-children-denorm node)

compute-attribute-dependency-graph clj/s

(compute-attribute-dependency-graph
  graph
  {:com.wsscode.pathom3.connect.planner/keys [recursive-joins] :as env}
  attr
  shape)

compute-attribute-graph clj/s

(compute-attribute-graph
  {:com.wsscode.pathom3.connect.planner/keys [unreachable-paths] :as graph}
  {:com.wsscode.pathom3.connect.planner/keys [attr-deps-trail]
   :com.wsscode.pathom3.connect.indexes/keys [index-oir]
   {attr :key} :edn-query-language.ast/node
   :as env})

Compute the run graph for a given attribute.

compute-attribute-graph* clj/s

(compute-attribute-graph* graph
                          {:com.wsscode.pathom3.connect.indexes/keys [index-oir]
                           :com.wsscode.pathom3.attribute/keys [attribute]
                           :as env})

Traverse the attribute options, for example, considering we are processing the attribute :a. And we have this index:

{::pci/index-oir {:a {{} #{a}}}}

This means we are now at the {{} #{a}} part, lets call each entry of this map a process path.

To break it down, in this case we have one process path to get :a. Each process pair contains an input shape and a set of resolvers.

You can read it as: I can fetch :a providing the data {} to the resolver a.

A bigger example:

{::pci/index-oir {:a {{:b {}} #{a-from-b}
                      {:c {}} #{a-from-c a-f-c}}}}

In this case we have two process paths.

This function iterates over each process path, if at least one can complete the path, it returns a graph with a root o the node. In case of many options, an OR node will be the root, providing each path.

compute-attribute-nested-input-require clj/s

(compute-attribute-nested-input-require graph env attr shape nodes)

compute-dynamic-nested-requirements clj/s

(compute-dynamic-nested-requirements
  {:com.wsscode.pathom3.attribute/keys [attribute]
   :com.wsscode.pathom3.connect.operation/keys [op-name]
   ast :edn-query-language.ast/node
   :as env})

Considering the operation output, find out what a query can extend during nesting.

Pathom uses it to compute the dynamic requirements to send into dynamic resolvers.

This function is a useful tool for developers of custom dynamic resolvers.

compute-dynamic-nested-requirements* clj/s

(compute-dynamic-nested-requirements* {ast :edn-query-language.ast/node :as env}
                                      dynamic-name
                                      available)

compute-dynamic-nested-union-requirements* clj/s

(compute-dynamic-nested-union-requirements* {ast :edn-query-language.ast/node
                                             :as env}
                                            dynamic-name
                                            available)

compute-input-resolvers-graph clj/s

(compute-input-resolvers-graph graph
                               {:com.wsscode.pathom3.connect.planner/keys
                                  [available-data attr-resolvers-trail]
                                :com.wsscode.pathom3.attribute/keys [attribute]
                                :as env}
                               input
                               resolvers)

This function computes the graph for a given process path. It creates the resolver nodes to execute the resolvers, in case of many resolvers it uses a OR node to combine them.

Then it fetches the dependencies, declared in the process path. If the dependencies are successfully computed, it returns the graph with the root on the node that fulfills the request.

compute-missing-chain clj/s

(compute-missing-chain graph env missing missing-optionals)

Start a recursive call to process the dependencies required by the resolver.

compute-missing-chain-deps clj/s

(compute-missing-chain-deps
  graph
  {:com.wsscode.pathom3.connect.planner/keys [available-data] :as env}
  missing)

compute-missing-chain-optional-deps clj/s

(compute-missing-chain-optional-deps
  graph
  {:com.wsscode.pathom3.connect.planner/keys [available-data] :as env}
  opt-missing
  node-map)

compute-nested-requirements clj/s

(compute-nested-requirements
  {:com.wsscode.pathom3.connect.planner/keys [available-data]
   :com.wsscode.pathom3.attribute/keys [attribute]
   :com.wsscode.pathom3.connect.operation/keys [op-name]
   ast :edn-query-language.ast/node
   :as env})

compute-non-index-attribute clj/s

(compute-non-index-attribute graph
                             {:com.wsscode.pathom3.connect.planner/keys
                                [available-data]
                              {attr :key :as ast} :edn-query-language.ast/node
                              :as env})

This function deals with attributes that are not part of the index execution. The cases here are:

• EQL idents
• Previously available data
• Placeholders

compute-plan-snapshots clj/s

(compute-plan-snapshots env)

Run compute graph capturing snapshots, return the snapshots vector in the end.

compute-resolver-leaf clj/s

(compute-resolver-leaf graph
                       {:com.wsscode.pathom3.connect.planner/keys [input]
                        :as env}
                       resolvers)

For a set of resolvers (the R part of OIR index), create one OR node that branches to each option in the set.

compute-run-graph clj/s

(compute-run-graph env)

(compute-run-graph graph
                   {:com.wsscode.pathom3.connect.planner/keys [optimize-graph?]
                    :or {optimize-graph? true}
                    :as env})

Generates a run plan for a given environment, the environment should contain the indexes in it (::pc/index-oir and ::pc/index-resolvers). It computes a plan to execute one level of an AST, the AST must be provided via the key :edn-query-language.ast/node.

(compute-run-graph (assoc indexes :edn-query-language.ast/node ...))

The resulting graph will look like this:

{::nodes                 {1 {::pco/op-name      a
                             ::node-id          1
                             ::requires         {:a {}}
                             ::input            {}
                             ::source-for-attrs #{:a}
                             ::node-parents      #{3}}
                          2 {::pco/op-name      b
                             ::node-id          2
                             ::requires         {:b {}}
                             ::input            {}
                             ::source-for-attrs #{:b}
                             ::node-parents      #{3}}
                          3 {::node-id  3
                             ::requires {:b {} :a {} :c {}}
                             ::run-and  #{2 1 4}}
                          4 {::pco/op-name      c
                             ::node-id          4
                             ::requires         {:c {}}
                             ::input            {}
                             ::source-for-attrs #{:c}
                             ::node-parents      #{3}}}
 ::index-resolver->nodes {a #{1} b #{2} c #{4}}
 ::unreachable-attrs     #{}
 ::index-attrs           {:a #{1} :b #{2} :c #{4}}
 ::root                  3}

compute-run-graph* clj/s

(compute-run-graph* graph env)

Starts scanning the AST to plan for each attribute.

create-and clj/s

(create-and graph env node-ids)

create-node-for-resolver-call clj/s

(create-node-for-resolver-call
  {:com.wsscode.pathom3.connect.planner/keys [input]
   :com.wsscode.pathom3.attribute/keys [attribute]
   :com.wsscode.pathom3.connect.operation/keys [op-name]
   ast :edn-query-language.ast/node
   :as env})

Create a new node representative to run a given resolver.

create-root-and clj/s

(create-root-and graph env node-ids)

create-root-or clj/s

(create-root-or graph
                {:com.wsscode.pathom3.attribute/keys [attribute] :as env}
                node-ids)

denormalize-node clj/s

(denormalize-node
  {:com.wsscode.pathom3.connect.planner/keys [denorm-update-node] :as graph}
  node-id)

Compute a version of the node that contains all forward references denormalized. It means instead of having the ids at run-next/branches (both OR and AND) the node will have the node data itself directly there. The denormalized version is added using the node-id at the ::nodes-denormalized key in the graph. All subsequent nodes are also denormalized in the process and also add to ::nodes-denormalized, so a lookup for then will be also readly available.

disj-rem clj/s

(disj-rem m k item)

entry-ast clj/s

(entry-ast graph k)

Find AST node a given entry from the source AST.

extend-attribute-sub-query clj/s

(extend-attribute-sub-query graph
                            {:com.wsscode.pathom3.connect.planner/keys
                               [optional-process?]}
                            attr
                            shape)

extend-available-attribute-nested clj/s

(extend-available-attribute-nested
  graph
  {:com.wsscode.pathom3.connect.planner/keys [available-data] :as env}
  attr
  shape)

find-chain-start clj/s

(find-chain-start graph node-id)

Given a graph and a node-id, walks the run-next chain until it finds the first node that's connected to a branch parent (via branch relationship, not as run next) or the root.

find-direct-node-successors clj/s

(find-direct-node-successors
  {:com.wsscode.pathom3.connect.planner/keys [run-next] :as node})

Direct successors of node, branch nodes and run-next, in case of branch nodes the branches will always come before the run-next.

find-leaf-node clj/s

(find-leaf-node graph node)

Traverses all run-next still it reaches a leaf.

find-root-resolver-nodes clj/s

(find-root-resolver-nodes {:com.wsscode.pathom3.connect.planner/keys [root]
                           :as graph})

Returns the first resolvers to get called in the graph. This will traverse AND and OR node branches until the first resolvers are found. This function doesn't work the run-next of nodes.

find-run-next-descendants clj/s

(find-run-next-descendants graph
                           {:com.wsscode.pathom3.connect.planner/keys
                              [node-id]})

Return descendants by walking the run-next

get-denormalized-node clj/s

(get-denormalized-node graph node-id)

get-node clj/s

(get-node graph node-id)

(get-node graph node-id k)

get-root-node clj/s

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

Returns the root node of the graph.

graph-provides clj/s

(graph-provides {:com.wsscode.pathom3.connect.planner/keys [index-attrs]})

Get a set with all provided attributes from the graph.

ignore-nils clj/s

(ignore-nils m)

inc-snapshot-depth clj/s

(inc-snapshot-depth env)

include-node clj/s

(include-node graph
              {:com.wsscode.pathom3.connect.planner/keys [node-id]
               :com.wsscode.pathom3.connect.operation/keys [op-name]
               :as node})

Add new node to the graph, this add the node and the index of in ::index-syms.

keep-required-transducer clj/s

mark-attribute-process-sub-query clj/s

(mark-attribute-process-sub-query graph {:keys [key children query]})

Add information about attribute that is present but requires further processing due to subquery, this is created so the runner can quickly know which attributes need to have the subquery processing done.

matching-chains? clj/s

(matching-chains? chain-a chain-b)

merge-ast-children clj/s

(merge-ast-children a b)

merge-placeholder-ast clj/s

(merge-placeholder-ast index-ast placeholder-ast)

merge-sibling-equal-branches clj/s

(merge-sibling-equal-branches graph
                              env
                              parent-node-id
                              [target-node-id & mergeable-siblings-ids :as
                               node-ids])

merge-sibling-or-sub-chains clj/s

(merge-sibling-or-sub-chains graph env [chain & other-chains])

merge-sibling-resolver-node clj/s

(merge-sibling-resolver-node graph target-node-id source-node-id)

Merges data from source-node-id into target-node-id, them removes the source node.

merge-sibling-resolver-nodes clj/s

(merge-sibling-resolver-nodes graph env parent-node-id node-ids)

merge-sibling-resolver-nodes* clj/s

(merge-sibling-resolver-nodes* graph pivot node-ids)

merge-unreachable clj/s

(merge-unreachable target-graph
                   {:com.wsscode.pathom3.connect.planner/keys
                      [unreachable-paths]})

(merge-unreachable target-graph graph env path)

Copy unreachable attributes from discard-graph to target-graph. Using the extra arity you can also add a new unreachable path in the same call.

move-branch-item-node clj/s

(move-branch-item-node graph target-parent-id node-id)

Move a branch item from source parent target parent.

move-branches-to-another-node clj/s

(move-branches-to-another-node graph source-node-id target-node-id)

move-run-next-to-edge clj/s

(move-run-next-to-edge graph target-node-id node-to-move-id)

Find the node at the end of chain from target-node-id and move node-to-move-id as the next of that

new-node clj/s

(new-node env node-data)

next-node-id clj/s

(next-node-id {:com.wsscode.pathom3.connect.planner/keys [id-counter]})

Return the next node ID in the system, its an incremental number

node->label clj/s

(node->label node)

Return a string representation for the node, for resolver nodes this is the symbol, branch nodes get AND / OR respectively.

node-ancestors clj/s

(node-ancestors graph node-id)

Return all node ancestors. The order of the output will go from closest to farthest nodes, like breathing out of the current node.

node-attribute-provides clj/s

(node-attribute-provides graph env attr)

For a specific attribute, return a vector containing the provides of each node of that resolver, or the current available data for it.

node-branch-type clj/s

(node-branch-type node)

node-branches clj/s

(node-branches node)

Return node branches, which can be the ::run-and or the ::run-or part of the node.

node-kind clj/s

(node-kind node)

Return a keyword describing the type of the node.

node-optional? clj/s

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

node-successors clj/s

(node-successors graph node-id)

Find successor nodes of node-id, node-id is included in the list. This will add branch nodes before run-next nodes. Returns a lazy sequence that traverse the graph as items are requested.

node-with-resolver-config clj/s

(node-with-resolver-config graph env node-id)

Get the node plus the resolver config, when the node has an op-name. If node is not a resolver not it returns nil.

optimize-AND-branches clj/s

(optimize-AND-branches graph env node-id)

optimize-AND-nested clj/s

(optimize-AND-nested graph env node-id)

This pass will look for branches of an AND node that are also AND nodes. In case further AND doesn't contain a run-next, it can be safely merged with the parent AND.

AND > AND -> A > -> A -> AND > -> B -> B > -> C -> C >

optimize-AND-resolver-siblings clj/s

(optimize-AND-resolver-siblings graph env parent-id pivot other-nodes)

optimize-AND-resolvers-pass clj/s

(optimize-AND-resolvers-pass graph env parent-id)

This pass will collapse the same resolver node branches. This also do a local optimization on AND's and OR's sub-nodes. This is important to simplify the pass to merge OR nodes.

optimize-branch-items clj/s

(optimize-branch-items graph env branch-node-id)

optimize-graph clj/s

(optimize-graph graph env)

optimize-nested-branch-with-same-branches clj/s

(optimize-nested-branch-with-same-branches graph env node-id)

Similar to optimize-siblings-with-same-braches, but looks if a branch node has a children item that has the same branch structure as the parent.

optimize-nested-OR clj/s

(optimize-nested-OR graph env node-id)

optimize-node clj/s

(optimize-node graph env node-id)

optimize-OR-branches clj/s

(optimize-OR-branches graph env node-id)

optimize-OR-sub-paths clj/s

(optimize-OR-sub-paths graph env node-id)

This function looks to match branches of the OR node that are sub-paths of each other (eg: A, A -> B, merge to just A -> B). In this case we can merge those chains and return the number of branches in the OR node.

At this moment this fn only deals with paths that have only resolvers, it may look for paths with sub-branches in the future.

optimize-resolver-chain clj/s

(optimize-resolver-chain graph env node-id)

Merge node and its run-next, when they are the same dynamic resolver.

optimize-resolver-chain? clj/s

(optimize-resolver-chain? graph
                          {:com.wsscode.pathom3.connect.operation/keys [op-name]
                           :com.wsscode.pathom3.connect.planner/keys
                             [run-next]})

optimize-resolver-node clj/s

(optimize-resolver-node graph env node-id)

optimize-siblings-with-same-branches clj/s

(optimize-siblings-with-same-branches graph env node-id)

When sibling branch nodes are of the same type and have the same branch structure we can merge then.

plan-mutation clj/s

(plan-mutation graph env {:keys [key] :as ast})

plan-mutation-nested-query clj/s

(plan-mutation-nested-query env {:keys [key] :as ast})

promote-foreign-ast-children clj/s

(promote-foreign-ast-children
  {:com.wsscode.pathom3.connect.planner/keys [foreign-ast] :as ast})

Moves the children from foreign ast to the main children. Also removes the foreign ast attribute.

push-path clj/s

(push-path env
           {:com.wsscode.pathom3.attribute/keys [attribute]
            :com.wsscode.pathom3.path/keys [path]})

rehydrate-graph-idents clj/s

(rehydrate-graph-idents graph ast)

To optimize the plan caching Pathom will remove the values of the idents at the cache key. But upon later usage of the cache, the cache key will hit the previous AST, but that AST still has the initial values used on caching. This function will rehydrate the AST replacing the cached ident values with the current ident values.

remove-branch-node-parents clj/s

(remove-branch-node-parents graph node-id)

When node-id is a branch node, remove all node-parents associated from its children.

remove-from-parent-branch clj/s

(remove-from-parent-branch graph node-id parent-id)

Disconnect a branch node from its parents.

remove-from-parent-branches clj/s

(remove-from-parent-branches graph
                             {:com.wsscode.pathom3.connect.planner/keys
                                [node-id node-parents]})

Disconnect a branch node from its parents.

remove-node clj/s

(remove-node graph node-id)

Remove a node from the graph. In case of resolver nodes it also removes them from the ::index-syms, the index-attrs and after node references.

remove-node* clj/s

(remove-node* graph node-id)

Remove a node from the graph. Doesn't remove any references, caution!

remove-node-edges clj/s

(remove-node-edges graph node-id)

Remove all node connections. This disconnect the nodes from parents and run-next.

remove-node-expects-index-attrs clj/s

(remove-node-expects-index-attrs graph node-id)

Since the node has attribute indexes associated with it, this removes those links considering the attributes listed on expects.

remove-node-parent clj/s

(remove-node-parent graph node-id node-parent-id)

Disconnect the parent node node-parent-id from node node-id

remove-root-node-cluster clj/s

(remove-root-node-cluster graph node-ids)

Remove a complete node cluster, starting from some node root.

remove-run-next-edge clj/s

(remove-run-next-edge graph node-id)

required-ast-from-index-ast clj/s

(required-ast-from-index-ast {:com.wsscode.pathom3.connect.planner/keys
                                [index-ast]})

required-ast-from-source-ast clj/s

(required-ast-from-source-ast {:com.wsscode.pathom3.connect.planner/keys
                                 [source-ast]})

reset-env clj/s

(reset-env env)

Restore the original environment sent to run-graph! Use this for nested graphs that need a clean environment.

resolvers-missing-optionals clj/s

(resolvers-missing-optionals
  {:com.wsscode.pathom3.connect.planner/keys [available-data] :as env}
  resolvers)

Merge the optionals from a collection of resolver symbols.

runner-node-sym clj/s

(runner-node-sym env resolver-name)

Find the runner symbol for a resolver, on normal resolvers that is the resolver symbol, but for foreign resolvers it uses its ::p.c.o/dynamic-name.

sanitize-params clj/s

(sanitize-params params)

set-node-expects clj/s

(set-node-expects graph node-id expects)

Set node expects, this also removes previous references from index-attrs and add new ones for the new expects.

set-node-run-next clj/s

(set-node-run-next graph run-next)

(set-node-run-next graph target-node-id run-next)

Set the node run next value and add the node-parent counterpart. Noop if target and run next are the same node.

set-node-run-next* clj/s

(set-node-run-next* graph node-id run-next)

Update the node-id run-next value, if run-next is nil the attribute will be removed from the map.

set-node-source-for-attrs clj/s

(set-node-source-for-attrs graph env)

(set-node-source-for-attrs graph
                           {:com.wsscode.pathom3.attribute/keys [attribute]}
                           node-id)

set-root-node clj/s

(set-root-node graph node-id)

shape-descriptor->ast-children-optional clj/s

(shape-descriptor->ast-children-optional shape)

Convert pathom output format into shape descriptor format.

shape-descriptor->ast-optional clj/s

(shape-descriptor->ast-optional shape)

Convert pathom output format into shape descriptor format.

shape-reachable? clj/s

(shape-reachable? {:com.wsscode.pathom3.connect.planner/keys [resolvers]
                   :as env}
                  available
                  shape)

Given an environment, available data and shape, determines if the whole shape is reachable (including nested dependencies).

simplify-single-branch-node clj/s

(simplify-single-branch-node graph env node-id)

When a branch node contains a single branch out, remove the node and put that single item in place.

Note in case the branch has a run-next, that run-next gets moved to the end of chain to retain the same order as it would run with the branch.

sub-sequence? clj/s

(sub-sequence? seq-a seq-b)

transfer-node-indexes clj/s

(transfer-node-indexes graph target-node-id source-node-id)

transfer-node-parent clj/s

(transfer-node-parent graph target-node-id source-node-id node-id)

Transfer the node parent from source node to target node. This function will also update the parents references to point to target node.

transfer-node-parents clj/s

(transfer-node-parents graph target-node-id source-node-id)

Transfer node parents from source node to target node. In case source node is root, the root will be transferred to target node.

update-node clj/s

(update-node graph node-id k f)

(update-node graph node-id k f v)

(update-node graph node-id k f v v2)

(update-node graph node-id k f v v2 v3)

(update-node graph node-id k f v v2 v3 & args)

Update a given node in a graph, like Clojure native update.

verify-plan! clj/s

(verify-plan! {:com.wsscode.pathom3.error/keys [lenient-mode?] :as env} graph)

This will cause an exception to throw in case the plan can't reach some required attribute

verify-plan!* clj/s

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

with-plan-cache clj/s

(with-plan-cache env)

(with-plan-cache env cache*)