public async Task WriteAsync( CodeWriter writer, ICodeDescriptor descriptor, ITypeLookup typeLookup) { await WriteUsings(writer, _innerGenerator).ConfigureAwait(false); await writer.WriteLineAsync().ConfigureAwait(false); await writer.WriteAsync($"namespace {_namespace}").ConfigureAwait(false); await writer.WriteLineAsync().ConfigureAwait(false); await writer.WriteAsync('{').ConfigureAwait(false); await writer.WriteLineAsync().ConfigureAwait(false); using (writer.IncreaseIndent()) { await _innerGenerator.WriteAsync( writer, descriptor, typeLookup) .ConfigureAwait(false); } await writer.WriteAsync('}').ConfigureAwait(false); await writer.WriteLineAsync().ConfigureAwait(false); }
public Task WriteAsync( CodeWriter writer, ICodeDescriptor descriptor, ITypeLookup typeLookup) { if (writer is null) { throw new ArgumentNullException(nameof(writer)); } if (descriptor is null) { throw new ArgumentNullException(nameof(descriptor)); } if (typeLookup is null) { throw new ArgumentNullException(nameof(typeLookup)); } if (descriptor is T t) { return(WriteAsync(writer, t, typeLookup)); } throw new ArgumentException( "The code generator expected " + $"descriptor type `{typeof(T).FullName}`."); }
public void Generate() { _context.Register(_query); GenerateEnumTypes(); var backlog = new Queue <FieldSelection>(); foreach (var operation in _document.Definitions.OfType <OperationDefinitionNode>()) { Path root = Path.New(operation.Name !.Value); ObjectType operationType = _schema.GetOperationType(operation.Operation); ICodeDescriptor resultType = GenerateOperationSelectionSet( operationType, operation, root, backlog); while (backlog.Any()) { FieldSelection current = backlog.Dequeue(); Path path = current.Path.Append(current.ResponseName); if (!current.Field.Type.NamedType().IsLeafType()) { GenerateFieldSelectionSet( operation, current.Field.Type, current.Selection, path, backlog); } } GenerateResultParserDescriptor(operation, resultType); } var clientDescriptor = new ClientDescriptor( _context.ClientName, _namespace, _context.Descriptors.OfType <IOperationDescriptor>().ToList()); var servicesDescriptor = new ServicesDescriptor( _context.ClientName + "ServiceCollectionExtensions", _context.Namespace, clientDescriptor, _context.Descriptors.OfType <IInputClassDescriptor>().ToList(), _context.Descriptors.OfType <IEnumDescriptor>().ToList(), _context.Descriptors.OfType <IResultParserDescriptor>().ToList()); _context.Register(clientDescriptor); _context.Register(servicesDescriptor); FieldTypes = _context.FieldTypes; Descriptors = _context.Descriptors; }
public void Register( ICodeDescriptor descriptor, ICodeGenerator generator) { _tasks.Add(new GeneratorTask { Descriptor = descriptor, Generator = new NamespaceGenerator( generator, ((IHasNamespace)descriptor).Namespace) }); }
public void Register(FieldNode field, ICodeDescriptor descriptor) { if (!_descriptors.TryGetValue(descriptor.Name, out ICodeDescriptor? d)) { d = descriptor; Register(d); } if (!_fieldTypes.ContainsKey(field)) { _fieldTypes.Add(field, descriptor); } }
public ICodeDescriptor Generate( IModelGeneratorContext context, ObjectType operationType, OperationDefinitionNode operation, ICodeDescriptor resultType) { var arguments = new List <Descriptors.IArgumentDescriptor>(); foreach (VariableDefinitionNode variableDefinition in operation.VariableDefinitions) { string typeName = variableDefinition.Type.NamedType().Name.Value; if (!context.Schema.TryGetType(typeName, out INamedType namedType)) { throw new InvalidOperationException( $"The variable type `{typeName}` is not supported by the schema."); } IType type = variableDefinition.Type.ToType(namedType); IInputClassDescriptor?inputClassDescriptor = null; if (namedType is InputObjectType inputObjectType) { inputClassDescriptor = GenerateInputObjectType(context, inputObjectType); } arguments.Add(new ArgumentDescriptor( variableDefinition.Variable.Name.Value, type, variableDefinition, inputClassDescriptor)); } string operationName = context.GetOrCreateName( operation, GetClassName(operation.Name !.Value) + "Operation"); var descriptor = new OperationDescriptor( operationName, context.Namespace, operationType, operation, arguments, context.Query, resultType); context.Register(descriptor); return(descriptor); }
private CSharpDocument WriteDocument( ICodeGenerator generator, ICodeDescriptor descriptor, StringBuilder code) { code.Clear(); using var writer = new CodeWriter(code); generator.Generate(writer, descriptor, out string fileName); writer.Flush(); return(new(fileName, code.ToString())); }
public void Generate(CodeWriter writer, ICodeDescriptor descriptor, out string fileName) { if (writer is null) { throw new ArgumentNullException(nameof(writer)); } if (descriptor is null) { throw new ArgumentNullException(nameof(descriptor)); } Generate(writer, (TDescriptor)descriptor, out fileName); }
public CSharpSyntaxGeneratorResult Generate( ICodeDescriptor descriptor, CSharpSyntaxGeneratorSettings settings) { if (descriptor is null) { throw new ArgumentNullException(nameof(descriptor)); } if (settings is null) { throw new ArgumentNullException(nameof(settings)); } return(Generate((TDescriptor)descriptor, settings)); }
public string CreateFileName(ICodeDescriptor descriptor) { if (descriptor is null) { throw new ArgumentNullException(nameof(descriptor)); } if (descriptor is T t) { return(CreateFileName(t)); } throw new ArgumentException( "The code generator expected " + $"descriptor type `{typeof(T).FullName}`."); }
private ICodeDescriptor GenerateOperation( ObjectType operationType, OperationDefinitionNode operation, ICodeDescriptor resultType) { var arguments = new List <Descriptors.IArgumentDescriptor>(); foreach (VariableDefinitionNode variableDefinition in operation.VariableDefinitions) { string typeName = variableDefinition.Type.NamedType().Name.Value; if (!_schema.TryGetType(typeName, out INamedType namedType)) { throw new InvalidOperationException( $"The variable type `{typeName}` is not supported by the schema."); } IType type = variableDefinition.Type.ToType(namedType); IInputClassDescriptor inputClassDescriptor = null; if (namedType is InputObjectType inputObjectType) { inputClassDescriptor = GenerateInputObjectType(inputObjectType); } arguments.Add(new ArgumentDescriptor( variableDefinition.Variable.Name.Value, type, variableDefinition, inputClassDescriptor)); } string operationName = CreateName(GetClassName(operation.Name.Value) + "Operation"); return(new OperationDescriptor( operationName, _namespace, operationType, operation, arguments, _query, resultType)); }
private static CSharpDocument WriteDocument( ICodeGenerator generator, ICodeDescriptor descriptor, StringBuilder code) { code.Clear(); using var writer = new CodeWriter(code); #if DEBUG writer.WriteLine("// " + generator.GetType().FullName); writer.WriteLine(); #endif generator.Generate(writer, descriptor, out string fileName); writer.Flush(); return(new(fileName, code.ToString())); }
private ICodeDescriptor GenerateOperationSelectionSet( ObjectType operationType, OperationDefinitionNode operation, Path path, Queue <FieldSelection> backlog) { PossibleSelections possibleSelections = _fieldCollector.CollectFields( operationType, operation.SelectionSet, path); EnqueueFields(backlog, possibleSelections.ReturnType.Fields, path); ICodeDescriptor resultDescriptor = _objectModelGenerator.Generate( _context, operation, operationType, new NonNullType(operationType), new FieldNode( null, new NameNode(operation.Name !.Value), null, new[] { new DirectiveNode( GeneratorDirectives.Type, new ArgumentNode("name", operation.Name.Value)), new DirectiveNode(GeneratorDirectives.Operation) }, Array.Empty <ArgumentNode>(), null), possibleSelections, path); _operationModelGenerator.Generate( _context, operationType, operation, resultDescriptor); return(resultDescriptor); }
public ResultParserDescriptor( string name, string ns, OperationDefinitionNode operation, ICodeDescriptor resultDescriptor, IReadOnlyList <IResultParserMethodDescriptor> parseMethods) { Name = name ?? throw new ArgumentNullException(nameof(name)); Namespace = ns ?? throw new ArgumentNullException(nameof(ns)); Operation = operation ?? throw new ArgumentNullException(nameof(operation)); ResultDescriptor = resultDescriptor ?? throw new ArgumentNullException(nameof(resultDescriptor)); ParseMethods = parseMethods ?? throw new ArgumentNullException(nameof(parseMethods)); InvolvedLeafTypes = CollectLeafTypes(parseMethods); }
public void Generate() { RegisterDescriptor(_query); var backlog = new Queue <FieldSelection>(); Path root = Path.New("root"); foreach (var operation in _document.Definitions.OfType <OperationDefinitionNode>()) { ObjectType operationType = _schema.GetOperationType(operation.Operation); ICodeDescriptor resultDescriptor = GenerateOperationSelectionSet( operationType, operation, root, backlog); RegisterDescriptor(GenerateOperation( operationType, operation, resultDescriptor)); while (backlog.Any()) { FieldSelection current = backlog.Dequeue(); Path path = current.Path.Append(current.ResponseName); GenerateFieldSelectionSet( operation, current.Field.Type, current.Selection, path, backlog); } RegisterDescriptor( CreateResultParserDescriptor(operation, resultDescriptor)); } RegisterDescriptor(new ClientDescriptor( _clientName, _namespace, _descriptors.Values.OfType <IOperationDescriptor>().ToList())); FieldTypes = _fieldTypes.ToDictionary(t => t.Key, t => t.Value.Name); Descriptors = _descriptors.Values; }
public void Register(ICodeDescriptor descriptor) { var queue = new Queue <ICodeDescriptor>(); queue.Enqueue(descriptor); while (queue.Count > 0) { ICodeDescriptor current = queue.Dequeue(); if (!_descriptors.ContainsKey(current.Name)) { _descriptors.Add(current.Name, current); foreach (ICodeDescriptor child in current.GetChildren()) { queue.Enqueue(child); } } } }
private IResultParserDescriptor CreateResultParserDescriptor( OperationDefinitionNode operation, ICodeDescriptor resultDescriptor) { string name = resultDescriptor is IInterfaceDescriptor ? resultDescriptor.Name.Substring(1) : resultDescriptor.Name; name += "ResultParser"; return(new ResultParserDescriptor ( name, _namespace, operation, resultDescriptor, _descriptors.Values .OfType <IResultParserMethodDescriptor>() .Where(t => t.Operation == operation).ToList() )); }
private void GenerateResultParserDescriptor( OperationDefinitionNode operation, ICodeDescriptor resultDescriptor) { string name = resultDescriptor is IInterfaceDescriptor ? resultDescriptor.Name.Substring(1) : resultDescriptor.Name; name += "ResultParser"; _context.Register(new ResultParserDescriptor ( name, _context.Namespace, operation, resultDescriptor, _context.Descriptors .OfType <IResultParserMethodDescriptor>() .Where(t => t.Operation == operation).ToList() )); }
public CSharpSyntaxGeneratorResult Generate( ICodeDescriptor descriptor, CSharpSyntaxGeneratorSettings settings) { if (descriptor is null) { throw new ArgumentNullException(nameof(descriptor)); } if (settings is null) { throw new ArgumentNullException(nameof(settings)); } var code = new StringBuilder(); using var stringWriter = new StringWriter(code); using var codeWriter = new CodeWriter(stringWriter); Generate( (TDescriptor)descriptor, settings, codeWriter, out var fileName, out var path, out var ns); codeWriter.Flush(); var sourceText = SourceText.From(code.ToString()); SyntaxTree tree = CSharpSyntaxTree.ParseText(sourceText); return(new CSharpSyntaxGeneratorResult( fileName, path, ns, tree.GetRoot().DescendantNodes().OfType <BaseTypeDeclarationSyntax>().First())); }
public OperationDescriptor( string name, string ns, ObjectType operationType, OperationDefinitionNode operation, IReadOnlyList <IArgumentDescriptor> arguments, IQueryDescriptor query, ICodeDescriptor resultType) { Name = name ?? throw new ArgumentNullException(nameof(name)); Namespace = ns ?? throw new ArgumentNullException(nameof(ns)); OperationType = operationType ?? throw new ArgumentNullException(nameof(operationType)); Operation = operation ?? throw new ArgumentNullException(nameof(operation)); Arguments = arguments ?? throw new ArgumentNullException(nameof(arguments)); Query = query ?? throw new ArgumentNullException(nameof(query)); ResultType = resultType ?? throw new ArgumentNullException(nameof(resultType)); }
public bool CanHandle(ICodeDescriptor descriptor) => descriptor is TDescriptor d && CanHandle(d);
public void Register(ICodeDescriptor descriptor) { Register(descriptor, false); }
public string CreateFileName(ICodeDescriptor descriptor) => _innerGenerator.CreateFileName(descriptor);
public bool CanHandle(ICodeDescriptor descriptor) => _innerGenerator.CanHandle(descriptor);
public Task WriteAsync( CodeWriter writer, ICodeDescriptor descriptor) => WriteAsync(writer, (TDescriptor)descriptor);
public bool CanHandle(ICodeDescriptor descriptor) { return(descriptor is T); }
public bool CanHandle( ICodeDescriptor descriptor, CSharpSyntaxGeneratorSettings settings) => descriptor is TDescriptor d && CanHandle(d, settings);
public GeneratorTask(ICodeDescriptor descriptor, ICodeGenerator generator) { Descriptor = descriptor; Generator = generator; }