public void QueryParameterReverseMapping() { var schema = DeserializeTestSchema("TestSchemaWithUnions"); var stringBuilder = new StringBuilder(); var generator = new GraphQlGenerator(); generator.Generate(CreateGenerationContext(stringBuilder, schema)); const string assemblyName = "QueryParameterReverseMappingTestAssembly"; CompileIntoAssembly(stringBuilder.ToString(), assemblyName); GetQueryParameterGraphQlType(GetGeneratedType("UnderscoreNamedInput"), true).ShouldBe("underscore_named_input"); GetQueryParameterGraphQlType(GetGeneratedType("UnderscoreNamedInput").MakeArrayType(), false).ShouldBe("[underscore_named_input]!"); GetQueryParameterGraphQlType(typeof(ICollection <>).MakeGenericType(typeof(Int32)), true).ShouldBe("[Int]"); GetQueryParameterGraphQlType(typeof(Double), true).ShouldBe("Float"); GetQueryParameterGraphQlType(typeof(Decimal), false).ShouldBe("Float!"); GetQueryParameterGraphQlType(typeof(Guid), true).ShouldBe("ID"); GetQueryParameterGraphQlType(typeof(String), false).ShouldBe("String!"); string GetQueryParameterGraphQlType(Type valueType, bool nullable) { var queryParameterType = GetGeneratedType("GraphQlQueryParameter`1"); var queryParameter = Activator.CreateInstance(queryParameterType.MakeGenericType(valueType), "parameter_name", null, nullable); return((string)queryParameterType.GetProperty("GraphQlTypeName", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(queryParameter)); } Type GetGeneratedType(string typeName) { typeName = $"{assemblyName}.{typeName}, {assemblyName}"; return(Type.GetType(typeName) ?? throw new InvalidOperationException($"value type \"{typeName}\" not found")); } }
public void NewCSharpSyntaxWithClassPrefixAndSuffix() { var configuration = new GraphQlGeneratorConfiguration { CSharpVersion = CSharpVersion.Newest, ClassPrefix = "Test", ClassSuffix = "V1", MemberAccessibility = MemberAccessibility.Internal }; var schema = DeserializeTestSchema("TestSchema2"); var stringBuilder = new StringBuilder(); var generator = new GraphQlGenerator(configuration); generator.Generate(CreateGenerationContext(stringBuilder, schema)); var generatedSourceCode = StripBaseClasses(stringBuilder.ToString()); var expectedOutput = GetTestResource("ExpectedNewCSharpSyntaxWithClassPrefixAndSuffix"); generatedSourceCode.ShouldBe(expectedOutput); CompileIntoAssembly(stringBuilder.ToString(), "GraphQLTestAssembly"); Type.GetType("GraphQLTestAssembly.GraphQlQueryBuilder, GraphQLTestAssembly").ShouldNotBeNull(); }
public static async Task <IReadOnlyCollection <FileInfo> > GenerateClientSourceCode(ProgramOptions options) { var schema = await GraphQlGenerator.RetrieveSchema(options.ServiceUrl, options.Authorization); var generatorConfiguration = new GraphQlGeneratorConfiguration { CSharpVersion = options.CSharpVersion, ClassPostfix = options.ClassPostfix, GeneratePartialClasses = options.PartialClasses, MemberAccessibility = options.MemberAccessibility, IdTypeMapping = options.IdTypeMapping }; var generator = new GraphQlGenerator(generatorConfiguration); if (options.OutputType == OutputType.SingleFile) { await File.WriteAllTextAsync(options.OutputPath, generator.GenerateFullClientCSharpFile(schema, options.Namespace)); return(new[] { new FileInfo(options.OutputPath) }); } var multipleFileGenerationContext = new MultipleFileGenerationContext(schema, options.OutputPath, options.Namespace); generator.Generate(multipleFileGenerationContext); return(multipleFileGenerationContext.Files); }
public static async Task GenerateGraphQlClient(string url, string targetFileName, string @namespace) { var schema = await GraphQlGenerator.RetrieveSchema(url); var builder = new StringBuilder(); GraphQlGenerator.GenerateQueryBuilder(schema, builder); builder.AppendLine(); builder.AppendLine(); GraphQlGenerator.GenerateDataClasses(schema, builder); using (var writer = File.CreateText(targetFileName)) { writer.WriteLine(GraphQlGenerator.RequiredNamespaces); writer.WriteLine(); writer.WriteLine($"namespace {@namespace}"); writer.WriteLine("{"); var indentedLines = builder .ToString() .Split(new[] { Environment.NewLine }, StringSplitOptions.None) .Select(l => $" {l}"); foreach (var line in indentedLines) { writer.WriteLine(line); } writer.WriteLine("}"); } }
public static async Task <FileInfo> GenerateClientCSharpFile(string url, string targetFileName, string @namespace) { var schema = await GraphQlGenerator.RetrieveSchema(url); await File.WriteAllTextAsync(targetFileName, GraphQlGenerator.GenerateFullClientCSharpFile(schema, @namespace)); return(new FileInfo(targetFileName)); }
public void GenerateDataClassesWithInterfaces() { var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateDataClasses(DeserializeTestSchema("TestSchema3"), stringBuilder); var expectedDataClasses = GetTestResource("ExpectedDataClassesWithInterfaces"); stringBuilder.ToString().ShouldBe(expectedDataClasses); }
public void GenerateDataClasses() { var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateDataClasses(TestSchema, stringBuilder); var expectedDataClasses = GetTestResource("ExpectedDataClasses"); stringBuilder.ToString().ShouldBe(expectedDataClasses); }
private static async Task GenerateClientSourceCode(ProgramOptions options, List <FileInfo> generatedFiles) { GraphQlSchema schema; if (String.IsNullOrWhiteSpace(options.ServiceUrl)) { schema = GraphQlGenerator.DeserializeGraphQlSchema(await File.ReadAllTextAsync(options.SchemaFileName)); } else { if (!KeyValueParameterParser.TryGetCustomHeaders(options.Header, out var headers, out var headerParsingErrorMessage)) { throw new InvalidOperationException(headerParsingErrorMessage); } schema = await GraphQlGenerator.RetrieveSchema(new HttpMethod(options.HttpMethod), options.ServiceUrl, headers); } var generatorConfiguration = new GraphQlGeneratorConfiguration { CSharpVersion = options.CSharpVersion, ClassPrefix = options.ClassPrefix, ClassSuffix = options.ClassSuffix, GeneratePartialClasses = options.PartialClasses, MemberAccessibility = options.MemberAccessibility, IdTypeMapping = options.IdTypeMapping, FloatTypeMapping = options.FloatTypeMapping, JsonPropertyGeneration = options.JsonPropertyAttribute }; if (!KeyValueParameterParser.TryGetCustomClassMapping(options.ClassMapping, out var customMapping, out var customMappingParsingErrorMessage)) { throw new InvalidOperationException(customMappingParsingErrorMessage); } foreach (var kvp in customMapping) { generatorConfiguration.CustomClassNameMapping.Add(kvp); } var generator = new GraphQlGenerator(generatorConfiguration); if (options.OutputType == OutputType.SingleFile) { await File.WriteAllTextAsync(options.OutputPath, generator.GenerateFullClientCSharpFile(schema, options.Namespace)); generatedFiles.Add(new FileInfo(options.OutputPath)); } else { var multipleFileGenerationContext = new MultipleFileGenerationContext(schema, options.OutputPath, options.Namespace); generator.Generate(multipleFileGenerationContext); generatedFiles.AddRange(multipleFileGenerationContext.Files); } }
private static GraphQlSchema?FromFile(FileInfo file) { var json = File.ReadAllText(file.FullName); if (file.FullName.EndsWith(MyFileExtension, StringComparison.OrdinalIgnoreCase)) { return(JsonConvert.DeserializeObject <GraphQlSchema>(json, SerializerSettings)); } return(GraphQlGenerator.DeserializeGraphQlSchema(json)); }
public void GenerateQueryBuildersWithListsOfScalarValuesAsArguments() { var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateQueryBuilder(DeserializeTestSchema("TestSchema3"), stringBuilder); var expectedQueryBuilders = GetTestResource("ExpectedQueryBuildersWithListsOfScalarValuesAsArguments"); stringBuilder.ToString().ShouldBe(expectedQueryBuilders); }
public void GenerateQueryBuilder() { var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateQueryBuilder(TestSchema, stringBuilder); var expectedQueryBuilders = GetTestResource("ExpectedQueryBuilders"); stringBuilder.ToString().ShouldBe(expectedQueryBuilders); }
public void NewCSharpSyntaxWithClassPostfix() { GraphQlGeneratorConfiguration.CSharpVersion = CSharpVersion.Newest; GraphQlGeneratorConfiguration.ClassPostfix = "V1"; var schema = DeserializeTestSchema("TestSchema2"); var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateQueryBuilder(schema, stringBuilder); GraphQlGenerator.GenerateDataClasses(schema, stringBuilder); var expectedOutput = GetTestResource("ExpectedNewCSharpSyntaxWithClassPostfix"); var generatedSourceCode = stringBuilder.ToString(); generatedSourceCode.ShouldBe(expectedOutput); var syntaxTree = SyntaxFactory.ParseSyntaxTree( $@"{GraphQlGenerator.RequiredNamespaces} namespace GraphQLTestAssembly {{ {generatedSourceCode} }}", CSharpParseOptions.Default.WithLanguageVersion(Enum.GetValues(typeof(LanguageVersion)).Cast <LanguageVersion>().Max())); var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary) .WithPlatform(Platform.AnyCpu) .WithOverflowChecks(true) .WithOptimizationLevel(OptimizationLevel.Release); var systemReference = MetadataReference.CreateFromFile(typeof(DateTimeOffset).Assembly.Location); var runtimeReference = MetadataReference.CreateFromFile(Assembly.Load("System.Runtime").Location); var netStandardReference = MetadataReference.CreateFromFile(Assembly.Load("netstandard").Location); var linqReference = MetadataReference.CreateFromFile(Assembly.Load("System.Linq").Location); var runtimeSerializationReference = MetadataReference.CreateFromFile(typeof(EnumMemberAttribute).Assembly.Location); var componentModelReference = MetadataReference.CreateFromFile(typeof(DescriptionAttribute).Assembly.Location); var compilation = CSharpCompilation.Create( "GraphQLTestAssembly", new [] { syntaxTree }, new [] { systemReference, runtimeSerializationReference, componentModelReference, runtimeReference, linqReference, netStandardReference }, compilationOptions); var assemblyFileName = Path.GetTempFileName(); var result = compilation.Emit(assemblyFileName); var errorReport = String.Join(Environment.NewLine, result.Diagnostics.Where(l => l.Severity != DiagnosticSeverity.Hidden).Select(l => $"[{l.Severity}] {l.ToString()}")); errorReport.ShouldBeNullOrEmpty(); Assembly.LoadFrom(assemblyFileName); Type.GetType("GraphQLTestAssembly.GraphQlQueryBuilder,GraphQLTestAssembly").ShouldNotBeNull(); }
public void GenerateDataClasses() { GraphQlGeneratorConfiguration.CustomClassNameMapping.Add("AwayMode", "VacationMode"); var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateDataClasses(TestSchema, stringBuilder); var expectedDataClasses = GetTestResource("ExpectedDataClasses"); stringBuilder.ToString().ShouldBe(expectedDataClasses); }
private IEnumerator Generate(string url, Dictionary <string, string> headers, string @namespace, string path) { return(GraphQlClientUtils.Send(url, headers, MakeQueryJson(IntrospectionQuery.Text), json => { Debug.Log(json); var schema = GraphQlGenerator.DeserializeGraphQlSchema(json); var csharpCode = new GraphQlGenerator().GenerateFullClientCSharpFile(schema, @namespace); File.WriteAllText(path, csharpCode); AssetDatabase.Refresh(); EditorUtility.DisplayDialog("Sucess", $"Generated \"{path}\"", "OK"); })); }
public void DeprecatedAttributes() { GraphQlGeneratorConfiguration.CSharpVersion = CSharpVersion.Newest; GraphQlGeneratorConfiguration.CommentGeneration = CommentGenerationOption.CodeSummary | CommentGenerationOption.DescriptionAttribute; GraphQlGeneratorConfiguration.IncludeDeprecatedFields = true; var schema = DeserializeTestSchema("TestSchemaWithDeprecatedFields"); var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateDataClasses(schema, stringBuilder); var expectedOutput = GetTestResource("ExpectedDeprecatedAttributes"); stringBuilder.ToString().ShouldBe(expectedOutput); }
public void GenerateFullClientCSharpFile() { var configuration = new GraphQlGeneratorConfiguration { CommentGeneration = CommentGenerationOption.CodeSummary | CommentGenerationOption.DescriptionAttribute }; var generator = new GraphQlGenerator(configuration); var generatedSourceCode = generator.GenerateFullClientCSharpFile(TestSchema, "GraphQlGenerator.Test"); var expectedOutput = GetTestResource("ExpectedFullClientCSharpFile"); generatedSourceCode.ShouldBe(expectedOutput); }
public void WithNullableReferences() { GraphQlGeneratorConfiguration.CSharpVersion = CSharpVersion.NewestWithNullableReferences; var schema = DeserializeTestSchema("TestSchema2"); var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateQueryBuilder(schema, stringBuilder); GraphQlGenerator.GenerateDataClasses(schema, stringBuilder); var expectedOutput = GetTestResource("ExpectedWithNullableReferences"); var generatedSourceCode = stringBuilder.ToString(); generatedSourceCode.ShouldBe(expectedOutput); }
public void GenerateDataClassesWithTypeConfiguration() { GraphQlGeneratorConfiguration.IntegerType = IntegerType.Int64; GraphQlGeneratorConfiguration.FloatType = FloatType.Double; GraphQlGeneratorConfiguration.IdType = IdType.String; GraphQlGeneratorConfiguration.GeneratePartialClasses = false; var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateDataClasses(TestSchema, stringBuilder); var expectedDataClasses = GetTestResource("ExpectedDataClassesWithTypeConfiguration"); stringBuilder.ToString().ShouldBe(expectedDataClasses); }
public void WithNullableReferences() { var configuration = new GraphQlGeneratorConfiguration { CSharpVersion = CSharpVersion.NewestWithNullableReferences }; var schema = DeserializeTestSchema("TestSchema2"); var stringBuilder = new StringBuilder(); var generator = new GraphQlGenerator(configuration); generator.Generate(CreateGenerationContext(stringBuilder, schema)); var expectedOutput = GetTestResource("ExpectedWithNullableReferences"); var generatedSourceCode = StripBaseClasses(stringBuilder.ToString()); generatedSourceCode.ShouldBe(expectedOutput); }
public void GenerateFormatMasks() { var configuration = new GraphQlGeneratorConfiguration { IdTypeMapping = IdTypeMapping.Custom }; configuration.CustomScalarFieldTypeMapping = (baseType, valueType, valueName) => { var isNotNull = valueType.Kind == GraphQlTypeKind.NonNull; var unwrappedType = valueType is GraphQlFieldType fieldType?fieldType.UnwrapIfNonNull() : valueType; var nullablePostfix = isNotNull ? "?" : null; if (unwrappedType.Name == "ID") { return new ScalarFieldTypeDescription { NetTypeName = "Guid" + nullablePostfix, FormatMask = "N" } } ; if (valueName == "before" || valueName == "after") { return new ScalarFieldTypeDescription { NetTypeName = "DateTimeOffset" + nullablePostfix, FormatMask = "yyyy-MM-dd\"T\"HH:mm" } } ; return(configuration.DefaultScalarFieldTypeMapping(baseType, valueType, valueName)); }; var stringBuilder = new StringBuilder(); var generator = new GraphQlGenerator(configuration); var schema = DeserializeTestSchema("TestSchema3"); generator.Generate(CreateGenerationContext(stringBuilder, schema)); var expectedDataClasses = GetTestResource("ExpectedFormatMasks"); var generatedSourceCode = StripBaseClasses(stringBuilder.ToString()); generatedSourceCode.ShouldBe(expectedDataClasses); }
public async Task RunAsync() { var config = new GraphQlGeneratorConfiguration() { IncludeDeprecatedFields = options.GenerateDeprecatedTypes, JsonPropertyGeneration = options.JsonPropertyGeneration, CSharpVersion = options.UseNullable ? CSharpVersion.NewestWithNullableReferences : CSharpVersion.Compatible }; var schema = await SchemaConverter.ReadAsync(options.Source).ConfigureAwait(false); var generator = new GraphQlGenerator(config); var content = generator.GenerateFullClientCSharpFile(schema, options.Namespace); Console.WriteLine($"writing client-code to {options.DestinationFile}"); File.WriteAllText(options.DestinationFile, content); }
private static async Task <GraphQlSchema> ReadAsyncCore(string schemaUriOrPath) { Console.WriteLine($"reading schema from {schemaUriOrPath}"); var file = new FileInfo(schemaUriOrPath); var schema = file.Exists ? FromFile(file) : await GraphQlGenerator.RetrieveSchema(schemaUriOrPath).ConfigureAwait(false) ; if (schema is null) { throw new InvalidOperationException($"failed to deserialize {file.FullName} to a GraphQlSchema"); } return(schema); }
public static ScalarFieldTypeDescription GetFallbackFieldType(GraphQlGeneratorConfiguration configuration, GraphQlTypeBase valueType) { valueType = (valueType as GraphQlFieldType)?.UnwrapIfNonNull() ?? valueType; if (valueType.Kind == GraphQlTypeKind.Enum) { return new ScalarFieldTypeDescription { NetTypeName = configuration.ClassPrefix + NamingHelper.ToPascalCase(valueType.Name) + configuration.ClassSuffix + "?" } } ; var dataType = valueType.Name == GraphQlTypeBase.GraphQlTypeScalarString ? "string" : "object"; return(new ScalarFieldTypeDescription { NetTypeName = GraphQlGenerator.AddQuestionMarkIfNullableReferencesEnabled(configuration, dataType) }); } }
public async Task GenerateAsync() { var schema = await GraphQlGenerator.RetrieveSchema("https://*****:*****@"C:\projects\SuSoClient\Repository\src\SurveySolutionsClient\Graphql.cs", csharpCode); }
public void GenerateDataClassesWithTypeConfiguration() { GraphQlGeneratorConfiguration.IntegerTypeMapping = IntegerTypeMapping.Int64; GraphQlGeneratorConfiguration.FloatTypeMapping = FloatTypeMapping.Double; GraphQlGeneratorConfiguration.BooleanTypeMapping = BooleanTypeMapping.Custom; GraphQlGeneratorConfiguration.IdTypeMapping = IdTypeMapping.String; GraphQlGeneratorConfiguration.GeneratePartialClasses = false; GraphQlGeneratorConfiguration.PropertyGeneration = PropertyGenerationOption.BackingField; GraphQlGeneratorConfiguration.CustomScalarFieldTypeMapping = (baseType, valueType, valueName) => valueType.Name == "Boolean" ? "bool" : GraphQlGeneratorConfiguration.DefaultScalarFieldTypeMapping(baseType, valueType, valueName); var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateDataClasses(TestSchema, stringBuilder); var expectedDataClasses = GetTestResource("ExpectedDataClassesWithTypeConfiguration"); stringBuilder.ToString().ShouldBe(expectedDataClasses); }
public static void CreateDataClasses(this GraphQlSchema schema, Options options) { var dataClassesPath = $"{options.OutputPath}\\Models"; dataClassesPath.CreateDirectory(); var objectTypes = schema.Types.Where(t => t.Kind == GraphQlGenerator.GraphQlTypeKindObject && !t.Name.StartsWith("__")).ToArray(); foreach (var graphQlType in objectTypes) { StringBuilder classBuilder = new StringBuilder(); GraphQlGenerator.GenerateDataClass(graphQlType, classBuilder); classBuilder.AppendLine(); var filePath = $"{dataClassesPath}\\{graphQlType.Name}.cs"; var file = filePath.CreateTextFile(); CreateCsContent(file, $"{options.TopNamespace}.Models", classBuilder.IndentLines()); file.Flush(); file.Close(); } }
public void NewCSharpSyntaxWithClassPostfix() { GraphQlGeneratorConfiguration.CSharpVersion = CSharpVersion.Newest; GraphQlGeneratorConfiguration.ClassPostfix = "V1"; var schema = DeserializeTestSchema("TestSchema2"); var stringBuilder = new StringBuilder(); GraphQlGenerator.GenerateQueryBuilder(schema, stringBuilder); GraphQlGenerator.GenerateDataClasses(schema, stringBuilder); var expectedOutput = GetTestResource("ExpectedNewCSharpSyntaxWithClassPostfix"); var generatedSourceCode = stringBuilder.ToString(); generatedSourceCode.ShouldBe(expectedOutput); CompileIntoAssembly(generatedSourceCode, "GraphQLTestAssembly"); Type.GetType("GraphQLTestAssembly.GraphQlQueryBuilder, GraphQLTestAssembly").ShouldNotBeNull(); }
public void GenerateFormatMasks() { var configuration = new GraphQlGeneratorConfiguration { IdTypeMapping = IdTypeMapping.Custom, ScalarFieldTypeMappingProvider = TestFormatMaskScalarFieldTypeMappingProvider.Instance }; var stringBuilder = new StringBuilder(); var generator = new GraphQlGenerator(configuration); var schema = DeserializeTestSchema("TestSchema3"); generator.Generate(CreateGenerationContext(stringBuilder, schema)); var expectedDataClasses = GetTestResource("ExpectedFormatMasks"); var generatedSourceCode = StripBaseClasses(stringBuilder.ToString()); generatedSourceCode.ShouldBe(expectedDataClasses); }
public static void CreateQueryBuilder(this GraphQlSchema schema, Options options) { var queryBuilderPath = $"{options.OutputPath}\\Builders"; queryBuilderPath.CreateDirectory(); var filePath = $"{queryBuilderPath}\\QueryQueryBuilder.cs"; var file = filePath.CreateTextFile(); var builder = new StringBuilder(); GraphQlGenerator.GenerateQueryBuilder(schema, builder); builder.AppendLine(); builder.AppendLine(); var indentedLines = builder.IndentLines(); CreateCsContent(file, $"{options.TopNamespace}.Builders", indentedLines); file.Flush(); file.Close(); }
public static void GenerateGraphQlClient(string url, string targetFileName, string @namespace) { var schema = GraphQlGenerator.RetrieveSchema(url).Result; var builder = new StringBuilder(); GraphQlGenerator.GenerateQueryBuilder(schema, builder); builder.AppendLine(); builder.AppendLine(); GraphQlGenerator.GenerateDataClasses(schema, builder); using (var writer = File.CreateText(targetFileName)) { writer.WriteLine("using System;"); writer.WriteLine("using System.Collections.Generic;"); writer.WriteLine("using System.Globalization;"); writer.WriteLine("using System.Linq;"); writer.WriteLine("using System.Reflection;"); writer.WriteLine("using System.Runtime.Serialization;"); writer.WriteLine("using System.Text;"); writer.WriteLine(); writer.WriteLine($"namespace {@namespace}"); writer.WriteLine("{"); var indentedLines = builder .ToString() .Split(new[] { Environment.NewLine }, StringSplitOptions.None) .Select(l => $" {l}"); foreach (var line in indentedLines) { writer.WriteLine(line); } writer.WriteLine("}"); } }