public ITypeDefinitionNode Rewrite(
ISchemaInfo schema,
ITypeDefinitionNode typeDefinition)
{
if (typeDefinition.Name.Value.Equals("Query") &&
typeDefinition is ObjectTypeDefinitionNode objectType)
{
var path = new SelectionPathComponent(
new NameNode("foo"),
new[]
{
new ArgumentNode(
"a",
new ScopedVariableNode(
ScopeNames.ContextData,
"foo_a"))
});
Dictionary <string, FieldDefinitionNode> fields =
objectType.Fields.ToDictionary(t => t.Name.Value);
fields["foo"] = fields["foo"]
.WithArguments(Array.Empty <InputValueDefinitionNode>())
.AddDelegationPath("someSchema", path);
return(objectType.WithFields(fields.Values.ToArray()));
}
return(typeDefinition);
}
public ITypeDefinitionNode Rewrite(
ISchemaInfo schema,
ITypeDefinitionNode typeDefinition)
{
if (SchemaName.HasValue && !SchemaName.Value.Equals(schema.Name))
{
return(typeDefinition);
}
NameString typeName = typeDefinition.GetOriginalName(schema.Name);
if (!Field.TypeName.Equals(typeName))
{
return(typeDefinition);
}
switch (typeDefinition)
{
case InputObjectTypeDefinitionNode iotd:
return(RenameFields(iotd, schema.Name));
case ObjectTypeDefinitionNode otd:
return(RenameFields(otd, schema.Name,
f => otd.WithFields(f)));
case InterfaceTypeDefinitionNode itd:
return(RenameFields(itd, schema.Name,
f => itd.WithFields(f)));
default:
return(typeDefinition);
}
}
private static bool IsIntrospectionType(
ITypeDefinitionNode typeDefinition)
{
// we should check this against the actual kown list of intro types.
return(typeDefinition.Name.Value
.StartsWith("__", StringComparison.Ordinal));
}
public static ITypeInfo Create(
ITypeDefinitionNode typeDefinition,
ISchemaInfo schema)
{
switch (typeDefinition)
{
case ObjectTypeDefinitionNode otd:
return(new ObjectTypeInfo(otd, schema));
case InterfaceTypeDefinitionNode itd:
return(new InterfaceTypeInfo(itd, schema));
case UnionTypeDefinitionNode utd:
return(new UnionTypeInfo(utd, schema));
case InputObjectTypeDefinitionNode iotd:
return(new InputObjectTypeInfo(iotd, schema));
case EnumTypeDefinitionNode etd:
return(new EnumTypeInfo(etd, schema));
case ScalarTypeDefinitionNode std:
return(new ScalarTypeInfo(std, schema));
default:
throw new NotSupportedException();
}
}
protected TypeInfo(
ITypeDefinitionNode typeDefinition,
ISchemaInfo schema)
{
Definition = typeDefinition
?? throw new ArgumentNullException(nameof(typeDefinition));
Schema = schema
?? throw new ArgumentNullException(nameof(schema));
IsRootType = schema.IsRootType(typeDefinition);
}
public SchemaMergeException(
ITypeDefinitionNode typeDefinition,
ITypeExtensionNode typeExtension,
string message)
: base(message)
{
TypeDefinition = typeDefinition
?? throw new ArgumentNullException(nameof(typeDefinition));
TypeExtension = typeExtension
?? throw new ArgumentNullException(nameof(typeExtension));
}
public bool IsRootType(ITypeDefinitionNode typeDefinition)
{
if (typeDefinition == null)
{
throw new ArgumentNullException(nameof(typeDefinition));
}
if (typeDefinition is ObjectTypeDefinitionNode ot)
{
return(RootTypes.ContainsValue(ot));
}
return(false);
}
public void AddType(ITypeDefinitionNode type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (_types.ContainsKey(type.Name.Value))
{
throw new ArgumentException(
"A type with that name was already added.");
}
_types.Add(type.Name.Value, type);
}
public ITypeDefinitionNode Rewrite(
ISchemaInfo schema,
ITypeDefinitionNode typeDefinition)
{
if (SchemaName.HasValue && !SchemaName.Value.Equals(schema.Name))
{
return(typeDefinition);
}
if (!OriginalTypeName.Equals(typeDefinition.Name.Value))
{
return(typeDefinition);
}
return(typeDefinition.Rename(NewTypeName, schema.Name));
}
public static T Rename <T>(
this T typeDefinitionNode,
NameString newName,
IEnumerable <NameString> schemaNames)
where T : ITypeDefinitionNode
{
ITypeDefinitionNode node = typeDefinitionNode;
switch (node)
{
case ObjectTypeDefinitionNode otd:
node = Rename(otd, newName, schemaNames);
break;
case InterfaceTypeDefinitionNode itd:
node = Rename(itd, newName, schemaNames);
break;
case UnionTypeDefinitionNode utd:
node = Rename(utd, newName, schemaNames);
break;
case InputObjectTypeDefinitionNode iotd:
node = Rename(iotd, newName, schemaNames);
break;
case EnumTypeDefinitionNode etd:
node = Rename(etd, newName, schemaNames);
break;
case ScalarTypeDefinitionNode std:
node = Rename(std, newName, schemaNames);
break;
default:
throw new NotSupportedException();
}
return((T)node);
}
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 == null)
{
return(document);
}
var definitions = new List <IDefinitionNode>(document.Definitions);
definitions.Remove(typeDefinition);
return(document.WithDefinitions(definitions));
}
public ITypeDefinitionNode Rewrite(
ISchemaInfo schema,
ITypeDefinitionNode typeDefinition)
{
return(_rewrite.Invoke(schema, typeDefinition));
}
private ITypeDefinitionNode DelegateTypes(ISchemaInfo s, ITypeDefinitionNode d)
{
return(d);
}
