Prospero

serve :: forall ctx errs gql. GraphQL ctx errs gql -> (forall a. Om ctx errs a -> Aff a) -> SubscriptionHandler -> { port :: Int } -> Effect BunServer

cacheControlFor :: forall ctx errs gql. { query :: GqlType | gql } -> Wrapper ctx errs

cacheControl :: forall ctx errs. GqlType -> Wrapper ctx errs

newtype Selection :: Type -> Type -> Row Type -> Typenewtype Selection (parent :: Type) (result :: Type) (params :: Row Type)

Constructors

• Selection String

data QueryResult :: Row Type -> Typedata QueryResult r

Constructors

• Success (Record r)
• PartialSuccess (Record r) (NonEmptyArray ClientError)
• Failure (NonEmptyArray ClientError)

type ClientError = { message :: String }

withArgs :: forall args parent result params. WriteForeign (Record args) => Record args -> Selection parent result params -> Selection parent result params

selection :: forall @q @fields qRow qRL resultRL paramsRL result params. RecordRow q qRow => RowToList qRow qRL => ParseGql fields "Query" qRL resultRL paramsRL => ListToRow resultRL result => ListToRow paramsRL params => IsSymbol fields => Selection q (Record result) params

runSelectionWith :: forall @a result params. ReadForeign { data :: Maybe (Record result), errors :: Maybe (Array ClientError) } => WriteForeign (Record params) => String -> String -> Record params -> Selection a (Record result) params -> Aff (QueryResult result)

runSelection :: forall @a result params. ReadForeign { data :: Maybe (Record result), errors :: Maybe (Array ClientError) } => WriteForeign (Record params) => String -> Record params -> Selection a (Record result) params -> Aff (QueryResult result)

runQuery :: forall @q @fields qRow qRL resultRL paramsRL result params. RecordRow q qRow => RowToList qRow qRL => ParseGql fields "Query" qRL resultRL paramsRL => ListToRow resultRL result => ListToRow paramsRL params => WriteForeign (Record params) => ReadForeign { data :: Maybe (Record result), errors :: Maybe (Array ClientError) } => IsSymbol fields => String -> Record params -> Aff (QueryResult result)

runMutationSelection :: forall @a result params. ReadForeign { data :: Maybe (Record result), errors :: Maybe (Array ClientError) } => WriteForeign (Record params) => String -> Record params -> Selection a (Record result) params -> Aff (QueryResult result)

runMutation :: forall @q @fields qRow qRL resultRL paramsRL result params. RecordRow q qRow => RowToList qRow qRL => ParseGql fields "Mutation" qRL resultRL paramsRL => ListToRow resultRL result => ListToRow paramsRL params => WriteForeign (Record params) => ReadForeign { data :: Maybe (Record result), errors :: Maybe (Array ClientError) } => IsSymbol fields => String -> Record params -> Aff (QueryResult result)

mutationSelection :: forall @q @fields qRow qRL resultRL paramsRL result params. RecordRow q qRow => RowToList qRow qRL => ParseGql fields "Mutation" qRL resultRL paramsRL => ListToRow resultRL result => ListToRow paramsRL params => IsSymbol fields => Selection q (Record result) params

newtype DataLoader k v

A DataLoader batches and caches individual key lookups. Create one per request to avoid stale caches across requests.

mkDataLoader :: forall k v. Ord k => (Array k -> Aff (Map k v)) -> Aff (DataLoader k v)

Create a new DataLoader with a batch function.

load :: forall k v. Ord k => DataLoader k v -> k -> Aff v

Load a single key. Batches with other concurrent loads and caches the result.

type DeferredResponse :: Type -> Row Type -> Typetype DeferredResponse ctx errs = { deferred :: Array (DeferPatch ctx errs), hasDeferred :: Boolean, initial :: Om ctx errs GraphQLResponse }

type DeferPatch :: Type -> Row Type -> Typetype DeferPatch ctx errs = { execute :: Om ctx errs GraphQLResponse, label :: Maybe String, path :: Array String }

executeWithDefer :: forall ctx errs gql. GraphQL ctx errs gql -> String -> Map String InputValue -> DeferredResponse ctx errs

encodePatchResponse :: GraphQLResponse -> Maybe String -> Array String -> Boolean -> ResponseValue

