public ISchemaBuilder BindClrType(Type clrType, Type schemaType) { if (clrType == null) { throw new ArgumentNullException(nameof(clrType)); } if (schemaType == null) { throw new ArgumentNullException(nameof(schemaType)); } if (!BaseTypes.IsSchemaType(schemaType)) { // TODO : resources throw new ArgumentException( TypeResources.SchemaBuilder_MustBeSchemaType, nameof(schemaType)); } TypeContext context = SchemaTypeReference.InferTypeContext(schemaType); _clrTypes[new ClrTypeReference(clrType, context)] = new ClrTypeReference(schemaType, context); return(this); }
private Type GetSchemaType( IDescriptorContext context, MemberInfo member) { Type? type = SchemaType; ITypeReference returnType = context.Inspector.GetReturnType( member, TypeContext.Output); if (type is null && returnType is ClrTypeReference clr && TypeInspector.Default.TryCreate(clr.Type, out var typeInfo)) { if (BaseTypes.IsSchemaType(typeInfo.ClrType)) { type = typeInfo.ClrType; } else if (SchemaTypeResolver.TryInferSchemaType( clr.WithType(typeInfo.ClrType), out ClrTypeReference schemaType)) { type = schemaType.Type; } } if (type is null || !typeof(IType).IsAssignableFrom(type)) { throw new SchemaException( SchemaErrorBuilder.New() .SetMessage("The UsePaging attribute needs a valid node schema type.") .SetCode("ATTR_USEPAGING_SCHEMATYPE_INVALID") .Build()); } return(type); }
protected ITypeReference RewriteTypeListType() { ITypeReference reference = Definition.Type; if (reference is IClrTypeReference clrRef) { if (BaseTypes.IsSchemaType(clrRef.Type)) { return(clrRef.WithType( typeof(ListType <>).MakeGenericType(clrRef.Type))); } else { return(clrRef.WithType( typeof(List <>).MakeGenericType(clrRef.Type))); } } if (reference is ISchemaTypeReference schemaRef) { return(schemaRef.WithType(new ListType((IType)schemaRef.Type))); } if (reference is ISyntaxTypeReference syntaxRef) { return(syntaxRef.WithType(new ListTypeNode(syntaxRef.Type))); } throw new NotSupportedException(); }
public IObjectFieldDescriptor Resolver( FieldResolverDelegate fieldResolver, Type resultType) { if (fieldResolver == null) { throw new ArgumentNullException(nameof(fieldResolver)); } Definition.Resolver = fieldResolver; if (resultType != null) { Definition.SetMoreSpecificType(resultType, TypeContext.Output); Type resultTypeDef = resultType.GetGenericTypeDefinition(); Type clrResultType = resultType.IsGenericType && resultTypeDef == typeof(NativeType <>) ? resultType.GetGenericArguments()[0] : resultType; if (!BaseTypes.IsSchemaType(clrResultType)) { Definition.ResultType = clrResultType; } } return(this); }
protected ITypeReference RewriteTypeToNullableType() { ITypeReference reference = Definition.Type; if (reference is IClrTypeReference clrRef && TypeInspector.Default.TryCreate( clrRef.Type, out Utilities.TypeInfo typeInfo)) { if (BaseTypes.IsSchemaType(typeInfo.ClrType)) { if (clrRef.Type.IsGenericType && clrRef.Type.GetGenericTypeDefinition() == typeof(NonNullType <>)) { return(clrRef.WithType(typeInfo.Components[1])); } return(clrRef); } else { if (clrRef.Type.IsValueType) { if (Nullable.GetUnderlyingType(clrRef.Type) == null) { return(clrRef.WithType( typeof(Nullable <>).MakeGenericType(clrRef.Type))); } return(clrRef); } else if (clrRef.Type.IsGenericType && clrRef.Type.GetGenericTypeDefinition() == typeof(NonNullType <>)) { return(clrRef.WithType(typeInfo.Components[1])); } return(clrRef); } } if (reference is ISchemaTypeReference schemaRef) { return(schemaRef.Type is NonNullType nnt ? schemaRef.WithType(nnt) : schemaRef); } if (reference is ISyntaxTypeReference syntaxRef) { return(syntaxRef.Type is NonNullTypeNode nnt ? syntaxRef.WithType(nnt) : syntaxRef); } throw new NotSupportedException(); }
public static bool IsTypeMoreSpecific( this TypeReference typeReference, Type type) { if (typeReference == null || BaseTypes.IsSchemaType(type)) { return(true); } if (typeReference.IsNativeTypeReference() && !BaseTypes.IsSchemaType(typeReference.NativeType)) { return(true); } return(false); }
public static TypeDependency FromSchemaType( Type type, TypeDependencyKind kind) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (BaseTypes.IsSchemaType(type)) { TypeContext context = SchemaTypeReference.InferTypeContext(type); var reference = new ClrTypeReference(type, context); return(new TypeDependency(reference, kind)); } throw new ArgumentException( TypeResources.TypeDependency_MustBeSchemaType, nameof(type)); }
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); }
private static bool IsTypeMoreSpecific( ITypeReference typeReference, Type type) { if (typeReference is SchemaTypeReference) { return(false); } if (typeReference == null || BaseTypes.IsSchemaType(type)) { return(true); } if (typeReference is ClrTypeReference clr && !BaseTypes.IsSchemaType(clr.Type)) { return(true); } return(false); }
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); }
public bool IsSchemaType(Type type) => BaseTypes.IsSchemaType(type);