com.wsscode.pathom.parser — com.wsscode/pathom 2.3.0-alpha16

ast->expr clj/s

(ast->expr ast)

(ast->expr {:keys [type component] ast-meta :meta :as ast} unparse?)

Given a query expression AST convert it back into a query expression.

ast->out-key clj/s

(ast->out-key ast)

async-parser clj/s

(async-parser {:keys [read mutate]})

call->ast clj/s

(call->ast [f args :as call])

call-parallel-parser clj/s

(call-parallel-parser {:keys [read mutate]}
                      {:com.wsscode.pathom.parser/keys
                         [waiting key-watchers max-key-iterations
                          key-process-timeout key-process-timeout-step]
                       :com.wsscode.pathom.core/keys [entity-path-cache path]
                       :or {max-key-iterations 5}
                       :as env}
                      tx)

default-step-fn clj/s

(default-step-fn amount min)

expr->ast clj/s

(expr->ast x)

Given a query expression convert it into an AST.

focus-subquery clj/s

(focus-subquery query sub-query)

Given a query, focus it along the specified query expression.

Examples: (focus-query [:foo :bar :baz] [:foo]) => [:foo]

(fulcro.client.primitives/focus-query [{:foo [:bar :baz]} :woz] [{:foo [:bar]} :woz]) => [{:foo [:bar]} :woz]

ident->ast clj/s

(ident->ast [k :as ref])

join->ast clj/s

(join->ast join)

keyword->ast clj/s

(keyword->ast k)

normalize-atom clj/s

(normalize-atom x)

parallel-parser clj/s

(parallel-parser {:keys [add-error] :as pconfig})

parameterize clj/s

(parameterize expr params)

parser clj/s

(parser {:keys [read mutate]})

process-next-message clj/s

(process-next-message {:com.wsscode.pathom.parser/keys
                         [done-signal* processing-recheck-timer active-paths]
                       :com.wsscode.pathom.core/keys [path]
                       :as env}
                      tx
                      waiting
                      indexed-props
                      processing
                      key-iterations
                      key-watchers
                      res)

query->ast clj/s

(query->ast query)

Convert a query to its AST representation.

remove-error-values clj/s

(remove-error-values m)

symbol->ast clj/s

(symbol->ast k)

union->ast clj/s

(union->ast m)

union-entry->ast clj/s

(union-entry->ast [k v])

unique-ident? clj/s

(unique-ident? x)

value-merge clj/s

(value-merge x y)

This is used for merging new parsed attributes from entity, works like regular merge but if the value from the right direction is not found, then the previous value will be kept.

watch-pending-key clj/s

(watch-pending-key {:com.wsscode.pathom.parser/keys
                      [key-watchers external-wait-ignore-timeout]
                    :or {external-wait-ignore-timeout 3000}
                    :as env}
                   key)

wrap-expr clj/s

(wrap-expr root? expr)

zero-inc clj/s