public void Merge(
ISchemaMergeContext context,
IReadOnlyList <ITypeInfo> types)
{
if (types.OfType <UnionTypeInfo>().Any())
{
var notMerged = types.OfType <UnionTypeInfo>().ToList();
bool hasLeftovers = types.Count > notMerged.Count;
for (int i = 0; i < notMerged.Count; i++)
{
context.AddType(notMerged[i].Definition.Rename(
TypeMergeHelpers.CreateName(context, notMerged[i]),
notMerged[i].Schema.Name));
}
if (hasLeftovers)
{
_next.Invoke(context, types.NotOfType <UnionTypeInfo>());
}
}
else
{
_next.Invoke(context, types);
}
}
public void Merge(
ISchemaMergeContext context,
IReadOnlyList <ITypeInfo> types)
{
var typeInfos = types.OfType <ObjectTypeInfo>().ToArray();
var fields = typeInfos[0].Definition.Fields.ToList();
fields.AddRange(typeInfos[1].Definition.Fields);
context.AddType(
typeInfos[0].Definition.WithFields(fields));
}
public void Merge(
ISchemaMergeContext context,
IReadOnlyList <HotChocolate.Stitching.Merge.ITypeInfo> types)
{
if (types.OfType <ITypeInfo <ScalarTypeDefinitionNode> >().Any())
{
ITypeInfo <ScalarTypeDefinitionNode> scalar =
types.OfType <ITypeInfo <ScalarTypeDefinitionNode> >().FirstOrDefault();
context.AddType(scalar.Definition);
return;
}
_next(context, types);
}
protected override void MergeTypes(
ISchemaMergeContext context,
IReadOnlyList <InputObjectTypeInfo> types,
NameString newTypeName)
{
List <InputObjectTypeDefinitionNode> definitions = types
.Select(t => t.Definition)
.ToList();
InputObjectTypeDefinitionNode definition =
definitions[0].Rename(
newTypeName,
types.Select(t => t.Schema.Name));
context.AddType(definition);
}
private static void MergeType(
ISchemaMergeContext context,
IReadOnlyList <EnumTypeInfo> types)
{
var definition = types[0].Definition;
EnumTypeDefinitionNode descriptionDef =
types.Select(t => t.Definition)
.FirstOrDefault(t => t.Description != null);
if (descriptionDef != null)
{
definition = definition.WithDescription(
descriptionDef.Description);
}
context.AddType(definition.Rename(
TypeMergeHelpers.CreateName(context, types),
types.Select(t => t.Schema.Name)));
}
protected override void MergeTypes(
ISchemaMergeContext context,
IReadOnlyList <ObjectTypeInfo> types,
NameString newTypeName)
{
List <ObjectTypeDefinitionNode> definitions = types
.Select(t => t.Definition)
.ToList();
// ? : how do we handle the interfaces correctly
var interfaces = new HashSet <string>(
definitions.SelectMany(d =>
d.Interfaces.Select(t => t.Name.Value)));
ObjectTypeDefinitionNode definition = definitions[0]
.WithInterfaces(interfaces.Select(t =>
new NamedTypeNode(new NameNode(t))).ToList())
.Rename(newTypeName, types.Select(t => t.Schema.Name));
context.AddType(definition);
}
public void Merge(
ISchemaMergeContext context,
IReadOnlyList <ITypeInfo> types)
{
if (types.Count > 0)
{
if (types[0].IsRootType)
{
var names = new HashSet <string>();
var fields = new List <FieldDefinitionNode>();
foreach (ObjectTypeInfo type in
types.OfType <ObjectTypeInfo>())
{
IntegrateFields(type.Definition, type, names, fields);
}
if (types[0].Schema.TryGetOperationType(
(ObjectTypeDefinitionNode)types[0].Definition,
out OperationType operationType))
{
var mergedRootType = new ObjectTypeDefinitionNode
(
null,
new NameNode(operationType.ToString()),
null,
Array.Empty <DirectiveNode>(),
Array.Empty <NamedTypeNode>(),
fields
);
context.AddType(mergedRootType);
}
}
else
{
_next.Invoke(context, types);
}
}
}
