com.wsscode.pathom.connect.graphql2 — com.wsscode/pathom 2.4.0

alias-for-line clj/s

(alias-for-line query line)

args-translate clj/s

(args-translate {:com.wsscode.pathom.connect.graphql2/keys [prefix ident-map]}
                args)

ast->graphql clj/s

(ast->graphql {:keys [ast] :com.wsscode.pathom.connect/keys [indexes]} ent)

build-query clj/s

(build-query env)

defgraphql-resolver clj/s

(defgraphql-resolver
  {:com.wsscode.pathom.connect/keys [resolver-dispatch mutate-dispatch]}
  {:com.wsscode.pathom.connect.graphql2/keys [resolver] :as config})

demung-key clj/s

(demung-key demung s)

demunger-map-reader clj/s

(demunger-map-reader {:com.wsscode.pathom.connect.graphql2/keys [demung]
                      :keys [ast query]
                      :as env})

Reader that will demunge keys using user function

entity-field-key clj/s

(entity-field-key {:com.wsscode.pathom.connect.graphql2/keys [mung prefix]}
                  entity
                  field)

error-stamper clj/s

(error-stamper {:com.wsscode.pathom.connect.graphql2/keys [errors base-path
                                                           demung]
                :com.wsscode.pathom.core/keys [path errors*]})

filter-graphql-subquery clj/s

(filter-graphql-subquery {:com.wsscode.pathom.connect.planner/keys [node]
                          :as env})

filter-graphql-subquery-legacy clj/s

(filter-graphql-subquery-legacy {:com.wsscode.pathom.core/keys [parent-query]
                                 :com.wsscode.pathom.connect.graphql2/keys
                                   [prefix]
                                 :as env})

Given the parent query, filter the fields to send to GraphQL, this implementation relies on the namespace to decide if a attribute should be picked or not.

filter-graphql-subquery-planner clj/s

(filter-graphql-subquery-planner {:com.wsscode.pathom.core/keys [parent-query]
                                  :com.wsscode.pathom.connect.planner/keys
                                    [node]
                                  :as env})

Given the parent query, filter the fields to send to GraphQL, this implementation relies on the pathom planner, pulling from the requires, this is more precise then the previous implementation.

filter-mutation-subquery clj/s

(filter-mutation-subquery {:keys [ast] :as env})

gql-ident-reader clj/s

(gql-ident-reader {:keys [ast] :as env})

graphql-mutation clj/s

(graphql-mutation {:com.wsscode.pathom.connect.graphql2/keys [demung]
                   :as config}
                  env)

graphql-resolve clj/s

(graphql-resolve {:com.wsscode.pathom.connect.graphql2/keys [demung] :as config}
                 {headers :com.wsscode.pathom.diplomat.http/headers :as env})

ident-map-entry clj/s

(ident-map-entry env item)

ident-map-params->io clj/s

(ident-map-params->io env params)

ident-root clj/s

(ident-root {:com.wsscode.pathom.connect.graphql2/keys [prefix ident-map]}
            {:keys [name] :as root-field})

ident-root? clj/s

(ident-root? {:com.wsscode.pathom.connect.graphql2/keys [ident-map]}
             {:keys [args]})

index-autocomplete-ignore clj/s

(index-autocomplete-ignore {:com.wsscode.pathom.connect.graphql2/keys [schema]
                            :as env})

index-graphql-errors clj/s

(index-graphql-errors errors)

index-graphql-idents clj/s

(index-graphql-idents {:com.wsscode.pathom.connect.graphql2/keys
                         [schema ident-map mung]
                       :com.wsscode.pathom.connect/keys [index-io]
                       :as env})

index-idents clj/s

(index-idents {:com.wsscode.pathom.connect.graphql2/keys [ident-map] :as env})

index-mutations clj/s

(index-mutations {:com.wsscode.pathom.connect.graphql2/keys [schema]
                  :as config})

index-schema clj/s

(index-schema {:com.wsscode.pathom.connect.graphql2/keys [resolver prefix]
               :as config})

index-schema-io clj/s

(index-schema-io {:com.wsscode.pathom.connect.graphql2/keys [prefix schema
                                                             ident-map mung]
                  :as input})

index-schema-oir clj/s

(index-schema-oir {:com.wsscode.pathom.connect.graphql2/keys
                     [prefix schema resolver ident-map mung]
                   :com.wsscode.pathom.connect/keys [index-io]
                   :as input})

index-schema-types clj/s

(index-schema-types schema)

index-type clj/s

(index-type env {:keys [fields name interfaces] :as input})

index-type-key clj/s

(index-type-key env {:keys [name kind]})

interface-key clj/s

(interface-key env s)

load-index clj/s

(load-index req)

(load-index req indexes)

mutation-key clj/s

(mutation-key {:com.wsscode.pathom.connect.graphql2/keys [prefix mung]} s)

normalize-schema clj/s

(normalize-schema schema)

Depending on encoding settings sometimes the :kind can come as a keyword, the indexer expects it to be a string, this function ensures all :kind fields are strings.

parser-item clj/s

prefixed-key clj/s

(prefixed-key {:com.wsscode.pathom.connect.graphql2/keys [prefix mung]} p s)

pull-idents clj/s

(pull-idents data)

query->graphql clj/s

(query->graphql query
                {:com.wsscode.pathom.connect.graphql2/keys [demung tempid?]
                 :or {demung identity tempid? (constantly false)}})

Like the pg/query-graphql, but adds name convertion so clj names like :first-name turns in firstName.

remove-pathom-params clj/s

(remove-pathom-params params)

request clj/s

(request {:com.wsscode.pathom.connect.graphql2/keys [url] :as env} query)

schema-query clj/s

service-mutation-key clj/s

(service-mutation-key {:com.wsscode.pathom.connect.graphql2/keys [prefix]})

service-resolver-key clj/s

(service-resolver-key env)

type->field-entry clj/s

(type->field-entry env type)

type->field-name clj/s

(type->field-name env {:keys [kind name ofType]})

type-key clj/s

(type-key env s)