/// <summary> /// Determines whether the the provided type to check is IDictionary{ExpectedKey, AnyValue} ensuring that it can be /// used as an input to a batch processor that supplies data to multiple waiting items. /// </summary> /// <param name="typeToCheck">The type being checked.</param> /// <param name="expectedKeyType">The expected key type.</param> /// <param name="batchedItemType">Type of the batched item. if the type to check returns an IEnumerable per /// key this type must represent the individual item of the set. (i.e. the 'T' of IEnumerable{T}).</param> /// <returns><c>true</c> if the type represents a dictionary keyed on the expected key type; otherwise, <c>false</c>.</returns> public static bool IsBatchDictionaryType(Type typeToCheck, Type expectedKeyType, Type batchedItemType) { if (typeToCheck == null || expectedKeyType == null || batchedItemType == null) { return(false); } var enumeratedType = typeToCheck.GetEnumerableUnderlyingType(); if (enumeratedType == null || !enumeratedType.IsGenericType || typeof(KeyValuePair <,>) != enumeratedType.GetGenericTypeDefinition()) { return(false); } var paramSet = enumeratedType.GetGenericArguments(); if (paramSet.Length != 2) { return(false); } if (paramSet[0] != expectedKeyType) { return(false); } var unwrapped = GraphValidation.EliminateWrappersFromCoreType(paramSet[1]); if (unwrapped != batchedItemType) { return(false); } return(true); }
/// <summary> /// Ensures the provided <see cref="IGraphType" /> exists in this collection (adding it if it is missing) /// and that the given type reference is assigned to it. An exception will be thrown if the type reference is already assigned /// to a different <see cref="IGraphType" />. No dependents or additional types will be added. /// </summary> /// <param name="graphType">Type of the graph.</param> /// <param name="associatedType">The concrete type to associate to the graph type.</param> /// <returns><c>true</c> if type had to be added, <c>false</c> if it already existed in the collection.</returns> public bool EnsureGraphType(IGraphType graphType, Type associatedType = null) { Validation.ThrowIfNull(graphType, nameof(graphType)); associatedType = GraphValidation.EliminateWrappersFromCoreType(associatedType); GraphValidation.EnsureValidGraphTypeOrThrow(associatedType); // attempt to create a relationship between the graph type and the associated type // the concrete type collection will throw an exception if that relationship fails or isnt // updated to the new data correctly. var justAdded = _graphTypesByName.TryAdd(graphType.Name, graphType); _concreteTypes.EnsureRelationship(graphType, associatedType); _extendableGraphTypeTracker.MonitorGraphType(graphType); // dequeue and add any extension fields if present if (associatedType != null) { var unregisteredFields = _typeQueue.DequeueFields(associatedType); if (graphType is IExtendableGraphType objType) { foreach (var field in unregisteredFields) { _extendableGraphTypeTracker.AddFieldExtension(objType, field); } } } return(justAdded); }
/// <summary> /// Adds the given type to the schema as a graph type or a registered controller depending /// on the type. /// </summary> /// <param name="type">The concrete type to add.</param> /// <param name="kind">The kind of graph type to create from the supplied concrete type. If not supplied the concrete type will /// attempt to auto assign a type of scalar, enum or object as necessary.</param> public void EnsureGraphType(Type type, TypeKind?kind = null) { if (Validation.IsCastable <GraphController>(type)) { if (GraphQLProviders.TemplateProvider.ParseType(type) is IGraphControllerTemplate controllerDefinition) { this.AddController(controllerDefinition); } return; } type = GraphValidation.EliminateWrappersFromCoreType(type); // if the type is already registered, early exit no point in running it through again var actualKind = GraphValidation.ResolveTypeKindOrThrow(type, kind); if (this.Schema.KnownTypes.Contains(type, actualKind)) { return; } var maker = GraphQLProviders.GraphTypeMakerProvider.CreateTypeMaker(this.Schema, actualKind); if (maker != null) { var result = maker.CreateGraphType(type); if (result != null) { this.Schema.KnownTypes.EnsureGraphType(result.GraphType, result.ConcreteType); this.EnsureDependents(result); } } }
/// <summary> /// Builds out this field template parsing out the required type declarations unions, nameing scheme etc. This method should be /// overridden in any child classes for additional decalration requirements. /// </summary> protected override void ParseTemplateDefinition() { // ensure type extension right out of the gate // the field can't be built otherwise _typeAttrib = this.SingleAttributeOfTypeOrDefault <TypeExtensionAttribute>(); if (_typeAttrib == null) { return; } _sourceType = _typeAttrib.TypeToExtend; base.ParseTemplateDefinition(); var returnType = GraphValidation.EliminateWrappersFromCoreType(this.DeclaredReturnType); if (returnType != typeof(IGraphActionResult)) { // inspect the return type, if its a valid dictionary extract the return type from the value // and set the type modifiers and method type based on the value of each dictionary entry if (_typeAttrib.ExecutionMode == FieldResolutionMode.Batch) { returnType = returnType.GetValueTypeOfDictionary(); this.ObjectType = GraphValidation.EliminateWrappersFromCoreType(returnType); this.TypeExpression = GraphValidation.GenerateTypeExpression(returnType, this); this.PossibleTypes.Insert(0, this.ObjectType); } } }
/// <summary> /// Type extensions used as batch methods required a speceial input and output signature for the runtime /// to properly supply and retrieve data from the batch. This method ensures the signature coorisponds to those requirements or /// throws an exception indicating the problem if one is found. /// </summary> private void ValidateBatchMethodSignatureOrThrow() { if (this.Mode != FieldResolutionMode.Batch) { return; } // the method MUST accept a parameter of type IEnumerable<TypeToExtend> in its signature somewhere // when declared in batch mode var requiredEnumerable = typeof(IEnumerable <>).MakeGenericType(this.SourceObjectType); if (this.Arguments.All(arg => arg.DeclaredArgumentType != requiredEnumerable)) { throw new GraphTypeDeclarationException( $"Invalid batch method signature. The field '{this.InternalFullName}' declares itself as batch method but does not accept a batch " + $"of data as an input parameter. This method must accept a parameter of type '{requiredEnumerable.FriendlyName()}' somewhere in its method signature to " + $"be used as a batch extension for the type '{this.SourceObjectType.FriendlyName()}'."); } var declaredType = GraphValidation.EliminateWrappersFromCoreType(this.DeclaredReturnType); if (declaredType == typeof(IGraphActionResult)) { return; } // when a batch method doesn't return an action result, indicating the developer // opts to specify his return types explicitly; ensure that their chosen return type is a dictionary // keyed on the type being extended allowing the runtime to seperate the batch // for proper segmentation in the object graph. // -- // when the return type is a graph action this check is deferred after results of the batch are produced if (!BatchResultProcessor.IsBatchDictionaryType(declaredType, this.SourceObjectType, this.ObjectType)) { throw new GraphTypeDeclarationException( $"Invalid batch method signature. The field '{this.InternalFullName}' declares a return type of '{declaredType.FriendlyName()}', however; " + $"batch methods must return either an '{typeof(IGraphActionResult).FriendlyName()}' or a dictionary keyed " + "on the provided source data (e.g. 'IDictionary<SourceType, ResultsPerSourceItem>')."); } // ensure any possible type declared via attribution matches the value type of the resultant dictionary // e.g.. if they supply a union for the field but declare a dictionary of IDictionary<T,K> // each member of the union must be castable to 'K' in order for the runtime to properly seperate // and process the batch results var dictionaryValue = GraphValidation.EliminateWrappersFromCoreType(declaredType.GetValueTypeOfDictionary()); foreach (var type in this.PossibleTypes) { if (!Validation.IsCastable(type, dictionaryValue)) { throw new GraphTypeDeclarationException( $"The field '{this.InternalFullName}' returns '{this.ObjectType.FriendlyName()}' and declares a possible type of '{type.FriendlyName()}' " + $"but that type is not castable to '{this.ObjectType.FriendlyName()}' and therefore not returnable by this field. Due to the strongly-typed nature of C# any possible type on a field " + "must be castable to the type of the field in order to ensure its not inadvertantly nulled out during processing. If this field returns a union " + $"of multiple, disperate types consider returning '{typeof(object).Name}' from the field to ensure each possible return type can be successfully processed."); } } }
/// <summary> /// Parses the primary metadata about the method. /// </summary> public void Parse() { DirectiveLifeCycle lifeCycle; switch (this.Method.Name) { case Constants.ReservedNames.DIRECTIVE_BEFORE_RESOLUTION_METHOD_NAME: lifeCycle = DirectiveLifeCycle.BeforeResolution; break; case Constants.ReservedNames.DIRECTIVE_AFTER_RESOLUTION_METHOD_NAME: lifeCycle = DirectiveLifeCycle.AfterResolution; break; default: return; } this.IsValidDirectiveMethod = (this.Method.ReturnType == typeof(IGraphActionResult) || this.Method.ReturnType == typeof(Task <IGraphActionResult>)) && !this.Method.IsGenericMethod; this.Description = this.Method.SingleAttributeOrDefault <DescriptionAttribute>()?.Description; this.DeclaredType = this.Method.ReturnType; this.IsAsyncField = Validation.IsCastable <Task>(this.Method.ReturnType); // is the method asyncronous? if so ensure that a Task<T> is returned // and not an empty task if (this.IsAsyncField && this.Method.ReturnType.IsGenericType) { // for any ssync field attempt to pull out the T in Task<T> var genericArgs = this.Method.ReturnType.GetGenericArguments(); if (genericArgs.Any()) { this.DeclaredType = genericArgs[0]; } } this.ObjectType = GraphValidation.EliminateWrappersFromCoreType(this.DeclaredType); this.LifeCycle = lifeCycle; this.Route = this.GenerateRoute(); this.TypeExpression = new GraphTypeExpression(this.ObjectType.FriendlyName()); // parse all input parameters into the method foreach (var parameter in this.Method.GetParameters()) { var argTemplate = new GraphFieldArgumentTemplate(this, parameter); argTemplate.Parse(); _arguments.Add(argTemplate); } this.MethodSignature = this.GenerateMethodSignatureString(); this.ExpectedReturnType = GraphValidation.EliminateWrappersFromCoreType( this.DeclaredType, false, true, false); }
/// <summary> /// Updates the field resolver used by this graph field. /// </summary> /// <param name="newResolver">The new resolver this field should use.</param> /// <param name="mode">The new resolution mode used by the runtime to invoke the resolver.</param> public void UpdateResolver(IGraphFieldResolver newResolver, FieldResolutionMode mode) { this.Resolver = newResolver; this.Mode = mode; var unrwrappedType = GraphValidation.EliminateWrappersFromCoreType(this.Resolver?.ObjectType); this.IsLeaf = this.Resolver?.ObjectType != null && GraphQLProviders.ScalarProvider.IsLeaf(unrwrappedType); }
/// <summary> /// When overridden in a child class this method builds out the template according to its own individual requirements. /// </summary> protected override void ParseTemplateDefinition() { base.ParseTemplateDefinition(); this.ExpectedReturnType = GraphValidation.EliminateWrappersFromCoreType( this.DeclaredReturnType, false, true, false); }
/// <summary> /// Invokes this middleware component allowing it to perform its work against the supplied context. /// </summary> /// <param name="context">The context containing the request passed through the pipeline.</param> /// <param name="next">The delegate pointing to the next piece of middleware to be invoked.</param> /// <param name="cancelToken">The cancel token.</param> /// <returns>Task.</returns> public Task InvokeAsync(GraphFieldExecutionContext context, GraphMiddlewareInvocationDelegate <GraphFieldExecutionContext> next, CancellationToken cancelToken) { // ensure that the data items on teh request match the field they are being executed against var field = context.Field; var expectedFieldGraphType = _schema.KnownTypes.FindGraphType(field); var dataSource = context.Request.DataSource; // ensure the source being supplied // matches the expected source of the field being resolved if (context.InvocationContext.ExpectedSourceType != null) { var expectedSourceType = context.InvocationContext.ExpectedSourceType; var actualSourceType = GraphValidation.EliminateWrappersFromCoreType(dataSource.Value.GetType()); if (expectedSourceType != actualSourceType) { var expectedSourceGraphType = _schema.KnownTypes.FindGraphType(expectedSourceType, TypeKind.OBJECT); var analysis = _schema.KnownTypes.AnalyzeRuntimeConcreteType(expectedSourceGraphType, actualSourceType); if (!analysis.ExactMatchFound) { throw new GraphExecutionException( $"Operation failed. The field execution context for '{field.Route.Path}' was passed " + $"a source item of type '{dataSource.Value.GetType().FriendlyName()}' which could not be coerced " + $"to '{context.InvocationContext.ExpectedSourceType}' as requested by the target graph type '{expectedFieldGraphType.Name}'."); } if (context.Field.Mode == FieldResolutionMode.Batch && !(dataSource.GetType() is IEnumerable)) { throw new GraphExecutionException( $"Operation failed. The field execution context for '{field.Route.Path}' was executed in batch mode " + $"but was not passed an {nameof(IEnumerable)} for its source data."); } } } if (dataSource.Items.Count == 0) { var expected = context.InvocationContext.Field.Mode == FieldResolutionMode.PerSourceItem ? "1" : "at least 1"; throw new GraphExecutionException( $"Operation failed. The field execution context for '{field.Route.Path}' was passed " + $"0 items but expected {expected}. (Field Mode: {field.Mode.ToString()})"); } if (context.InvocationContext.Field.Mode == FieldResolutionMode.PerSourceItem && dataSource.Items.Count != 1) { throw new GraphExecutionException( $"Operation failed. The field execution context for '{field.Route.Path}' was passed " + $"{dataSource.Items.Count} items to resolve but expected 1. (Field Mode: {field.Mode.ToString()})"); } return(next(context, cancelToken)); }
/// <summary> /// Parses the template contents according to the rules of the template. /// </summary> public virtual void Parse() { this.DeclaredArgumentType = this.Parameter.ParameterType; this.ObjectType = GraphValidation.EliminateWrappersFromCoreType(this.Parameter.ParameterType); // set the name _fieldDeclaration = this.Parameter.SingleAttributeOrDefault <FromGraphQLAttribute>(); string name = null; if (_fieldDeclaration != null) { name = _fieldDeclaration?.ArgumentName?.Trim(); } if (string.IsNullOrWhiteSpace(name)) { name = Constants.Routing.PARAMETER_META_NAME; } name = name.Replace(Constants.Routing.PARAMETER_META_NAME, this.Parameter.Name); this.Route = new GraphArgumentFieldPath(this.Parent.Route, name); this.Description = this.Parameter.SingleAttributeOrDefault <DescriptionAttribute>()?.Description?.Trim(); if (this.Parameter.HasDefaultValue && this.Parameter.DefaultValue != null) { // enums will present their default value as a raw int if (this.ObjectType.IsEnum) { this.DefaultValue = Enum.ToObject(this.ObjectType, this.Parameter.DefaultValue); } else { this.DefaultValue = this.Parameter.DefaultValue; } } // set appropriate meta data about this parameter for inclusion in the type system this.TypeExpression = GraphValidation.GenerateTypeExpression(this.DeclaredArgumentType, this); this.TypeExpression = this.TypeExpression.CloneTo(GraphTypeNames.ParseName(this.ObjectType, TypeKind.INPUT_OBJECT)); // when this argument accepts the same data type as the data returned by its owners target source type // i.e. if the source data supplied to the field for resolution is the same as this argument // then assume this argument is to contain the source data // since the source data will be an OBJECT type (not INPUT_OBJECT) there is no way the user could have supplied it if (this.IsSourceDataArgument()) { this.ArgumentModifiers = this.ArgumentModifiers | GraphArgumentModifiers.ParentFieldResult | GraphArgumentModifiers.Internal; } }
/// <summary> /// When overridden in a child class this method builds out the template according to its own individual requirements. /// </summary> protected override void ParseTemplateDefinition() { base.ParseTemplateDefinition(); // parse all input parameters from the method signature foreach (var parameter in this.Method.GetParameters()) { var argTemplate = this.CreateGraphFieldArgument(parameter); argTemplate.Parse(); _arguments.Add(argTemplate); } this.ExpectedReturnType = GraphValidation.EliminateWrappersFromCoreType( this.DeclaredReturnType, false, true, false); }
/// <summary> /// Validates the completed field context to ensure it is "correct" against the specification before finalizing its reslts. /// </summary> /// <param name="context">The context containing the resolved field.</param> /// <returns><c>true</c> if the node is valid, <c>false</c> otherwise.</returns> public override bool Execute(FieldValidationContext context) { var dataObject = context.ResultData; // did they forget to await a task and accidentally returned Task<T> from their resolver? if (dataObject is Task) { this.ValidationError( context, $"A field resolver for '{context.FieldPath}' yielded an invalid data object. See exception " + "for details. ", new GraphExecutionException( $"The field '{context.FieldPath}' yielded a {nameof(Task)} as its result but expected a value. " + "Did you forget to await an async method?")); context.DataItem.InvalidateResult(); } else { // is the concrete type of the data item not known to the schema? var strippedSourceType = GraphValidation.EliminateWrappersFromCoreType(dataObject.GetType()); var graphType = context.Schema.KnownTypes.FindGraphType(strippedSourceType); if (graphType == null) { this.ValidationError( context, $"A field resolver for '{context.Field.Route.Path}' generated a result " + "object type not known to the target schema. See exception for " + "details", new GraphExecutionException( $"The class '{strippedSourceType.FriendlyName()}' is not not mapped to a graph type " + "on the target schema.")); context.DataItem.InvalidateResult(); } } return(true); }
/// <summary> /// Validates the completed field context to ensure it is "correct" against the specification before finalizing its reslts. /// </summary> /// <param name="context">The context containing the resolved field.</param> /// <returns><c>true</c> if the node is valid, <c>false</c> otherwise.</returns> public override bool Execute(FieldValidationContext context) { var typeExpression = context.TypeExpression; if (typeExpression.IsRequired && context.ResultData == null) { // 6.4.3 section 1c this.ValidationError( context, $"Field '{context.FieldPath}' expected a non-null result but received {{null}}."); context.DataItem.InvalidateResult(); } // 6.4.3 section 2 if (context.ResultData == null) { return(true); } // 6.4.3 section 3, ensure an IEnumerable for a type expression that is a list if (typeExpression.IsListOfItems && !GraphValidation.IsValidListType(context.ResultData.GetType())) { this.ValidationError( context, $"Field '{context.FieldPath}' was expected to return a list of items but instead returned a single item."); context.DataItem.InvalidateResult(); return(true); } var graphType = context.Schema?.KnownTypes.FindGraphType(typeExpression?.TypeName); if (graphType == null) { this.ValidationError( context, $"The graph type for field '{context.FieldPath}' ({typeExpression?.TypeName}) does not exist on the target schema. The field" + $"cannot be properly evaluated."); context.DataItem.InvalidateResult(); } else if (!typeExpression.Matches(context.ResultData, graphType.ValidateObject)) { // generate a valid, properly cased type expression reference for the data that was provided var actualExpression = GraphValidation.GenerateTypeExpression(context.ResultData.GetType()); var coreType = GraphValidation.EliminateWrappersFromCoreType(context.ResultData.GetType()); var actualType = context.Schema.KnownTypes.FindGraphType(coreType); if (actualType != null) { actualExpression = actualExpression.CloneTo(actualType.Name); } // 6.4.3 section 4 & 5 this.ValidationError( context, $"The resolved value for field '{context.FieldPath}' does not match the required type expression. " + $"Expected {typeExpression} but got {actualExpression}."); context.DataItem.InvalidateResult(); } return(true); }
/// <summary> /// Validates the completed field context to ensure it is "correct" against the specification before finalizing its reslts. /// </summary> /// <param name="context">The context containing the resolved field.</param> /// <returns><c>true</c> if the node is valid, <c>false</c> otherwise.</returns> public override bool Execute(FieldValidationContext context) { var dataObject = context.ResultData; var dataItemTypeExpression = context.DataItem.TypeExpression; // did they forget to await a task and accidentally returned Task<T> from their resolver? // put in a special error message for better feed back if (dataObject is Task) { this.ValidationError( context, $"A field resolver for '{context.FieldPath}' yielded an invalid data object. See exception " + "for details. ", new GraphExecutionException( $"The field '{context.FieldPath}' yielded a {nameof(Task)} as its result but expected a value. " + "Did you forget to await an async method?")); context.DataItem.InvalidateResult(); return(true); } var expectedGraphType = context.Schema?.KnownTypes.FindGraphType(context.Field); if (expectedGraphType == null) { this.ValidationError( context, $"The graph type for field '{context.FieldPath}' ({dataItemTypeExpression?.TypeName}) does not exist on the target schema. The field" + "cannot be properly evaluated."); context.DataItem.InvalidateResult(); return(true); } // virtual graph types aren't real, they can be safely skipped if (expectedGraphType.IsVirtual) { return(true); } var rootSourceType = GraphValidation.EliminateWrappersFromCoreType(dataObject.GetType()); // Check that the actual .NET type of the result data IS (or can be cast to) the expected .NET // type for the graphtype of the field being checked var analysisResult = context.Schema.KnownTypes.AnalyzeRuntimeConcreteType(expectedGraphType, rootSourceType); if (!analysisResult.ExactMatchFound) { string foundTypeNames; if (!analysisResult.FoundTypes.Any()) { foundTypeNames = "~none~"; } else { foundTypeNames = string.Join(", ", analysisResult.FoundTypes.Select(x => x.FriendlyName())); } this.ValidationError( context, $"A field resolver for '{context.Field.Route.Path}' generated a result " + "object type not known to the target schema. See exception for " + "details", new GraphExecutionException( $"For target field of '{context.FieldPath}' (Graph Type: {expectedGraphType.Name}, Kind: {expectedGraphType.Kind}), a supplied object " + $"of class '{rootSourceType.FriendlyName()}' attempted to fill the request but graphql was not able to determine which " + $"of the matched concrete types to use and cannot resolve the field. Matched Types: [{foundTypeNames}]")); context.DataItem.InvalidateResult(); } else { // once the type is confirmed, confirm the actual value // for scenarios such as where a number may be masqurading as an enum but the enum doesn't define // a label for said number. var isValidValue = expectedGraphType.ValidateObject(dataObject); if (!isValidValue) { string actual = string.Empty; if (expectedGraphType is ObjectGraphType) { actual = dataObject.GetType().Name; } else { actual = dataObject.ToString(); } this.ValidationError( context, $"A resolved value for field '{context.FieldPath}' does not match the required graph type. " + $"Expected '{expectedGraphType.Name}' but got '{actual}'."); context.DataItem.InvalidateResult(); } } return(true); }
/// <summary> /// When overridden in a child class this method builds out the template according to its own individual requirements. /// </summary> protected override void ParseTemplateDefinition() { _fieldDeclaration = this.SingleAttributeOfTypeOrDefault <GraphFieldAttribute>(); // ------------------------------------ // Common Metadata // ------------------------------------ this.Route = this.GenerateFieldPath(); this.Mode = _fieldDeclaration?.ExecutionMode ?? FieldResolutionMode.PerSourceItem; this.Complexity = _fieldDeclaration?.Complexity; this.Description = this.SingleAttributeOfTypeOrDefault <DescriptionAttribute>()?.Description; var depreciated = this.SingleAttributeOfTypeOrDefault <DeprecatedAttribute>(); if (depreciated != null) { this.IsDeprecated = true; this.DeprecationReason = depreciated.Reason?.Trim(); } var objectType = GraphValidation.EliminateWrappersFromCoreType(this.DeclaredReturnType); var typeExpression = GraphValidation.GenerateTypeExpression(this.DeclaredReturnType, this); typeExpression = typeExpression.CloneTo(GraphTypeNames.ParseName(objectType, this.Parent.Kind)); // ------------------------------------ // Gather Possible Types and/or union definition // ------------------------------------ this.BuildUnionProxyInstance(); if (this.UnionProxy != null) { this.PossibleTypes = new List <Type>(this.UnionProxy.Types); } else { this.PossibleTypes = new List <Type>(); // the possible types attribte is optional but expects taht the concrete types are added // to the schema else where lest a runtime exception occurs of a missing graph type. var typesAttrib = this.SingleAttributeOfTypeOrDefault <PossibleTypesAttribute>(); if (typesAttrib != null) { foreach (var type in typesAttrib.PossibleTypes) { this.PossibleTypes.Add(type); } } // add any types decalred on the primary field declaration if (_fieldDeclaration != null) { foreach (var type in _fieldDeclaration.Types) { var strippedType = GraphValidation.EliminateWrappersFromCoreType(type); if (strippedType != null) { this.PossibleTypes.Add(strippedType); } } } if (objectType != null && !Validation.IsCastable <IGraphActionResult>(objectType) && GraphValidation.IsValidGraphType(objectType)) { this.PossibleTypes.Insert(0, objectType); } } this.PossibleTypes = this.PossibleTypes.Distinct().ToList(); // ------------------------------------ // Adjust the action result to the actual return type this field returns // ------------------------------------ if (Validation.IsCastable <IGraphActionResult>(objectType)) { if (this.UnionProxy != null) { // if a union was decalred preserve whatever modifer elements // were decalred but alter the return type to object (a known common element among all members of the union) objectType = typeof(object); } else if (_fieldDeclaration != null && _fieldDeclaration.Types.Count > 0) { objectType = _fieldDeclaration.Types[0]; typeExpression = GraphValidation.GenerateTypeExpression(objectType, this) .CloneTo(GraphTypeNames.ParseName(objectType, this.Parent.Kind)); objectType = GraphValidation.EliminateWrappersFromCoreType(objectType); } else if (this.PossibleTypes.Count > 0) { objectType = this.PossibleTypes[0]; typeExpression = GraphValidation.GenerateTypeExpression(objectType, this) .CloneTo(GraphTypeNames.ParseName(objectType, this.Parent.Kind)); objectType = GraphValidation.EliminateWrappersFromCoreType(objectType); } else { objectType = typeof(object); } } this.ObjectType = objectType; if (this.UnionProxy != null) { this.TypeExpression = typeExpression.CloneTo(this.UnionProxy.Name); } else { this.TypeExpression = typeExpression; } // ------------------------------------ // Async Requirements // ------------------------------------ this.IsAsyncField = Validation.IsCastable <Task>(this.DeclaredReturnType); // ------------------------------------ // Security Policies // ------------------------------------ _securityPolicies = FieldSecurityGroup.FromAttributeCollection(this.AttributeProvider); }
/// <summary> /// Validates the completed field context to ensure it is "correct" against the specification before finalizing its reslts. /// </summary> /// <param name="context">The context containing the resolved field.</param> /// <returns><c>true</c> if the node is valid, <c>false</c> otherwise.</returns> public override bool Execute(FieldValidationContext context) { var dataObject = context.ResultData; // 6.4.3 section 1c // This is a quick short cut and customed error message for a common top-level null mismatch. var dataItemTypeExpression = context.DataItem.TypeExpression; if (dataItemTypeExpression.IsRequired && dataObject == null) { this.ValidationError( context, $"Field '{context.FieldPath}' expected a non-null result but received {{null}}."); context.DataItem.InvalidateResult(); } // 6.4.3 section 2 if (dataObject == null) { return(true); } // 6.4.3 section 3, ensure list type in the result object for a type expression that is a list. // This is a quick short cut and customed error message for a common top-level list mismatch. if (dataItemTypeExpression.IsListOfItems && !GraphValidation.IsValidListType(dataObject.GetType())) { this.ValidationError( context, $"Field '{context.FieldPath}' was expected to return a list of items but instead returned a single item."); context.DataItem.InvalidateResult(); return(true); } var expectedGraphType = context.Schema?.KnownTypes.FindGraphType(context.Field); if (expectedGraphType == null) { this.ValidationError( context, $"The graph type for field '{context.FieldPath}' ({dataItemTypeExpression?.TypeName}) does not exist on the target schema. The field" + "cannot be properly evaluated."); context.DataItem.InvalidateResult(); return(true); } // Perform a deep check of the meta-type chain (list and nullability wrappers) against the result data. // For example, if the type expression is [[SomeType]] ensure the result object is List<List<T>> etc.) // however, use the type name of the actual data object, not the graph type itself // we only want to check the type expression wrappers in this step var rootSourceType = GraphValidation.EliminateWrappersFromCoreType(dataObject.GetType()); var mangledTypeExpression = dataItemTypeExpression.CloneTo(rootSourceType.Name); if (!mangledTypeExpression.Matches(dataObject)) { // generate a valid, properly cased type expression reference for the data that was provided var actualExpression = GraphValidation.GenerateTypeExpression(context.ResultData.GetType()); // Fake the type expression against the real graph type // this step only validates the meta graph types the actual type may be different (but castable to the concrete // type of the graphType). Don't confuse the user in this step. actualExpression = actualExpression.CloneTo(expectedGraphType.Name); // 6.4.3 section 4 & 5 this.ValidationError( context, $"The resolved value for field '{context.FieldPath}' does not match the required type expression. " + $"Expected {dataItemTypeExpression} but got {actualExpression}."); context.DataItem.InvalidateResult(); } return(true); }