open System

open System.Reflection

open System.Collections

open System.Collections.Concurrent

open System.Collections.Generic

open System.Collections.Immutable

open System.Text.Json

open FSharp.Data.GraphQL

open FSharp.Data.GraphQL.Ast

open FSharp.Data.GraphQL.Extensions

open FSharp.Quotations

open FSharp.Quotations.Patterns

open FSharp.Reflection

open FSharp.Linq.RuntimeHelpers

type DirectiveLocation =

| QUERY = 1

| MUTATION = 2

| SUBSCRIPTION = 4

| FIELD = 8

| FRAGMENT_DEFINITION = 16

| FRAGMENT_SPREAD = 32

| INLINE_FRAGMENT = 64

| SCHEMA = 128

| SCALAR = 256

| OBJECT = 512

| FIELD_DEFINITION = 1024

| ARGUMENT_DEFINITION = 2048

| INTERFACE = 4096

| UNION = 8192

| ENUM = 16384

| ENUM_VALUE = 32768

| INPUT_OBJECT = 65536

| INPUT_FIELD_DEFINITION = 131072

/// Type kind. GraphQL type system puts all types into one of eight categories.

type TypeKind =

| SCALAR = 1

| OBJECT = 2

| INTERFACE = 3

| UNION = 4

| ENUM = 5

| INPUT_OBJECT = 6

| LIST = 7

| NON_NULL = 8

/// Introspection descriptor of a directive (i.e. @skip(if:...), @include(if:...) etc).

type IntrospectionDirective =

{ /// Directive name.

Name : string

/// Description of a target directive.

Description : string option

/// Array of AST locations, where it's valid to place target directive.

Locations : DirectiveLocation []

/// Array of arguments, current directive can be parametrized with.

Args : IntrospectionInputVal [] }

/// Introspection descriptor of a GraphQL type defintion.

and IntrospectionType =

{ /// Which kind category current type belongs to.

Kind : TypeKind

/// Type name. Must be unique in scope of the defined schema.

Name : string

/// Optional type description.

Description : string option

/// Array of field descriptors defined within current type.

/// Only present for Object and Interface types.

Fields : IntrospectionField [] option

/// Array of interfaces implemented by output object type defintion.

Interfaces : IntrospectionTypeRef [] option

/// Array of type references being possible implementation of current type.

/// Only present for Union types (list of union cases) and Interface types

/// (list of all objects implementing interface in scope of the schema).

PossibleTypes : IntrospectionTypeRef [] option

/// Array of enum values defined by current Enum type.

EnumValues : IntrospectionEnumVal [] option

/// Array of input fields defined by current InputObject type.

InputFields : IntrospectionInputVal [] option

/// Type param reference - used only by List and NonNull types.

OfType : IntrospectionTypeRef option }

/// <summary>

/// Constructs an introspection descriptor for a <see cref="TypeKind.SCALAR"/> types.

/// </summary>

/// <param name="name">Type name (unique in the scope of current schema).</param>

/// <param name="description">Optional type description.</param>

static member Scalar(name : string, description : string option) =

{ Kind = TypeKind.SCALAR

Name = name

Description = description

Fields = None

Interfaces = None

PossibleTypes = None

EnumValues = None

InputFields = None

OfType = None }

/// <summary>

/// Constructs an introspection descriptor for a <see cref="TypeKind.OBJECT"/> types.

/// </summary>

/// <param name="name">Type name (unique in the scope of current schema).</param>

/// <param name="description">Optional type description.</param>

/// <param name="fields">Array of fields defined in current object.</param>

/// <param name="interfaces">Array of interfaces, current object implements.</param>

static member Object(name : string, description : string option, fields : IntrospectionField [],

interfaces : IntrospectionTypeRef []) =

{ Kind = TypeKind.OBJECT

Name = name

Description = description

Fields = Some fields

Interfaces = Some interfaces

PossibleTypes = None

EnumValues = None

InputFields = None

OfType = None }

/// <summary>

/// Constructs an introspection descriptor for a <see cref="TypeKind.INPUT_OBJECT"/> types.

