private static void CollectComputeDependencies( Context context, IComplexOutputType type, IOutputField field) { IDirective directive = field.Directives[DirectiveNames.Computed] .FirstOrDefault(); if (directive != null) { NameString[] dependantOn = directive .ToObject <ComputedDirective>() .DependantOn; if (dependantOn != null) { foreach (string fieldName in dependantOn) { if (type.Fields.TryGetField( fieldName, out IOutputField dependency)) { context.Dependencies.Add(new FieldDependency( type.Name, dependency.Name)); } } } } }
public static void EnsureFieldNamesAreValid( IComplexOutputType type, ICollection <ISchemaError> errors) { for (var i = 0; i < type.Fields.Count; i++) { IOutputField field = type.Fields[i]; if (!field.IsIntrospectionField) { if (field.Name.Value.StartsWith(_twoUnderscores)) { errors.Add(TwoUnderscoresNotAllowedField(type, field)); } for (var j = 0; j < field.Arguments.Count; j++) { IInputField argument = field.Arguments[j]; if (argument.Name.Value.StartsWith(_twoUnderscores)) { errors.Add(TwoUnderscoresNotAllowedOnArgument( type, field, argument)); } } } } }
private static void ValidateImplementation( IComplexOutputType type, IInterfaceType implementedType, ICollection <ISchemaError> errors) { if (!IsFullyImplementingInterface(type, implementedType)) { errors.Add(NotTransitivelyImplemented(type, implementedType)); } foreach (IOutputField implementedField in implementedType.Fields) { if (type.Fields.TryGetField(implementedField.Name, out IOutputField? field)) { ValidateArguments(field, implementedField, errors); if (!IsValidImplementationFieldType(field.Type, implementedField.Type)) { errors.Add(InvalidFieldType(type, field, implementedField)); } } else { errors.Add(FieldNotImplemented(type, implementedField)); } } }
private IReadOnlyList <IFieldDescriptor> CreateFields( IComplexOutputType type, IEnumerable <ISelectionNode> selections, Func <string, bool> addField, Path path) { var fields = new Dictionary <string, FieldSelection>(); foreach (FieldNode selection in selections.OfType <FieldNode>()) { NameString responseName = selection.Alias == null ? selection.Name.Value : selection.Alias.Value; if (addField(responseName)) { FieldCollector.ResolveFieldSelection( type, selection, path, fields); } } return(fields.Values.Select(t => { string responseName = (t.Selection.Alias ?? t.Selection.Name).Value; return new FieldDescriptor( t.Field, t.Selection, t.Field.Type, path.Append(responseName)); }).ToList()); }
private static IReadOnlyList <VariableValue> ResolveScopedVariables( IResolverContext context, NameString schemaName, OperationType operationType, IEnumerable <SelectionPathComponent> components) { IStitchingContext stitchingContext = context.Service <IStitchingContext>(); ISchema remoteSchema = stitchingContext.GetRemoteSchema(schemaName); IComplexOutputType type = remoteSchema.GetOperationType(operationType); var variables = new List <VariableValue>(); SelectionPathComponent[] comps = components.Reverse().ToArray(); for (int i = 0; i < comps.Length; i++) { SelectionPathComponent component = comps[i]; if (!type.Fields.TryGetField(component.Name.Value, out IOutputField field)) { throw new QueryException(new Error { Message = string.Format( CultureInfo.InvariantCulture, StitchingResources .DelegationMiddleware_PathElementInvalid, component.Name.Value, type.Name) }); } ResolveScopedVariableArguments( context, component, field, variables); if (i + 1 < comps.Length) { if (!field.Type.IsComplexType()) { throw new QueryException(new Error { Message = StitchingResources .DelegationMiddleware_PathElementTypeUnexpected }); } type = (IComplexOutputType)field.Type.NamedType(); } } return(variables); }
public static void EnsureTypeHasFields( IComplexOutputType type, ICollection <ISchemaError> errors) { if (type.Fields.Count == 0 || type.Fields.All(t => t.IsIntrospectionField)) { errors.Add(NeedsOneAtLeastField(type)); } }
private static bool FieldExists( IComplexOutputType type, NameString fieldName) { if (IsTypeNameField(fieldName)) { return(true); } return(type.Fields.ContainsField(fieldName)); }
public static void EnsureInterfacesAreCorrectlyImplemented( IComplexOutputType type, ICollection <ISchemaError> errors) { if (type.Implements.Count > 0) { foreach (IInterfaceType implementedType in type.Implements) { ValidateImplementation(type, implementedType, errors); } } }
private static bool IsFullyImplementingInterface( IComplexOutputType type, IInterfaceType implementedType) { foreach (IInterfaceType?interfaceType in implementedType.Implements) { if (!type.IsImplementing(interfaceType)) { return(false); } } return(true); }
public static ISchemaError NeedsOneAtLeastField(IComplexOutputType type) { bool isInterface = type.Kind == TypeKind.Interface; return(SchemaErrorBuilder.New() .SetMessage( "The {0} type `{1}` has to at least define one field in " + "order to be valid.", isInterface ? _interface : _object, type.Name) .SetType(type) .SetSpecifiedBy(isInterface) .Build()); }
public static ISchemaError TwoUnderscoresNotAllowedField( IComplexOutputType type, IOutputField field) { bool isInterface = type.Kind == TypeKind.Interface; return(SchemaErrorBuilder.New() .SetMessage( "Field names starting with `__` are reserved for " + "the GraphQL specification.") .SetType(type) .SetField(field) .SetSpecifiedBy(isInterface) .Build()); }
/// <summary> /// Initializes a new instance of <see cref="EntityModel" />. /// </summary> /// <param name="type"> /// The entity type. /// </param> public EntityModel(IComplexOutputType type) { Name = type.Name; Type = type; Definition = type.GetEntityDefinition(); var fields = new Dictionary <string, IOutputField>(); foreach (var fieldSyntax in Definition.Selections.OfType <FieldNode>()) { fields.Add(fieldSyntax.Name.Value, type.Fields[fieldSyntax.Name.Value]); } Fields = fields.Values.ToList(); }
public static ISchemaError NotTransitivelyImplemented( IComplexOutputType type, IComplexOutputType implementedType) { bool isInterface = type.Kind == TypeKind.Interface; return(SchemaErrorBuilder.New() .SetMessage( "The {0} type must also declare all interfaces " + "declared by implemented interfaces.", isInterface ? _interface : _object) .SetType(type) .SetImplementedType(implementedType) .SetSpecifiedBy(isInterface) .Build()); }
public static IError FieldDoesNotExist( this IDocumentValidatorContext context, FieldNode node, IComplexOutputType outputType) { return(ErrorBuilder.New() .SetMessage( Resources.ErrorHelper_FieldDoesNotExist, node.Name.Value, outputType.Name) .AddLocation(node) .SetPath(context.CreateErrorPath()) .SetExtension("type", outputType.Name) .SetExtension("field", node.Name.Value) .SetExtension("responseName", (node.Alias ?? node.Name).Value) .SpecifiedBy("sec-Field-Selections-on-Objects-Interfaces-and-Unions-Types") .Build()); }
public static ISchemaError FieldNotImplemented( IComplexOutputType type, IOutputField implementedField) { bool isInterface = type.Kind == TypeKind.Interface; return(SchemaErrorBuilder.New() .SetMessage( "The field `{0}` must be implement by {1} type `{2}`.", implementedField.Name, isInterface ? _interface : _object, type.Print()) .SetType(type) .SetImplementedField(implementedField) .SetSpecifiedBy(isInterface) .Build()); }
public static IError NoSelectionOnCompositeField( this IDocumentValidatorContext context, FieldNode node, IComplexOutputType declaringType, IType fieldType) { return(ErrorBuilder.New() .SetMessage( Resources.ErrorHelper_NoSelectionOnCompositeField, node.Name.Value) .AddLocation(node) .SetPath(context.CreateErrorPath()) .SetExtension("declaringType", declaringType.Name) .SetExtension("field", node.Name.Value) .SetExtension("type", fieldType.Print()) .SetExtension("responseName", (node.Alias ?? node.Name).Value) .SpecifiedBy("sec-Field-Selections-on-Objects-Interfaces-and-Unions-Types") .Build()); }
public static IError LeafFieldsCannotHaveSelections( this IDocumentValidatorContext context, FieldNode node, IComplexOutputType declaringType, IType fieldType) { return(ErrorBuilder.New() .SetMessage( Resources.ErrorHelper_LeafFieldsCannotHaveSelections, node.Name.Value, fieldType.IsScalarType() ? "a scalar" : "an enum") .AddLocation(node) .SetPath(context.CreateErrorPath()) .SetExtension("declaringType", declaringType.Name) .SetExtension("field", node.Name.Value) .SetExtension("type", fieldType.Print()) .SetExtension("responseName", (node.Alias ?? node.Name).Value) .SpecifiedBy("sec-Leaf-Field-Selections") .Build()); }
public static ISchemaError InvalidFieldType( IComplexOutputType type, IOutputField field, IOutputField implementedField) { bool isInterface = type.Kind == TypeKind.Interface; return(SchemaErrorBuilder.New() .SetMessage( "Field `{0}` must return a type which is equal to " + "or a sub‐type of (covariant) the return type `{1}` " + "of the interface field.", field.Name, implementedField.Type.Print()) .SetType(type) .SetField(field) .SetImplementedField(implementedField) .SetSpecifiedBy(isInterface) .Build()); }
private static ISchemaErrorBuilder SetType( this ISchemaErrorBuilder errorBuilder, IComplexOutputType type) => errorBuilder .AddSyntaxNode(type.SyntaxNode) .SetTypeSystemObject((TypeSystemObjectBase)type);
private static ISchemaErrorBuilder SetImplementedType( this ISchemaErrorBuilder errorBuilder, IComplexOutputType type) => errorBuilder .AddSyntaxNode(type.SyntaxNode) .SetExtension("implementedType", type);
public TypeInfo(IComplexOutputType type, IDictionary <string, object?> contextData) { Type = type; ContextData = contextData; }