com.wsscode.pathom.parser — com.wsscode/pathom 2.2.5

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 id :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]})

query->ast clj/s

(query->ast query)

Convert a query to its AST representation.

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)

watch-pending-key clj/s

(watch-pending-key {:com.wsscode.pathom.parser/keys [key-watchers] :as env} key)

wrap-expr clj/s

(wrap-expr root? expr)