/// </summary>

/// <param name="name">Type name (unique in the scope of current schema).</param>

/// <param name="description">Optional type description.</param>

/// <param name="inputFields">Array of input fields defined in current input object.</param>

static member InputObject(name : string, description : string option, inputFields : IntrospectionInputVal []) =

{ Kind = TypeKind.INPUT_OBJECT

Name = name

Description = description

Fields = None

Interfaces = None

PossibleTypes = None

EnumValues = None

InputFields = Some inputFields

OfType = None }

/// <summary>

/// Constructs an introspection descriptor for a <see cref="TypeKind.UNION"/> types.

/// </summary>

/// <param name="name">Type name (unique in the scope of current schema).</param>

/// <param name="description">Optional type description.</param>

/// <param name="possibleTypes">Array of union case types. They can be any type defined in GraphQL schema.</param>

static member Union(name : string, description : string option, possibleTypes : IntrospectionTypeRef []) =

{ Kind = TypeKind.UNION

Name = name

Description = description

Fields = None

Interfaces = None

PossibleTypes = Some possibleTypes

EnumValues = None

InputFields = None

OfType = None }

/// <summary>

/// Constructs an introspection descriptor for a <see cref="TypeKind.ENUM"/> types.

/// </summary>

/// <param name="name">Type name (unique in the scope of current schema).</param>

/// <param name="description">Optional type description.</param>

/// <param name="enumValues">Array of enum value descriptors.</param>

static member Enum(name : string, description : string option, enumValues : IntrospectionEnumVal []) =

{ Kind = TypeKind.ENUM

Name = name

Description = description

Fields = None

Interfaces = None

PossibleTypes = None

EnumValues = Some enumValues

InputFields = None

OfType = None }

/// <summary>

/// Constructs an introspection descriptor for a <see cref="TypeKind.INTERFACE"/> types.

/// </summary>

/// <param name="name">Type name (unique in the scope of current schema).</param>

/// <param name="description">Optional type description.</param>

/// <param name="fields">Array of fields being part of the interface contract.</param>

/// <param name="possibleTypes">Array of schema objects implementing target interface.</param>

static member Interface(name : string, description : string option, fields : IntrospectionField [],

possibleTypes : IntrospectionTypeRef []) =

{ Kind = TypeKind.INTERFACE

Name = name

Description = description

Fields = Some fields

Interfaces = None

PossibleTypes = Some possibleTypes

EnumValues = None

InputFields = None

OfType = None }

/// Introspection type reference. Used to navigate between type dependencies inside introspected schema.

and IntrospectionTypeRef =

{ /// Referenced type kind.

Kind : TypeKind

/// Type name. None if referenced type is List or NonNull.

Name : string option

/// Optional type description.

Description : string option

/// Type param reference. Used only by List and NonNull types.

OfType : IntrospectionTypeRef option }

/// <summary>

/// Constructs an introspection type reference for List types.

/// </summary>

/// <param name="inner">Type reference for type used as List's type param.</param>

static member List(inner : IntrospectionTypeRef) =

{ Kind = TypeKind.LIST

Name = None

Description = None

OfType = Some inner }

/// <summary>

/// Constructs an introspection type reference for NonNull types.

/// </summary>

/// <param name="inner">Type reference for type used as NonNull's type param.</param>

static member NonNull(inner : IntrospectionTypeRef) =

{ Kind = TypeKind.NON_NULL

Name = None

Description = None

OfType = Some inner }

/// <summary>

/// Constructs an introspection type reference for any named type defintion

/// (any type other than List or NonNull) with unique name included.

/// </summary>

/// <param name="inner">Introspection type descriptor to construct reference from.</param>

static member Named(inner : IntrospectionType) =

{ Kind = inner.Kind

Name = Some inner.Name

Description = inner.Description

OfType = None }

/// Introspection descriptor for input values (InputObject fields or field arguments).

and IntrospectionInputVal =

{ /// Input argument name.

Name : string

/// Optional input argument description.

Description : string option

/// Introspection reference to argument's type.

Type : IntrospectionTypeRef

/// Default arguments value, if provided.

DefaultValue : string option }