encodeInitialResponse :: GraphQLResponse -> Boolean -> ResponseValue

data DirectiveLocation

Constructors

• FIELD
• FRAGMENT_SPREAD
• INLINE_FRAGMENT
• QUERY
• MUTATION
• SUBSCRIPTION
• SCHEMA
• SCALAR
• OBJECT
• FIELD_DEFINITION
• ARGUMENT_DEFINITION
• INTERFACE
• UNION
• ENUM
• ENUM_VALUE
• INPUT_OBJECT
• INPUT_FIELD_DEFINITION

type CustomDirective :: Type -> Row Type -> Typetype CustomDirective ctx errs = { apply :: Map String InputValue -> Om ctx errs ResponseValue -> Om ctx errs ResponseValue, args :: Array GqlInputValue, description :: Maybe String, locations :: Array DirectiveLocation, name :: String }

withDirectives :: forall ctx errs gql. Array (CustomDirective ctx errs) -> Schema ctx errs gql -> Schema ctx errs gql

type SimpleErrs :: Row Typetype SimpleErrs = (wrongArgumentType :: String)

serveGraphQL :: forall ctxRow errs gql r rl err_ outerRow extra errs'. RowToList (exception :: Error -> Aff GraphQLResponse | r) rl => VariantMatchCases rl err_ (Aff GraphQLResponse) => Union err_ () (exception :: Error | errs) => Union ctxRow extra outerRow => Keys ctxRow => GraphQL (Record ctxRow) errs gql -> { exception :: Error -> Aff GraphQLResponse | r } -> Fastify -> Om (Record outerRow) errs' Unit

runSimple :: forall a. Om (Record ()) SimpleErrs a -> Aff a

runServeGraphQL :: forall ctx errs gql r rl err_. RowToList (exception :: Error -> Aff GraphQLResponse | r) rl => VariantMatchCases rl err_ (Aff GraphQLResponse) => Union err_ () (exception :: Error | errs) => GraphQL ctx errs gql -> ctx -> { exception :: Error -> Aff GraphQLResponse | r } -> Fastify -> Effect Unit

type EntityResolvers :: Type -> Row Type -> Typetype EntityResolvers ctx errs = Map String (EntityDef ctx errs)

type EntityResolver :: Type -> Row Type -> Typetype EntityResolver ctx errs = Map String InputValue -> Step ctx errs

type EntityDef :: Type -> Row Type -> Typetype EntityDef ctx errs = { keys :: Array String, resolver :: EntityResolver ctx errs }

data Subscription result

data Query args result

data Mutation args result

type GraphQLResponse = { data :: ResponseValue, errors :: Array GraphQLError, extensions :: Object ResponseValue }

type GraphQLError = { extensions :: Object ResponseValue, locations :: Array SourceLocation, message :: String, path :: Array PathSegment }

responseToResponseValue :: GraphQLResponse -> ResponseValue

mkResponseWithErrors :: ResponseValue -> Array GraphQLError -> GraphQLResponse

mkResponse :: ResponseValue -> GraphQLResponse

mkErrorWithExtensions :: String -> Object ResponseValue -> GraphQLError

mkErrorWithCode :: String -> String -> GraphQLError

mkErrorResponse :: Array GraphQLError -> GraphQLResponse

mkErrorAt :: String -> Array PathSegment -> GraphQLError

mkError :: String -> GraphQLError

type SubscriptionHandler = { fieldName :: String, selections :: Array Selection, send :: ResponseValue -> Effect Unit } -> Effect (Effect Unit)

handleGraphQLWS :: forall ctx errs gql. GraphQL ctx errs gql -> (forall a. Om ctx errs a -> Aff a) -> SubscriptionHandler -> WebSocket -> Effect { onClose :: Effect Unit, onMessage :: String -> Effect Unit }

queryWith :: forall ctx errs gql. Array (Wrapper ctx errs) -> GraphQL ctx errs gql -> String -> Om ctx errs GraphQLResponse

Execute a GraphQL query string with wrappers

query :: forall ctx errs gql. GraphQL ctx errs gql -> String -> Om ctx errs GraphQLResponse

Execute a GraphQL query string against a schema

executeRequestWith :: forall ctx errs gql. Array (Wrapper ctx errs) -> GraphQL ctx errs gql -> GraphQLRequest -> Om ctx errs GraphQLResponse

