// The MIT License (MIT)

// Copyright (c) 2016 Bazinga Technologies Inc

namespace FSharp.Data.GraphQL.Types

open System

open System.Reflection

open System.Collections

open System.Collections.Concurrent

open System.Collections.Generic

open FSharp.Data.GraphQL

open FSharp.Data.GraphQL.Validation

open FSharp.Data.GraphQL.Ast

open FSharp.Data.GraphQL.Extensions

open FSharp.Quotations

open FSharp.Quotations.Patterns

open FSharp.Reflection

open FSharp.Linq.RuntimeHelpers

/// Enum describing parts of the GraphQL query document AST, where

/// related directive is valid to be used.

[<Flags>]

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

module Introspection =

/// 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 of all directives supported by current schema.

Directives : IntrospectionDirective [] }

/// Represents a subscription as described in the schema.

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> }

/// Describes the backing implementation for a subscription system.

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

/// Represents a subscription of a field in a live query.

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

/// Represents a generic typed, subscription field in a live query.

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

/// Represents a subscription of a field in a live query.

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

/// Represents a generic typed, subscription field in a live query.

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

/// Describes the backing implementation of a live query subscription system.

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

/// Interface used for receiving information about a whole

/// schema and type system defined within it.

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 : exn -> string

/// 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

/// A type alias for a field execute compiler function.

and FieldExecuteCompiler = FieldDef -> ExecuteField

/// A field execute map object.

/// Field execute maps are mutable objects built to compile fields at runtime.

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()

/// Root of GraphQL type system. All type definitions use TypeDef as

/// a common root.

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

/// Root of GraphQL type system. Constrained to represent .NET type

/// provided as generic parameter.

and TypeDef<'Val> =

interface

inherit TypeDef

end

/// Representation of all type defintions, that can be uses as inputs.

/// By default only scalars, enums, lists, nullables and input objects

/// are valid input types.

and InputDef =

interface

inherit TypeDef

end

/// Representation of all type defintions, that can be uses as inputs.

/// By default only scalars, enums, lists, nullables and input objects

/// are valid input types. Constrained to represent .NET type provided

/// as generic parameter.

and InputDef<'Val> =

interface

inherit InputDef

inherit TypeDef<'Val>

end

/// Representation of all type defintions, that can be uses as outputs.

/// By default only scalars, enums, lists, nullables, unions, interfaces

/// and objects are valid output types.

and OutputDef =

interface

inherit TypeDef

end

/// Representation of all type defintions, that can be uses as outputs.

/// By default only scalars, enums, lists, nullables, unions, interfaces

/// and objects are valid input types. Constrained to represent .NET type

/// provided as generic parameter.

and OutputDef<'Val> =

interface

inherit OutputDef

inherit TypeDef<'Val>

end

/// Representation of leaf type definitions. Leaf types represents leafs

/// of the GraphQL query tree. Each query path must end with a leaf.

/// By default only scalars and enums are valid leaf types.

and LeafDef =

interface

inherit TypeDef

end

/// Representation of composite types. Composites are non-leaf nodes of

/// the GraphQL query tree. Query path cannot end with a composite.

/// Composite type defines list of fields, it consists of. By default

/// only interfaces, unions and objects are valid composite types.

and CompositeDef =

interface

inherit TypeDef

end

/// Representation of abstract types: interfaces and unions. Each abstract

/// type contains a collection of possible object types, which can be resolved

/// from schema.

and AbstractDef =

interface

inherit TypeDef

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

inherit CompositeDef

end

/// Representation of named types. All named types are registered in

/// a schema. By default only non-named types are nullables and lists.

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

/// A context holding all the information needed for planning an operation.

and PlanningContext =

{ Schema : ISchema

RootDef : ObjectDef

Document : Document

Operation : OperationDefinition

DocumentId : int

Metadata : Metadata

ValidationResult : ValidationResult<AstError> }

/// A function type, which upon execution returns true if related field should

/// be included in result set for the query.

and Includer = Map<string, obj> -> bool

/// A node representing part of the current GraphQL query execution plan.

/// It contains info about both document AST fragment of incoming query as well,

/// as field defintion and type info of related fields, defined in schema.

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()

/// Kind of ExecutionInfo, marking a reduction operations, that should be applied to it.

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

/// Buffered stream options. Used to specify how the buffer will behavior in a stream.

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 }

/// Wrapper for a resolve method defined by the user or generated by a runtime.

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

/// Execution strategy for provided queries. Defines if object fields should

/// be resolved either sequentially one-by-one or in parallel.

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

/// Type representing a variable definition inside GraphQL query.

and VarDef =

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

Name: string

/// Type definition in corresponding GraphQL schema.

TypeDef: InputDef

/// Optional default value.

DefaultValue: Value option }

/// The context used to hold all the information for a schema compiling proccess.

and SchemaCompileContext =

{ Schema : ISchema

TypeMap : TypeMap

FieldExecuteMap : FieldExecuteMap }

/// A planning of an execution phase.

/// It is used by the execution process to execute an operation.

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

/// The validation result for the document being processed.

ValidationResult : ValidationResult<AstError> }

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

/// Execution context of the current GraphQL operation. It contains a full

/// knowledge about which fields will be accessed, what types are associated

/// with them and what variable values have been set by incoming query.

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 : Map<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 }

/// An execution context for the particular field, applied as the first

/// parameter for target resolve function.

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 : Map<string, obj>

/// Field path

Path : obj list }

/// 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)

| None -> None

/// Returns an argument by provided name. If argument was not found

/// and exception will be thrown.

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

match Map.tryFind name x.Args with

| Some found -> downcast found

| None -> raise (System.Collections.Generic.KeyNotFoundException(sprintf "Argument '%s' was not provided within context of a field '%s'. Check if it was supplied within GraphQL query." name x.ExecutionInfo.Identifier))

/// Function type for the compiled field executor.

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

/// Untyped representation of the GraphQL field defintion.

/// Can be used only withing object and interface definitions.

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

/// A paritally typed representation of the GraphQL field defintion.

/// Contains type parameter describing .NET type used as it's container.

/// Can be used only withing object and interface definitions.

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()

/// An untyped representation of GraphQL scalar type.

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.

abstract CoerceInput : Value -> obj option

/// A function used to set a surrogate representation to be

/// returned as a query result.

abstract CoerceValue : obj -> obj option

inherit TypeDef

inherit NamedDef

inherit InputDef

inherit OutputDef

inherit LeafDef

end

/// Concrete representation of the scalar types.