/// Introspection descriptor for enum values.

and IntrospectionEnumVal =

{ /// Enum value name - must be unique in scope of defining enum.

Name : string

/// Optional enum value description.

Description : string option

/// If true, marks current value as deprecated, but still

/// available for compatibility reasons.

IsDeprecated : bool

/// If value is deprecated this field may describe a deprecation reason.

DeprecationReason : string option }

/// Introspection descriptor for Object and Interface fields.

and IntrospectionField =

{ /// Field name. Must be unique in scope of the definin object/interface.

Name : string

/// Optional field description.

Description : string option

/// Array of field arguments. In GraphQL fields can be parametrized,

/// working effectively like methods.

Args : IntrospectionInputVal []

/// Introspection reference to field's type.

Type : IntrospectionTypeRef

/// If true, marks current field as deprecated, but still

/// available for compatibility reasons.

IsDeprecated : bool

/// If field is deprecated here a deprecation reason may be set.

DeprecationReason : string option }

/// Introspection descriptor for target schema. Contains informations about

/// all types defined within current schema.

and IntrospectionSchema =

{ /// Introspection reference to schema's query root.

QueryType : IntrospectionTypeRef

/// Introspection reference to schema's mutation root.

MutationType : IntrospectionTypeRef option

/// Introspection reference to schema's subscription root.

SubscriptionType : IntrospectionTypeRef option

/// Array of all introspection types defined within current schema.

/// Includes types for queries, mutations and subscriptions.

Types : IntrospectionType array

/// Array of all directives supported by current schema.

Directives : IntrospectionDirective array }

type Subscription = {

/// The name of the subscription type in the schema.

Name : string

/// Filter function, used to determine what events we will propagate.

/// The first object is the boxed root value, the second is the boxed value of the input object.

Filter : ResolveFieldContext -> obj -> obj -> Async<obj option> }

and ISubscriptionProvider =

interface

/// Registers a new subscription type, called at schema compilation time.

abstract member AsyncRegister : Subscription -> Async<unit>

/// Creates an active subscription, and returns the IObservable stream of POCO objects that will be projected on.

abstract member Add : ResolveFieldContext -> obj -> SubscriptionFieldDef -> IObservable<obj>

/// Publishes an event to the subscription system given the identifier of the subscription type.

abstract member AsyncPublish<'T> : string -> 'T -> Async<unit>

/// Publishes an event to the subscription system given the identifier of the subscription type

/// and a filter identity that can be used to choose which filter functions will be applied.

abstract member AsyncPublishTag<'T> : string -> Tag -> 'T -> Async<unit>

end

and ILiveFieldSubscription =

interface

/// Determine if we should propagate the event

abstract member Filter : obj -> obj -> bool

/// Project out the field marked with the @live directive

abstract member Project : obj -> obj

/// The type name of the object that is ready for live query in this subscription.

abstract member TypeName : string

/// The field name of the object that is ready for live query in this subscription.

abstract member FieldName : string

end

and ILiveFieldSubscription<'Object, 'Field> =

interface

inherit ILiveFieldSubscription

/// Determine if we should propagate the event

abstract member Filter : 'Object -> 'Object -> bool

/// Project out the field marked with the @live directive

abstract member Project : 'Object -> 'Field

end

and LiveFieldSubscription =

{ /// Determine if we should propagate the event

Filter : obj -> obj -> bool

/// Project out the field marked with the @live directive

Project : obj -> obj

/// The type name of the object that is ready for live query in this subscription.

TypeName : string

/// The field name of the object that is ready for live query in this subscription.

FieldName : string }

interface ILiveFieldSubscription with

member this.Filter x y = this.Filter x y

member this.Project x = this.Project x

member this.TypeName = this.TypeName

member this.FieldName = this.FieldName

and LiveFieldSubscription<'Object, 'Field> =

{ /// Determine if we should propagate the event

Filter : 'Object -> 'Object -> bool

/// Project out the field marked with the @live directive

Project : 'Object -> 'Field

/// The type name of the object that is ready for live query in this subscription.

TypeName : string

/// The field name of the object that is ready for live query in this subscription.

FieldName : string }

