private static bool IsMutationType( ITypeInspector typeInspector, TypeSystemObjectBase type, Dictionary <OperationType, ITypeReference> operations) { if (type is ObjectType objectType) { if (operations.TryGetValue(OperationType.Mutation, out ITypeReference? typeRef)) { if (typeRef is SchemaTypeReference sr) { return(sr.Type == objectType); } if (typeRef is ExtendedTypeReference cr) { return(cr.Type == typeInspector.GetType(objectType.GetType()) || cr.Type == typeInspector.GetType(objectType.RuntimeType)); } if (typeRef is SyntaxTypeReference str) { return(objectType.Name.Equals(str.Type.NamedType().Name.Value)); } } else { return(type.Name.Equals(WellKnownTypes.Mutation)); } } return(false); }
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)); }
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); } } } }
private static void AddSerializerToObjectField( ITypeCompletionContext completionContext, ObjectFieldDefinition definition, FieldMiddleware placeholder, NameString typeName) { ITypeInspector typeInspector = completionContext.TypeInspector; IExtendedType? resultType; if (definition.ResultType is not null) { resultType = typeInspector.GetType(definition.ResultType); } else if (definition.Type is ExtendedTypeReference typeReference) { resultType = typeReference.Type; } else { throw new SchemaException(SchemaErrorBuilder.New() .SetMessage("Unable to resolve type from field `{0}`.", definition.Name) .SetTypeSystemObject(completionContext.Type) .Build()); } NameString schemaName = default; completionContext.DescriptorContext.SchemaCompleted += (sender, args) => schemaName = args.Schema.Name; IIdSerializer serializer = completionContext.Services.GetService <IIdSerializer>() ?? new IdSerializer(); var index = definition.MiddlewareComponents.IndexOf(placeholder); definition.MiddlewareComponents[index] = next => async context => { await next(context).ConfigureAwait(false); if (context.Result is not null) { if (resultType.IsArrayOrList) { var list = new List <object?>(); foreach (object?element in (IEnumerable)context.Result) { list.Add(element is null ? element : serializer.Serialize(schemaName, typeName, element)); } context.Result = list; } else { context.Result = serializer.Serialize(schemaName, typeName, context.Result); } } }; }
public void ITypeReference_Equals_To_SyntaxTypeRef() { // arrange SyntaxTypeReference x = TypeReference.Create( "Foo", TypeContext.None); // act var xx = x.Equals(TypeReference.Create(_typeInspector.GetType(typeof(int)))); // assert Assert.False(xx); }
private static bool IsOperationType( ObjectType objectType, OperationType operationType, ITypeInspector typeInspector, Dictionary <OperationType, ITypeReference> operations) { if (operations.TryGetValue(operationType, out ITypeReference? typeRef)) { if (typeRef is SchemaTypeReference sr) { return(sr.Type == objectType); } if (typeRef is ExtendedTypeReference cr) { return(cr.Type == typeInspector.GetType(objectType.GetType()) || cr.Type == typeInspector.GetType(objectType.RuntimeType)); } if (typeRef is SyntaxTypeReference str) { return(objectType.Name.Equals(str.Type.NamedType().Name.Value)); } } else if (operationType == OperationType.Query) { return(objectType.Name.Equals(OperationTypeNames.Query)); } else if (operationType == OperationType.Mutation) { return(objectType.Name.Equals(OperationTypeNames.Mutation)); } else if (operationType == OperationType.Subscription) { return(objectType.Name.Equals(OperationTypeNames.Subscription)); } return(false); }
private static IExtendedType GetSourceType( ITypeInspector typeInspector, ObjectFieldDefinition definition, Type entityType) { // if an explicit result type is defined we will type it since it expresses the // intend. if (definition.ResultType is not null) { return(typeInspector.GetType(definition.ResultType)); } // Otherwise we will look at specified members and extract the return type. MemberInfo?member = definition.ResolverMember ?? definition.Member; if (member is not null) { return(typeInspector.GetReturnType(member, true)); } // if we were not able to resolve the source type we will assume that it is // an enumerable of the entity type. return(typeInspector.GetType(typeof(IEnumerable <>).MakeGenericType(entityType))); }
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 IExtendedType RewriteType(ITypeInspector typeInspector, ITypeInfo typeInfo) { Type current = typeof(IdType); if (typeInfo.Components.Count > 1) { 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); } } } return(typeInspector.GetType(current)); }
public static bool TryInferSchemaType( ITypeInspector typeInspector, ExtendedTypeReference unresolvedType, out ExtendedTypeReference schemaType) { if (IsObjectTypeExtension(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(ObjectTypeExtension <>).MakeGenericType(unresolvedType.Type.Type))); } else if (IsUnionType(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(UnionType <>).MakeGenericType(unresolvedType.Type.Type))); } else if (IsInterfaceType(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(InterfaceType <>).MakeGenericType(unresolvedType.Type.Type))); } else if (IsObjectType(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(ObjectType <>).MakeGenericType(unresolvedType.Type.Type))); } else if (IsInputObjectType(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(InputObjectType <>).MakeGenericType(unresolvedType.Type.Type))); } else if (IsEnumType(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(EnumType <>).MakeGenericType(unresolvedType.Type.Type))); } else { schemaType = null; } return(schemaType != null); }
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); } } }
public void TypeReference_Create( Type clrType, TypeContext context, string scope) { // arrange // act ExtendedTypeReference typeReference = TypeReference.Create( _typeInspector.GetType(clrType), context, scope: scope); // assert Assert.Equal(clrType, typeReference.Type.Source); Assert.Equal(context, typeReference.Context); Assert.Equal(scope, typeReference.Scope); }
public static bool TryInferSchemaType( ITypeInspector typeInspector, ExtendedTypeReference unresolvedType, out ExtendedTypeReference schemaType) { if (typeInspector is null) { throw new ArgumentNullException(nameof(typeInspector)); } if (unresolvedType is null) { throw new ArgumentNullException(nameof(unresolvedType)); } if (IsObjectTypeExtension(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(ObjectTypeExtension <>).MakeGenericType(unresolvedType.Type.Type))); } else if (IsUnionType(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(UnionType <>).MakeGenericType(unresolvedType.Type.Type))); } else if (IsInterfaceType(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(InterfaceType <>).MakeGenericType(unresolvedType.Type.Type))); } else if (IsObjectType(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(ObjectType <>).MakeGenericType(unresolvedType.Type.Type))); } else if (IsInputObjectType(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(InputObjectType <>).MakeGenericType(unresolvedType.Type.Type))); } else if (IsEnumType(unresolvedType)) { schemaType = unresolvedType.With( type: typeInspector.GetType( typeof(EnumType <>).MakeGenericType(unresolvedType.Type.Type))); } else if (Scalars.TryGetScalar(unresolvedType.Type.Type, out Type scalarType)) { schemaType = unresolvedType.With( type: typeInspector.GetType(scalarType)); } else { schemaType = null; } return(schemaType != null); }
private static void AddSerializerToObjectField( ITypeCompletionContext completionContext, ObjectFieldDefinition definition, ResultConverterDefinition placeholder, NameString typeName) { ITypeInspector typeInspector = completionContext.TypeInspector; IExtendedType? resultType; if (definition.ResultType is not null) { resultType = typeInspector.GetType(definition.ResultType); } else if (definition.Type is ExtendedTypeReference typeReference) { resultType = typeReference.Type; } else { throw new SchemaException(SchemaErrorBuilder.New() .SetMessage("Unable to resolve type from field `{0}`.", definition.Name) .SetTypeSystemObject(completionContext.Type) .Build()); } NameString schemaName = default; completionContext.DescriptorContext.SchemaCompleted += (_, args) => schemaName = args.Schema.Name; IIdSerializer serializer = completionContext.Services.GetService <IIdSerializer>() ?? new IdSerializer(); var index = definition.ResultConverters.IndexOf(placeholder); if (typeName.IsEmpty) { typeName = completionContext.Type.Name; } definition.ResultConverters[index] = new((_, result) => { if (result is not null) { if (resultType.IsArrayOrList) { var list = new List <object?>(); foreach (var element in (IEnumerable)result) { list.Add(element is null ? element : serializer.Serialize(schemaName, typeName, element)); } return(list); } return(serializer.Serialize(schemaName, typeName, result)); } return(result); }, key : WellKnownMiddleware.GlobalId, isRepeatable : false); }