private void AddRootEntityFields(ISchema schema)
{
var query = schema.Query;
if (query == null)
{
schema.Query = query = new ObjectGraphType {
Name = "Query"
};
}
query.Field("_service", new NonNullGraphType(new GraphQLTypeReference("_Service")), resolve: context => new { });
var representationsType = new NonNullGraphType(new ListGraphType(new NonNullGraphType(new GraphQLTypeReference("_Any"))));
query.FieldAsync(
"_entities",
new NonNullGraphType(new ListGraphType(new GraphQLTypeReference("_Entity"))),
arguments: new QueryArguments(new QueryArgument(representationsType)
{
Name = "representations"
}),
resolve: async context =>
{
AddTypeNameToSelection(context.FieldAst, context.Document);
var reps = context.GetArgument <List <Dictionary <string, object> > >("representations");
var results = new List <object?>();
foreach (var rep in reps !)
{
var typeName = rep !["__typename"].ToString();
var type = context.Schema.AllTypes[typeName !];
public void ToITypeNonNullBase()
{
var nonnullType = new NonNullGraphType(new GraphQLTypeReference(typeof(ATestGraphQLClass).Name));
((nonnullType.ToIType() as NonNullType)
.Type as NamedType).Name.Should().Be(typeof(ATestGraphQLClass).Name);
}
private void AddRootEntityFields(ISchema schema)
{
var query = schema.Query;
if (query == null)
{
schema.Query = query = new ObjectGraphType {
Name = "Query"
};
}
query.Field("_service", new NonNullGraphType(new GraphQLTypeReference("_Service")), resolve: context => new { });
var representationsType = new NonNullGraphType(new ListGraphType(new NonNullGraphType(new GraphQLTypeReference("_Any"))));
query.FieldAsync(
"_entities",
new NonNullGraphType(new ListGraphType(new GraphQLTypeReference("_Entity"))),
arguments: new QueryArguments(new QueryArgument(representationsType)
{
Name = "representations"
}),
resolve: async context =>
{
AddTypeNameToSelection(context.FieldAst, context.Document);
var reps = context.GetArgument <List <Dictionary <string, object> > >("representations");
var results = new List <object?>();
foreach (var rep in reps !)
{
var typeName = rep !["__typename"].ToString();
var type = context.Schema.AllTypes[typeName];
if (type != null)
{
// execute resolver
var resolver = type.GetMetadata <IFederatedResolver>(RESOLVER_METADATA_FIELD);
if (resolver != null)
{
var resolveContext = new FederatedResolveContext
{
Arguments = rep !,
ParentFieldContext = context
};
var result = await resolver.Resolve(resolveContext).ConfigureAwait(false);
results.Add(result);
}
else
{
results.Add(rep);
}
}
else
{
// otherwise return the representation
results.Add(rep);
}
}
public void IsListType_NonNullOfListGraphType_ReturnsFTrue()
{
var graphType = new NonNullGraphType(new ListGraphType(new ObjectGraphType()));
var isListType = graphType.IsListType();
isListType.Should().BeTrue();
}
private string build_schema(string propType)
{
var nestedObjType = new ObjectGraphType
{
Name = "NestedObjType"
};
nestedObjType.AddField(new FieldType
{
ResolvedType = new IntGraphType(),
Name = "intField"
});
var rootType = new ObjectGraphType {
Name = "root"
};
IGraphType resolvedType;
switch (propType)
{
case "none":
{
resolvedType = nestedObjType;
break;
}
case "list":
{
resolvedType = new ListGraphType(nestedObjType);
break;
}
case "non-null":
{
resolvedType = new NonNullGraphType(nestedObjType);
break;
}
default:
{
throw new NotSupportedException();
}
}
rootType.AddField(new FieldType
{
Name = "listOfObjField",
ResolvedType = resolvedType
});
var s = new Schema
{
Query = rootType
};
var schema = new SchemaPrinter(s).Print();
return(schema);
}
private static bool HasFullSpecifiedResolvedType(IProvideResolvedType type)
{
return(type.ResolvedType switch
{
null => false,
ListGraphType list => HasFullSpecifiedResolvedType(list),
NonNullGraphType nonNull => HasFullSpecifiedResolvedType(nonNull),
_ => true, // not null
});
public ContentDataGraphInputType(IGraphModel model, ISchemaEntity schema)
{
var schemaType = schema.TypeName();
var schemaName = schema.DisplayName();
Name = $"{schemaType}InputDto";
foreach (var field in schema.SchemaDef.Fields.Where(x => !x.IsHidden))
{
var inputType = model.GetInputGraphType(field);
if (inputType != null)
{
if (field.RawProperties.IsRequired)
{
inputType = new NonNullGraphType(inputType);
}
var fieldName = field.RawProperties.Label.WithFallback(field.Name);
var fieldGraphType = new InputObjectGraphType
{
Name = $"{schemaType}Data{field.Name.ToPascalCase()}InputDto"
};
var partition = model.ResolvePartition(field.Partitioning);
foreach (var partitionItem in partition)
{
fieldGraphType.AddField(new FieldType
{
Name = partitionItem.Key,
ResolvedType = inputType,
Resolver = null,
Description = field.RawProperties.Hints
});
}
fieldGraphType.Description = $"The input structure of the {fieldName} of a {schemaName} content type.";
var fieldResolver = new FuncFieldResolver <NamedContentData, ContentFieldData>(c => c.Source.GetOrDefault(field.Name));
AddField(new FieldType
{
Name = field.Name.ToCamelCase(),
Resolver = fieldResolver,
ResolvedType = fieldGraphType,
Description = $"The {fieldName} field."
});
}
}
Description = $"The structure of a {schemaName} content type.";
}
public void AddNavigationProperties(FieldType fieldType)
{
Type entityType = GetEntityTypeFromResolvedType(((ListGraphType)fieldType.ResolvedType).ResolvedType);
var entityGraphType = (IObjectGraphType)_clrTypeToObjectGraphType[entityType];
foreach (PropertyInfo propertyInfo in entityType.GetProperties())
{
if (!entityGraphType.HasField(propertyInfo.Name))
{
IGraphType? resolvedType;
QueryArgument[] queryArguments;
Type? itemType = Parsers.OeExpressionHelper.GetCollectionItemTypeOrNull(propertyInfo.PropertyType);
if (itemType == null)
{
if (!_clrTypeToObjectGraphType.TryGetValue(propertyInfo.PropertyType, out resolvedType))
{
continue;
}
queryArguments = CreateQueryArguments(propertyInfo.PropertyType, true);
}
else
{
if (!_clrTypeToObjectGraphType.TryGetValue(itemType, out resolvedType))
{
continue;
}
resolvedType = new ListGraphType(resolvedType);
queryArguments = CreateQueryArguments(itemType, true);
}
if (IsRequired(propertyInfo))
{
resolvedType = new NonNullGraphType(resolvedType);
}
var entityFieldType = new FieldType()
{
Arguments = new QueryArguments(queryArguments),
Name = propertyInfo.Name,
ResolvedType = resolvedType,
Resolver = new FieldResolver(propertyInfo),
};
entityGraphType.AddField(entityFieldType);
}
}
fieldType.Arguments = new QueryArguments(CreateQueryArguments(entityType, false));
}
public static QueryArguments GetArguments(Type parametersType, IGraphQueryHandler graphQuery, Boolean isInput)
{
var qas = new List <QueryArgument>();
foreach (var prop in parametersType.GetProperties().Where(i => i.CanWrite))
{
var type = GetGraphType(prop.PropertyType, isInput);
var allowNulls = prop.GetCustomAttribute <AllowNullAttribute>() != null;
var description = prop.GetCustomAttribute <DescriptionAttribute>()?.Description;
if (type == null)
{
var gType = GetQueryItemType(graphQuery, prop.PropertyType, true);
if (!allowNulls && isInput)
{
gType = new NonNullGraphType(gType);
}
qas.Add(new QueryArgument(gType)
{
Name = prop.Name, Description = description
});
}
else
{
if (!allowNulls && isInput)
{
if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(NonNullGraphType <>))
{
type = typeof(NonNullGraphType <>).MakeGenericType(type);
}
}
else
{
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(NonNullGraphType <>))
{
type = type.GetGenericArguments()[0];
}
}
qas.Add(new QueryArgument(type)
{
Name = prop.Name, Description = description
});
}
}
return(new QueryArguments(qas));
}
public static IEnumerable <FieldType> GetFields(Type modelType, IGraphQueryHandler graphQuery, Boolean isInput)
{
var qas = new List <FieldType>();
foreach (var prop in modelType.GetProperties())
{
var description = prop.GetCustomAttribute <DescriptionAttribute>()?.Description;
var allowNulls = prop.GetCustomAttribute <AllowNullAttribute>() != null;
var type = GetGraphType(prop.PropertyType, isInput);
if (type == null)
{
var gType = GetQueryItemType(graphQuery, prop.PropertyType, isInput);
if (!allowNulls && isInput)
{
gType = new NonNullGraphType(gType);
}
qas.Add(new FieldType {
ResolvedType = gType, Name = prop.Name, Description = description
});
}
else
{
if (!allowNulls && isInput)
{
if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(NonNullGraphType <>))
{
type = typeof(NonNullGraphType <>).MakeGenericType(type);
}
}
else
{
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(NonNullGraphType <>))
{
type = type.GetGenericArguments()[0];
}
}
qas.Add(new FieldType {
Type = type, Name = prop.Name, Description = description
});
}
}
return(qas);
}
public void NonNull_ResolvedType_And_Type_Should_Match()
{
var type = new NonNullGraphType <StringGraphType>();
Should.Throw <ArgumentOutOfRangeException>(() => type.ResolvedType = new IntGraphType()).Message.ShouldStartWith("Type 'StringGraphType' should be assignable from ResolvedType 'IntGraphType'.");
}
/// <summary>
/// Initializes a new instance of the <c>__Type</c> introspection type.
/// </summary>
/// <param name="allowAppliedDirectives">Allows 'appliedDirectives' field for this type. It is an experimental feature.</param>
public __Type(bool allowAppliedDirectives = false)
{
Name = nameof(__Type);
Description =
"The fundamental unit of any GraphQL Schema is the type. There are " +
"many kinds of types in GraphQL as represented by the `__TypeKind` enum." +
@"
" +
"Depending on the kind of a type, certain fields describe " +
"information about that type. Scalar types provide no information " +
"beyond a name and description, while Enum types provide their values. " +
"Object and Interface types provide the fields they describe. Abstract " +
"types, Union and Interface, provide the Object types possible " +
"at runtime. List and NonNull types compose other types.";
Field <NonNullGraphType <__TypeKind> >("kind", resolve: context =>
{
return(context.Source is IGraphType type
? KindForInstance(type)
: throw new InvalidOperationException($"Unknown kind of type: {context.Source}"));
});
Field <StringGraphType>("name", resolve: context => context.Source !.Name);
Field <StringGraphType>("description");
FieldAsync <ListGraphType <NonNullGraphType <__Field> > >("fields", null,
new QueryArguments(
new QueryArgument <BooleanGraphType>
{
Name = "includeDeprecated",
DefaultValue = BoolBox.False
}),
async context =>
{
if (context.Source is IObjectGraphType || context.Source is IInterfaceGraphType)
{
var type = (IComplexGraphType)context.Source;
var fields = context.ArrayPool.Rent <FieldType>(type.Fields.Count);
bool includeDeprecated = context.GetArgument <bool>("includeDeprecated");
int index = 0;
foreach (var field in type.Fields.List)
{
if ((includeDeprecated || string.IsNullOrWhiteSpace(field.DeprecationReason)) && await context.Schema.Filter.AllowField(type, field).ConfigureAwait(false))
{
fields[index++] = field;
}
}
var comparer = context.Schema.Comparer.FieldComparer(type);
if (comparer != null)
{
Array.Sort(fields, 0, index, comparer);
}
return(fields.Constrained(index));
}
return(null);
});
FieldAsync <ListGraphType <NonNullGraphType <__Type> > >("interfaces", resolve: async context =>
{
if (context.Source is IImplementInterfaces type)
{
var interfaces = context.ArrayPool.Rent <IInterfaceGraphType>(type.ResolvedInterfaces.Count);
int index = 0;
foreach (var resolved in type.ResolvedInterfaces.List)
{
if (await context.Schema.Filter.AllowType(resolved).ConfigureAwait(false))
{
interfaces[index++] = resolved;
}
}
var comparer = context.Schema.Comparer.TypeComparer;
if (comparer != null)
{
Array.Sort(interfaces, 0, index, comparer);
}
return(interfaces.Constrained(index));
}
return(null);
});
FieldAsync <ListGraphType <NonNullGraphType <__Type> > >("possibleTypes", resolve: async context =>
{
if (context.Source is IAbstractGraphType type)
{
var possibleTypes = context.ArrayPool.Rent <IObjectGraphType>(type.PossibleTypes.Count);
int index = 0;
foreach (var possible in type.PossibleTypes.List)
{
if (await context.Schema.Filter.AllowType(possible).ConfigureAwait(false))
{
possibleTypes[index++] = possible;
}
}
var comparer = context.Schema.Comparer.TypeComparer;
if (comparer != null)
{
Array.Sort(possibleTypes, 0, index, comparer);
}
return(possibleTypes.Constrained(index));
}
return(null);
});
FieldAsync <ListGraphType <NonNullGraphType <__EnumValue> > >("enumValues",
arguments: new QueryArguments(new QueryArgument <BooleanGraphType>
{
Name = "includeDeprecated",
DefaultValue = BoolBox.False
}),
resolve: async context =>
{
if (context.Source is EnumerationGraphType type)
{
var enumValueDefinitions = context.ArrayPool.Rent <EnumValueDefinition>(type.Values.Count);
bool includeDeprecated = context.GetArgument <bool>("includeDeprecated");
int index = 0;
foreach (var def in type.Values.List)
{
if ((includeDeprecated || string.IsNullOrWhiteSpace(def.DeprecationReason)) && await context.Schema.Filter.AllowEnumValue(type, def).ConfigureAwait(false))
{
enumValueDefinitions[index++] = def;
}
}
var comparer = context.Schema.Comparer.EnumValueComparer(type);
if (comparer != null)
{
Array.Sort(enumValueDefinitions, 0, index, comparer);
}
return(enumValueDefinitions.Constrained(index));
}
return(null);
});
FieldAsync <ListGraphType <NonNullGraphType <__InputValue> > >("inputFields", resolve: async context =>
{
if (context.Source is IInputObjectGraphType type)
{
var inputFields = context.ArrayPool.Rent <FieldType>(type.Fields.Count);
int index = 0;
foreach (var field in type.Fields.List)
{
if (await context.Schema.Filter.AllowField(type, field).ConfigureAwait(false))
{
inputFields[index++] = field;
}
}
var comparer = context.Schema.Comparer.FieldComparer(type);
if (comparer != null)
{
Array.Sort(inputFields, 0, index, comparer);
}
return(inputFields.Constrained(index));
}
return(null);
});
Field <__Type>("ofType", resolve: context =>
{
return(context.Source switch
{
NonNullGraphType nonNull => nonNull.ResolvedType,
ListGraphType list => list.ResolvedType,
_ => null
});
public AppMutationsGraphType(Builder builder, IEnumerable <SchemaInfo> schemas)
{
foreach (var schemaInfo in schemas.Where(x => x.Fields.Count > 0))
{
var contentType = new NonNullGraphType(builder.GetContentType(schemaInfo));
var inputType = new DataInputGraphType(builder, schemaInfo);
AddField(new FieldType
{
Name = $"create{schemaInfo.TypeName}Content",
Arguments = ContentActions.Create.Arguments(inputType),
ResolvedType = contentType,
Resolver = ContentActions.Create.Resolver,
Description = $"Creates an {schemaInfo.DisplayName} content."
}).WithSchemaNamedId(schemaInfo);
AddField(new FieldType
{
Name = $"update{schemaInfo.TypeName}Content",
Arguments = ContentActions.Update.Arguments(inputType),
ResolvedType = contentType,
Resolver = ContentActions.Update.Resolver,
Description = $"Update an {schemaInfo.DisplayName} content by id."
}).WithSchemaNamedId(schemaInfo);
AddField(new FieldType
{
Name = $"upsert{schemaInfo.TypeName}Content",
Arguments = ContentActions.Upsert.Arguments(inputType),
ResolvedType = contentType,
Resolver = ContentActions.Upsert.Resolver,
Description = $"Upsert an {schemaInfo.DisplayName} content by id."
}).WithSchemaNamedId(schemaInfo);
AddField(new FieldType
{
Name = $"patch{schemaInfo.TypeName}Content",
Arguments = ContentActions.Patch.Arguments(inputType),
ResolvedType = contentType,
Resolver = ContentActions.Patch.Resolver,
Description = $"Patch an {schemaInfo.DisplayName} content by id."
}).WithSchemaNamedId(schemaInfo);
AddField(new FieldType
{
Name = $"change{schemaInfo.TypeName}Content",
Arguments = ContentActions.ChangeStatus.Arguments,
ResolvedType = contentType,
Resolver = ContentActions.ChangeStatus.Resolver,
Description = $"Change a {schemaInfo.DisplayName} content."
}).WithSchemaNamedId(schemaInfo);
AddField(new FieldType
{
Name = $"delete{schemaInfo.TypeName}Content",
Arguments = ContentActions.Delete.Arguments,
ResolvedType = EntitySavedGraphType.NonNull,
Resolver = ContentActions.Delete.Resolver,
Description = $"Delete an {schemaInfo.DisplayName} content."
}).WithSchemaNamedId(schemaInfo);
AddField(new FieldType
{
Name = $"publish{schemaInfo.TypeName}Content",
Arguments = ContentActions.ChangeStatus.Arguments,
ResolvedType = contentType,
Resolver = ContentActions.ChangeStatus.Resolver,
Description = $"Publish a {schemaInfo.DisplayName} content.",
DeprecationReason = $"Use 'change{schemaInfo.TypeName}Content' instead"
}).WithSchemaNamedId(schemaInfo);
}
Description = "The app mutations.";
}
public void NonNullListsAreListGraphType()
{
var nonnullListType = new NonNullGraphType(new ListGraphType(new GraphQLTypeReference(typeof(ATestGraphQLClass).Name)));
nonnullListType.IsListGraphType().Should().BeTrue();
}