interface ILiveFieldSubscription<'Object, 'Field> with

member this.Filter x y = this.Filter x y

member this.Project x = this.Project x

interface ILiveFieldSubscription with

member this.Filter x y = this.Filter (downcast x) (downcast y)

member this.Project x = upcast this.Project (downcast x)

member this.TypeName = this.TypeName

member this.FieldName = this.FieldName

and ILiveFieldSubscriptionProvider =

interface

/// Checks if a live field subscription has subscribers.

abstract member HasSubscribers : string -> string -> bool

/// Checks if a type and a field is registered in the provider.

abstract member IsRegistered : string -> string -> bool

/// Registers a new live query subscription type, called at schema compilation time.

abstract member AsyncRegister : ILiveFieldSubscription -> Async<unit>

/// Tries to find a subscription based on the type name and field name.

abstract member TryFind : string -> string -> ILiveFieldSubscription option

/// Creates an active subscription, and returns the IObservable stream of projected POCO objects

abstract member Add : (obj -> bool) -> string -> string -> IObservable<obj>

/// Publishes an event to the subscription system, given the key of the subscription type.

abstract member AsyncPublish<'T> : string -> string -> 'T -> Async<unit>

end

and ISchema =

interface

inherit seq<NamedDef>

/// Map of defined types by their names.

abstract TypeMap : TypeMap

/// A query root object. Defines all top level fields,

/// that can be accessed from GraphQL queries.

abstract Query : ObjectDef

/// A mutation root object. Defines all top level operations,

/// that can be performed from GraphQL mutations.

abstract Mutation : ObjectDef option

// A subscription root object. Defines all top level operations,

// that can be performed from GraphQL subscriptions.

abstract Subscription : SubscriptionObjectDef option

/// List of all directives supported by the current schema.

abstract Directives : DirectiveDef []

/// Method which, given type name, returns Some if provided

/// type has been defined in current schema. Otherwise None.

abstract TryFindType : string -> NamedDef option

/// Returns array of all possible types for provided abstract

/// type. For Union types, it's the array of all union options.

/// For Interface types, it's an array of all types - within

/// schema - implementing target interface.

abstract GetPossibleTypes : TypeDef -> ObjectDef []

/// Checks if provided object is a possible type type (case

/// for Unions and implementation for Interfaces) of provided

/// abstract type.

abstract IsPossibleType : AbstractDef -> ObjectDef -> bool

/// Returns an introspected representation of current schema.

abstract Introspected : Introspection.IntrospectionSchema

/// Returns a function called when errors occurred during query execution.

/// It's used to retrieve messages shown as output to the client.

/// May be also used to log messages before returning them.

abstract ParseError : FieldPath -> exn -> IGQLError list

/// Returns the subscription provider implementation for this schema.

abstract SubscriptionProvider : ISubscriptionProvider

/// Returns the live query subscription provider implementation for this schema.

abstract LiveFieldSubscriptionProvider : ILiveFieldSubscriptionProvider

end

and ISchema<'Root> =

interface

inherit ISchema

abstract Query : ObjectDef<'Root>

abstract Mutation : ObjectDef<'Root> option

abstract Subscription : SubscriptionObjectDef<'Root> option

end

and FieldExecuteCompiler = FieldDef -> ExecuteField

and FieldExecuteMap(compiler : FieldExecuteCompiler) =

let map = new Dictionary<string * string, ExecuteField * InputFieldDef []>()

let getKey typeName fieldName =

if List.exists ((=) fieldName) ["__schema"; "__type"; "__typename" ]

then "", fieldName

else typeName, fieldName

/// <summary>

/// Sets an execute function for a field of a named type of the schema.

/// </summary>

/// <param name="typeName">The type name of the parent object that has the field that needs to be executed.</param>

/// <param name="def">The FieldDef that will have its execute function configured into the FieldExecuteMap.</param>

/// <param name="overwrite">

/// If set to true, and an exists an entry with the <paramref name="typeName"/> and the name of the FieldDef,

