public Fragment(
int fragmentId,
IObjectType typeCondition,
InlineFragmentNode inlineFragment,
ISelectionSet selectionSet,
bool internalFragment,
SelectionIncludeCondition?includeCondition)
{
TypeCondition = typeCondition;
SyntaxNode = inlineFragment;
SelectionSet = selectionSet;
Directives = inlineFragment.Directives;
IsInternal = internalFragment;
IsConditional = includeCondition is not null;
_fragmentId = fragmentId;
_includeCondition = includeCondition;
InclusionKind = internalFragment
? SelectionInclusionKind.Internal
: SelectionInclusionKind.Always;
if (IsConditional)
{
InclusionKind = internalFragment
? SelectionInclusionKind.InternalConditional
: SelectionInclusionKind.Conditional;
}
}
public VisitorAction Enter(
InlineFragmentNode node,
ISyntaxNode parent,
IReadOnlyList <object> path,
IReadOnlyList <ISyntaxNode> ancestors)
{
if (node.TypeCondition is { } &&
protected override void VisitInlineFragment(
InlineFragmentNode node,
object context)
{
VisitedInlineFragment = true;
base.VisitInlineFragment(node, context);
}
private void ResolveInlineFragment(
CompilerContext context,
InlineFragmentNode inlineFragment,
SelectionIncludeCondition?includeCondition)
{
if (inlineFragment.SelectionSet.Selections.Count == 0)
{
throw OperationCompiler_FragmentNoSelections(inlineFragment);
}
if (_fragments.GetFragment(context.Type, inlineFragment) is { } fragmentInfo&&
DoesTypeApply(fragmentInfo.TypeCondition, context.Type))
{
if (inlineFragment.IsDeferrable() &&
AllowFragmentDeferral(context, inlineFragment))
{
CompilerContext deferContext = context.Branch(fragmentInfo);
CompileSelectionSet(deferContext);
context.RegisterFragment(new Fragment(
context.Type,
inlineFragment,
deferContext.GetSelectionSet(),
context.IsInternalSelection,
includeCondition));
}
else
{
CollectFields(
context,
fragmentInfo.SelectionSet,
includeCondition);
}
}
}
private bool AllowFragmentDeferral(
CompilerContext context,
InlineFragmentNode fragment)
{
if (context.Optimizers.Count == 0)
{
return(true);
}
var optimizerContext = new SelectionOptimizerContext
(
_schema,
context.Path,
context.Type,
context.SelectionSet,
context.Fields,
CreateFieldMiddleware
);
if (context.Optimizers.Count == 1)
{
return(context.Optimizers[0].AllowFragmentDeferral(optimizerContext, fragment));
}
for (var i = 0; i < context.Optimizers.Count; i++)
{
if (!context.Optimizers[i].AllowFragmentDeferral(optimizerContext, fragment))
{
return(false);
}
}
return(true);
}
protected override ISyntaxVisitorAction Enter(
InlineFragmentNode node,
IDocumentValidatorContext context)
{
ValidateDirectiveAreUniquePerLocation(node, context);
return(Continue);
}
private bool AllowFragmentDeferral(
CompilerContext context,
InlineFragmentNode fragment)
{
if (context.Optimizers.Count == 0)
{
return(true);
}
var optimizerContext = new SelectionOptimizerContext(this, context);
if (context.Optimizers.Count == 1)
{
return(context.Optimizers[0].AllowFragmentDeferral(optimizerContext, fragment));
}
for (var i = 0; i < context.Optimizers.Count; i++)
{
if (!context.Optimizers[i].AllowFragmentDeferral(optimizerContext, fragment))
{
return(false);
}
}
return(true);
}
public Fragment GetFragment(
ObjectType parentType,
InlineFragmentNode inlineFragment)
{
if (parentType == null)
{
throw new ArgumentNullException(nameof(parentType));
}
if (inlineFragment == null)
{
throw new ArgumentNullException(nameof(inlineFragment));
}
string fragmentName = CreateInlineFragmentName(inlineFragment);
if (!_fragments.TryGetValue(fragmentName,
out List <Fragment> fragments))
{
fragments = new List <Fragment>();
fragments.Add(CreateFragment(parentType, inlineFragment));
_fragments[fragmentName] = fragments;
}
return(fragments.First());
}
protected override InlineFragmentNode RewriteInlineFragment(
InlineFragmentNode node,
Context context)
{
Context currentContext = context;
InlineFragmentNode current = node;
if (_schema.TryGetType(
current.TypeCondition.Name.Value,
out IComplexOutputType type))
{
currentContext = currentContext.Clone();
currentContext.TypeContext = type;
if (type.TryGetSourceDirective(context.Schema,
out SourceDirective sourceDirective))
{
current = current.WithTypeCondition(
current.TypeCondition.WithName(
new NameNode(sourceDirective.Name)));
}
}
return(base.RewriteInlineFragment(current, currentContext));
}
protected override ISyntaxVisitorAction Enter(
InlineFragmentNode node,
IDocumentValidatorContext context)
{
if (node.TypeCondition is null)
{
return(Continue);
}
if (context.Schema.TryGetType(
node.TypeCondition.Name.Value,
out INamedOutputType type))
{
if (type.IsCompositeType())
{
ValidateFragmentSpreadIsPossible(
node, context,
context.Types.Peek().NamedType(),
type);
context.Types.Push(type);
return(Continue);
}
context.Errors.Add(context.FragmentOnlyCompositeType(node, type.NamedType()));
return(Skip);
}
context.Errors.Add(context.FragmentTypeConditionUnknown(node, node.TypeCondition));
return(Skip);
}
private Fragment CreateFragment(ObjectType parentType, InlineFragmentNode inlineFragment)
{
INamedType type = inlineFragment.TypeCondition == null
? parentType
: _schema.GetType <INamedType>(inlineFragment.TypeCondition.Name.Value);
return(new Fragment(type, inlineFragment.SelectionSet, inlineFragment.Directives));
}
private Fragment CreateFragment(InlineFragmentNode inlineFragment)
{
// TODO : maybe introduce a tryget to the schema
INamedType type = _schema.GetType <INamedType>(
inlineFragment.TypeCondition.Name.Value);
return(new Fragment(type, inlineFragment.SelectionSet));
}
protected override ISyntaxVisitorAction Enter(
InlineFragmentNode node,
IDocumentValidatorContext context)
{
ValidateTypeCondition(node, node.TypeCondition, context);
ValidateFragmentSpreadIsPossible(node, context);
return(Continue);
}
protected override void ResolveChildren(
InlineFragmentNode node,
IList <SyntaxNodeInfo> children)
{
ResolveChildren(
nameof(node.SelectionSet),
node.SelectionSet,
children);
}
public Fragment?GetFragment(ObjectType parentType, InlineFragmentNode inlineFragment)
{
if (!_fragments.TryGetValue(inlineFragment, out Fragment? fragment))
{
fragment = CreateFragment(parentType, inlineFragment);
_fragments[inlineFragment] = fragment;
}
return(fragment);
}
public VisitorAction Leave(
InlineFragmentNode node,
ISyntaxNode parent,
IReadOnlyList <object> path,
IReadOnlyList <ISyntaxNode> ancestors)
{
if (_action.Pop() == VisitorAction.Continue)
{
_type.Pop();
}
return(VisitorAction.Continue);
}
protected override InlineFragmentNode RewriteInlineFragment(
InlineFragmentNode node,
Context context)
{
context.Nodes.Push(node);
context.Types.Push(node.TypeCondition is null
? context.Types.Peek()
: context.Schema.GetType <INamedType>(node.TypeCondition.Name.Value));
node = base.RewriteInlineFragment(node, context);
context.Types.Pop();
context.Nodes.Pop();
return(node);
}
private void ResolveInlineFragment(
ObjectType type,
InlineFragmentNode inlineFragment,
Action <QueryError> reportError,
Dictionary <string, FieldSelection> fields)
{
Fragment fragment = _fragments.GetFragment(type, inlineFragment);
if (DoesTypeApply(fragment.TypeCondition, type))
{
CollectFields(type, fragment.SelectionSet, reportError, fields);
}
}
protected override void VisitInlineFragment(
InlineFragmentNode node,
MaxComplexityVisitorContext context)
{
MaxComplexityVisitorContext newContext = context;
if (newContext.Schema.TryGetType(
node.TypeCondition.Name.Value,
out IComplexOutputType type))
{
newContext = newContext.SetTypeContext(type);
}
base.VisitInlineFragment(node, newContext);
}
protected override void VisitInlineFragment(
InlineFragmentNode inlineFragment,
IType parentType,
IType typeCondition,
ImmutableStack <ISyntaxNode> path)
{
ValidateTypeCondition(
inlineFragment,
typeCondition);
base.VisitInlineFragment(
inlineFragment,
parentType,
typeCondition,
path);
}
public VisitorAction Enter(
InlineFragmentNode node,
ISyntaxNode parent,
IReadOnlyList <object> path,
IReadOnlyList <ISyntaxNode> ancestors)
{
if (node.TypeCondition is not null &&
_schema.TryGetType <INamedType>(node.TypeCondition.Name.Value, out INamedType? type))
{
_type.Push(type);
_action.Push(VisitorAction.Continue);
return(VisitorAction.Continue);
}
_action.Push(VisitorAction.Skip);
return(VisitorAction.Skip);
}
private void ResolveInlineFragment(
CompilerContext context,
InlineFragmentNode inlineFragment,
SelectionIncludeCondition?includeCondition)
{
if (inlineFragment.SelectionSet.Selections.Count == 0)
{
throw OperationCompiler_FragmentNoSelections(inlineFragment);
}
if (_fragments.GetFragment(context.Type, inlineFragment) is { } fragmentInfo&&
DoesTypeApply(fragmentInfo.TypeCondition, context.Type))
{
var reference = new SpreadReference(context.SelectionPath, inlineFragment);
if (!context.Spreads.TryGetValue(reference, out var selectionSet))
{
selectionSet = inlineFragment.SelectionSet.WithSelections(
inlineFragment.SelectionSet.Selections);
context.Spreads.Add(reference, selectionSet);
}
if (inlineFragment.IsDeferrable() &&
AllowFragmentDeferral(context, inlineFragment))
{
CompilerContext deferContext = context.Branch(selectionSet);
CompileSelectionSet(deferContext);
context.RegisterFragment(new Fragment(
_nextFragmentId++,
context.Type,
inlineFragment,
deferContext.GetSelectionSet(),
context.IsInternalSelection,
includeCondition));
}
else
{
CollectFields(
context,
selectionSet,
includeCondition);
}
}
}
protected sealed override ISyntaxVisitorAction Enter(
ISyntaxNode node,
ISyntaxVisitorContext context)
{
return(node switch
{
DocumentNode n => Enter(n, context),
OperationDefinitionNode n => Enter(n, context),
VariableDefinitionNode n => Enter(n, context),
VariableNode n => Enter(n, context),
SelectionSetNode n => Enter(n, context),
FieldNode n => Enter(n, context),
ArgumentNode n => Enter(n, context),
FragmentSpreadNode n => Enter(n, context),
InlineFragmentNode n => Enter(n, context),
FragmentDefinitionNode n => Enter(n, context),
DirectiveNode n => Enter(n, context),
NamedTypeNode n => Enter(n, context),
ListTypeNode n => Enter(n, context),
NonNullTypeNode n => Enter(n, context),
ListValueNode n => Enter(n, context),
ObjectValueNode n => Enter(n, context),
ObjectFieldNode n => Enter(n, context),
IValueNode n => Enter(n, context),
SchemaDefinitionNode n => Enter(n, context),
OperationTypeDefinitionNode n => Enter(n, context),
ScalarTypeDefinitionNode n => Enter(n, context),
ObjectTypeDefinitionNode n => Enter(n, context),
FieldDefinitionNode n => Enter(n, context),
InputValueDefinitionNode n => Enter(n, context),
InterfaceTypeDefinitionNode n => Enter(n, context),
UnionTypeDefinitionNode n => Enter(n, context),
EnumTypeDefinitionNode n => Enter(n, context),
EnumValueDefinitionNode n => Enter(n, context),
InputObjectTypeDefinitionNode n => Enter(n, context),
DirectiveDefinitionNode n => Enter(n, context),
SchemaExtensionNode n => Enter(n, context),
ScalarTypeExtensionNode n => Enter(n, context),
ObjectTypeExtensionNode n => Enter(n, context),
InterfaceTypeExtensionNode n => Enter(n, context),
UnionTypeExtensionNode n => Enter(n, context),
EnumTypeExtensionNode n => Enter(n, context),
InputObjectTypeExtensionNode n => Enter(n, context),
_ => throw new NotSupportedException()
});
private Fragment CreateFragment(
INamedOutputType parentType,
InlineFragmentNode inlineFragment)
{
INamedType type;
if (inlineFragment.TypeCondition == null)
{
type = parentType;
}
else
{
type = _schema.GetType <INamedType>(
inlineFragment.TypeCondition.Name.Value);
}
return(new Fragment(type.Name, FragmentKind.Inline, type, inlineFragment.SelectionSet));
}
private void ResolveInlineFragment(
ObjectType type,
InlineFragmentNode inlineFragment,
Path path,
FieldVisibility fieldVisibility,
IDictionary <string, FieldInfo> fields)
{
Fragment fragment = _fragments.GetFragment(type, inlineFragment);
if (DoesTypeApply(fragment.TypeCondition, type))
{
CollectFields(
type,
fragment.SelectionSet,
path,
fieldVisibility,
fields);
}
}
protected override void VisitInlineFragment(
InlineFragmentNode node,
TContext context)
{
if (node.TypeCondition != null)
{
VisitNamedType(node.TypeCondition, context);
}
VisitMany(
node.Directives,
context,
VisitDirective);
if (node.SelectionSet != null)
{
VisitSelectionSet(node.SelectionSet, context);
}
}
private void VisitInlineFragmentInternal(
InlineFragmentNode inlineFragment,
IType type,
ImmutableStack <ISyntaxNode> path)
{
if (inlineFragment.TypeCondition?.Name?.Value == null)
{
VisitInlineFragment(inlineFragment, type, type, path);
}
else if (Schema.TryGetType(
inlineFragment.TypeCondition.Name.Value,
out INamedOutputType typeCondition))
{
VisitInlineFragment(inlineFragment, type, typeCondition, path);
}
else
{
VisitInlineFragment(inlineFragment, type, null, path);
}
}
protected virtual void VisitInlineFragment(
InlineFragmentNode inlineFragment,
IType type,
ImmutableStack <ISyntaxNode> path)
{
if (inlineFragment.TypeCondition?.Name?.Value != null &&
Schema.TryGetType <INamedOutputType>(
inlineFragment.TypeCondition.Name.Value,
out INamedOutputType typeCondition))
{
VisitSelectionSet(
inlineFragment.SelectionSet,
typeCondition,
path.Push(inlineFragment));
VisitDirectives(
inlineFragment.Directives,
path.Push(inlineFragment));
}
}
protected virtual void VisitInlineFragment(
InlineFragmentNode inlineFragment,
IType parentType,
IType typeCondition,
ImmutableStack <ISyntaxNode> path)
{
if (typeCondition != null)
{
ImmutableStack <ISyntaxNode> newpath = path.Push(inlineFragment);
VisitSelectionSet(
inlineFragment.SelectionSet,
typeCondition,
newpath);
VisitDirectives(
inlineFragment.Directives,
newpath);
}
}
protected override void VisitInlineFragment(
InlineFragmentNode inlineFragment,
IType parentType,
IType typeCondition,
ImmutableStack <ISyntaxNode> path)
{
if (typeCondition == null)
{
Errors.Add(new ValidationError(
"The specified inline fragment " +
"does not exist in the current schema.",
inlineFragment));
}
base.VisitInlineFragment(
inlineFragment,
parentType,
typeCondition,
path);
}