Execute a GraphQL request with wrappers applied

executeRequest :: forall ctx errs gql. GraphQL ctx errs gql -> GraphQLRequest -> Om ctx errs GraphQLResponse

Execute a GraphQL request against a schema, returning a structured response

data InputValue

Constructors

• InputString String
• InputInt Int
• InputNumber Number
• InputBoolean Boolean
• InputEnum String
• InputList (Array InputValue)
• InputNull

Instances

• Eq InputValue
• Ord InputValue
• Show InputValue

data InputError

Constructors

• MissingArgument String
• TypeMismatch { expected :: String, got :: InputValue }
• ArgumentError { argument :: String, error :: InputError }
• UnknownEnumValue String

Instances

• Eq InputError
• Show InputError

class FromInputValue a 

Instances

• FromInputValue String
• FromInputValue Int
• FromInputValue Number
• FromInputValue Boolean
• (FromInputValue a) => FromInputValue (Maybe a)
• (FromInputValue a) => FromInputValue (Array a)
• (FromInputValue a) => FromInputValue (Defaulted value a)
• (RowToList r rl, FromInputRecord rl r) => FromInputValue (Record r)

newtypeFromInputValue :: forall a r rl. Newtype a (Record r) => RowToList r rl => FromInputRecord rl r => InputValue -> Either InputError a

data Union

data TimeUnit

data Seconds :: TimeUnitdata Seconds

Instances

• ToSeconds Seconds

data Scalar

newtype Private a

Instances

• Newtype (Private a) _
• (HasGqlName a) => HasGqlName (Private a)
• (HasGqlCacheControl a) => HasGqlCacheControl (Private a)

data Object

newtype Named :: Symbol -> Type -> Typenewtype Named gqlName a

Instances

• (HasGqlDescription a) => HasGqlDescription (Named gqlName a)
• (HasGqlDeprecated a) => HasGqlDeprecated (Named gqlName a)
• (HasGqlDefaultValue a) => HasGqlDefaultValue (Named gqlName a)
• (HasGqlCost a) => HasGqlCost (Named gqlName a)
• Newtype (Named gqlName a) _
• (IsSymbol gqlName) => HasGqlName (Named gqlName a)
• (HasGqlCacheControl a) => HasGqlCacheControl (Named gqlName a)

newtype Name :: Symbol -> Type -> Typenewtype Name name a

Instances

• Newtype (Name name a) _

data Minutes :: TimeUnitdata Minutes

Instances

• ToSeconds Minutes

newtype MaxAge :: Int -> TimeUnit -> Type -> Typenewtype MaxAge n unit a

Instances

• Newtype (MaxAge n unit a) _
• (HasGqlName a) => HasGqlName (MaxAge n unit a)
• (Reflectable n Int, ToSeconds unit) => HasGqlCacheControl (MaxAge n unit a)

data Interface

data InputObject

data Hours :: TimeUnitdata Hours

Instances

• ToSeconds Hours

newtype GqlUnion_ :: Symbol -> Type -> Typenewtype GqlUnion_ name a

Constructors

• GqlUnion_ a

Instances

• Newtype (GqlUnion_ name a) _

newtype GqlObject_ :: Symbol -> Type -> Typenewtype GqlObject_ name a

Constructors

• GqlObject_ a

Instances

• Newtype (GqlObject_ name a) _

newtype GqlInputObject_ :: Symbol -> Type -> Typenewtype GqlInputObject_ name a

Constructors

• GqlInputObject_ a

Instances

• Newtype (GqlInputObject_ name a) _

newtype GqlEnum_ :: Symbol -> Type -> Typenewtype GqlEnum_ name a

Constructors

• GqlEnum_ a

Instances

• Newtype (GqlEnum_ name a) _

newtype Excluded a

Instances

• Newtype (Excluded a) _
• HasGqlExcluded (Excluded a)

data Enum

newtype Described :: Symbol -> Type -> Typenewtype Described desc a

Instances

• (IsSymbol desc) => HasGqlDescription (Described desc a)
• (HasGqlDefaultValue a) => HasGqlDefaultValue (Described desc a)
• (HasGqlCost a) => HasGqlCost (Described desc a)
• Newtype (Described desc a) _
• (HasGqlName a) => HasGqlName (Described desc a)
• (HasGqlCacheControl a) => HasGqlCacheControl (Described desc a)