/// then it will be overwritten.

/// </param>

member _.SetExecute(typeName: string, def: FieldDef, ?overwrite : bool) =

let overwrite = defaultArg overwrite false

let key = typeName, def.Name

let compiled = compiler def

let args = def.Args

match map.ContainsKey(key), overwrite with

| true, true -> map.Remove(key) |> ignore; map.Add(key, (compiled, args))

| false, _ -> map.Add(key, (compiled, args))

| _ -> ()

/// <summary>

/// Sets an execute function for a field of an unamed type in the schema.

/// </summary>

/// <param name="def">The FieldDef that will have its execute function configured into the FieldExecuteMap.</param>

/// <param name="overwrite">If set to true, and an exists an entry with the FieldDef name, then it will be overwritten.</param>

member this.SetExecute(def : FieldDef, ?overwrite : bool) =

let overwrite = defaultArg overwrite false

this.SetExecute("", def, overwrite)

/// <summary>

/// Gets an ExecuteField based on the name of the type and the name of the field.

/// </summary>

/// <param name="typeName">The type name of the parent object that has the field that needs to be executed.</param>

/// <param name="fieldName">The field name of the object that has the field that needs to be executed.</param>

member _.GetExecute(typeName: string, fieldName: string) =

let key = getKey typeName fieldName

if map.ContainsKey(key) then fst map.[key] else Unchecked.defaultof<ExecuteField>

/// <summary>

/// Gets the field arguments based on the name of the type and the name of the field.

/// </summary>

/// <param name="typeName">The type name of the parent object that has the field that needs to be executed.</param>

/// <param name="fieldName">The field name of the object that has the field that needs to be executed.</param>

member _.GetArgs(typeName : string, fieldName : string) =

let key = getKey typeName fieldName

if map.ContainsKey(key) then snd map.[key] else Unchecked.defaultof<InputFieldDef []>

interface IEnumerable<string * string * ExecuteField> with

member _.GetEnumerator() =

let seq = map |> Seq.map(fun kvp -> fst kvp.Key, snd kvp.Key, fst kvp.Value)

seq.GetEnumerator()

interface IEnumerable with

member _.GetEnumerator() =

let seq = map |> Seq.map(fun kvp -> fst kvp.Value)

upcast seq.GetEnumerator()

and TypeDef =

interface

/// Return .NET CLR type associated with current type definition.

abstract Type : Type

/// INTERNAL API: creates a List definition of a current type.

abstract MakeList : unit -> ListOfDef

/// INTERNAL API: creates a Nullable definition of a current type.

abstract MakeNullable : unit -> NullableDef

end

and TypeDef<'Val> =

interface

inherit TypeDef

end

and InputDef =

interface

inherit TypeDef

end

and InputDef<'Val> =

interface

inherit InputDef

inherit TypeDef<'Val>

end

and OutputDef =

interface

inherit TypeDef

end

and OutputDef<'Val> =

interface

inherit OutputDef

inherit TypeDef<'Val>

end

and LeafDef =

interface

inherit TypeDef

end

and CompositeDef =

interface

inherit TypeDef

end

and AbstractDef =

interface

inherit TypeDef

//NOTE: only abstract types are Interface and Union, which are both composite defs too

inherit CompositeDef

end

and NamedDef =

interface

inherit TypeDef

/// Returns a name of the current named type. It must be unique

/// in scope of the defining schema.

abstract Name : string

end

and PlanningContext =

{ Schema : ISchema

RootDef : ObjectDef

Document : Document

Operation : OperationDefinition

DocumentId : int

Metadata : Metadata }

and Includer = ImmutableDictionary<string, obj> -> Result<bool, IGQLError list>

and ExecutionInfo =

{ /// Field identifier, which may be either field name or alias. For top level execution plan it will be None.

Identifier : string

/// Field definition of corresponding type found in current schema.

Definition : FieldDef

/// AST node of the parsed query document.

Ast : Field

/// A type of execution plan.

Kind : ExecutionInfoKind

/// Logic describing, if correlated field should be included in result set.

Include : Includer

/// Composite definition being the parent of the current field, execution plan refers to.

ParentDef : OutputDef

/// Type definition marking returned type.

ReturnDef : OutputDef

/// Flag determining if flag allows to have nullable output.

IsNullable : bool }

