private void CreateClassModels(
IModelGeneratorContext context,
OperationDefinitionNode operation,
IType fieldType,
FieldNode fieldSelection,
PossibleSelections possibleSelections,
IFragmentNode returnType,
IInterfaceDescriptor interfaceDescriptor,
Path path)
{
var resultParserTypes = new List <ResultParserTypeDescriptor>();
IReadOnlyCollection <SelectionInfo> selections = possibleSelections.Variants;
CreateClassModels(
context,
fieldSelection,
returnType,
interfaceDescriptor,
selections,
resultParserTypes,
path);
context.Register(
new ResultParserMethodDescriptor(
GetPathName(path),
operation,
fieldType,
fieldSelection,
path,
interfaceDescriptor,
resultParserTypes));
}
private IReadOnlyList <IInterfaceDescriptor> CreateChildInterfaceModels(
IModelGeneratorContext context,
IFragmentNode fragmentNode,
Path path,
Stack <ISet <string> > levels,
ISet <string> implementedFields)
{
var implementedByChildren = new HashSet <string>();
levels.Push(implementedByChildren);
var implements = new List <IInterfaceDescriptor>();
foreach (IFragmentNode child in fragmentNode.Children)
{
implements.Add(CreateInterfaceModel(context, child, path, levels));
}
levels.Pop();
foreach (string fieldName in implementedByChildren)
{
implementedFields.Add(fieldName);
}
return(implements);
}
public override ICodeDescriptor Generate(
IModelGeneratorContext context,
OperationDefinitionNode operation,
UnionType namedType,
IType fieldType,
FieldNode fieldSelection,
PossibleSelections possibleSelections,
Path path)
{
IFragmentNode returnType = ResolveReturnType(
context,
namedType,
fieldSelection,
possibleSelections.ReturnType);
IInterfaceDescriptor interfaceDescriptor = CreateInterfaceModel(
context, returnType, path);
context.Register(fieldSelection, interfaceDescriptor);
CreateClassModels(
context,
operation,
fieldType,
fieldSelection,
possibleSelections,
returnType,
interfaceDescriptor,
path);
return(interfaceDescriptor);
}
public ICodeDescriptor Generate(IModelGeneratorContext context, EnumType enumType)
{
var values = new List <EnumValueDescriptor>();
foreach (EnumValue value in enumType.Values)
{
IDirective directive = value.Directives.FirstOrDefault(t =>
t.Name.Equals(GeneratorDirectives.Name) &&
t.GetArgument <string>(GeneratorDirectives.ValueArgument) != null);
string name = directive is null
? GetPropertyName(value.Name.ToLowerInvariant())
: directive.GetArgument <string>(GeneratorDirectives.ValueArgument);
values.Add(new EnumValueDescriptor(name, value.Name));
}
NameString typeName = context.GetOrCreateName(
enumType.SyntaxNode,
GetClassName(enumType.Name));
var descriptor = new EnumDescriptor(
typeName,
context.Namespace,
values);
context.Register(descriptor);
return(descriptor);
}
public abstract ICodeDescriptor Generate(
IModelGeneratorContext context,
OperationDefinitionNode operation,
T namedType,
IType returnType,
FieldNode fieldSelection,
PossibleSelections possibleSelections,
Path path);
private IInputClassDescriptor GenerateInputObjectType(
IModelGeneratorContext context,
InputObjectType inputObjectType)
{
return(GenerateInputObjectType(
context,
inputObjectType,
new Dictionary <string, IInputClassDescriptor>()));
}
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);
}
protected IInterfaceDescriptor CreateInterfaceModel(
IModelGeneratorContext context,
IFragmentNode fragmentNode,
Path path)
{
var levels = new Stack <ISet <string> >();
levels.Push(new HashSet <string>());
return(CreateInterfaceModel(
context,
fragmentNode,
path,
levels));
}
private IInterfaceDescriptor CreateInterfaceModel(
IModelGeneratorContext context,
IFragmentNode fragmentNode,
Path path,
Stack <ISet <string> > levels)
{
ISet <string> implementedFields = levels.Peek();
IReadOnlyList <IFieldDescriptor> fieldDescriptors =
Array.Empty <IFieldDescriptor>();
IReadOnlyList <IInterfaceDescriptor> implements =
CreateChildInterfaceModels(
context,
fragmentNode,
path,
levels,
implementedFields);
if (fragmentNode.Fragment.TypeCondition is IComplexOutputType type)
{
fieldDescriptors = CreateFields(
type,
fragmentNode.Fragment.SelectionSet.Selections,
name =>
{
if (implementedFields.Add(name))
{
return(true);
}
return(false);
},
path);
}
NameString interfaceName = context.GetOrCreateName(
fragmentNode.Fragment.SelectionSet,
GetInterfaceName(fragmentNode.Name));
var descriptor = new InterfaceDescriptor(
interfaceName,
context.Namespace,
fragmentNode.Fragment.TypeCondition,
fieldDescriptors,
implements);
context.Register(descriptor);
return(descriptor);
}
protected void CreateClassModel(
IModelGeneratorContext context,
IFragmentNode returnType,
IInterfaceDescriptor interfaceDescriptor,
SelectionInfo selection,
List <ResultParserTypeDescriptor> resultParserTypes)
{
var modelClass = new ClassDescriptor(
GetClassName(returnType.Name),
context.Namespace,
selection.Type,
new[] { interfaceDescriptor });
context.Register(modelClass);
resultParserTypes.Add(new ResultParserTypeDescriptor(modelClass));
}
protected void CreateClassModels(
IModelGeneratorContext context,
FieldNode fieldSelection,
IFragmentNode returnType,
IInterfaceDescriptor interfaceDescriptor,
IReadOnlyCollection <SelectionInfo> selections,
List <ResultParserTypeDescriptor> resultParserTypes,
Path path)
{
foreach (SelectionInfo selection in selections)
{
IFragmentNode modelType = ResolveReturnType(
context,
selection.Type,
fieldSelection,
selection);
var interfaces = new List <IInterfaceDescriptor>();
foreach (IFragmentNode fragment in
ShedNonMatchingFragments(selection.Type, modelType))
{
interfaces.Add(CreateInterfaceModel(context, fragment, path));
}
interfaces.Insert(0, interfaceDescriptor);
NameString typeName = HoistName(selection.Type, modelType);
string className = context.GetOrCreateName(
modelType.Fragment.SelectionSet,
GetClassName(typeName));
var modelClass = new ClassDescriptor(
className,
context.Namespace,
selection.Type,
interfaces);
context.Register(modelClass);
resultParserTypes.Add(new ResultParserTypeDescriptor(modelClass));
}
}
public override ICodeDescriptor Generate(
IModelGeneratorContext context,
OperationDefinitionNode operation,
ObjectType namedType,
IType fieldType,
FieldNode fieldSelection,
PossibleSelections possibleSelections,
Path path)
{
IFragmentNode returnType = ResolveReturnType(
context,
namedType,
fieldSelection,
possibleSelections.ReturnType);
IInterfaceDescriptor interfaceDescriptor = CreateInterfaceModel(
context, returnType, path);
context.Register(fieldSelection, interfaceDescriptor);
var resultParserTypes = new List <ResultParserTypeDescriptor>();
CreateClassModel(
context,
returnType,
interfaceDescriptor,
possibleSelections.ReturnType,
resultParserTypes);
context.Register(
new ResultParserMethodDescriptor(
GetPathName(path),
operation,
fieldType,
fieldSelection,
path,
interfaceDescriptor,
resultParserTypes));
return(interfaceDescriptor);
}
private IInputClassDescriptor GenerateInputObjectType(
IModelGeneratorContext context,
InputObjectType inputObjectType,
IDictionary <string, IInputClassDescriptor> knownTypes)
{
if (knownTypes.TryGetValue(
inputObjectType.Name,
out IInputClassDescriptor? descriptor))
{
return(descriptor);
}
string typeName = context.GetOrCreateName(
inputObjectType.SyntaxNode,
GetClassName(inputObjectType.Name));
var fields = new List <Descriptors.IInputFieldDescriptor>();
descriptor = new InputClassDescriptor(
typeName, context.Namespace, inputObjectType, fields);
knownTypes[inputObjectType.Name] = descriptor;
foreach (InputField field in inputObjectType.Fields)
{
if (field.Type.NamedType() is InputObjectType fieldType)
{
fields.Add(new InputFieldDescriptor(
field.Name, field.Type, field,
GenerateInputObjectType(context, fieldType, knownTypes)));
}
else
{
fields.Add(new InputFieldDescriptor(
field.Name, field.Type, field, null));
}
}
return(descriptor);
}
public CodeModelGenerator(
ISchema schema,
IQueryDescriptor query,
ISet <string> usedNames,
string clientName,
string ns)
{
_schema = schema ?? throw new ArgumentNullException(nameof(schema));
_query = query ?? throw new ArgumentNullException(nameof(query));
_usedNames = usedNames ?? throw new ArgumentNullException(nameof(usedNames));
_clientName = clientName ?? throw new ArgumentNullException(nameof(clientName));
_namespace = ns ?? throw new ArgumentNullException(nameof(ns));
_document = query.OriginalDocument;
_fieldCollector = new FieldCollector(
schema,
new FragmentCollection(schema, query.OriginalDocument));
Descriptors = Array.Empty <ICodeDescriptor>();
FieldTypes = new Dictionary <FieldNode, string>();
_context = new ModelGeneratorContext(schema, query, clientName, ns);
}
protected void CreateClassModel(
IModelGeneratorContext context,
IFragmentNode returnType,
IInterfaceDescriptor interfaceDescriptor,
SelectionInfo selection,
List <ResultParserTypeDescriptor> resultParserTypes)
{
var fieldNames = new HashSet <string>(
selection.Fields.Select(t => GetPropertyName(t.ResponseName)));
string className = context.GetOrCreateName(
returnType.Fragment.SelectionSet,
GetClassName(returnType.Name),
fieldNames);
var modelClass = new ClassDescriptor(
className,
context.Namespace,
selection.Type,
new[] { interfaceDescriptor });
context.Register(modelClass);
resultParserTypes.Add(new ResultParserTypeDescriptor(modelClass));
}
protected void CreateClassModels(
IModelGeneratorContext context,
FieldNode fieldSelection,
IFragmentNode returnType,
IInterfaceDescriptor interfaceDescriptor,
IReadOnlyCollection <SelectionInfo> selections,
List <ResultParserTypeDescriptor> resultParserTypes,
Path path)
{
foreach (SelectionInfo selection in selections)
{
IFragmentNode modelType = ResolveReturnType(
context,
selection.Type,
fieldSelection,
selection);
var interfaces = new List <IInterfaceDescriptor>();
foreach (IFragmentNode fragment in
ShedNonMatchingFragments(selection.Type, modelType))
{
interfaces.Add(CreateInterfaceModel(context, fragment, path));
}
interfaces.Insert(0, interfaceDescriptor);
NameString typeName = HoistName(selection.Type, modelType);
if (typeName.IsEmpty)
{
typeName = selection.Type.Name;
}
bool update = false;
var fieldNames = new HashSet <string>(
selection.Fields.Select(t => GetPropertyName(t.ResponseName)));
string className = context.GetOrCreateName(
modelType.Fragment.SelectionSet,
GetClassName(typeName),
fieldNames);
if (context.TryGetDescriptor(className, out ClassDescriptor? modelClass))
{
var interfaceNames = new HashSet <string>(interfaces.Select(t => t.Name));
foreach (IInterfaceDescriptor item in modelClass !.Implements.Reverse())
{
if (!interfaceNames.Contains(item.Name))
{
interfaces.Insert(0, item);
}
}
update = true;
}
modelClass = new ClassDescriptor(
className,
context.Namespace,
selection.Type,
interfaces);
context.Register(modelClass, update);
resultParserTypes.Add(new ResultParserTypeDescriptor(modelClass));
}
}