newtype Deprecated :: Symbol -> Type -> Typenewtype Deprecated reason a

Instances

• (IsSymbol reason) => HasGqlDeprecated (Deprecated reason a)
• (HasGqlDefaultValue a) => HasGqlDefaultValue (Deprecated reason a)
• (HasGqlCost a) => HasGqlCost (Deprecated reason a)
• Newtype (Deprecated reason a) _
• (HasGqlName a) => HasGqlName (Deprecated reason a)
• (HasGqlCacheControl a) => HasGqlCacheControl (Deprecated reason a)

newtype Cost :: Int -> Type -> Typenewtype Cost cost a

Instances

• (Reflectable cost Int) => HasGqlCost (Cost cost a)
• Newtype (Cost cost a) _
• (HasGqlName a) => HasGqlName (Cost cost a)
• (HasGqlCacheControl a) => HasGqlCacheControl (Cost cost a)

class IsGql :: Type -> Symbol -> Type -> Constraintclass IsGql kind name a | a -> kind name

class ToSeconds :: TimeUnit -> Constraintclass ToSeconds unit 

Instances

• ToSeconds Seconds
• ToSeconds Minutes
• ToSeconds Hours

private :: forall a. a -> Private a

named :: forall @gqlName a. a -> Named gqlName a

nameType :: forall @name a. a -> Name name a

maxAge :: forall @n @unit a. a -> MaxAge n unit a

excluded :: forall a. a -> Excluded a

described :: forall @desc a. a -> Described desc a

deprecated :: forall @reason a. a -> Deprecated reason a

cost :: forall @cost a. a -> Cost cost a

type PersistedQueryCache = Ref (Map String String)

persistedQueries :: forall ctx errs gql. PersistedQueryCache -> (GraphQL ctx errs gql -> GraphQLRequest -> Om ctx errs GraphQLResponse) -> GraphQL ctx errs gql -> GraphQLRequest -> ResponseValue -> Om ctx errs GraphQLResponse

mkCache :: Effect PersistedQueryCache

type PageInfoRecord = { endCursor :: Maybe String, hasNextPage :: Boolean, hasPreviousPage :: Boolean, startCursor :: Maybe String }

type PageInfo = GqlObject_ "PageInfo" PageInfoRecord

newtype Edge a

Constructors

• Edge { cursor :: String, node :: a }

Instances

• Newtype (Edge a) _

type ConnectionArgs = { after :: Maybe String, before :: Maybe String, first :: Maybe Int, last :: Maybe Int }

newtype Connection a

Constructors

• Connection { edges :: Array (Edge a), pageInfo :: PageInfo, totalCount :: Maybe Int }

Instances

• Newtype (Connection a) _

mkConnection :: forall a. { edges :: Array (Edge a), hasNextPage :: Boolean, hasPreviousPage :: Boolean, totalCount :: Maybe Int } -> Connection a

emptyConnection :: forall a. Connection a

connectionFromArray :: forall a. Array a -> ConnectionArgs -> Connection a

data ResponseValue

Constructors

• ObjectValue (Object ResponseValue)
• ListValue (Array ResponseValue)
• StringValue String
• IntValue Int
• NumberValue Number
• BooleanValue Boolean
• EnumValue String
• NullValue

Instances

• Eq ResponseValue
• Ord ResponseValue
• Show ResponseValue
• WriteForeign ResponseValue
• ReadForeign ResponseValue

type GraphQL :: Type -> Row Type -> Type -> Typetype GraphQL ctx errs schemaGql = { mutation :: Maybe GqlType, mutationStep :: Maybe (Step ctx errs), query :: GqlType, queryStep :: Step ctx errs, subscription :: Maybe GqlType, subscriptionStep :: Maybe (Step ctx errs) }

class ImplType :: Type -> Row Type -> RowList Type -> Row Type -> Constraintclass ImplType (ctx :: Type) (errs :: Row Type) (schemaRL :: RowList Type) (implRow :: Row Type) | ctx errs schemaRL -> implRow

Derives the Om-wrapped implementation row from a pure schema row. Plain fields get wrapped in Om, function fields get their return type wrapped.

Instances