/// Get a nested info recognized by path provided as parameter. Path may consist of fields names or aliases.

member this.GetPath (keys: string list) : ExecutionInfo option =

let rec path info segments =

match segments with

| [] ->

match info.Kind with

| ResolveCollection inner -> Some inner

| _ -> Some info

| head :: tail ->

match info.Kind with

| ResolveDeferred inner -> path inner segments

| ResolveLive inner -> path inner segments

| ResolveStreamed (inner, _) -> path inner segments

| ResolveValue -> None

| ResolveCollection inner -> path inner segments

| SelectFields fields ->

fields

|> List.tryFind (fun f -> f.Identifier = head)

|> Option.bind (fun f -> path f tail)

| ResolveAbstraction typeMap ->

typeMap

|> Map.toSeq

|> Seq.map snd

|> Seq.collect id

|> Seq.tryFind (fun f -> f.Identifier = head)

|> Option.bind (fun f -> path f tail)

path this keys

override this.ToString () =

let pad indent (sb: Text.StringBuilder) = for i = 0 to indent do sb.Append '\t' |> ignore

let nameAs info =

match info.Ast.Alias with

| Some alias ->

info.Ast.Name + " as " + alias + " of " + info.ReturnDef.ToString() + (if info.IsNullable then "" else "!")

| None -> info.Ast.Name + " of " + info.ReturnDef.ToString() + (if info.IsNullable then "" else "!")

let rec str indent sb info =

match info.Kind with

| ResolveValue ->

pad indent sb

sb.Append("ResolveValue: ").AppendLine(nameAs info) |> ignore

| ResolveDeferred inner ->

pad indent sb

sb.Append("ResolveDeferred: ").AppendLine(nameAs info) |> ignore

str (indent+1) sb inner

| ResolveLive inner ->

pad indent sb

sb.Append("ResolveLive: ").AppendLine(nameAs info) |> ignore

str (indent+1) sb inner

| ResolveStreamed (inner, mode) ->

pad indent sb

sb.Append("ResolveStreamed: ").AppendLine(nameAs info) |> ignore

str (indent+1) sb inner

| SelectFields fields ->

pad indent sb

sb.Append("SelectFields: ").AppendLine(nameAs info) |> ignore

fields |> List.iter (str (indent+1) sb)

| ResolveCollection inner ->

pad indent sb

sb.Append("ResolveCollection: ").AppendLine(nameAs info) |> ignore

str (indent+1) sb inner

| ResolveAbstraction types ->

pad indent sb

sb.Append("ResolveAbstraction: ").AppendLine(nameAs info) |> ignore

types

|> Map.iter (fun tname fields ->

pad (indent+1) sb

sb.Append("Case: ").AppendLine(tname) |> ignore

fields |> List.iter (str (indent+2) sb))

let sb = Text.StringBuilder ()

str 0 sb this

sb.ToString()

and ExecutionInfoKind =

/// Reduce scalar or enum to a returned value.

| ResolveValue

/// Reduce result set by selecting provided set of fields,

/// defined inside composite type, current execution info

/// refers to.

| SelectFields of fields : ExecutionInfo list

/// Reduce current field as a collection, applying provided

/// execution info on each of the collection's element.

| ResolveCollection of elementPlan : ExecutionInfo

/// Reduce union or interface types by applying provided set of

/// field infos depending on what concrete object implementation

/// will be found.

| ResolveAbstraction of typeFields : Map<string, ExecutionInfo list>

/// Reduce result set as a deferred result.

| ResolveDeferred of ExecutionInfo

/// Reduce the current field as a stream, applying

/// the provided execution info on each of the

/// collection's elements.

| ResolveStreamed of ExecutionInfo * BufferedStreamOptions

/// Reduce the current field as a live query.

| ResolveLive of ExecutionInfo

and BufferedStreamOptions =

