public override ICodeDescriptor Generate( IModelGeneratorContext context, OperationDefinitionNode operation, UnionType namedType, IType fieldType, FieldNode fieldSelection, PossibleSelections possibleSelections, Path path) { IFragmentNode returnType = ResolveReturnType( context, namedType, fieldSelection, possibleSelections.ReturnType); IInterfaceDescriptor interfaceDescriptor = CreateInterfaceModel( context, returnType, path); context.Register(fieldSelection, interfaceDescriptor); CreateClassModels( context, operation, fieldType, fieldSelection, possibleSelections, returnType, interfaceDescriptor, path); return(interfaceDescriptor); }
private void CreateClassModels( IModelGeneratorContext context, OperationDefinitionNode operation, IType fieldType, FieldNode fieldSelection, PossibleSelections possibleSelections, IFragmentNode returnType, IInterfaceDescriptor interfaceDescriptor, Path path) { var resultParserTypes = new List <ResultParserTypeDescriptor>(); IReadOnlyCollection <SelectionInfo> selections = possibleSelections.Variants; CreateClassModels( context, fieldSelection, returnType, interfaceDescriptor, selections, resultParserTypes, path); context.Register( new ResultParserMethodDescriptor( GetPathName(path), operation, fieldType, fieldSelection, path, interfaceDescriptor, resultParserTypes)); }
public ResultParserMethodDescriptor( string name, OperationDefinitionNode operation, IType resultType, FieldNode resultSelection, Path path, IInterfaceDescriptor resultDescriptor, IReadOnlyList <IResultParserTypeDescriptor> possibleTypes, IResultParserTypeDescriptor unknownType) { Name = name ?? throw new ArgumentNullException(nameof(name)); Operation = operation ?? throw new ArgumentNullException(nameof(operation)); ResultType = resultType ?? throw new ArgumentNullException(nameof(resultType)); ResultSelection = resultSelection; Path = path ?? throw new ArgumentNullException(nameof(path)); ResultDescriptor = resultDescriptor ?? throw new ArgumentNullException(nameof(resultDescriptor)); PossibleTypes = possibleTypes ?? throw new ArgumentNullException(nameof(possibleTypes)); UnknownType = unknownType; }
public ClassDescriptor( string name, string ns, INamedType type, IInterfaceDescriptor implements) : this(name, ns, type, new[] { implements }) { }
private ICodeDescriptor GenerateObjectSelectionSet( OperationDefinitionNode operation, ObjectType objectType, IType fieldType, WithDirectives fieldOrOperation, FieldCollectionResult typeCase, Path path) { IFragmentNode returnType = HoistFragment( objectType, typeCase.SelectionSet, typeCase.Fragments); IReadOnlyList <IFragmentNode> fragments; string className; if (returnType is null) { fragments = typeCase.Fragments; className = CreateName(fieldOrOperation, objectType, GetClassName); } else { fragments = returnType.Children; className = CreateName(GetClassName(returnType.Fragment.Name)); } var modelSelectionSet = new SelectionSetNode( typeCase.Fields.Select(t => t.Selection).ToList()); var modelFragment = new FragmentNode(new Fragment( className, objectType, modelSelectionSet)); modelFragment.Children.AddRange(fragments); IInterfaceDescriptor modelInterface = CreateInterface(modelFragment, path); var modelClass = new ClassDescriptor( className, _namespace, typeCase.Type, modelInterface); RegisterDescriptor(modelInterface); RegisterDescriptor(modelClass); RegisterDescriptor( new ResultParserMethodDescriptor( GetPathName(path), operation, fieldType, fieldOrOperation as FieldNode, path, modelInterface, new[] { new ResultParserTypeDescriptor(modelClass) })); return(modelInterface); }
public ResultParserMethodDescriptor( string name, OperationDefinitionNode operation, IType resultType, FieldNode resultSelection, Path path, IInterfaceDescriptor resultDescriptor, IReadOnlyList <IResultParserTypeDescriptor> possibleTypes) : this(name, operation, resultType, resultSelection, path, resultDescriptor, possibleTypes, null) { }
private void GenerateInterfaceTypeCaseModel( FieldCollectionResult typeCase, IFragmentNode returnType, ICollection <ResultParserTypeDescriptor> resultParser, Path path) { string className; IReadOnlyList <IFragmentNode> fragments; IFragmentNode modelType = HoistFragment( (ObjectType)typeCase.Type, typeCase.SelectionSet, typeCase.Fragments); if (modelType is null) { fragments = typeCase.Fragments; className = CreateName(GetClassName(typeCase.Type.Name)); } else { fragments = modelType.Children; className = CreateName(GetClassName(modelType.Fragment.Name)); } var modelSelectionSet = new SelectionSetNode( typeCase.Fields.Select(t => t.Selection).ToList()); var modelFragment = new FragmentNode(new Fragment( className, typeCase.Type, modelSelectionSet)); modelFragment.Children.AddRange(fragments); if (modelFragment.Children.All(t => t.Fragment.SelectionSet != returnType.Fragment.SelectionSet)) { modelFragment.Children.Add(returnType); } IInterfaceDescriptor modelInterface = CreateInterface(modelFragment, path); var modelClass = new ClassDescriptor( className, _namespace, typeCase.Type, modelInterface); RegisterDescriptor(modelInterface); RegisterDescriptor(modelClass); resultParser.Add(new ResultParserTypeDescriptor(modelClass)); }
protected void CreateClassModel( IModelGeneratorContext context, IFragmentNode returnType, IInterfaceDescriptor interfaceDescriptor, SelectionInfo selection, List <ResultParserTypeDescriptor> resultParserTypes) { var modelClass = new ClassDescriptor( GetClassName(returnType.Name), context.Namespace, selection.Type, new[] { interfaceDescriptor }); context.Register(modelClass); resultParserTypes.Add(new ResultParserTypeDescriptor(modelClass)); }
public InterfaceDescriptor TryAddImplements(IInterfaceDescriptor descriptor) { var implements = new Dictionary <string, IInterfaceDescriptor>(); foreach (IInterfaceDescriptor d in Implements) { implements[d.Name] = d; } implements[descriptor.Name] = descriptor; return(new InterfaceDescriptor( Name, Namespace, Type, Fields, implements.Values.ToList())); }
protected void CreateClassModels( IModelGeneratorContext context, FieldNode fieldSelection, IFragmentNode returnType, IInterfaceDescriptor interfaceDescriptor, IReadOnlyCollection <SelectionInfo> selections, List <ResultParserTypeDescriptor> resultParserTypes, Path path) { foreach (SelectionInfo selection in selections) { IFragmentNode modelType = ResolveReturnType( context, selection.Type, fieldSelection, selection); var interfaces = new List <IInterfaceDescriptor>(); foreach (IFragmentNode fragment in ShedNonMatchingFragments(selection.Type, modelType)) { interfaces.Add(CreateInterfaceModel(context, fragment, path)); } interfaces.Insert(0, interfaceDescriptor); NameString typeName = HoistName(selection.Type, modelType); string className = context.GetOrCreateName( modelType.Fragment.SelectionSet, GetClassName(typeName)); var modelClass = new ClassDescriptor( className, context.Namespace, selection.Type, interfaces); context.Register(modelClass); resultParserTypes.Add(new ResultParserTypeDescriptor(modelClass)); } }
public override ICodeDescriptor Generate( IModelGeneratorContext context, OperationDefinitionNode operation, ObjectType namedType, IType fieldType, FieldNode fieldSelection, PossibleSelections possibleSelections, Path path) { IFragmentNode returnType = ResolveReturnType( context, namedType, fieldSelection, possibleSelections.ReturnType); IInterfaceDescriptor interfaceDescriptor = CreateInterfaceModel( context, returnType, path); context.Register(fieldSelection, interfaceDescriptor); var resultParserTypes = new List <ResultParserTypeDescriptor>(); CreateClassModel( context, returnType, interfaceDescriptor, possibleSelections.ReturnType, resultParserTypes); context.Register( new ResultParserMethodDescriptor( GetPathName(path), operation, fieldType, fieldSelection, path, interfaceDescriptor, resultParserTypes)); return(interfaceDescriptor); }
private static IReadOnlyList <IFieldDescriptor> CreateFields( INamedType type, IReadOnlyList <IInterfaceDescriptor> implements) { var handled = new HashSet <IInterfaceDescriptor>(); var handledField = new HashSet <string>(); var queue = new Queue <IInterfaceDescriptor>(implements); var list = new List <IFieldDescriptor>(); if (type is IComplexOutputType complexType) { while (queue.Count > 0) { IInterfaceDescriptor current = queue.Dequeue(); if (handled.Add(current)) { foreach (IFieldDescriptor descriptor in current.Fields) { if (handledField.Add(descriptor.ResponseName) && complexType.Fields.TryGetField( descriptor.Field.Name, out IOutputField field)) { list.Add(new FieldDescriptor( field, descriptor.Selection, descriptor.Type, descriptor.Path)); } } foreach (IInterfaceDescriptor child in current.Implements) { queue.Enqueue(child); } } } } return(list); }
protected void CreateClassModel( IModelGeneratorContext context, IFragmentNode returnType, IInterfaceDescriptor interfaceDescriptor, SelectionInfo selection, List <ResultParserTypeDescriptor> resultParserTypes) { var fieldNames = new HashSet <string>( selection.Fields.Select(t => GetPropertyName(t.ResponseName))); string className = context.GetOrCreateName( returnType.Fragment.SelectionSet, GetClassName(returnType.Name), fieldNames); var modelClass = new ClassDescriptor( className, context.Namespace, selection.Type, new[] { interfaceDescriptor }); context.Register(modelClass); resultParserTypes.Add(new ResultParserTypeDescriptor(modelClass)); }
protected void CreateClassModels( IModelGeneratorContext context, FieldNode fieldSelection, IFragmentNode returnType, IInterfaceDescriptor interfaceDescriptor, IReadOnlyCollection <SelectionInfo> selections, List <ResultParserTypeDescriptor> resultParserTypes, Path path) { foreach (SelectionInfo selection in selections) { IFragmentNode modelType = ResolveReturnType( context, selection.Type, fieldSelection, selection); var interfaces = new List <IInterfaceDescriptor>(); foreach (IFragmentNode fragment in ShedNonMatchingFragments(selection.Type, modelType)) { interfaces.Add(CreateInterfaceModel(context, fragment, path)); } interfaces.Insert(0, interfaceDescriptor); NameString typeName = HoistName(selection.Type, modelType); if (typeName.IsEmpty) { typeName = selection.Type.Name; } bool update = false; var fieldNames = new HashSet <string>( selection.Fields.Select(t => GetPropertyName(t.ResponseName))); string className = context.GetOrCreateName( modelType.Fragment.SelectionSet, GetClassName(typeName), fieldNames); if (context.TryGetDescriptor(className, out ClassDescriptor? modelClass)) { var interfaceNames = new HashSet <string>(interfaces.Select(t => t.Name)); foreach (IInterfaceDescriptor item in modelClass !.Implements.Reverse()) { if (!interfaceNames.Contains(item.Name)) { interfaces.Insert(0, item); } } update = true; } modelClass = new ClassDescriptor( className, context.Namespace, selection.Type, interfaces); context.Register(modelClass, update); resultParserTypes.Add(new ResultParserTypeDescriptor(modelClass)); } }
IInterfaceDescriptor IInterfaceDescriptor.TryAddImplements( IInterfaceDescriptor descriptor) => TryAddImplements(descriptor);