com.wsscode.pathom.core — com.wsscode/pathom 2.1.0

? clj/s

apply-plugins clj/s

(apply-plugins v plugins key)

ast->query clj/s

(ast->query query-ast)

ast-key-id clj/s

(ast-key-id ast)

DEPRECATED: use ident-value instead

async-parser clj/s

(async-parser settings)

cache-hit clj/s

(cache-hit {:com.wsscode.pathom.core/keys [request-cache]} key value)

cached clj/s macro

(cached env key body)

collapse-error-path clj/s

(collapse-error-path m path)

continue clj/s

continue-seq clj/s

deep-merge clj/s

(deep-merge & xs)

default-union-path clj/s

(default-union-path {:keys [query] :as env})

easy-plugins clj/s

(easy-plugins {:com.wsscode.pathom.core/keys [plugins env]})

elide-ast-nodes clj/s

(elide-ast-nodes {:keys [key union-key] :as ast} elision-set)

Remove items from a query (AST) that have a key listed in the elision-set

elide-items clj/s

(elide-items item-set input)

Removes any item on set item-set from the input

elide-not-found clj/s

(elide-not-found input)

Convert all ::p/not-found values of maps to nil

ensure-attrs clj/s

(ensure-attrs env attributes)

entity clj/s

(entity env)

(entity {:keys [parser] :as env} attributes)

Fetch the entity according to the ::entity-key. If the entity is an IAtom, it will be derefed.

If a second argument is sent, calls the parser against current element to guarantee that some fields are loaded. This is useful when you need to ensure some values are loaded in order to fetch some more complex data. NOTE: When using this call with an explicit vector of attributes the parser will not be invoked for attributes that already exist in the current value of the current entity.

entity! clj/s

(entity! {:com.wsscode.pathom.core/keys [path] :as env} attributes)

entity-attr clj/s

(entity-attr env attr)

(entity-attr env attr default)

Helper function to fetch a single attribute from current entity.

entity-attr! clj/s

(entity-attr! env attr)

Like entity-attr. Raises an exception if the property can't be retrieved.

entity-dispatch clj/s

(entity-dispatch {:keys [ast]})

Dispatch on the first element (type) of an incoming ident.

entity-value-merge clj/s

