public void test_inputs()
{
var innerObject = new InputObjectGraphType();
innerObject.AddField(new FieldType {
Name = "test", ResolvedType = new StringGraphType(), Type = typeof(StringGraphType)
});
var list = new ListGraphType(innerObject);
var inputObj = new InputObjectGraphType();
inputObj.AddField(new FieldType {
Name = "list", ResolvedType = list, Type = list.GetType()
});
var obj = new ObjectGraphType();
var field = new FieldType
{
Name = "hello",
ResolvedType = new StringGraphType(),
Type = typeof(StringGraphType),
Arguments = new QueryArguments {
new QueryArgument(inputObj)
{
Name = "input"
}
}
};
obj.AddField(field);
var schema = new Schema
{
Query = obj
};
schema.Initialize();
}
public SchemaWithNotFullSpecifiedResolvedType()
{
var stringFilterInputType = new InputObjectGraphType {
Name = "InputString"
};
stringFilterInputType.AddField(new FieldType
{
Name = "eq",
ResolvedType = new StringGraphType()
});
stringFilterInputType.AddField(new FieldType
{
Name = "in",
ResolvedType = new ListGraphType <StringGraphType>()
});
stringFilterInputType.AddField(new FieldType
{
Name = "not",
ResolvedType = new NonNullGraphType <StringGraphType>()
});
Query = new ObjectGraphType();
Query.Field(
"test",
new StringGraphType(),
arguments: new QueryArguments(new QueryArgument(stringFilterInputType)
{
Name = "a"
}),
resolve: context => "ok");
}
public void should_throw_an_exception_if_input_object_graph_type_contains_object_graph_type_field()
{
var type = new InputObjectGraphType();
var exception = Should.Throw <ArgumentException>(() => type.Field <ObjectGraphType>().Name("test"));
exception.Message.ShouldContain("InputObjectGraphType cannot have fields containing a ObjectGraphType.");
}
public void InputTypeIsDereferenced_InputField(Type referenceType, Type mappedType)
{
var inputType = new InputObjectGraphType();
inputType.Field(referenceType, "field");
var query = new ObjectGraphType();
query.Field(typeof(IntGraphType), "test",
arguments: new QueryArguments
{
new QueryArgument(inputType)
{
Name = "arg"
}
});
var schema = new Schema
{
Query = query
};
schema.RegisterTypeMapping(typeof(MyClass), typeof(MyClassObjectType));
schema.RegisterTypeMapping(typeof(MyClass), typeof(MyClassInputType));
schema.RegisterTypeMapping(typeof(MappedEnum), typeof(MappedEnumGraphType));
schema.Initialize();
var inputTypeActual = schema.Query.Fields.Find("test").Arguments.Find("arg").ResolvedType.ShouldBeOfType <InputObjectGraphType>();
inputTypeActual.ShouldBe(inputType);
inputTypeActual.Fields.Find("field").Type.ShouldBe(mappedType);
}
public void should_throw_an_exception_if_input_object_graph_type_contains_object_graph_type_field()
{
var type = new InputObjectGraphType();
var exception = Should.Throw <ArgumentOutOfRangeException>(() => type.Field <ObjectGraphType>().Name("test"));
exception.Message.ShouldContain("Input type 'InputObject' can have fields only of input types: ScalarGraphType, EnumerationGraphType or IInputObjectGraphType.");
}
public InputField(InputObjectGraphType oldType, InputObjectGraphType newType, FieldType oldField, FieldType newField)
{
this.oldType = oldType;
this.newType = newType;
this.oldField = oldField;
this.newField = newField;
}
public string PrintInputObject(InputObjectGraphType type)
{
var description = PrintDescription(type.Description);
var fields = type.Fields.Select(x => " " + PrintInputValue(x));
return(description + "input {1} {{{0}{2}{0}}}".ToFormat(Environment.NewLine, type.Name, string.Join(Environment.NewLine, fields)));
}
protected virtual InputObjectGraphType ToInputObjectType(GraphQLInputObjectTypeDefinition inputDef)
{
var name = (string)inputDef.Name.Value;
var typeConfig = Types.For(name);
AssertKnownType(typeConfig);
var type = new InputObjectGraphType
{
Name = name,
Description = typeConfig.Description ?? inputDef.Description?.Value.ToString() ?? inputDef.Comment?.Text.ToString(),
}.SetAstType(inputDef);
OverrideDeprecationReason(type, typeConfig.DeprecationReason);
typeConfig.CopyMetadataTo(type);
if (inputDef.Fields != null)
{
foreach (var f in inputDef.Fields)
{
type.AddField(ToFieldType(type.Name, f));
}
}
return(type);
}
private InputObjectGraphType GetSecondGraphType(ColumnMetadata columnMetadata, TableMetadata metaTable = null)
{
string key = $"{columnMetadata.Type.Name}_internal_input";
InputObjectGraphType objectGraphType = null;
if (metaTable == null)
{
metaTable = _dbMetadata.GetTableMetadatas().FirstOrDefault(x => x.Type.Name == columnMetadata.Type.Name);
}
if (!_tableNameLookup.ExistInputGraphType(key))
{
//Creacion de instancia
//var inherateListType = typeof(InputObjectGraphType<>).MakeGenericType(new Type[] { columnMetadata.Type });
objectGraphType = new InputObjectGraphType();
//objectGraphType = Activator.CreateInstance(inherateListType);
objectGraphType.Name = key;
foreach (var tableColumn in metaTable.Columns)
{
objectGraphType.Field(
GraphUtils.ResolveGraphType(tableColumn.Type),
tableColumn.ColumnName
);
}
}
return(_tableNameLookup.GetOrInsertInputGraphType(key, objectGraphType));
}
public InputObjectType(InputObjectGraphType oldType, InputObjectGraphType newType)
{
this.oldType = oldType;
this.newType = newType;
oldFields = oldType.Fields;
newFields = newType.Fields;
}
public static void Build(InputObjectGraphType graphType, Type type)
{
ProcessType(graphType, type);
bool hasDataContract = type.ShouldIncludeInGraph();
ProcessProperties(graphType, GetProperties(hasDataContract, type), true);
ProcessFields(graphType, GetFields(hasDataContract, type));
ProcessMethods(graphType, type, type.GetMethods());
}
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 bool TryPrimeInput <T>(InputObjectGraphType <T> graphType)
{
if (_inputTypeCache.ContainsKey(typeof(T)))
{
return(false);
}
_inputTypeCache[typeof(T)] = graphType;
return(true);
}
protected virtual InputObjectGraphType ToInputObjectType(GraphQLInputObjectTypeDefinition inputDef)
{
var type = new InputObjectGraphType();
type.Name = inputDef.Name.Value;
var fields = inputDef.Fields.Select(ToFieldType);
fields.Apply(f => type.AddField(f));
return(type);
}
protected virtual InputObjectGraphType ToInputObjectType(GraphQLInputObjectTypeDefinition inputDef)
{
var type = new InputObjectGraphType();
type.Name = inputDef.Name.Value;
ApplyDeprecatedDirective(inputDef.Directives, reason =>
{
type.DeprecationReason = reason;
});
var fields = inputDef.Fields.Select(x => ToFieldType(type.Name, x));
fields.Apply(f => type.AddField(f));
return(type);
}
public static void AddFieldsFromType <T>(this InputObjectGraphType type, bool omitIdProperty)
{
var properties = typeof(T).GetExactProperies();
foreach (var property in properties)
{
var typeName = property.PropertyType.Name;
var propertyName = property.Name.ToFirstLower();
// create IdGraphType field for Id property
if (propertyName == "id")
{
// skip id property if desired
if (omitIdProperty)
{
continue;
}
type.Field <IdGraphType>("id", "The global unique id of an object");
continue;
}
// create primitive fields like ints, strings, floats etc.
if (property.PropertyType.IsSimpleType())
{
type.CreateFieldFromPrimitiveProperty(property);
continue;
}
// generate list field for collection / list
if (property.PropertyType.GetTypeInfo().GetInterface("ICollection") != null && property.PropertyType.IsGenericType())
{
// create an InputType<itemType>
var itemType = property.PropertyType.GenericTypeArguments[0];
var graphQLType = typeof(InputType <>);
graphQLType = graphQLType.MakeGenericType(itemType);
graphQLType = graphQLType.ConvertToVirtualType();
// call AddListField like type.AddListField<Order, InputType<Order>>("orders")
var method = typeof(ComplexGraphTypeExtensions).GetMethod("AddListField");
method = method.MakeGenericMethod(new[] { itemType, graphQLType });
method.Invoke(type, new object[] { type, propertyName });
}
}
}
protected virtual InputObjectGraphType ToInputObjectType(GraphQLInputObjectTypeDefinition inputDef)
{
var typeConfig = Types.For(inputDef.Name.Value);
var type = new InputObjectGraphType
{
Name = inputDef.Name.Value,
Description = typeConfig.Description ?? inputDef.Comment?.Text
};
CopyMetadata(type, typeConfig);
var fields = inputDef.Fields.Select(x => ToFieldType(type.Name, x));
fields.Apply(f => type.AddField(f));
return(type);
}
public ContentDataInputGraphType(ISchemaEntity schema, string schemaName, string schemaType, IGraphModel model)
{
Name = $"{schemaType}DataInputDto";
foreach (var(field, fieldName, typeName) in schema.SchemaDef.Fields.SafeFields().Where(x => x.Field.IsForApi(true)))
{
var resolvedType = model.GetInputGraphType(schema, field, typeName);
if (resolvedType != null)
{
var displayName = field.DisplayName();
var fieldGraphType = new InputObjectGraphType
{
Name = $"{schemaType}Data{typeName}InputDto"
};
var partitioning = model.ResolvePartition(field.Partitioning);
foreach (var partitionKey in partitioning.AllKeys)
{
fieldGraphType.AddField(new FieldType
{
Name = partitionKey.EscapePartition(),
ResolvedType = resolvedType,
Resolver = null,
Description = field.RawProperties.Hints
}).WithSourceName(partitionKey);
}
fieldGraphType.Description = $"The structure of the {displayName} field of the {schemaName} content input type.";
AddField(new FieldType
{
Name = fieldName,
ResolvedType = fieldGraphType,
Resolver = null,
Description = $"The {displayName} field."
}).WithSourceName(field.Name);
}
}
Description = $"The structure of the {schemaName} data input type.";
}
public InputObjectGraphType <TModel> BuildInputGraphType(GraphTypeCache cache)
{
var graphType = new InputObjectGraphType <TModel>
{
Name = GraphTypeName + "Input"
};
if (!cache.TryPrimeInput(graphType))
{
return((InputObjectGraphType <TModel>)cache.GetOrCreateInputType(typeof(TModel)));
}
foreach (var prop in typeof(TModel).GetProperties().Except(_config.PropsToIgnore))
{
var fieldConfig = _config.GetFieldConfig(prop);
fieldConfig.ConfigureInputTypeField(graphType, cache);
}
return(graphType);
}
public DataInputGraphType(Builder builder, SchemaInfo schemaInfo)
{
// The name is used for equal comparison. Therefore it is important to treat it as readonly.
Name = schemaInfo.DataInputType;
foreach (var fieldInfo in schemaInfo.Fields)
{
var resolvedType = builder.GetInputGraphType(fieldInfo);
if (resolvedType != null)
{
var fieldGraphType = new InputObjectGraphType
{
// The name is used for equal comparison. Therefore it is important to treat it as readonly.
Name = fieldInfo.LocalizedInputType
};
var partitioning = builder.ResolvePartition(((RootField)fieldInfo.Field).Partitioning);
foreach (var partitionKey in partitioning.AllKeys)
{
fieldGraphType.AddField(new FieldType
{
Name = partitionKey.EscapePartition(),
ResolvedType = resolvedType,
Resolver = null,
Description = fieldInfo.Field.RawProperties.Hints
}).WithSourceName(partitionKey);
}
fieldGraphType.Description = $"The structure of the {fieldInfo.DisplayName} field of the {schemaInfo.DisplayName} content input type.";
AddField(new FieldType
{
Name = fieldInfo.FieldName,
ResolvedType = fieldGraphType,
Resolver = null
}).WithSourceName(fieldInfo);
}
}
Description = $"The structure of the {schemaInfo.DisplayName} data input type.";
}
private dynamic GetInternalListInstances(ColumnMetadata columnMetadata)
{
var metaTable = _dbMetadata.GetTableMetadatas().FirstOrDefault(x => x.Type.Name == columnMetadata.Type.Name);
string key = $"{metaTable.Type.Name.ToLower().ToSnakeCase()}_list_input";
var objectGraphType = new InputObjectGraphType
{
Name = key
};
dynamic listGraphType = null;
if (!_tableNameLookup.ExistInputListGraphType(key))
{
var tableType = GetSecondGraphType(columnMetadata, metaTable);
var inherateListType = typeof(ListGraphType <>).MakeGenericType(new Type[] { tableType.GetType() });
listGraphType = Activator.CreateInstance(inherateListType);
listGraphType.ResolvedType = tableType;
// Field<ListGraphType<CityType>>(nameof(State.cities));
}
return(_tableNameLookup.GetOrInsertInputListGraphType(key, listGraphType));
}
public void ConfigureInputTypeField(InputObjectGraphType <TModel> graphType, GraphTypeCache cache)
{
if (TryGetScalarGraphType(out var graphQlType))
{
graphType.Field(
type: graphQlType,
name: Property.Name
);
}
else
{
var inputType = cache.GetOrCreateInputType(Property.PropertyType);
inputType = TryWrapNonNull(inputType);
graphType.AddField(new FieldType
{
ResolvedType = inputType,
Type = Property.PropertyType,
Name = Property.Name
});
}
}
private InputObjectGraphType GetInternalInstances(ColumnMetadata columnMetadata)
{
var metaTable = _dbMetadata.GetTableMetadatas().FirstOrDefault(x => x.Type.Name == columnMetadata.Type.Name);
string key = $"{metaTable.Type.Name.ToLower().ToSnakeCase()}_first_internal_input";
InputObjectGraphType objectGraphType = null;
if (!_tableNameLookup.ExistInputGraphType(key))
{
//var inherateListType = typeof(InputObjectGraphType<>).MakeGenericType(new Type[] { columnMetadata.Type });
objectGraphType = new InputObjectGraphType(); // Activator.CreateInstance(inherateListType);
objectGraphType.Name = key;
foreach (var tableColumn in metaTable.Columns)
{
objectGraphType.Field(
GraphUtils.ResolveGraphType(tableColumn.Type),
tableColumn.ColumnName
);
}
}
return(_tableNameLookup.GetOrInsertInputGraphType(key, objectGraphType));
}
/// <summary>
/// Inspects the given type and, in accordance with the rules of this maker, will
/// generate a complete set of necessary graph types required to support it.
/// </summary>
/// <param name="concreteType">The concrete type to incorporate into the schema.</param>
/// <returns>GraphTypeCreationResult.</returns>
public virtual GraphTypeCreationResult CreateGraphType(Type concreteType)
{
var template = GraphQLProviders.TemplateProvider.ParseType(concreteType, TypeKind.INPUT_OBJECT) as IInputObjectGraphTypeTemplate;
if (template == null)
{
return(null);
}
var formatter = _schema.Configuration.DeclarationOptions.GraphNamingFormatter;
var result = new GraphTypeCreationResult();
var fieldSet = new List <IGraphField>();
var fieldMaker = new GraphFieldMaker(_schema);
foreach (var fieldTemplate in ObjectGraphTypeMaker.GatherFieldTemplates(template, _schema))
{
var fieldResult = fieldMaker.CreateField(fieldTemplate);
fieldSet.Add(fieldResult.Field);
result.MergeDependents(fieldResult);
}
var inputObjectType = new InputObjectGraphType(
formatter.FormatGraphTypeName(template.Name),
concreteType,
fieldSet)
{
Description = template.Description,
Publish = template.Publish,
};
result.GraphType = inputObjectType;
result.ConcreteType = concreteType;
return(result);
}
public virtual void VisitInputObject(InputObjectGraphType type)
{
}
public void can_create_custom_directive_for_all_locations_graph_type_first()
{
var schema = new Schema();
schema.ApplyDirective("schema");
schema.HasAppliedDirectives().ShouldBeTrue();
schema.GetAppliedDirectives().Count.ShouldBe(1);
var objectType = new ObjectGraphType();
objectType.ApplyDirective("type");
objectType.HasAppliedDirectives().ShouldBeTrue();
objectType.GetAppliedDirectives().Count.ShouldBe(1);
var field = objectType.Field <StringGraphType>("test");
field.ApplyDirective("field");
field.HasAppliedDirectives().ShouldBeTrue();
field.GetAppliedDirectives().Count.ShouldBe(1);
var interfaceType = new InterfaceGraphType();
interfaceType.ApplyDirective("interface");
interfaceType.HasAppliedDirectives().ShouldBeTrue();
interfaceType.GetAppliedDirectives().Count.ShouldBe(1);
var unionType = new UnionGraphType();
unionType.ApplyDirective("union");
unionType.HasAppliedDirectives().ShouldBeTrue();
unionType.GetAppliedDirectives().Count.ShouldBe(1);
var arg = new QueryArgument(new StringGraphType());
arg.ApplyDirective("arg");
arg.HasAppliedDirectives().ShouldBeTrue();
arg.GetAppliedDirectives().Count.ShouldBe(1);
var enumType = new EnumerationGraphType();
enumType.ApplyDirective("enumType");
enumType.HasAppliedDirectives().ShouldBeTrue();
enumType.GetAppliedDirectives().Count.ShouldBe(1);
var enumValue = new EnumValueDefinition("UNUSED", null);
enumValue.ApplyDirective("enumValue");
enumValue.HasAppliedDirectives().ShouldBeTrue();
enumValue.GetAppliedDirectives().Count.ShouldBe(1);
var inputType = new InputObjectGraphType();
inputType.ApplyDirective("inputType");
inputType.HasAppliedDirectives().ShouldBeTrue();
inputType.GetAppliedDirectives().Count.ShouldBe(1);
var input = inputType.Field <StringGraphType>("test");
input.ApplyDirective("inputField");
input.HasAppliedDirectives().ShouldBeTrue();
input.GetAppliedDirectives().Count.ShouldBe(1);
var scalarType = new BigIntGraphType();
scalarType.ApplyDirective("scalar");
scalarType.HasAppliedDirectives().ShouldBeTrue();
scalarType.GetAppliedDirectives().Count.ShouldBe(1);
}
public void should_not_throw_an_exception_if_input_object_graph_type_doesnt_contains_object_graph_type_field()
{
var type = new InputObjectGraphType();
var exception = type.Field <ComplexGraphType <object> >().Name("test");
}