public void AddType <TType>(TypeCollectionContext context)
where TType : GraphType
{
var instance = context.ResolveType(typeof(TType));
AddType(instance, context);
}
public override string CollectTypes(TypeCollectionContext context)
{
if (!string.IsNullOrWhiteSpace(_remoteLocation) && !string.IsNullOrWhiteSpace(_name))
{
// get remote server information
// if we haven't fetched the remote types for this remote:
if (!RemoteServerSchemas.TryGetValue(_remoteLocation, out var schema))
{
throw new Exception($"Schema not already loaded for remote {_remoteLocation}");
}
// get type
if (!TryGetFieldTypeFromRemoteSchema(schema, _name, out var type))
{
// if no type found: fail
// TODO: fail better
throw new Exception($"Failed to find type '{_name}' in remote '{_remoteLocation}' schema");
}
Name = $"{_remoteLocation}.{_name}";
if (!_hasAddedFields)
{
var fields = GetFieldsForFieldType(_remoteLocation, type).Where(f => f != null).ToList();
foreach (var field in fields)
{
AddField(field);
}
_hasAddedFields = true;
}
}
return(base.CollectTypes(context));
}
public override string CollectTypes(TypeCollectionContext context)
{
var innerType = context.ResolveType(Type);
var name = innerType.CollectTypes(context);
context.AddType(name, innerType, context);
return(Name);
}
private void AddTypeIfNotRegistered(Type type, TypeCollectionContext context)
{
var foundType = this[type];
if (foundType == null)
{
AddType(context.ResolveType(type), context);
}
}
public void AddType <TType>()
where TType : GraphType, new()
{
var context = new TypeCollectionContext(
type => (GraphType)Activator.CreateInstance(type),
(name, type, _) =>
{
_types[name] = type;
_?.AddType(name, type, null);
});
AddType <TType>(context);
}
public override string CollectTypes(TypeCollectionContext context)
{
Name = Name ?? typeof(T).Name;
if (!_hasAddedFields)
{
var fields = GetFields().Where(f => f != null).ToList();
foreach (var field in fields)
{
AddField(field);
}
_hasAddedFields = true;
}
return(base.CollectTypes(context));
}
public static GraphTypesLookup Create(IEnumerable <GraphType> types, Func <Type, GraphType> resolveType)
{
var lookup = new GraphTypesLookup();
var ctx = new TypeCollectionContext(resolveType, (name, graphType, context) =>
{
if (lookup[name] == null)
{
lookup.AddType(graphType, context);
}
});
foreach (var type in types)
{
lookup.AddType(type, ctx);
}
;
return(lookup);
}
public string CollectTypes(TypeCollectionContext context)
{
return(Name);
}
public void AddType(GraphType type, TypeCollectionContext context)
{
if (type == null)
{
return;
}
var name = type.CollectTypes(context);
_types[name] = type;
bool isInput = type is InputObjectGraphType;
foreach (var field in type.Fields)
{
field.Type = updateInputFieldType(isInput, field.Type);
AddTypeIfNotRegistered(field.Type, context);
if (field.Arguments != null)
{
foreach (var arg in field.Arguments)
{
AddTypeIfNotRegistered(arg.Type, context);
}
}
}
if (type is ObjectGraphType)
{
var obj = (ObjectGraphType)type;
foreach (var objectInterface in obj.Interfaces)
{
AddTypeIfNotRegistered(objectInterface, context);
var interfaceInstance = this[objectInterface] as InterfaceGraphType;
if (interfaceInstance != null)
{
interfaceInstance.AddPossibleType(obj);
if (interfaceInstance.ResolveType == null && obj.IsTypeOf == null)
{
throw new ExecutionError((
"Interface type {0} does not provide a \"resolveType\" function" +
"and possible Type \"{1}\" does not provide a \"isTypeOf\" function. " +
"There is no way to resolve this possible type during execution.")
.ToFormat(interfaceInstance, obj));
}
}
}
}
if (type is UnionGraphType)
{
var union = (UnionGraphType)type;
if (!union.Types.Any())
{
throw new ExecutionError("Must provide types for Union {0}.".ToFormat(union));
}
union.Types.Apply(unionedType =>
{
AddTypeIfNotRegistered(unionedType, context);
var objType = this[unionedType] as ObjectGraphType;
if (union.ResolveType == null && objType != null && objType.IsTypeOf == null)
{
throw new ExecutionError((
"Union type {0} does not provide a \"resolveType\" function" +
"and possible Type \"{1}\" does not provide a \"isTypeOf\" function. " +
"There is no way to resolve this possible type during execution.")
.ToFormat(union, objType));
}
union.AddPossibleType(objType);
});
}
}
public override string CollectTypes(TypeCollectionContext context)
{
context.AddType(staticEntry.Name, staticEntry, context);
context.AddType(processEntry.Name, processEntry, context);
return(base.CollectTypes(context));
}