• ImplType ctx errs Nil ()
• (ImplType ctx errs tail tailImpl, Cons name (Record args -> Om ctx errs result) tailImpl implRow, Lacks name tailImpl) => ImplType ctx errs (Cons name (Query (Record args) result) tail) implRow
• (ImplType ctx errs tail tailImpl, Cons name (Om ctx errs ty) tailImpl implRow, Lacks name tailImpl) => ImplType ctx errs (Cons name (Query Unit ty) tail) implRow
• (ImplType ctx errs (Cons name inner tail) implRow) => ImplType ctx errs (Cons name (Described desc inner) tail) implRow
• (ImplType ctx errs (Cons name inner tail) implRow) => ImplType ctx errs (Cons name (Cost cost inner) tail) implRow
• (ImplType ctx errs (Cons name inner tail) implRow) => ImplType ctx errs (Cons name (MaxAge n unit inner) tail) implRow
• (ImplType ctx errs (Cons name inner tail) implRow) => ImplType ctx errs (Cons name (Private inner) tail) implRow

class RecordRow :: Type -> Row Type -> Constraintclass RecordRow (rec :: Type) (row :: Row Type) | rec -> row

Extracts the row from a Record type

Instances

• RecordRow (Record row) row

withFederation :: forall ctx errs gql. EntityResolvers ctx errs -> GraphQL ctx errs gql -> GraphQL ctx errs gql

mkGraphQL' :: forall ctx errs q qGql. GqlSchema ctx errs (Record q) qGql => { introspection :: Boolean } -> Record q -> GraphQL ctx errs qGql

mkGraphQL :: forall ctx errs q qGql. GqlSchema ctx errs (Record q) qGql => Record q -> GraphQL ctx errs qGql

graphql :: forall @schema schemaRow schemaRL ctx errs implRow qRow mRow sRow qGql mGql sGql. RecordRow schema schemaRow => RowToList schemaRow schemaRL => SplitSchema ctx errs schemaRL implRow qRow mRow sRow => GqlSchema ctx errs (Record qRow) qGql => GqlSchema ctx errs (Record mRow) mGql => GqlSchema ctx errs (Record sRow) sGql => Record implRow -> GraphQL ctx errs qGql

executeQuery :: forall ctx errs schemaGql. GraphQL ctx errs schemaGql -> Array Selection -> Om ctx errs ResponseValue

executeOperation :: forall ctx errs schemaGql. GraphQL ctx errs schemaGql -> ParsedOperation -> Om ctx errs ResponseValue

toSDL :: forall r. { mutation :: Maybe GqlType, query :: GqlType, subscription :: Maybe GqlType | r } -> String

federationSDL :: forall r. { mutation :: Maybe GqlType, query :: GqlType, subscription :: Maybe GqlType | r } -> String

newtype ID

GraphQL ID scalar — accepts both String and Int inputs

Constructors

• ID String

Instances

• Eq ID
• Ord ID
• Show ID
• FromInputValue ID

class GqlSchema :: Type -> Row Type -> Type -> Type -> Constraintclass GqlSchema ctx errs a gql | a -> gql

Maps a PureScript type to its GraphQL type-level representation and runtime behavior. The fundep a -> gql means the GraphQL schema shape is fully determined by the PureScript type.

Instances

