public DocumentNode AddExtensions(
DocumentNode schema,
DocumentNode extensions)
{
if (schema == null)
{
throw new ArgumentNullException(nameof(schema));
}
if (extensions == null)
{
throw new ArgumentNullException(nameof(extensions));
}
var newTypes = extensions.Definitions.OfType <ITypeDefinitionNode>().ToList();
var newDirectives = extensions.Definitions.OfType <DirectiveDefinitionNode>().ToList();
DocumentNode current = schema;
if (newTypes.Count > 0 || newDirectives.Count > 0)
{
current = RemoveDirectives(current, newDirectives.Select(t => t.Name.Value));
current = RemoveTypes(current, newTypes.Select(t => t.Name.Value));
var definitions = schema.Definitions.ToList();
definitions.AddRange(newTypes);
definitions.AddRange(newDirectives);
current = current.WithDefinitions(definitions);
}
var context = new MergeContext(current, extensions);
current = RewriteDocument(current, context);
if (context.Extensions.Count > 0)
{
var definitions = current.Definitions.ToList();
foreach (string notProcessed in context.Extensions.Keys.Except(
current.Definitions.OfType <ITypeDefinitionNode>().Select(t => t.Name.Value)))
{
definitions.Add(context.Extensions[notProcessed]);
}
return(current.WithDefinitions(definitions));
}
return(current);
}
private DocumentNode RewriteTypes(
ISchemaInfo schema,
DocumentNode document)
{
if (_typeRewriters.Count == 0)
{
return(document);
}
var definitions = new List <IDefinitionNode>();
foreach (IDefinitionNode definition in document.Definitions)
{
if (definition is ITypeDefinitionNode typeDefinition)
{
foreach (ITypeRewriter rewriter in _typeRewriters)
{
typeDefinition = rewriter.Rewrite(
schema, typeDefinition);
}
definitions.Add(typeDefinition);
}
else
{
definitions.Add(definition);
}
}
return(document.WithDefinitions(definitions));
}
/// <summary>
/// Renames files when neccessary.
/// </summary>
/// <param name="schema"></param>
/// <param name="definitionSchema"></param>
/// <returns></returns>
private DocumentNode RewriteDocument(ISchemaInfo schema, DocumentNode definitionSchema)
{
var definitions = new List <IDefinitionNode>();
var schemaName = schema.Name.Value;
if (schemaName.Contains("api"))
{
schemaName = schemaName.Substring(0, schemaName.Length - 3);
}
else if (schemaName.Contains("service"))
{
schemaName = schemaName.Substring(0, schemaName.Length - 7);
}
foreach (var definition in definitionSchema.Definitions)
{
if (definition is ObjectTypeDefinitionNode typeDefinition)
{
if (!(typeDefinition.Name.Value.ToLower().Contains(schemaName)))
{
definitions.Add(typeDefinition.WithName(new NameNode(schemaName + "_" + typeDefinition.Name.Value)));
continue;
}
}
definitions.Add(definition);
}
return(definitionSchema.WithDefinitions(definitions));
}
private static DocumentNode CreateIntrospectionQuery(
SchemaFeatures features)
{
DocumentNode query = Parser.Default.Parse(
GetIntrospectionQuery(_phase2));
OperationDefinitionNode operation =
query.Definitions.OfType <OperationDefinitionNode>().First();
FieldNode schema =
operation.SelectionSet.Selections.OfType <FieldNode>().First();
FieldNode directives =
schema.SelectionSet.Selections.OfType <FieldNode>().First(t =>
t.Name.Value.Equals(_directivesField
, StringComparison.Ordinal));
var selections = directives.SelectionSet.Selections.ToList();
if (features.HasDirectiveLocations)
{
selections.Add(CreateField(_locations));
}
else
{
selections.Add(CreateField(_onField));
selections.Add(CreateField(_onFragment));
selections.Add(CreateField(_onOperation));
}
if (features.HasRepeatableDirectives)
{
selections.Add(CreateField(_isRepeatable));
}
FieldNode newField = directives.WithSelectionSet(
directives.SelectionSet.WithSelections(selections));
selections = schema.SelectionSet.Selections.ToList();
selections.Remove(directives);
selections.Add(newField);
newField = schema.WithSelectionSet(
schema.SelectionSet.WithSelections(selections));
selections = operation.SelectionSet.Selections.ToList();
selections.Remove(schema);
selections.Add(newField);
OperationDefinitionNode newOp = operation.WithSelectionSet(
operation.SelectionSet.WithSelections(selections));
var definitions = query.Definitions.ToList();
definitions.Remove(operation);
definitions.Insert(0, newOp);
return(query.WithDefinitions(definitions));
}
private static DocumentNode CreateIntrospectionQueryDocument(ISchemaFeatures features)
{
DocumentNode query = Utf8GraphQLParser.Parse(GetIntrospectionQuery());
OperationDefinitionNode operation =
query.Definitions.OfType <OperationDefinitionNode>().First();
FieldNode schema =
operation.SelectionSet.Selections.OfType <FieldNode>().First();
if (schema.SelectionSet is null)
{
throw new IntrospectionException();
}
FieldNode directives =
schema.SelectionSet.Selections.OfType <FieldNode>().First(t =>
t.Name.Value.Equals(_directivesField,
StringComparison.Ordinal));
if (directives.SelectionSet is null)
{
throw new IntrospectionException();
}
var selections = directives.SelectionSet.Selections.ToList();
AddDirectiveFeatures(features, selections);
FieldNode newField = directives.WithSelectionSet(
directives.SelectionSet.WithSelections(selections));
selections = schema.SelectionSet.Selections.ToList();
RemoveSubscriptionIfNotSupported(features, selections);
selections.Remove(directives);
selections.Add(newField);
newField = schema.WithSelectionSet(
schema.SelectionSet.WithSelections(selections));
selections = operation.SelectionSet.Selections.ToList();
selections.Remove(schema);
selections.Add(newField);
OperationDefinitionNode newOp = operation.WithSelectionSet(
operation.SelectionSet.WithSelections(selections));
var definitions = query.Definitions.ToList();
definitions.Remove(operation);
definitions.Insert(0, newOp);
return(query.WithDefinitions(definitions));
}
public ClientGenerator AddSchemaDocument(
string name,
DocumentNode document)
{
if (name is null)
{
throw new ArgumentNullException(nameof(name));
}
if (document is null)
{
throw new ArgumentNullException(nameof(document));
}
if (_clientName is null)
{
_clientName = name + "Client";
}
var extensions = new HashSet <IDefinitionNode>(
document.Definitions.OfType <ITypeExtensionNode>());
if (extensions.Count == 0)
{
_schemas.Add(name, document);
return(this);
}
var types = extensions.Except(document.Definitions).ToList();
if (types.Count > 0)
{
_schemas.Add(name, document.WithDefinitions(types));
}
_extensions.Add(document.WithDefinitions(extensions.ToList()));
return(this);
}
public void Duplicate_Fragment()
{
// arrange
DocumentNode query1 = Parse(Open("simple.query1.graphql"));
DocumentNode query2 = query1.WithDefinitions(query1.Definitions.Skip(2).ToArray());
List <DocumentNode> queries = new() { query1, query2 };
// act
void Error() => CreateOperationDocuments(queries);
// assert
Assert.Throws <CodeGeneratorException>(Error).Message.MatchSnapshot();
}
public DocumentNode Rewrite(ISchemaInfo schema, DocumentNode document)
{
if (SchemaName.HasValue && !SchemaName.Value.Equals(schema.Name))
{
return(document);
}
var definitions = new List <IDefinitionNode>(document.Definitions);
RemoveType(definitions, schema.QueryType?.Name.Value);
RemoveType(definitions, schema.MutationType?.Name.Value);
RemoveType(definitions, schema.SubscriptionType?.Name.Value);
return(document.WithDefinitions(definitions));
}
private static DocumentNode RemoveDefinitions(
DocumentNode document,
Func <DocumentNode, Dictionary <string, IDefinitionNode> > toDict,
IEnumerable <string> names)
{
List <IDefinitionNode> definitions = document.Definitions.ToList();
Dictionary <string, IDefinitionNode> directives = toDict(document);
foreach (string name in names)
{
if (directives.TryGetValue(name, out IDefinitionNode directive))
{
definitions.Remove(directive);
}
}
return(document.WithDefinitions(definitions));
}
public DocumentNode Rewrite(ISchemaInfo schema, DocumentNode document)
{
if (SchemaName.HasValue && !SchemaName.Value.Equals(schema.Name))
{
return(document);
}
ITypeDefinitionNode?typeDefinition = document.Definitions
.OfType <ITypeDefinitionNode>()
.FirstOrDefault(t => TypeName.Equals(t.GetOriginalName(schema.Name)));
if (typeDefinition is null)
{
return(document);
}
var definitions = new List <IDefinitionNode>(document.Definitions);
definitions.Remove(typeDefinition);
return(document.WithDefinitions(definitions));
}
public void DuplicatesWillBeIgnoredOnFieldMerging()
{
// arrange
ISchema schema = SchemaBuilder.New()
.AddStarWarsTypes()
.Create();
DocumentNode document = Utf8GraphQLParser.Parse(
FileResource.Open("InvalidIntrospectionQuery.graphql"));
var originalOperation = ((OperationDefinitionNode)document.Definitions[0]);
OperationDefinitionNode operationWithDuplicates = originalOperation.WithSelectionSet(
originalOperation.SelectionSet.WithSelections(
new List <ISelectionNode>
{
originalOperation.SelectionSet.Selections[0],
originalOperation.SelectionSet.Selections[0]
}));
document = document.WithDefinitions(
new List <IDefinitionNode>(document.Definitions.Skip(1))
{
operationWithDuplicates
});
ServiceProvider services = new ServiceCollection()
.AddValidation()
.Services
.BuildServiceProvider();
IDocumentValidatorFactory factory = services.GetRequiredService <IDocumentValidatorFactory>();
IDocumentValidator validator = factory.CreateValidator();
// act
DocumentValidatorResult result = validator.Validate(schema, document);
// assert
Assert.False(result.HasErrors);
}
private static DocumentNode PrepareSchemaDocument(
DocumentNode document,
NameString schemaName)
{
var definitions = new List <IDefinitionNode>();
foreach (IDefinitionNode definition in document.Definitions)
{
if (definition is ITypeDefinitionNode typeDefinition)
{
if (!IsIntrospectionType(typeDefinition))
{
definitions.Add(typeDefinition.Rename(
typeDefinition.Name.Value, schemaName));
}
}
else
{
definitions.Add(definition);
}
}
return(document.WithDefinitions(definitions));
}
