private static EnumValueDefinitionNode SerializeEnumValue(
EnumValue enumValue,
ReferencedTypes referenced)
{
var directives = enumValue.Directives
.Select(t => SerializeDirective(t, referenced))
.ToList();
if (enumValue.IsDeprecated)
{
directives.Add(new DirectiveNode(
WellKnownDirectives.Deprecated,
new ArgumentNode(
WellKnownDirectives.DeprecationReasonArgument,
enumValue.DeprecationReason)));
}
return(new EnumValueDefinitionNode
(
null,
new NameNode(enumValue.Name),
SerializeDescription(enumValue.Description),
directives
));
}
private void _addAttributes(ConstructorInfo constructorInfo)
{
foreach (ParameterInfo parameterInfo in constructorInfo.GetParameters())
{
ReferencedTypes.Add(new DllTypeParameter(parameterInfo));
}
}
private static InputObjectTypeDefinitionNode SerializeInputObjectType(
InputObjectType inputObjectType,
ReferencedTypes referenced)
{
var directives = inputObjectType.Directives
.Select(
t => SerializeDirective(
t,
referenced))
.ToList();
var fields = inputObjectType.Fields
.Select(
t => SerializeInputField(
t,
referenced))
.ToList();
return(new InputObjectTypeDefinitionNode(
null,
new NameNode(inputObjectType.Name),
SerializeDescription(inputObjectType.Description),
directives,
fields));
}
private static FieldDefinitionNode SerializeObjectField(
IOutputField field,
ReferencedTypes referenced)
{
var arguments = field.Arguments
.Select(
t => SerializeInputField(
t,
referenced))
.ToList();
var directives = field.Directives
.Select(
t => SerializeDirective(
t,
referenced))
.ToList();
return(new FieldDefinitionNode(
null,
new NameNode(field.Name),
SerializeDescription(field.Description),
arguments,
SerializeType(
field.Type,
referenced),
directives));
}
private static string PrettyTypeName(Type type)
{
var result = type.Name;
if (type.IsGenericType)
{
result = result.Remove(result.IndexOf('`'));
}
if (type.IsNested && !type.IsGenericParameter)
{
return(type.DeclaringType.PrettyName() + "." + result);
}
if (type.Namespace == null)
{
return(result);
}
var conflictingTypes = ReferencedTypes
.Where(definedType => definedType.Name == type.Name && definedType.Namespace != type.Namespace)
.ToArray();
var namespaceParts = type.Namespace.Split('.').Reverse().ToArray();
var namespacePart = "";
for (var i = 0; i < namespaceParts.Length && conflictingTypes.Length > 0; i++)
{
namespacePart = namespaceParts[i] + "." + namespacePart;
conflictingTypes = conflictingTypes
.Where(conflictingType => (conflictingType.Namespace + ".").EndsWith(namespacePart))
.ToArray();
}
return(namespacePart + result);
}
private void _addParameters(MethodInfo repMethodInfo)
{
foreach (ParameterInfo parameterInfo in repMethodInfo.GetParameters())
{
ReferencedTypes.Add(new DllTypeParameter(parameterInfo));
}
}
private static ObjectTypeDefinitionNode SerializeObjectType(
ObjectType objectType,
ReferencedTypes referenced)
{
var directives = objectType.Directives
.Select(t => SerializeDirective(t, referenced))
.ToList();
var interfaces = objectType.Interfaces.Values
.Select(t => SerializeNamedType(t, referenced))
.ToList();
var fields = objectType.Fields
.Where(t => !t.IsIntrospectionField)
.Select(t => SerializeObjectField(t, referenced))
.ToList();
return(new ObjectTypeDefinitionNode
(
null,
new NameNode(objectType.Name),
SerializeDescription(objectType.Description),
directives,
interfaces,
fields
));
}
private static ITypeNode SerializeType(
IType type,
ReferencedTypes referenced)
{
if (type is NonNullType nt)
{
return(new NonNullTypeNode(
null,
(INullableTypeNode)SerializeType(
nt.Type,
referenced)));
}
if (type is ListType lt)
{
return(new ListTypeNode(
null,
SerializeType(
lt.ElementType,
referenced)));
}
if (type is INamedType namedType)
{
return(SerializeNamedType(
namedType,
referenced));
}
throw new NotSupportedException();
}
private static ITypeDefinitionNode SerializeNonScalarTypeDefinition(
INamedType namedType,
ReferencedTypes referenced)
{
switch (namedType)
{
case ObjectType type:
return(SerializeObjectType(type, referenced));
case InterfaceType type:
return(SerializeInterfaceType(type, referenced));
case InputObjectType type:
return(SerializeInputObjectType(type, referenced));
case UnionType type:
return(SerializeUnionType(type, referenced));
case EnumType type:
return(SerializeEnumType(type, referenced));
default:
throw new NotSupportedException();
}
}
private static NamedTypeNode SerializeNamedType(
INamedType namedType,
ReferencedTypes referenced)
{
referenced.TypeNames.Add(namedType.Name);
return(new NamedTypeNode(null, new NameNode(namedType.Name)));
}
private static DirectiveNode SerializeDirective(
IDirective directiveType,
ReferencedTypes referenced)
{
referenced.DirectiveNames.Add(directiveType.Name);
return(directiveType.ToNode(true));
}
private static FieldDefinitionNode SerializeObjectField(
IOutputField field,
ReferencedTypes referenced)
{
var arguments = field.Arguments
.Select(t => SerializeInputField(t, referenced))
.ToList();
var directives = field.Directives
.Select(t => SerializeDirective(t, referenced))
.ToList();
if (field.IsDeprecated)
{
directives.Add(new DirectiveNode(
WellKnownDirectives.Deprecated,
new ArgumentNode(
WellKnownDirectives.DeprecationReasonArgument,
field.DeprecationReason)));
}
return(new FieldDefinitionNode
(
null,
new NameNode(field.Name),
SerializeDescription(field.Description),
arguments,
SerializeType(field.Type, referenced),
directives
));
}
private static EnumTypeDefinitionNode SerializeEnumType(
EnumType enumType,
ReferencedTypes referenced)
{
var directives = enumType.Directives
.Select(
t => SerializeDirective(
t,
referenced))
.ToList();
var values = enumType.Values
.Select(
t => SerializeEnumValue(
t,
referenced))
.ToList();
return(new EnumTypeDefinitionNode(
null,
new NameNode(enumType.Name),
SerializeDescription(enumType.Description),
directives,
values));
}
private static UnionTypeDefinitionNode SerializeUnionType(
UnionType unionType,
ReferencedTypes referenced)
{
var directives = unionType.Directives
.Select(
t => SerializeDirective(
t,
referenced))
.ToList();
var types = unionType.Types.Values
.Select(
t => SerializeNamedType(
t,
referenced))
.ToList();
return(new UnionTypeDefinitionNode(
null,
new NameNode(unionType.Name),
SerializeDescription(unionType.Description),
directives,
types));
}
private void _addFieldType(FieldInfo repFieldInfo)
{
if (!DllTypeManager.RememberedTypesDictionary.ContainsKey(repFieldInfo.FieldType.GUID))
{
DllTypeManager.RememberedTypesDictionary.Add(repFieldInfo.FieldType.GUID, new DllTypeClass(repFieldInfo.FieldType));
}
ReferencedTypes.Add(DllTypeManager.RememberedTypesDictionary[repFieldInfo.FieldType.GUID]);
}
private void _addParameterType(ParameterInfo repParameterInfo)
{
if (!DllTypeManager.RememberedTypesDictionary.ContainsKey(repParameterInfo.ParameterType.GUID))
{
DllTypeManager.RememberedTypesDictionary.Add(repParameterInfo.ParameterType.GUID, new DllTypeClass(repParameterInfo.GetType()));
}
ReferencedTypes.Add(DllTypeManager.RememberedTypesDictionary[repParameterInfo.ParameterType.GUID]);
}
private void _addPropertyType(PropertyInfo propertyInfo)
{
if (!DllTypeManager.RememberedTypesDictionary.ContainsKey(propertyInfo.PropertyType.GUID))
{
DllTypeManager.RememberedTypesDictionary.Add(propertyInfo.PropertyType.GUID, new DllTypeClass(propertyInfo.PropertyType));
}
ReferencedTypes.Add(DllTypeManager.RememberedTypesDictionary[propertyInfo.PropertyType.GUID]);
}
private void PropogateTypeReference(IExpression inner, IExpression outer)
{
Contract.Requires(inner != null);
Contract.Requires(outer != null);
if (ReferencedTypes.ContainsKey(inner))
{
AddTypeReference(ReferencedTypes[inner], outer);
}
}
private void _addReturnType(ParameterInfo repParameterInfo, bool doShallow)
{
if (!DllTypeManager.RememberedTypesDictionary.ContainsKey(repParameterInfo.ParameterType.GUID))
{
if (doShallow)
{
return;
}
DllTypeManager.RememberedTypesDictionary.Add(repParameterInfo.ParameterType.GUID, new DllTypeClass(repParameterInfo.ParameterType));
}
ReferencedTypes.Add(DllTypeManager.RememberedTypesDictionary[repParameterInfo.ParameterType.GUID]);
}
private static OperationTypeDefinitionNode SerializeOperationType(
ObjectType type,
OperationType operation,
ReferencedTypes referenced)
{
return(new OperationTypeDefinitionNode
(
null,
operation,
SerializeNamedType(type, referenced)
));
}
private static InputValueDefinitionNode SerializeInputField(
IInputField inputValue,
ReferencedTypes referenced)
{
return(new InputValueDefinitionNode
(
null,
new NameNode(inputValue.Name),
SerializeDescription(inputValue.Description),
SerializeType(inputValue.Type, referenced),
inputValue.DefaultValue,
inputValue.Directives.Select(t =>
SerializeDirective(t, referenced)).ToList()
));
}
void AddTypeToCheckProps(Type parentType, Type type)
{
var newRef = new TypeInformation()
{
Type = type
};
newRef.ReferencesIn.Add(parentType);
if (parentType != null)
{
ReferencedTypes[parentType].ReferencesOut.Add(type);
}
ReferencedTypes.Add(type, newRef);
PendingPropTypes.Enqueue(type);
}
private static DocumentNode SerializeSchema(
ISchema schema)
{
var referenced = new ReferencedTypes();
var typeDefinitions = GetNonScalarTypes(schema)
.Select(t => SerializeNonScalarTypeDefinition(t, referenced))
.Where(node => node != null)
.OfType <IDefinitionNode>()
.ToList();
return(new DocumentNode(
null,
typeDefinitions));
}
private void AddTypeReference(ITypeReference type, IExpression expr)
{
Contract.Requires(type != null);
Contract.Requires(expr != null);
Contract.Ensures(ReferencedTypes.ContainsKey(expr));
Contract.Ensures(ReferencedTypes[expr] == type);
if (!ReferencedTypes.ContainsKey(expr))
{
ReferencedTypes.Add(expr, type);
}
else
{
Contract.Assume(ReferencedTypes[expr] == type);
}
}
public static DocumentNode SerializeSchema(
ISchema schema)
{
if (schema == null)
{
throw new ArgumentNullException(nameof(schema));
}
var referenced = new ReferencedTypes();
var typeDefinitions = GetNonScalarTypes(schema)
.Select(t => SerializeNonScalarTypeDefinition(t, referenced))
.OfType <IDefinitionNode>()
.ToList();
if (schema.QueryType != null ||
schema.MutationType != null ||
schema.SubscriptionType != null)
{
typeDefinitions.Insert(0,
SerializeSchemaTypeDefinition(schema, referenced));
}
IEnumerable <DirectiveDefinitionNode> directiveTypeDefinitions =
schema.DirectiveTypes
.Where(t => referenced.DirectiveNames.Contains(t.Name))
.OrderBy(t => t.Name.ToString(), StringComparer.Ordinal)
.Select(t => SerializeDirectiveTypeDefinition(t, referenced));
typeDefinitions.AddRange(directiveTypeDefinitions);
IEnumerable <ScalarTypeDefinitionNode> scalarTypeDefinitions =
schema.Types
.OfType <ScalarType>()
.Where(t => referenced.TypeNames.Contains(t.Name))
.OrderBy(t => t.Name.ToString(), StringComparer.Ordinal)
.Select(t => SerializeScalarType(t));
typeDefinitions.AddRange(scalarTypeDefinitions);
return(new DocumentNode(null, typeDefinitions));
}
private static SchemaDefinitionNode SerializeSchemaTypeDefinition(
ISchema schema,
ReferencedTypes referenced)
{
var operations = new List <OperationTypeDefinitionNode>();
if (schema.QueryType != null)
{
operations.Add(SerializeOperationType(
schema.QueryType,
OperationType.Query,
referenced));
}
if (schema.MutationType != null)
{
operations.Add(SerializeOperationType(
schema.MutationType,
OperationType.Mutation,
referenced));
}
if (schema.SubscriptionType != null)
{
operations.Add(SerializeOperationType(
schema.SubscriptionType,
OperationType.Subscription,
referenced));
}
var directives = schema.Directives
.Select(t => SerializeDirective(t, referenced))
.ToList();
return(new SchemaDefinitionNode
(
null,
SerializeDescription(schema.Description),
directives,
operations
));
}
private static IDefinitionNode?SerializeObjectType(
ObjectType objectType,
ReferencedTypes referenced)
{
var directives = objectType.Directives
.Select(t => SerializeDirective(t, referenced))
.ToList();
var interfaces = objectType.Implements
.Select(t => SerializeNamedType(t, referenced))
.ToList();
var fields = objectType.Fields
.Where(t => !t.IsIntrospectionField)
.Where(t => !IsApolloTypeAddition(t.Type.NamedType()))
.Select(t => SerializeObjectField(t, referenced))
.ToList();
if (fields.Count == 0)
{
return(null);
}
if (objectType.ContextData.ContainsKey(WellKnownContextData.ExtendMarker))
{
return(new ObjectTypeExtensionNode(
null,
new NameNode(objectType.Name),
directives,
interfaces,
fields));
}
return(new ObjectTypeDefinitionNode(
null,
new NameNode(objectType.Name),
SerializeDescription(objectType.Description),
directives,
interfaces,
fields));
}
public byte[] Compile(string code)
{
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var references = GetTrustedReferences().Concat(ReferencedTypes.Select(GetReference));
var compileOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
.WithConcurrentBuild(true)
.WithOptimizationLevel(OptimizationLevel.Release)
.WithWarningLevel(0);
var compilation = CSharpCompilation.Create($"{Guid.NewGuid():N}", syntaxTree.Yield(), references, compileOptions);
using var ms = new MemoryStream();
var result = compilation.Emit(ms);
if (!result.Success)
{
throw new CompilationErrorException("Code failed to compile",
result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error).ToImmutableArray());
}
ms.Position = 0;
return(ms.ToArray());
}
private static DirectiveDefinitionNode SerializeDirectiveTypeDefinition(
DirectiveType directiveType,
ReferencedTypes referenced)
{
var arguments = directiveType.Arguments
.Select(t => SerializeInputField(t, referenced))
.ToList();
var locations = directiveType.Locations
.Select(l => new NameNode(l.MapDirectiveLocation().ToString()))
.ToList();
return(new DirectiveDefinitionNode
(
null,
new NameNode(directiveType.Name),
SerializeDescription(directiveType.Description),
directiveType.IsRepeatable,
arguments,
locations
));
}
public void FullReset()
{
ReferencedObjects.Reset();
ReferencedTypes.Reset();
}