• GqlSchema ctx errs String (GqlNonNull GqlString)
• GqlSchema ctx errs Int (GqlNonNull GqlInt)
• GqlSchema ctx errs Number (GqlNonNull GqlFloat)
• GqlSchema ctx errs Boolean (GqlNonNull GqlBoolean)
• GqlSchema ctx errs ID (GqlNonNull GqlID)
• (GqlSchema ctx errs a gql, StripNonNull gql inner) => GqlSchema ctx errs (Maybe a) (GqlNullable inner)
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Array a) (GqlNonNull (GqlList gql))
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Om ctx errs a) gql
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (EventSource a) gql
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Edge a) (GqlNonNull (GqlObject "Edge" ()))
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Connection a) (GqlNonNull (GqlObject "Connection" ()))
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Described desc a) gql
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Deprecated reason a) gql
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Defaulted value a) gql
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Cost cost a) gql
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (MaxAge n unit a) gql
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Named gqlName a) gql
• (IsSymbol name, GqlSchema ctx errs a gql) => GqlSchema ctx errs (Name name a) gql
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Excluded a) gql
• (GqlSchema ctx errs a gql) => GqlSchema ctx errs (Private a) gql
• (RowToList args argsRL, FromInputRecord argsRL args, GqlSchemaArgs ctx errs argsRL, GqlSchema ctx errs a gql, ToGqlArgs argsRL argsGql, Cons "wrongArgumentType" String errs_ errs) => GqlSchema ctx errs (Record args -> a) gql
• (RowToList r rl, GqlSchemaFields ctx errs rl r fieldsGql) => GqlSchema ctx errs (Record r) (GqlNonNull (GqlObject "Object" fieldsGql))
• (IsSymbol name, RowToList r rl, GqlSchemaFields ctx errs rl r fieldsGql) => GqlSchema ctx errs (GqlObject_ name (Record r)) (GqlNonNull (GqlObject name fieldsGql))
• (IsSymbol name, Newtype a (Record r), RowToList r rl, GqlSchemaFields ctx errs rl r fieldsGql) => GqlSchema ctx errs (GqlObject_ name a) (GqlNonNull (GqlObject name fieldsGql))
• (IsSymbol name, Generic a rep, GqlEnumValues rep, GqlEnumResolve rep) => GqlSchema ctx errs (GqlEnum_ name a) (GqlNonNull (GqlEnum name))
• (IsSymbol name, RowToList row rl, GqlVariantMembers ctx errs rl row) => GqlSchema ctx errs (GqlUnion_ name (Variant row)) (GqlNonNull (GqlUnion name ()))
• (IsSymbol name, Newtype a (Variant row), RowToList row rl, GqlVariantMembers ctx errs rl row) => GqlSchema ctx errs (GqlUnion_ name a) (GqlNonNull (GqlUnion name ()))
• (IsSymbol name, RowToList r rl, GqlSchemaArgs ctx errs rl) => GqlSchema ctx errs (GqlInputObject_ name (Record r)) (GqlNonNull (GqlInputObject name ()))
• (IsSymbol name, Newtype a (Record r), RowToList r rl, GqlSchemaArgs ctx errs rl) => GqlSchema ctx errs (GqlInputObject_ name a) (GqlNonNull (GqlInputObject name ()))
• (IsGql kind name a, IsSymbol name, GqlSchemaByKind ctx errs kind name a gql) => GqlSchema ctx errs a gql

genericFromInputValue :: forall a rep. Generic a rep => GqlEnumResolve rep => InputValue -> Either InputError a

newtype EventSource a

An EventSource emits values to subscribers.

subscribe :: forall a m. MonadEffect m => EventSource a -> (a -> Effect Unit) -> m (Effect Unit)

Subscribe to an EventSource. Returns an unsubscribe effect.

mkEventSource :: forall a m. MonadEffect m => m (EventSource a)

Create a new EventSource.

emit :: forall a m. MonadEffect m => EventSource a -> a -> m Unit

Emit a value to all current subscribers.

apolloTracing :: forall ctx errs. Effect (Array (Wrapper ctx errs))

data GqlTypeKind

Constructors

• Scalar
• Object
• Interface
• Union
• Enum
• List
• NonNull

Instances

• Eq GqlTypeKind
• Ord GqlTypeKind
• Show GqlTypeKind

data GqlType

Constructors

• NamedType { description :: Maybe String, enumValues :: Array String, fields :: Array GqlField, keys :: Array String, kind :: GqlTypeKind, name :: String, possibleTypes :: Array String }
• ListType GqlType
• NonNullType GqlType

type GqlInputValue = { defaultValue :: Maybe String, description :: Maybe String, name :: String, type :: GqlType }

type GqlField = { args :: Array GqlInputValue, cost :: Int, deprecationReason :: Maybe String, description :: Maybe String, isDeprecated :: Boolean, isPrivate :: Boolean, maxAge :: Maybe Seconds, name :: String, type :: GqlType }

newtype Upload

Upload scalar for GraphQL file uploads. At the schema level, Upload is a String scalar (filename). Actual file data is injected by the multipart HTTP handler.

Constructors

• Upload String

Instances

• Newtype Upload _
• IsGql Scalar "Upload" Upload
• FromInputValue Upload

registerMultipart :: Fastify -> Effect Unit

data WebSocket

send :: WebSocket -> String -> Effect Unit