{ /// The maximum time in milliseconds that the buffer will be filled before being sent to the subscriber.

Interval : int option

/// The maximum number of items that will be buffered before being sent to the subscriber.

PreferredBatchSize : int option }

and Resolve =

/// Resolve function hasn't been defined. Valid only for interface fields.

| Undefined

/// Resolve field value in synchronous way.

/// input defines .NET type of the provided object

/// output defines .NET type of the returned value

/// expr is untyped version of Expr<ResolveFieldContext->'Input->'Output>

| Sync of input:Type * output:Type * expr:Expr

/// Resolve field value as part of Async computation.

/// input defines .NET type of the provided object

/// output defines .NET type of the returned value

/// expr is untyped version of Expr<ResolveFieldContext->'Input->Async<'Output>>

| Async of input:Type * output:Type * expr:Expr

/// Resolves the filter function of a subscription.

/// root defines the .NET type of the root object

/// input defines the .NET type of the value being subscribed to

/// expr is the untyped version of Expr<ResolveFieldContext -> 'Root -> 'Input -> bool>

| Filter of root: Type * input:Type * output:Type * expr:Expr

/// Resolves the filter function of a subscription that has asyncronous fields.

/// root defines the .NET type of the root object

/// input defines the .NET type of the value being subscribed to

/// expr is the untyped version of Expr<ResolveFieldContext -> 'Root -> 'Input -> bool>

| AsyncFilter of root: Type * input:Type * output:Type * expr:Expr

| ResolveExpr of expr:Expr

/// Returns an expression defining resolver function.

member x.Expr =

match x with

| Sync(_,_,e) -> e

| Async(_,_,e) -> e

| ResolveExpr(e) -> e

| Undefined -> failwith "Resolve function was not defined"

| x -> failwith <| sprintf "Unexpected resolve function %A" x

and ExecutionStrategy =

/// Object fields will be resolved one-by-one. This is default option

/// for mutations.

| Sequential

/// Object fields will be reslved in parallel. It's only valid for

/// read-only operations like queries. It's not valid for mutations.

| Parallel

and VarDef =

{ /// Variable name without prefixed '$'.

Name: string

/// Type definition in corresponding GraphQL schema.

TypeDef: InputDef

/// Optional default value.

DefaultValue: InputValue option }

and SchemaCompileContext =

{ Schema : ISchema

TypeMap : TypeMap

FieldExecuteMap : FieldExecuteMap }

and ExecutionPlan =

{ /// Unique identifier of the current execution plan.

DocumentId : int

/// AST defintion of current operation.

Operation : OperationDefinition

/// Definition of the root type (either query or mutation) used by the

/// current operation.

RootDef : ObjectDef

/// Execution strategy applied on the underlying object's fields.

Strategy : ExecutionStrategy

/// List of fields of top level query/mutation object to be resolved.

Fields : ExecutionInfo list

/// List of variables defined within executed query.

Variables : VarDef list

/// A dictionary of metadata associated with custom operations on the planning of this plan.

Metadata : Metadata }

member x.Item with get(id) = x.Fields |> List.find (fun f -> f.Identifier = id)

and ExecutionContext =

{ /// GraphQL schema definition.

Schema : ISchema

/// Boxed value of the top level type, root query/mutation.

RootValue : obj

/// Execution plan describing, what fiedls are going to be resolved.

ExecutionPlan : ExecutionPlan

/// Collection of variables provided to execute current operation.

Variables : ImmutableDictionary<string, obj>

/// Collection of errors that occurred while executing current operation.

Errors : ConcurrentBag<exn>

/// A map of all fields of the query and their respective execution operations.

FieldExecuteMap : FieldExecuteMap

/// A simple dictionary to hold metadata that can be used by execution customizations.

Metadata : Metadata }

and ResolveFieldContext =

