public void Register( ITypeRegistrar typeRegistrar, IEnumerable <ITypeReference> typeReferences) { foreach (ExtendedTypeReference typeReference in typeReferences.OfType <ExtendedTypeReference>()) { if (_typeInspector.TryCreateTypeInfo(typeReference.Type, out ITypeInfo? typeInfo) && !ExtendedType.Tools.IsNonGenericBaseType(typeInfo.NamedType)) { Type namedType = typeInfo.NamedType; if (IsTypeSystemObject(namedType)) { IExtendedType extendedType = _typeInspector.GetType(namedType); ExtendedTypeReference namedTypeReference = typeReference.With(extendedType); if (!typeRegistrar.IsResolved(namedTypeReference)) { typeRegistrar.Register( typeRegistrar.CreateInstance(namedType), typeReference.Scope, ExtendedType.Tools.IsGenericBaseType(namedType)); } } else { TryMapToExistingRegistration( typeRegistrar, typeInfo, typeReference.Context, typeReference.Scope); } } } }
public static IExtendedType GetSchemaType( ITypeInspector typeInspector, MemberInfo?member, Type?type) { if (type is null && member is not null && typeInspector.GetOutputReturnTypeRef(member) is ExtendedTypeReference r && typeInspector.TryCreateTypeInfo(r.Type, out ITypeInfo? typeInfo)) { // if the member has already associated a schema type with an attribute for instance // we will just take it. Since we want the entity element we are going to take // the element type of the list or array as our entity type. if (r.Type.IsSchemaType && r.Type.IsArrayOrList) { return(r.Type.ElementType !); } // if the member type is unknown we will try to infer it by extracting // the named type component from it and running the type inference. // It might be that we either are unable to infer or get the wrong type // in special cases. In the case we are getting it wrong the user has // to explicitly bind the type. if (SchemaTypeResolver.TryInferSchemaType( typeInspector, r.WithType(typeInspector.GetType(typeInfo.NamedType)), out ExtendedTypeReference schemaTypeRef)) { // if we are able to infer the type we will reconstruct its structure so that // we can correctly extract from it the element type with the correct // nullability information. Type current = schemaTypeRef.Type.Type; foreach (TypeComponent component in typeInfo.Components.Reverse().Skip(1)) { if (component.Kind == TypeComponentKind.NonNull) { current = typeof(NonNullType <>).MakeGenericType(current); } else if (component.Kind == TypeComponentKind.List) { current = typeof(ListType <>).MakeGenericType(current); } } if (typeInspector.GetType(current) is { IsArrayOrList : true } schemaType) { return(schemaType.ElementType !); } } } if (type is null || !typeof(IType).IsAssignableFrom(type)) { throw ThrowHelper.UsePagingAttribute_NodeTypeUnknown(member); } return(typeInspector.GetType(type)); }
private bool TryNormalizeExtendedTypeReference( ExtendedTypeReference typeRef, [NotNullWhen(true)] out ITypeReference?namedTypeRef) { if (typeRef is null) { throw new ArgumentNullException(nameof(typeRef)); } // if the typeRef refers to a schema type base class we skip since such a type is not // resolvable. if (typeRef.Type.Type.IsNonGenericSchemaType() || !_typeInspector.TryCreateTypeInfo(typeRef.Type, out ITypeInfo? typeInfo)) { namedTypeRef = null; return(false); } // if we have a concrete schema type we will extract the named type component of // the type and rewrite the type reference. if (typeRef.Type.IsSchemaType) { namedTypeRef = typeRef.With(_typeInspector.GetType(typeInfo.NamedType)); return(true); } // we check each component layer since there could be a binding on a list type, // eg list<byte> to ByteArray. for (var i = 0; i < typeInfo.Components.Count; i++) { IExtendedType componentType = typeInfo.Components[i].Type; ExtendedTypeReference componentRef = typeRef.WithType(componentType); if (_typeRegistry.TryGetTypeRef(componentRef, out namedTypeRef) || _typeRegistry.TryGetTypeRef(componentRef.WithContext(), out namedTypeRef)) { return(true); } } namedTypeRef = null; return(false); }
private static Type GetArgumentType( ObjectFieldDefinition definition, Type?filterType, ITypeInspector typeInspector) { Type?argumentType = filterType; if (argumentType is null) { if (definition.ResultType is null || definition.ResultType == typeof(object) || !typeInspector.TryCreateTypeInfo( definition.ResultType, out ITypeInfo? typeInfo)) { throw new SchemaException( SchemaErrorBuilder.New() .SetMessage("Cannot handle the specified type.") .SetExtension("fieldName", definition.Name) .Build()); } argumentType = typeof(SortInputType <>).MakeGenericType(typeInfo.NamedType); } if (argumentType == typeof(object)) { // TODO : resources throw new SchemaException( SchemaErrorBuilder.New() .SetMessage( "The sort type cannot be " + "inferred from `System.Object`.") .SetCode(ErrorCodes.Filtering.FilterObjectType) .Build()); } return(argumentType); }
public void Handle(ITypeRegistrar typeRegistrar, ITypeReference typeReference) { var typeRef = (ExtendedTypeReference)typeReference; if (_typeInspector.TryCreateTypeInfo(typeRef.Type, out ITypeInfo? typeInfo) && !ExtendedType.Tools.IsNonGenericBaseType(typeInfo.NamedType)) { if (typeInfo.NamedType == typeof(IExecutable)) { throw ThrowHelper.NonGenericExecutableNotAllowed(); } Type namedType = typeInfo.NamedType; if (IsTypeSystemObject(namedType)) { IExtendedType extendedType = _typeInspector.GetType(namedType); ExtendedTypeReference namedTypeReference = typeRef.With(extendedType); if (!typeRegistrar.IsResolved(namedTypeReference)) { typeRegistrar.Register( typeRegistrar.CreateInstance(namedType), typeReference.Scope, ExtendedType.Tools.IsGenericBaseType(namedType)); } } else { TryMapToExistingRegistration( typeRegistrar, typeInfo, typeReference.Context, typeReference.Scope); } } }