com.wsscode.pathom3.graphql — com.wsscode/pathom3-graphql 2022.02.21-2-alpha

adapt-field clj/s

(adapt-field {:com.wsscode.pathom3.graphql/keys [gql-types-index] :as env}
             {type-name "name"}
             {:strs [type name args] :as field})

adapt-type clj/s

(adapt-type env type)

build-indexes clj/s

(build-indexes {:com.wsscode.pathom3.graphql/keys [namespace root-entries-map]
                :as env}
               schema)

connect-graphql clj/s

(connect-graphql env
                 {:com.wsscode.pathom3.graphql/keys [namespace] :as config}
                 request)

Setup a GraphQL connection on the env.

The request must be a function that takes a GraphQL string, executes it (or maybe send to a server) and return the response as a Clojure map. The Clojure map should be the exact same data the GraphQL returns. The keys MUST be encoded as strings, if you convert the keys to keywords it wont work.

Config may include the following keys:

::namespace (required) - a namespace (as string) to prefix the entries for this graphql

convert-back clj/s

(convert-back env response)

entity-field-key clj/s

(entity-field-key {:com.wsscode.pathom3.graphql/keys [namespace]} entity field)

fields-index clj/s

(fields-index {:com.wsscode.pathom3.graphql/keys [gql-types-index]})

format-error clj/s

(format-error {:strs [message path]})

index-root-entries-fields clj/s

(index-root-entries-fields env)

inferred-root-entries-map clj/s

(inferred-root-entries-map {:com.wsscode.pathom3.graphql/keys [gql-types-index]}
                           {:strs [fields]})

inject-gql-on clj/s

(inject-gql-on parent-type {:keys [dispatch-key] :as node})

interface-key clj/s

(interface-key env s)

interfaces-usage-index clj/s

(interfaces-usage-index {:com.wsscode.pathom3.graphql/keys [gql-object-types
                                                            gql-types-index]})

load-schema clj/s

(load-schema config request)

map-children clj/s

(map-children f node)

next-is-expected-dynamic? clj/s

(next-is-expected-dynamic? {:com.wsscode.pathom3.connect.planner/keys [node
                                                                       graph]}
                           gql-dynamic-op-name)

pathom-main-resolver clj/s

(pathom-main-resolver env gql-dynamic-op-name)

pathom-mutations clj/s

(pathom-mutations {:com.wsscode.pathom3.graphql/keys [gql-dynamic-op-name
                                                      gql-mutation-type]})

pathom-query-entry-resolver clj/s

(pathom-query-entry-resolver type-name)

pathom-root-entries-map-resolve clj/s

(pathom-root-entries-map-resolve
  {:com.wsscode.pathom3.graphql/keys [gql-dynamic-op-name root-entries-map]
   :as env}
  {:com.wsscode.pathom3.graphql/keys [gql-field-name] :strs [name]})

pathom-root-entries-resolvers clj/s

(pathom-root-entries-resolvers {:com.wsscode.pathom3.graphql/keys
                                  [gql-query-type gql-types-index
                                   root-entries-map namespace]
                                :as env})

pathom-type-resolvers clj/s

(pathom-type-resolvers {:com.wsscode.pathom3.graphql/keys
                          [namespace gql-indexable-types
                           gql-interface-usages-index gql-dynamic-op-name]})

prefixed-key clj/s

(prefixed-key {:com.wsscode.pathom3.graphql/keys [namespace]} p s)

prepare-gql-ast clj/s

(prepare-gql-ast env ast)

process-gql-request clj/s

(process-gql-request {:com.wsscode.pathom3.graphql/keys [request]
                      :as schema-env}
                     env
                     input)

schema-query clj/s

set-union-path clj/s

(set-union-path schema-env entity)

type->field-name clj/s

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

type-chain clj/s

(type-chain type)

type-indexable? clj/s

(type-indexable? {:com.wsscode.pathom3.graphql/keys [gql-mutation-type-name]}
                 {:strs [name kind]})

type-key clj/s

(type-key env s)

type-leaf-name clj/s

(type-leaf-name {:strs [kind name ofType]})