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));
}
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");
}));
}
private static GraphQlSchema DeserializeTestSchema(string resourceName) => GraphQlGenerator.DeserializeGraphQlSchema(GetTestResource(resourceName));
public static async Task GeneratAsync(this GraphqlGeneratorConfig config)
{
try
{
GraphQlGeneratorConfiguration.CustomScalarFieldTypeMapping =
(baseType, valueType, valueName) =>
{
valueType = valueType is GraphQlFieldType fieldType?fieldType.UnwrapIfNonNull() : valueType;
return(config.FieldTypeMappings.TryGetValue(valueType.Name, out var overrideTypeName)
? overrideTypeName
: GraphQlGeneratorConfiguration.DefaultScalarFieldTypeMapping(baseType, valueType, valueName));
};
var httpClient = new HttpClient();
if (!string.IsNullOrEmpty(config.AuthenticationHeander.Key))
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(config.AuthenticationHeander.Key, config.AuthenticationHeander.Value);
}
foreach (var header in config.HttpHeaders)
{
httpClient.DefaultRequestHeaders.Add(header.Key, header.Value);
}
using var response =
await httpClient.PostAsync(config.SchemaUrl,
new StringContent (JsonConvert.SerializeObject(new { query = IntrospectionQuery.Text }), Encoding.UTF8, "application/json"));
var schema =
response.Content == null
? "(no content)"
: await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new InvalidOperationException($"Status code: {(int)response.StatusCode} ({response.StatusCode}); content: {schema}");
}
if (config.GenerateSchema)
{
var formattedSchema = JToken.Parse(schema).ToString(Formatting.Indented);
using var schemaWriter = File.CreateText(config.DestinationPath + "schema.graphql");
await schemaWriter.WriteAsync(formattedSchema);
}
var deserializedSchema = GraphQlGenerator.DeserializeGraphQlSchema(schema);
var builder = new StringBuilder();
GraphQlGenerator.GenerateQueryBuilder(deserializedSchema, builder);
builder.AppendLine();
builder.AppendLine();
GraphQlGenerator.GenerateDataClasses(deserializedSchema, builder);
using var writer = File.CreateText(config.DestinationPath + "QueryBuilder.cs");
writer.WriteLine(RequiredNamespaces);
writer.WriteLine();
writer.WriteLine($"namespace {config.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("}");
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public static async Task <IReadOnlyCollection <FileInfo> > GenerateClientSourceCode(ProgramOptions options)
{
var isServiceUrlMissing = String.IsNullOrWhiteSpace(options.ServiceUrl);
if (isServiceUrlMissing && String.IsNullOrWhiteSpace(options.SchemaFileName))
{
System.Console.WriteLine("ERROR: Either \"serviceUrl\" or \"schemaFileName\" parameter must be specified. ");
Environment.Exit(4);
}
if (!isServiceUrlMissing && !String.IsNullOrWhiteSpace(options.SchemaFileName))
{
System.Console.WriteLine("ERROR: \"serviceUrl\" and \"schemaFileName\" parameters are mutually exclusive. ");
Environment.Exit(5);
}
GraphQlSchema schema;
if (isServiceUrlMissing)
{
schema = GraphQlGenerator.DeserializeGraphQlSchema(await File.ReadAllTextAsync(options.SchemaFileName));
}
else
{
if (!KeyValueParameterParser.TryGetCustomHeaders(options.Headers, out var headers, out var headerParsingErrorMessage))
{
System.Console.WriteLine("ERROR: " + headerParsingErrorMessage);
Environment.Exit(3);
}
schema = await GraphQlGenerator.RetrieveSchema(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))
{
System.Console.WriteLine("ERROR: " + customMappingParsingErrorMessage);
Environment.Exit(3);
}
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));
return(new[] { new FileInfo(options.OutputPath) });
}
var multipleFileGenerationContext = new MultipleFileGenerationContext(schema, options.OutputPath, options.Namespace);
generator.Generate(multipleFileGenerationContext);
return(multipleFileGenerationContext.Files);
}
