public void Register(
ITypeRegistrar typeRegistrar,
IEnumerable <ITypeReference> typeReferences)
{
foreach (ClrTypeReference typeReference in typeReferences.OfType <ClrTypeReference>())
{
if (!BaseTypes.IsNonGenericBaseType(typeReference.Type) &&
_typeInspector.TryCreate(typeReference.Type, out TypeInfo typeInfo))
{
Type type = typeInfo.ClrType;
if (IsTypeSystemObject(type))
{
ClrTypeReference namedTypeReference = typeReference.With(type);
if (!typeRegistrar.IsResolved(namedTypeReference))
{
typeRegistrar.Register(
typeRegistrar.CreateInstance(type),
typeReference.Scope,
BaseTypes.IsGenericBaseType(type));
}
}
else
{
TryMapToExistingRegistration(
typeRegistrar,
typeInfo,
typeReference.Context,
typeReference.Scope);
}
}
}
}
internal static bool IsNonGenericBaseType(Type type)
{
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
return(BaseTypes.IsNonGenericBaseType(type));
}
private RegisteredType InitializeType(
TypeSystemObjectBase typeSystemObject,
string?scope,
bool isInferred)
{
try
{
var discoveryContext = new TypeDiscoveryContext(
typeSystemObject,
scope,
_serviceFactory.Services,
_descriptorContext,
_interceptor);
typeSystemObject.Initialize(discoveryContext);
var references = new List <ITypeReference>();
if (!isInferred)
{
references.Add(TypeReference.Create(
typeSystemObject,
scope: scope));
}
if (!BaseTypes.IsNonGenericBaseType(typeSystemObject.GetType()))
{
references.Add(TypeReference.Create(
typeSystemObject.GetType(),
SchemaTypeReference.InferTypeContext(typeSystemObject),
scope: scope));
}
if (typeSystemObject is IHasTypeIdentity hasTypeIdentity &&
hasTypeIdentity.TypeIdentity is { })
{
var reference = TypeReference.Create(
hasTypeIdentity.TypeIdentity,
SchemaTypeReference.InferTypeContext(typeSystemObject),
scope: scope);
if (!references.Contains(reference))
{
references.Add(reference);
}
}
var registeredType = new RegisteredType(
references,
typeSystemObject,
discoveryContext,
CollectDependencies(discoveryContext),
isInferred);
return(registeredType);
}
private RegisteredType InitializeType(
TypeSystemObjectBase typeSystemObject,
bool isInferred)
{
try
{
var initializationContext = new InitializationContext(
typeSystemObject,
_serviceFactory.Services,
_descriptorContext,
_contextData,
_interceptor);
typeSystemObject.Initialize(initializationContext);
var references = new List <ITypeReference>();
if (!isInferred)
{
references.Add(new SchemaTypeReference(typeSystemObject));
}
if (!BaseTypes.IsNonGenericBaseType(typeSystemObject.GetType()))
{
references.Add(new ClrTypeReference(
typeSystemObject.GetType(),
SchemaTypeReference.InferTypeContext(typeSystemObject)));
}
if (typeSystemObject is IHasTypeIdentity hasTypeIdentity &&
hasTypeIdentity.TypeIdentity is { })
{
var reference = new ClrTypeReference(
hasTypeIdentity.TypeIdentity,
SchemaTypeReference.InferTypeContext(typeSystemObject));
if (!references.Contains(reference))
{
references.Add(reference);
}
}
var registeredType = new RegisteredType(
references,
typeSystemObject,
initializationContext,
initializationContext.TypeDependencies,
isInferred);
return(registeredType);
}
private INamedType CreateAndRegisterType(Type type)
{
if (BaseTypes.IsNonGenericBaseType(type))
{
throw new SchemaException(new SchemaError(
"You cannot add a type without specifing its " +
"name and attributes."));
}
TypeReference typeReference = type.GetOutputType();
_typeRegistry.RegisterType(typeReference);
return(_typeRegistry.GetType <INamedType>(typeReference));
}
public void RegisterType(TypeReference typeReference)
{
if (typeReference == null)
{
throw new ArgumentNullException(nameof(typeReference));
}
if (!_sealed &&
typeReference.IsClrTypeReference() &&
!BaseTypes.IsNonGenericBaseType(typeReference.ClrType))
{
RegisterNativeType(typeReference.ClrType);
}
}
private T CreateAndRegisterType <T>()
where T : class, INamedType
{
if (BaseTypes.IsNonGenericBaseType(typeof(T)))
{
throw new SchemaException(new SchemaError(
"You cannot add a type without specifing its " +
"name and attributes."));
}
TypeReference typeReference = new TypeReference(typeof(T));
_typeRegistry.RegisterType(typeReference);
return(_typeRegistry.GetType <T>(typeReference));
}
private void RegisterExternalResolvers()
{
if (_externalResolverTypes.Count == 0)
{
return;
}
IDescriptorContext descriptorContext =
DescriptorContext.Create(_services);
Dictionary <NameString, ObjectType> types =
_types.Select(t => t.Value.Type)
.OfType <ObjectType>()
.ToDictionary(t => t.Name);
foreach (Type type in _externalResolverTypes)
{
GraphQLResolverOfAttribute attribute =
type.GetCustomAttribute <GraphQLResolverOfAttribute>();
if (attribute.TypeNames != null)
{
foreach (string typeName in attribute.TypeNames)
{
if (types.TryGetValue(typeName,
out ObjectType objectType))
{
AddResolvers(descriptorContext, objectType, type);
}
}
}
if (attribute.Types != null)
{
foreach (Type sourceType in attribute.Types
.Where(t => !BaseTypes.IsNonGenericBaseType(t)))
{
ObjectType objectType = types.Values
.FirstOrDefault(t => t.GetType() == sourceType);
if (objectType != null)
{
AddResolvers(descriptorContext, objectType, type);
}
}
}
}
}
private void InitializeTypes()
{
foreach (ITypeReference typeReference in _unregistered.ToList())
{
if (typeReference is IClrTypeReference ctr)
{
RegisterClrType(ctr);
}
else if (typeReference is ISchemaTypeReference str &&
str.Type is TypeSystemObjectBase tso)
{
if (BaseTypes.IsNonGenericBaseType(tso.GetType()))
{
RegisterTypeSystemObject(tso, str);
}
else
{
RegisterTypeSystemObject(tso);
}
}
private void AddResolverType(Type type)
{
GraphQLResolverOfAttribute attribute =
type.GetCustomAttribute <GraphQLResolverOfAttribute>(true);
_resolverTypes.Add(type);
if (attribute.Types != null)
{
foreach (Type schemaType in attribute.Types)
{
if (typeof(ObjectType).IsAssignableFrom(schemaType) &&
!BaseTypes.IsNonGenericBaseType(schemaType))
{
_types.Add(new ClrTypeReference(
schemaType,
SchemaTypeReference.InferTypeContext(schemaType)));
}
}
}
}
public ISchemaBuilder AddRootType(
Type type,
OperationType operation)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (!type.IsClass)
{
// TODO : resources
throw new ArgumentException(
"Root type must be a class",
nameof(type));
}
if (BaseTypes.IsNonGenericBaseType(type))
{
// TODO : resources
throw new ArgumentException(
"Non-generic schema types are not allowed.",
nameof(type));
}
if (BaseTypes.IsSchemaType(type) &&
!typeof(ObjectType).IsAssignableFrom(type))
{
// TODO : resources
throw new ArgumentException(
"must be object type",
nameof(type));
}
var reference = new ClrTypeReference(type, TypeContext.Output);
_operations.Add(operation, reference);
_types.Add(reference);
return(this);
}
public void RegisterType(TypeReference typeReference)
{
if (typeReference == null)
{
throw new ArgumentNullException(nameof(typeReference));
}
if (!_sealed)
{
if (typeReference.IsSchemaTypeReference())
{
TryUpdateNamedType(typeReference.SchemaType.NamedType());
}
else if (typeReference.IsClrTypeReference() &&
!BaseTypes.IsNonGenericBaseType(typeReference.ClrType))
{
RegisterType(
typeReference.ClrType,
typeReference.Context);
}
}
}
private bool TryNormalizeClrReference(
IClrTypeReference typeReference,
out ITypeReference normalized)
{
if (!BaseTypes.IsNonGenericBaseType(typeReference.Type) &&
_typeInspector.TryCreate(typeReference.Type,
out Utilities.TypeInfo typeInfo))
{
if (IsTypeSystemObject(typeInfo.ClrType))
{
normalized = new ClrTypeReference(
typeInfo.ClrType,
SchemaTypeReference.InferTypeContext(typeInfo.ClrType));
return(true);
}
else
{
for (int i = 0; i < typeInfo.Components.Count; i++)
{
var n = new ClrTypeReference(
typeInfo.Components[i],
typeReference.Context);
if ((ClrTypes.TryGetValue(
n, out ITypeReference r) ||
ClrTypes.TryGetValue(
n.WithoutContext(), out r)))
{
normalized = r;
return(true);
}
}
}
}
normalized = null;
return(false);
}
private void TryUpdateNamedType(INamedType namedType)
{
if (!_namedTypes.TryGetValue(namedType.Name,
out INamedType namedTypeRef))
{
namedTypeRef = namedType;
_namedTypes[namedTypeRef.Name] = namedTypeRef;
}
Type type = namedTypeRef.GetType();
if (!_clrTypeToSchemaType.ContainsKey(type) &&
!BaseTypes.IsNonGenericBaseType(type))
{
_clrTypeToSchemaType[type] = namedTypeRef.Name;
}
if (namedTypeRef is IHasClrType inputType &&
inputType.ClrType != null)
{
AddNativeTypeBinding(inputType.ClrType, namedTypeRef.Name);
}
}
public ISchemaBuilder AddRootType(
Type type,
OperationType operation)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (!type.IsClass)
{
throw new ArgumentException(
TypeResources.SchemaBuilder_RootType_MustBeClass,
nameof(type));
}
if (BaseTypes.IsNonGenericBaseType(type))
{
throw new ArgumentException(
TypeResources.SchemaBuilder_RootType_NonGenericType,
nameof(type));
}
if (BaseTypes.IsSchemaType(type) &&
!typeof(ObjectType).IsAssignableFrom(type))
{
throw new ArgumentException(
TypeResources.SchemaBuilder_RootType_MustBeObjectType,
nameof(type));
}
var reference = new ClrTypeReference(type, TypeContext.Output);
_operations.Add(operation, reference);
_types.Add(reference);
return(this);
}
private void InitializeTypes()
{
foreach (ITypeReference typeReference in _unregistered.ToList())
{
if (typeReference is IClrTypeReference ctr)
{
RegisterClrType(ctr);
}
else if (typeReference is ISchemaTypeReference str &&
str.Type is TypeSystemObjectBase tso)
{
if (BaseTypes.IsNonGenericBaseType(tso.GetType()))
{
RegisterTypeSystemObject(tso, str);
}
else
{
var secondaryRef = new ClrTypeReference(
tso.GetType(),
SchemaTypeReference.InferTypeContext(tso));
RegisterTypeSystemObject(tso, str, secondaryRef);
}
}
private bool TryNormalizeClrReference(
IClrTypeReference typeReference,
out IClrTypeReference normalized)
{
if (!BaseTypes.IsNonGenericBaseType(typeReference.Type) &&
_typeInspector.TryCreate(typeReference.Type,
out Utilities.TypeInfo typeInfo))
{
if (IsTypeSystemObject(typeInfo.ClrType))
{
normalized = new ClrTypeReference(
typeInfo.ClrType,
SchemaTypeReference.InferTypeContext(typeInfo.ClrType));
return(true);
}
else
{
normalized = new ClrTypeReference(
typeInfo.ClrType,
typeReference.Context);
if ((_clrTypes.TryGetValue(
normalized, out ITypeReference r) ||
_clrTypes.TryGetValue(
normalized.WithoutContext(), out r)) &&
r is IClrTypeReference cr)
{
normalized = cr;
return(true);
}
}
}
normalized = null;
return(false);
}
