protected virtual void VisitTypeExtensionDefinition(IDefinitionNode node)
{
switch (node)
{
case ScalarTypeExtensionNode value:
VisitScalarTypeExtension(value);
break;
case ObjectTypeExtensionNode value:
VisitObjectTypeExtension(value);
break;
case InterfaceTypeExtensionNode value:
VisitInterfaceTypeExtension(value);
break;
case UnionTypeExtensionNode value:
VisitUnionTypeExtension(value);
break;
case EnumTypeExtensionNode value:
VisitEnumTypeExtension(value);
break;
case InputObjectTypeExtensionNode value:
VisitInputObjectTypeExtension(value);
break;
}
}
public void Validate(IDocumentValidatorContext context, DocumentNode document)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (document is null)
{
throw new ArgumentNullException(nameof(document));
}
IDefinitionNode?typeSystemNode = null;
for (var i = 0; i < document.Definitions.Count; i++)
{
IDefinitionNode node = document.Definitions[i];
if (node.Kind is not SyntaxKind.OperationDefinition
and not SyntaxKind.FragmentDefinition)
{
typeSystemNode = node;
break;
}
}
if (typeSystemNode is not null)
{
context.Errors.Add(context.TypeSystemDefinitionNotAllowed(typeSystemNode));
}
}
protected override ISyntaxVisitorAction Enter(
DocumentNode node,
IDocumentValidatorContext context)
{
context.Names.Clear();
for (int i = 0; i < node.Definitions.Count; i++)
{
IDefinitionNode definition = node.Definitions[i];
if (definition.Kind == NodeKind.FragmentDefinition)
{
string fragmentName = ((FragmentDefinitionNode)definition).Name.Value;
if (!context.Names.Add(fragmentName))
{
context.Errors.Add(
ErrorBuilder.New()
.SetMessage(
"There are multiple fragments with the name " +
$"`{fragmentName}`.")
.AddLocation(definition)
.SetExtension("fragment", fragmentName)
.SpecifiedBy("sec-Fragment-Name-Uniqueness")
.Build());
}
}
}
context.Names.Clear();
return(Continue);
}
public void Validate(IDocumentValidatorContext context, DocumentNode document)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (document is null)
{
throw new ArgumentNullException(nameof(document));
}
IDefinitionNode?typeSystemNode = null;
for (int i = 0; i < document.Definitions.Count; i++)
{
IDefinitionNode node = document.Definitions[i];
if (node.Kind != NodeKind.OperationDefinition &&
node.Kind != NodeKind.FragmentDefinition)
{
typeSystemNode = node;
break;
}
}
if (typeSystemNode is { })
private void PrepareContext(
ISchema schema,
DocumentNode document,
DocumentValidatorContext context,
IEnumerable <KeyValuePair <string, object?> >?contextData)
{
context.Schema = schema;
for (var i = 0; i < document.Definitions.Count; i++)
{
IDefinitionNode definitionNode = document.Definitions[i];
if (definitionNode.Kind == SyntaxKind.FragmentDefinition)
{
var fragmentDefinition = (FragmentDefinitionNode)definitionNode;
context.Fragments[fragmentDefinition.Name.Value] = fragmentDefinition;
}
}
if (contextData is not null)
{
foreach (KeyValuePair <string, object?> entry in contextData)
{
context.ContextData[entry.Key] = entry.Value;
}
}
}
public static IError TypeSystemDefinitionNotAllowed(
this IDocumentValidatorContext context,
IDefinitionNode node)
{
return(ErrorBuilder.New()
.SetMessage(Resources.ErrorHelper_TypeSystemDefinitionNotAllowed)
.AddLocation(node)
.SpecifiedBy("sec-Executable-Definitions")
.Build());
}
protected virtual void VisitDefinition(IDefinitionNode node)
{
if (node is ITypeExtensionNode)
{
VisitTypeExtensionDefinition(node);
}
else
{
VisitTypeDefinition(node);
}
}
protected virtual void VisitDefinition(
IDefinitionNode node,
TContext context)
{
if (node is ITypeSystemExtensionNode)
{
VisitTypeExtensionDefinition(node, context);
}
else
{
VisitTypeDefinition(node, context);
}
}
public static void Prepare(this IDocumentValidatorContext context, DocumentNode document)
{
context.Fragments.Clear();
for (var i = 0; i < document.Definitions.Count; i++)
{
IDefinitionNode definitionNode = document.Definitions[i];
if (definitionNode.Kind == SyntaxKind.FragmentDefinition)
{
var fragmentDefinition = (FragmentDefinitionNode)definitionNode;
context.Fragments[fragmentDefinition.Name.Value] = fragmentDefinition;
}
}
}
protected virtual void VisitDefinition(IDefinitionNode node)
{
switch (node)
{
case OperationDefinitionNode value:
VisitOperationDefinition(value);
break;
case FragmentDefinitionNode value:
VisitFragmentDefinition(value);
break;
default:
throw new NotSupportedException();
}
}
private void PrepareContext(
ISchema schema,
DocumentNode document,
DocumentValidatorContext context)
{
context.Schema = schema;
for (int i = 0; i < document.Definitions.Count; i++)
{
IDefinitionNode definitionNode = document.Definitions[i];
if (definitionNode.Kind == NodeKind.FragmentDefinition)
{
var fragmentDefinition = (FragmentDefinitionNode)definitionNode;
context.Fragments[fragmentDefinition.Name.Value] = fragmentDefinition;
}
}
}
protected virtual IDefinitionNode RewriteDefinition(
IDefinitionNode node,
TContext context)
{
switch (node)
{
case OperationDefinitionNode value:
return(RewriteOperationDefinition(value, context));
case FragmentDefinitionNode value:
return(VisitFragmentDefinitions
? RewriteFragmentDefinition(value, context)
: value);
default:
return(node);
}
}
protected virtual void VisitTypeDefinition(
IDefinitionNode node,
TContext context)
{
switch (node)
{
case SchemaDefinitionNode value:
VisitSchemaDefinition(value, context);
break;
case DirectiveDefinitionNode value:
VisitDirectiveDefinition(value, context);
break;
case ScalarTypeDefinitionNode value:
VisitScalarTypeDefinition(value, context);
break;
case ObjectTypeDefinitionNode value:
VisitObjectTypeDefinition(value, context);
break;
case InputObjectTypeDefinitionNode value:
VisitInputObjectTypeDefinition(value, context);
break;
case InterfaceTypeDefinitionNode value:
VisitInterfaceTypeDefinition(value, context);
break;
case UnionTypeDefinitionNode value:
VisitUnionTypeDefinition(value, context);
break;
case EnumTypeDefinitionNode value:
VisitEnumTypeDefinition(value, context);
break;
default:
throw new NotSupportedException();
}
}
protected virtual void VisitDefinition(IDefinitionNode node)
{
switch (node)
{
case OperationDefinitionNode value:
VisitOperationDefinition(value);
break;
case FragmentDefinitionNode value:
if (VisitFragmentDefinitions)
{
VisitFragmentDefinition(value);
}
break;
default:
VisitUnsupportedDefinitions(node);
break;
}
}
private void PrepareContext(
ISchema schema,
DocumentNode document,
DocumentValidatorContext context,
IDictionary <string, object?> contextData)
{
context.Schema = schema;
for (var i = 0; i < document.Definitions.Count; i++)
{
IDefinitionNode definitionNode = document.Definitions[i];
if (definitionNode.Kind is SyntaxKind.FragmentDefinition)
{
var fragmentDefinition = (FragmentDefinitionNode)definitionNode;
context.Fragments[fragmentDefinition.Name.Value] = fragmentDefinition;
}
}
context.ContextData = contextData;
}
protected override ISyntaxVisitorAction Enter(
DocumentNode node,
IDocumentValidatorContext context)
{
bool hasAnonymousOp = false;
int opCount = 0;
OperationDefinitionNode?anonymousOp = null;
context.Names.Clear();
for (int i = 0; i < node.Definitions.Count; i++)
{
IDefinitionNode definition = node.Definitions[i];
if (definition.Kind == SyntaxKind.OperationDefinition)
{
opCount++;
var operation = (OperationDefinitionNode)definition;
if (operation.Name is null)
{
hasAnonymousOp = true;
anonymousOp = operation;
}
else if (!context.Names.Add(operation.Name.Value))
{
context.Errors.Add(context.OperationNameNotUnique(
operation, operation.Name.Value));
}
}
}
if (hasAnonymousOp && opCount > 1)
{
context.Errors.Add(context.OperationAnonymousMoreThanOne(anonymousOp !, opCount));
}
return(Continue);
}
protected override ISyntaxVisitorAction Enter(
DocumentNode node,
IDocumentValidatorContext context)
{
context.Names.Clear();
for (int i = 0; i < node.Definitions.Count; i++)
{
IDefinitionNode definition = node.Definitions[i];
if (definition.Kind == NodeKind.FragmentDefinition)
{
FragmentDefinitionNode fragment = (FragmentDefinitionNode)definition;
if (!context.Names.Add(fragment.Name.Value))
{
context.Errors.Add(context.FragmentNameNotUnique(fragment));
}
}
}
context.Names.Clear();
return(Continue);
}
public QueryValidationResult Validate(
ISchema schema,
DocumentNode queryDocument)
{
if (schema == null)
{
throw new ArgumentNullException(nameof(schema));
}
if (queryDocument == null)
{
throw new ArgumentNullException(nameof(queryDocument));
}
IDefinitionNode typeSystemNode = null;
for (int i = 0; i < queryDocument.Definitions.Count; i++)
{
IDefinitionNode node = queryDocument.Definitions[i];
if (node is ITypeSystemDefinitionNode ||
node is ITypeSystemExtensionNode)
{
typeSystemNode = node;
break;
}
}
if (typeSystemNode is null)
{
return(QueryValidationResult.OK);
}
return(new QueryValidationResult(
new ValidationError(
"A document containing TypeSystemDefinition " +
"is invalid for execution.", typeSystemNode)));
}
protected virtual void VisitTypeExtensionDefinition(
IDefinitionNode node)
{
switch (node)
{
case SchemaExtensionNode value:
VisitSchemaExtension(value);
break;
case ScalarTypeExtensionNode value:
VisitScalarTypeExtension(value);
break;
case ObjectTypeExtensionNode value:
VisitObjectTypeExtension(value);
break;
case InterfaceTypeExtensionNode value:
VisitInterfaceTypeExtension(value);
break;
case UnionTypeExtensionNode value:
VisitUnionTypeExtension(value);
break;
case EnumTypeExtensionNode value:
VisitEnumTypeExtension(value);
break;
case InputObjectTypeExtensionNode value:
VisitInputObjectTypeExtension(value);
break;
default:
throw new NotSupportedException();
}
}
protected virtual void VisitDefinition(
IDefinitionNode node,
TypeDefinitionItem context)
{
VisitTypeDefinition(node, context);
}
public void visit(IDefinitionNode value)
{
throw new System.NotSupportedException(value.GetType().ToString());
}
public static PathRequest <TPath> Create <TPath>(IDefinitionNode start, IDefinitionNode end, PathfindaxCollisionCategory collisionCategory = PathfindaxCollisionCategory.None, byte agentSize = 1)
where TPath : IPath
{
return(new PathRequest <TPath>(start, end, collisionCategory, agentSize));
}
protected virtual void VisitUnsupportedDefinitions(
IDefinitionNode node,
TContext context)
{
}
protected virtual void VisitUnsupportedDefinitions(
IDefinitionNode node)
{
}
public void visit(IDefinitionNode value)
{
}
public virtual void visit(IDefinitionNode value)
{
}
private void VisitDefinition(IDefinitionNode node, ISyntaxWriter writer)
{
switch (node.Kind)
{
case SyntaxKind.OperationDefinition:
VisitOperationDefinition((OperationDefinitionNode)node, writer);
break;
case SyntaxKind.FragmentDefinition:
VisitFragmentDefinition((FragmentDefinitionNode)node, writer);
break;
case SyntaxKind.SchemaDefinition:
VisitSchemaDefinition((SchemaDefinitionNode)node, writer);
break;
case SyntaxKind.DirectiveDefinition:
VisitDirectiveDefinition((DirectiveDefinitionNode)node, writer);
break;
case SyntaxKind.ScalarTypeDefinition:
VisitScalarTypeDefinition((ScalarTypeDefinitionNode)node, writer);
break;
case SyntaxKind.ObjectTypeDefinition:
VisitObjectTypeDefinition((ObjectTypeDefinitionNode)node, writer);
break;
case SyntaxKind.InputObjectTypeDefinition:
VisitInputObjectTypeDefinition((InputObjectTypeDefinitionNode)node, writer);
break;
case SyntaxKind.InterfaceTypeDefinition:
VisitInterfaceTypeDefinition((InterfaceTypeDefinitionNode)node, writer);
break;
case SyntaxKind.UnionTypeDefinition:
VisitUnionTypeDefinition((UnionTypeDefinitionNode)node, writer);
break;
case SyntaxKind.EnumTypeDefinition:
VisitEnumTypeDefinition((EnumTypeDefinitionNode)node, writer);
break;
case SyntaxKind.SchemaExtension:
VisitSchemaExtension((SchemaExtensionNode)node, writer);
break;
case SyntaxKind.ScalarTypeExtension:
VisitScalarTypeExtension((ScalarTypeExtensionNode)node, writer);
break;
case SyntaxKind.ObjectTypeExtension:
VisitObjectTypeExtension((ObjectTypeExtensionNode)node, writer);
break;
case SyntaxKind.InterfaceTypeExtension:
VisitInterfaceTypeExtension((InterfaceTypeExtensionNode)node, writer);
break;
case SyntaxKind.UnionTypeExtension:
VisitUnionTypeExtension((UnionTypeExtensionNode)node, writer);
break;
case SyntaxKind.EnumTypeExtension:
VisitEnumTypeExtension((EnumTypeExtensionNode)node, writer);
break;
case SyntaxKind.InputObjectTypeExtension:
VisitInputObjectTypeExtension((InputObjectTypeExtensionNode)node, writer);
break;
default:
ThrowHelper.NodeKindIsNotSupported(node.Kind);
break;
}
}
