public IEnumerable <CSharpDocument> Generate(
ClientModel clientModel,
string ns,
string clientName)
{
if (clientModel is null)
{
throw new ArgumentNullException(nameof(clientModel));
}
var context = new MapperContext(ns, clientName);
EnumDescriptorMapper.Map(clientModel, context);
EntityIdFactoryDescriptorMapper.Map(clientModel, context);
TypeDescriptorMapper.Map(clientModel, context);
EntityTypeDescriptorMapper.Map(clientModel, context);
OperationDescriptorMapper.Map(clientModel, context);
ClientDescriptorMapper.Map(clientModel, context);
ResultBuilderDescriptorMapper.Map(clientModel, context);
DependencyInjectionMapper.Map(clientModel, context);
DataTypeDescriptorMapper.Map(clientModel, context);
var code = new StringBuilder();
foreach (var descriptor in context.GetAllDescriptors())
{
foreach (var generator in _generators)
{
if (generator.CanHandle(descriptor))
{
yield return(WriteDocument(generator, descriptor, code));
}
}
}
}
private static IReadOnlyList <GeneratorResult> GenerateCSharpDocuments(
MapperContext context,
CSharpGeneratorSettings settings)
{
var generatorSettings = new CSharpSyntaxGeneratorSettings(
settings.NoStore,
settings.InputRecords,
settings.EntityRecords,
settings.RazorComponents);
var results = new List <GeneratorResult>();
foreach (var descriptor in context.GetAllDescriptors())
{
foreach (var generator in _generators)
{
if (generator.CanHandle(descriptor, generatorSettings))
{
CSharpSyntaxGeneratorResult result =
generator.Generate(descriptor, generatorSettings);
results.Add(new(generator.GetType(), result));
}
}
}
return(results);
}
public IEnumerable <CSharpDocument> Generate(
ClientModel clientModel,
string ns,
string clientName)
{
if (clientModel is null)
{
throw new ArgumentNullException(nameof(clientModel));
}
var context = new MapperContext(ns, clientName);
// First we run all mappers that do not have any dependencies on others.
EntityIdFactoryDescriptorMapper.Map(clientModel, context);
// Second we start with the type descriptor mapper which creates
// the type structure for the generators.
// The following mappers can depend on this foundational data.
TypeDescriptorMapper.Map(clientModel, context);
// now we execute all mappers that depend on the previous type mappers.
OperationDescriptorMapper.Map(clientModel, context);
DependencyInjectionMapper.Map(clientModel, context);
DataTypeDescriptorMapper.Map(clientModel, context);
EntityTypeDescriptorMapper.Map(clientModel, context);
ResultBuilderDescriptorMapper.Map(clientModel, context);
// Lastly we generate the client mapper
ClientDescriptorMapper.Map(clientModel, context);
// Last we execute all our generators with the descriptiptors.
var code = new StringBuilder();
foreach (var descriptor in context.GetAllDescriptors())
{
foreach (var generator in _generators)
{
if (generator.CanHandle(descriptor))
{
yield return(WriteDocument(generator, descriptor, code));
}
}
}
}
public static CSharpGeneratorResult Generate(
ClientModel clientModel,
CSharpGeneratorSettings settings)
{
if (clientModel is null)
{
throw new ArgumentNullException(nameof(clientModel));
}
if (string.IsNullOrEmpty(settings.ClientName))
{
throw new ArgumentException(
string.Format(
Resources.CSharpGenerator_Generate_ArgumentCannotBeNull,
nameof(settings.ClientName)),
nameof(settings));
}
if (string.IsNullOrEmpty(settings.Namespace))
{
throw new ArgumentException(
string.Format(
Resources.CSharpGenerator_Generate_ArgumentCannotBeNull,
nameof(settings.Namespace)),
nameof(settings));
}
var context = new MapperContext(
settings.Namespace,
settings.ClientName,
settings.HashProvider,
settings.RequestStrategy,
settings.TransportProfiles);
// First we run all mappers that do not have any dependencies on others.
EntityIdFactoryDescriptorMapper.Map(clientModel, context);
// Second we start with the type descriptor mapper which creates
// the type structure for the generators.
// The following mappers can depend on this foundational data.
TypeDescriptorMapper.Map(clientModel, context);
// now we execute all mappers that depend on the previous type mappers.
OperationDescriptorMapper.Map(clientModel, context);
StoreAccessorMapper.Map(clientModel, context);
DataTypeDescriptorMapper.Map(clientModel, context);
EntityTypeDescriptorMapper.Map(clientModel, context);
ResultBuilderDescriptorMapper.Map(clientModel, context);
// We generate the client mapper next as we have all components of the client generated
ClientDescriptorMapper.Map(clientModel, context);
// Lastly we generate the DI code, as we now have collected everything
DependencyInjectionMapper.Map(clientModel, context);
// Last we execute all our generators with the descriptors.
var code = new StringBuilder();
var documents = new List <SourceDocument>();
foreach (var descriptor in context.GetAllDescriptors())
{
foreach (var generator in _generators)
{
if (generator.CanHandle(descriptor))
{
documents.Add(WriteDocument(generator, descriptor, code));
}
}
}
if (settings.RequestStrategy == RequestStrategy.PersistedQuery)
{
foreach (var operation in context.Operations)
{
documents.Add(new SourceDocument(
operation.Name,
Encoding.UTF8.GetString(operation.Body),
SourceDocumentKind.GraphQL,
operation.HashValue));
}
}
return(new(documents));
}
private static void GenerateMultipleCSharpDocuments(
MapperContext context,
CSharpGeneratorSettings settings,
ICollection <SourceDocument> documents)
{
var generatorSettings = new CSharpSyntaxGeneratorSettings(
settings.NoStore,
settings.InputRecords,
settings.EntityRecords);
var results = new List <(Type Generator, CSharpSyntaxGeneratorResult Result)>();
foreach (var descriptor in context.GetAllDescriptors())
{
foreach (var generator in _generators)
{
if (generator.CanHandle(descriptor, generatorSettings))
{
CSharpSyntaxGeneratorResult result =
generator.Generate(descriptor, generatorSettings);
results.Add((generator.GetType(), result));
}
}
}
foreach (var group in results.GroupBy(t => t.Result.Namespace).OrderBy(t => t.Key))
{
foreach ((Type generator, CSharpSyntaxGeneratorResult result) in group)
{
BaseTypeDeclarationSyntax typeDeclaration = result.TypeDeclaration;
#if DEBUG
SyntaxTriviaList trivia = typeDeclaration
.GetLeadingTrivia()
.Insert(0, Comment("// " + generator.FullName));
typeDeclaration = typeDeclaration.WithLeadingTrivia(trivia);
#endif
CompilationUnitSyntax compilationUnit =
CompilationUnit().AddMembers(
NamespaceDeclaration(IdentifierName(group.Key)).AddMembers(
typeDeclaration));
compilationUnit = compilationUnit.NormalizeWhitespace(elasticTrivia: true);
var code = new StringBuilder();
// marker for style cop to ignore this code
code.AppendLine("// <auto-generated/>");
// enable nullability settings
code.AppendLine("#nullable enable");
code.AppendLine();
code.AppendLine(compilationUnit.ToFullString());
documents.Add(new(
result.FileName,
code.ToString(),
SourceDocumentKind.CSharp,
path: result.Path));
}
}
}
public static CSharpGeneratorResult Generate(
ClientModel clientModel,
string clientName = "GraphQLClient",
string @namespace = "StrawberryShake.GraphQL")
{
if (clientModel is null)
{
throw new ArgumentNullException(nameof(clientModel));
}
if (string.IsNullOrEmpty(clientName))
{
throw new ArgumentException(
string.Format(
Resources.CSharpGenerator_Generate_ArgumentCannotBeNull,
nameof(clientName)),
nameof(clientName));
}
if (string.IsNullOrEmpty(@namespace))
{
throw new ArgumentException(
string.Format(
Resources.CSharpGenerator_Generate_ArgumentCannotBeNull,
nameof(@namespace)),
nameof(@namespace));
}
var context = new MapperContext(@namespace, clientName);
// First we run all mappers that do not have any dependencies on others.
EntityIdFactoryDescriptorMapper.Map(clientModel, context);
// Second we start with the type descriptor mapper which creates
// the type structure for the generators.
// The following mappers can depend on this foundational data.
TypeDescriptorMapper.Map(clientModel, context);
// now we execute all mappers that depend on the previous type mappers.
OperationDescriptorMapper.Map(clientModel, context);
DependencyInjectionMapper.Map(clientModel, context);
DataTypeDescriptorMapper.Map(clientModel, context);
EntityTypeDescriptorMapper.Map(clientModel, context);
ResultBuilderDescriptorMapper.Map(clientModel, context);
// Lastly we generate the client mapper
ClientDescriptorMapper.Map(clientModel, context);
// Last we execute all our generators with the descriptiptors.
var code = new StringBuilder();
var documents = new List <CSharpDocument>();
foreach (var descriptor in context.GetAllDescriptors())
{
foreach (var generator in _generators)
{
if (generator.CanHandle(descriptor))
{
documents.Add(WriteDocument(generator, descriptor, code));
}
}
}
return(new(documents));
}