close :: WebSocket -> Effect Unit

data Wrapper :: Type -> Row Type -> Typedata Wrapper ctx errs

A collection of wrappers that can be applied to a schema

data FieldWrapper :: Type -> Row Type -> Typedata FieldWrapper ctx errs

Field wrapper: wraps individual field resolution

Constructors

• FieldWrapper (String -> String -> Om ctx errs ResponseValue -> Om ctx errs ResponseValue)

validateLimitsFor :: forall ctx errs gql. { query :: GqlType | gql } -> { maxCost :: Maybe Int, maxDepth :: Maybe Int, maxFields :: Maybe Int } -> Wrapper ctx errs

validateLimits :: forall ctx errs. GqlType -> { maxCost :: Maybe Int, maxDepth :: Maybe Int, maxFields :: Maybe Int } -> Wrapper ctx errs

Pre-built wrapper: check depth, field count, and cost in a single pass

timeout :: forall ctx errs. Int -> Wrapper ctx errs

Pre-built wrapper: apply a timeout to execution (in milliseconds)

maxFields :: forall ctx errs. Int -> Wrapper ctx errs

Pre-built wrapper: reject queries with more than maxFields total fields

maxDepth :: forall ctx errs. Int -> Wrapper ctx errs

Pre-built wrapper: reject queries deeper than maxDepth

maxCostFor :: forall ctx errs gql. { query :: GqlType | gql } -> Int -> Wrapper ctx errs

maxCost :: forall ctx errs. GqlType -> Int -> Wrapper ctx errs

Pre-built wrapper: reject queries exceeding a cost budget

logSlowFields :: forall ctx errs. Int -> Wrapper ctx errs

Pre-built wrapper: log fields that take longer than a threshold (in milliseconds)

newtype Om :: Type -> Row Type -> Type -> Typenewtype Om ctx err a

"dependency injection" via ReaderT which tracks a context, and checked exceptions and early return with ExceptV.

Instances

• Newtype (Om ctx err a) _
• Functor (Om ctx err)
• Applicative (Om ctx err)
• Apply (Om ctx err)
• Bind (Om ctx err)
• Monad (Om ctx err)
• MonadEffect (Om ctx err)
• MonadAff (Om ctx err)
• MonadAsk ctx (Om ctx err)
• MonadReader ctx (Om ctx err)
• MonadThrow (Variant (Exception err)) (Om ctx err)
• MonadError (Variant (Exception err)) (Om ctx err)
• MonadRec (Om ctx err)
• (Semigroup a) => Semigroup (Om ctx err a)
• Alt (Om ctx err)
• Plus (Om ctx err)
• (RowToList ctx ctxRL, RowToList err errRL, Union ctx _c ctxRow, Keys ctx, Union err _e errRow) => Mapping (ExpandAndRun ctxRow errRow) (Om (Record ctx) err a) (Aff a)
• (IsSymbol sym, Cons sym a rb rc, Lacks sym rb, RowToList cSmall _cRL, RowToList eSmall _eRL, Union cSmall _c ctxRow, Keys cSmall, Union eSmall _e err) => FoldingWithIndex (SequenceOm ctxRow err) (Proxy sym) (Om (Record ctxRow) err (Builder (Record ra) (Record rb))) (Om (Record cSmall) eSmall a) (Om (Record ctxRow) err (Builder (Record ra) (Record rc)))
• (RowToList ctx ctxRL, RowToList err errRL) => Mapping CloseOmRows (Om (Record ctx) err a) (Om (Record ctx) err a)
• Parallel (ParOm ctx err) (Om ctx err)

toOm :: forall f ctx err a. ToOm f => f a -> Om ctx err a

runOm :: forall ctx r rl err_ err a. RowToList (exception :: Error -> Aff a | r) rl => VariantMatchCases rl err_ (Aff a) => Union err_ () (Exception err) => ctx -> { exception :: Error -> Aff a | r } -> Om ctx err a -> Aff a

Invoke this function in the end and handle all possible errors, e.g.

runOm { token: "123" } { someError: \e -> handleTheError e } someApp

inParallel :: forall ctx e a. Array (Om ctx e a) -> Om ctx e (Array a)

Run multiple Oms in parallel, and collect all results To only take the fastest result, use race

ask :: forall r m. MonadAsk r m => m r