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("}");
}
}