(entity-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.

env-placeholder-reader clj/s

(env-placeholder-reader {:com.wsscode.pathom.core/keys [placeholder-prefixes]
                         :as env})

Produces a reader that will respond to any keyword whose namespace is in the set (::placeholder-prefixes env). The join node logical level stays the same as the parent where the placeholder node is requested.

env-plugin clj/s

(env-plugin extra-env)

env-wrap-plugin clj/s

(env-wrap-plugin extra-env-wrapper)

This plugin receives a function that will be called to wrap the current enviroment each time the main parser is called (parser level).

error-handler-plugin clj/s

error-message clj/s

(error-message err)

error-str clj/s

(error-str err)

exec-plugin-actions clj/s

(exec-plugin-actions env key v & args)

filter-ast clj/s

(filter-ast f ast)

group-plugins-by-action clj/s

(group-plugins-by-action plugins)

ident-join-reader clj/s

(ident-join-reader env)

This reader will join on any ident join, the entity for the join will be a map containing the same key and value expressed on the ident, eg: [{[:id 123] [:id]}], the join entry will be {:id 123}.

ident-key clj/s

(ident-key {:keys [ast]})

The first element of an ident.

ident-key* clj/s

(ident-key* key)

ident-value clj/s

(ident-value {:keys [ast]})

The second element of an ident

ident-value* clj/s

(ident-value* key)

ident? clj/s

(ident? x)

join clj/s

(join {:keys [parser ast query]
       :com.wsscode.pathom.core/keys [union-path parent-query
                                      processing-sequence placeholder-prefixes]
       :as env})

(join entity {:com.wsscode.pathom.core/keys [entity-key] :as env})

Runs a parser with current sub-query. When run with an entity argument, that entity is set as the new environment value of ::entity, and the subquery is parsered with that new environment. When run without an entity it parses the current subquery in the context of whatever entity was already in ::entity of the env.

join-seq clj/s

(join-seq {:com.wsscode.pathom.core/keys [entity-key] :as env} coll)

Runs the current subquery against the items of the given collection.

js-obj-reader cljs

(js-obj-reader {:keys [query ast]
                :com.wsscode.pathom.core/keys [js-key-transform
                                               js-value-transform entity-key]
                :as env
                :or {js-key-transform name js-value-transform (fn [_ v] v)}})

Like map-reader*, but handles plain Javascript objects instead of Clojure maps.

key-dispatch clj/s

(key-dispatch {:keys [ast]})

lift-placeholders clj/s

(lift-placeholders {:com.wsscode.pathom.core/keys [placeholder-prefixes]} query)

This will lift the queries from placeholders to the same level of the query, as if there was not placeholders in it.

map-reader clj/s

(map-reader {:keys [ast query] :as env})

Map reader will try to find the ast key on the current entity and output it. When the value is a map and a sub query is present, it will apply the sub query on that value (recursively). When the value is a sequence, map-reader will do a join on each of the items (and apply sub queries if it's present and values are maps.

Map-reader will defer the read when the key is not present at entity.

map-reader* clj/s

(map-reader* {:com.wsscode.pathom.core/keys [map-key-transform
                                             map-value-transform]})

Like map-reader, but it has extra options (read from the environment): map-key-transform: (fn [key]) will transform the key on the AST before trying to match with entity key map-value-transform: (fn [key value]) will transform the output value after reading from the entity.

The reason to have a separated reader is so the plain version (map-reader) can be faster by avoiding checking the presence of transform functions.

maybe-atom clj/s

(maybe-atom x)

merge-queries clj/s

(merge-queries qa qb)

merge-queries* clj/s

(merge-queries* qa qb)

normalize-env clj/s

(normalize-env {:keys [ast] :as env})

optional-attribute clj/s

(optional-attribute x)

parser clj/s

(parser settings)

pathom-read clj/s

(pathom-read {:com.wsscode.pathom.core/keys [reader process-reader] :as env}
             _
             _)

DEPRECATED: use p/parser to create your parser

pathom-read' clj/s

(pathom-read' {:com.wsscode.pathom.core/keys [reader] :as env})

placeholder-node clj/s

placeholder-reader clj/s

(placeholder-reader)

(placeholder-reader ns)

DEPRECATED: use env-placeholder-reader instead.

Produces a reader that will respond to any keyword with the namespace ns. The join node logical level stays the same as the parent where the placeholder node is requested.

post-process-parser-plugin clj/s

(post-process-parser-plugin f)

Helper to create a plugin to work on the parser output. f will run once with the parser final result.

query->ast clj/s

(query->ast query-expr)

Given a query expression convert it into an AST.

query->ast1 clj/s

(query->ast1 query-expr)

Call query->ast and return the first children.

raise-errors clj/s

(raise-errors data)

raise-mutation-result-plugin clj/s

raise-response clj/s

(raise-response resp)

Mutations running through a parser all come back in a map like this {'my/mutation {:result {...}}}. This function converts that to {'my/mutation {...}}. Copied from fulcro.server.

raw-entity clj/s

(raw-entity {:com.wsscode.pathom.core/keys [entity-key] :as env})

read-from clj/s

(read-from env reader)

Runs the read process for the reading, the reader can be a function, a vector or a map:

function: will receive the environment as argument map: will dispatch from the ast key to a reader on the map value vector: will try to run each reader in sequence, when a reader returns ::p/continue it will try the next

read-from* clj/s

(read-from* {:keys [ast] :as env} reader)

remove-query-wildcard clj/s

(remove-query-wildcard query)

request-cache-plugin clj/s

settings-mutation clj/s

(settings-mutation settings)

swap-entity! clj/s

(swap-entity! env fn & args)

Helper to swap the current entity value.

transduce-children clj/s

(transduce-children xform {:keys [children] :as node})

Recursivelly transduce children on the AST, you can use this to apply filter/transformations on a whole AST. Each iteration of the transducer will get a single AST node to process.

(->> [:a {:b [:c :d]} :e]
     (p/query->ast)
     (p/transduce-children (remove (comp #{:a :c} :key)))
     (p/ast->query))
; => [{:b [:d]} :e]

transduce-maps clj/s

(transduce-maps xform input)

Walk the structure and transduce every map with xform.

union-children? clj/s

(union-children? ast)

Given an AST point, check if the children is a union query type.

update-action clj/s

(update-action m f)

Helper function to update a mutation action.

update-attribute-param clj/s

(update-attribute-param x f & args)

Add attribute param, eg:

(p/update-attribute-param :keyword assoc :foo "bar") => (:keyword {:foo "bar"})
(p/update-attribute-param '(:keyword {:param "prev"}) assoc :foo "bar") => (:keyword {:foo "bar" :param "prev"})

update-child clj/s

(update-child ast key & args)

Given an AST, find the child with a given key and run update against it.

update-recursive-depth clj/s

(update-recursive-depth ast key & args)

Given an AST, find the child with a given key and run update against it.

wrap-add-path clj/s

(wrap-add-path reader)

wrap-handle-exception clj/s

(wrap-handle-exception reader)

wrap-mutate-handle-exception clj/s

(wrap-mutate-handle-exception mutate)

wrap-normalize-env clj/s

(wrap-normalize-env parser)

(wrap-normalize-env parser plugins)

wrap-parser-exception clj/s

(wrap-parser-exception parser)

wrap-reduce-params clj/s

(wrap-reduce-params reader)