com.wsscode.pathom3.format.eql — com.wsscode/pathom3 2021.07.10-alpha

Helpers to manipulate EQL.

ast-contains-wildcard? clj/s

(ast-contains-wildcard? {:keys [children]})

Check if some of the AST children is the wildcard value, which is *.

data->query clj/s

(data->query data)

Helper function to transform a data into an output shape.

extend-ast-with-wildcard clj/s

(extend-ast-with-wildcard source children)

ident-key clj/s

(ident-key key)

When key is an ident, return the first part of it. Otherwise returns nil.

include-extra-attrs clj/s

(include-extra-attrs children attrs)

index-ast clj/s

(index-ast {:keys [children]})

map-children->children clj/s

(map-children->children map-children)

map-select clj/s

(map-select env source tx)

Starting from a map, do a EQL selection on that map. Think of this function as a power up version of select-keys.

Example: (p/map-select {:foo "bar" :deep {:a 1 :b 2}} [{:deep [:a]}]) => {:deep {:a 1}}

map-select-ast clj/s

(map-select-ast {:com.wsscode.pathom3.format.eql/keys [map-select-include]
                 :as env}
                source
                ast)

Same as map-select, but using AST as source.

map-select-entry clj/s

(map-select-entry env source {:keys [key query type] :as ast})

maybe-merge-union-ast clj/s

(maybe-merge-union-ast ast)

Check if AST entry is a union, if so it computes a new AST entry by combining all union paths as a single entry.

merge-ast-children clj/s

(merge-ast-children ast1 ast2)

pick-union-entry clj/s

(pick-union-entry ast m)

Check if ast children is a union type. If so, makes a decision to choose a path and return that AST.

prop clj/s

(prop k)

query-root-properties clj/s

(query-root-properties query)

Returns a vector with the properties at the root of the query.

For example:

(query-root-properties [{:a [:b]} :c]) => [:a :c]

In case the query is a union query, it will merge the roots of then will merge:

(query-root-properties {:foo [{:a [:b]} :c] :bar [:a :d]}) => [:a :c :d]

recursive-query? clj/s

(recursive-query? query)

union->root clj/s

(union->root ast)

Convert a union entry to a root.

union-children clj/s

(union-children ast)

Get union children when its an union, otherwise return nil.

union-children? clj/s

(union-children? ast)

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

union-key-on-data? clj/s

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