{ /// Fragment of the overall execution plan related to current field.

ExecutionInfo : ExecutionInfo

/// Current operation execution context.

Context : ExecutionContext

/// GraphQL type definition for the returned value.

ReturnType : TypeDef

/// GraphQL type definition for a parent object, current value needs

/// to be resolved from.

ParentType : ObjectDef

/// Current GraphQL schema.

Schema : ISchema

/// Untyped map of all argument values used for as current field's

/// parametrized inputs.

Args : Map<string, obj>

/// Variables provided by the operation caller.

Variables : ImmutableDictionary<string, obj>

/// Field path

Path : FieldPath }

/// Remembers an exception, so it can be included in the final response.

member x.AddError(error : exn) = x.Context.Errors.Add error

/// Tries to find an argument by provided name.

member x.TryArg(name : string) : 't option =

match Map.tryFind name x.Args with

| Some o -> Some(o :?> 't) // TODO: Use Convert.ChangeType

| None -> None

/// Returns an argument by provided name. If argument was not found a GraphQL exception will be thrown.

/// <exception cref="GraphQLException">When argument with the name not found in the Args.</exception>

member x.Arg(name : string) : 't =

match Map.tryFind name x.Args with

| Some found -> downcast found

| None -> raise (GraphQLException $"Argument '%s{name}' was not provided within context of a field '%s{x.ExecutionInfo.Identifier}'. Check if it was supplied within GraphQL query.")

and ExecuteField = ResolveFieldContext -> obj -> AsyncVal<obj>

and FieldDef =

interface

/// Name of the field.

abstract Name : string

/// Optional field description.

abstract Description : string option

/// Optional field deprecation warning.

abstract DeprecationReason : string option

/// Field's GraphQL type definition.

abstract TypeDef : OutputDef

/// Field's arguments list.

abstract Args : InputFieldDef []

/// Field's metadata.

abstract Metadata : Metadata

/// Field resolution function.

abstract Resolve : Resolve

// INTERNAL API: Compiled field executor. To be set only by the runtime.

inherit IEquatable<FieldDef>

end

and FieldDef<'Val> =

interface

inherit FieldDef

end

and [<CustomEquality; NoComparison>] internal FieldDefinition<'Val, 'Res> =

{ /// Name of the field.

Name : string

/// Optional field description.

Description : string option

/// Field's GraphQL type definition.

TypeDef : OutputDef<'Res>

/// Field resolution function.

Resolve : Resolve

/// Field's arguments list.

Args : InputFieldDef []

/// Optional field deprecation warning.

DeprecationReason : string option

/// Field metadata definition.

Metadata : Metadata }

interface FieldDef with

member x.Name = x.Name

member x.Description = x.Description

member x.DeprecationReason = x.DeprecationReason

member x.TypeDef = x.TypeDef :> OutputDef

member x.Args = x.Args

member x.Resolve = x.Resolve

member x.Metadata = x.Metadata

interface FieldDef<'Val>

interface IEquatable<FieldDef> with

member x.Equals f = x.Name = f.Name && x.TypeDef :> OutputDef = f.TypeDef && x.Args = f.Args

override x.Equals y =

match y with

| :? FieldDef as f -> (x :> IEquatable<FieldDef>).Equals(f)

| _ -> false

override x.GetHashCode() =

let mutable hash = x.Name.GetHashCode()

hash <- (hash * 397) ^^^ (x.TypeDef.GetHashCode())

hash <- (hash * 397) ^^^ (x.Args.GetHashCode())

hash

override x.ToString() =

if not (Array.isEmpty x.Args)

then x.Name + "(" + String.Join(", ", x.Args) + "): " + x.TypeDef.ToString()

else x.Name + ": " + x.TypeDef.ToString()

and InputParameterValue =

| InlineConstant of InputValue

| Variable of JsonElement

and ScalarDef =

interface

/// Name of the scalar type.

abstract Name : string

/// Optional scalar type description.

abstract Description : string option

/// A function used to retrieve a .NET object from provided GraphQL query or JsonElement variable.

abstract CoerceInput : InputParameterValue -> Result<obj, IGQLError list>

/// A function used to serialize a .NET object and coerce its value to JSON compatible if needed.

abstract CoerceOutput : obj -> obj option

inherit TypeDef

inherit NamedDef

inherit InputDef

inherit OutputDef

inherit LeafDef

end