grape.graphql.core — grape 0.1.7

argument clj

(argument name type & {:keys [description default-value]})

batched-data-fetcher clj

(batched-data-fetcher f)

build-schema clj

(build-schema {:keys [resources-registry] :as deps})

connection clj

(connection name type type-resolver)

connection-args clj

connection-data-fetcher clj

(connection-data-fetcher f)

data-fetcher clj

(data-fetcher f)

enum clj

(enum name values & {:keys [description]})

enum-value clj

(enum-value name value & {:keys [description deprecation-reason]})

execute clj

(execute {:keys [graphql] :as deps} request q & [params])

field clj

(field name
       type
       &
       {:keys [description data-fetcher static-value deprecation-reason
               arguments]})

input-field clj

(input-field name type & {:keys [description default-value]})

input-object clj

(input-object name fields & {:keys [description]})

interface clj

(interface name fields type-resolver & {:keys [description]})

mongo->graphql clj

(mongo->graphql type)

node-interface clj

(node-interface type-resolver)

object clj

(object name fields & {:keys [description interfaces]})

relay clj

resource->input-graphql-type clj

(resource->input-graphql-type {:keys [resources-registry] :as deps}
                              resource
                              &
                              {:keys [skip-hidden? skip-read-only?]
                               :or {skip-hidden? false skip-read-only? false}})

resource->output-graphql-type clj

(resource->output-graphql-type {:keys [resources-registry] :as deps}
                               resource
                               &
                               {:keys [skip-hidden? skip-read-only?]
                                :or {skip-hidden? false skip-read-only? false}})

ScalarDateTime clj

ScalarObjectId clj

schema clj

(schema query & {:keys [mutation]})

to-clj clj

(to-clj data)

type-ref clj

(type-ref {:keys [resources-registry] :as deps} resource v)

type-ref-data-fetcher clj

(type-ref-data-fetcher grape-type-ref & {:keys [many?]})

type-ref? clj

type-resolver clj

(type-resolver f)

types-map clj

union clj

(union name types type-resolver & {:keys [description]})