private TypeDefBase CreateTypeDef(Type type, TypeKind typeKind, GraphQLModule module)
{
var allAttrs = GetAllAttributesAndAdjustments(type);
var nameAttr = allAttrs.Find <GraphQLNameAttribute>();
var typeName = nameAttr?.Name ?? GetGraphQLName(type);
var moduleName = module.Name;
switch (typeKind)
{
case TypeKind.Enum:
if (!type.IsEnum)
{
AddError($"Type {type} cannot be registered as Enum GraphQL type, must be enum; module: {moduleName}");
return(null);
}
return(new EnumTypeDef(type, allAttrs, module));
case TypeKind.Object:
return(new ObjectTypeDef(typeName, type, allAttrs, module));
case TypeKind.Interface:
return(new InterfaceTypeDef(typeName, type, allAttrs, module));
case TypeKind.InputObject:
return(new InputObjectTypeDef(typeName, type, allAttrs, module));
case TypeKind.Union:
return(new UnionTypeDef(typeName, type, allAttrs, module));
}
// should never happen
return(null);
}
/// <summary>Registers a handler for a directive that is already registered, possibly in another module. </summary>
/// <param name="module">GraphQL module.</param>
/// <param name="name">Directive name.</param>
/// <param name="handler">Handler instance.</param>
/// <remarks>The purpose of this method is to allow registering handlers separately from the directives themselves.
/// You can have a directive defined in light, module not dependent on any server-side assemblies, so it can be
/// used in client-side code. The directive's handler can be registered in server-side assembly, as it likely
/// needs access to server-side functionality.
/// </remarks>
public static void RegisterDirectiveHandler(this GraphQLModule module, string name, IDirectiveHandler handler = null)
{
var reg = new DirectiveRegistration()
{
Name = name, Handler = handler
};
module.RegisteredDirectives.Add(reg);
}
/// <summary>Registers a type of handler for a directive that is already registered, possibly in another module. </summary>
/// <param name="module">GraphQL module.</param>
/// <param name="name">Directive name.</param>
/// <param name="handlerType">Handler type.</param>
/// <remarks>The purpose of this method is to allow registering handlers separately from the directives themselves.
/// You can have a directive defined in light-weight module not dependent on any server-side assemblies, so it can be
/// used in client-side code. The directive's handler can be registered in server-side assembly, as it likely
/// needs access to server-side functionality.
/// </remarks>
public static void RegisterDirectiveHandler(this GraphQLModule module, string name, Type handlerType)
{
var dirInfo = new DirectiveHandlerInfo()
{
Name = name, Type = handlerType
};
module.DirectiveHandlers.Add(dirInfo);
}
public TypeDefBase(string name, TypeKind kind, Type clrType, IList <Attribute> attributes, GraphQLModule module)
{
Name = name;
Kind = kind;
ClrType = clrType;
Attributes = attributes;
Module = module;
TypeRefNull = new TypeRef(this);
TypeRefNotNull = new TypeRef(TypeRefNull, TypeKind.NonNull);
TypeRefs.Add(TypeRefNull);
TypeRefs.Add(TypeRefNotNull);
}
public static void RegisterDirective(this GraphQLModule module, string name, string signatureMethodName,
DirectiveLocation locations, string description = null, IDirectiveHandler handler = null, bool listInSchema = true)
{
var method = module.GetType().GetMethod(signatureMethodName,
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
if (method == null)
{
throw new ArgumentException($"RegisterDirective, name={name}: method {signatureMethodName} not found in module {module.Name}");
}
RegisterDirective(module, name, method, locations, description, handler, listInSchema);
}
public static void RegisterDirective(this GraphQLModule module, string name, MethodInfo signature,
DirectiveLocation locations, string description = null, IDirectiveHandler handler = null, bool listInSchema = true)
{
if (signature == null)
{
throw new ArgumentException("RegisterDirective method: signature parameter may not be null.");
}
var reg = new DirectiveRegistration()
{
Name = name, Signature = signature, Locations = locations, Description = description,
ListInSchema = listInSchema, Handler = handler
};
module.RegisteredDirectives.Add(reg);
}
public static void RegisterDirective(this GraphQLModule module, string name, Type directiveAttributeType,
DirectiveLocation locations, string description = null, IDirectiveHandler handler = null, bool listInSchema = true)
{
if (!typeof(BaseDirectiveAttribute).IsAssignableFrom(directiveAttributeType))
{
throw new ArgumentException(
$"RegisterDirective method: directive attribute must be subclass of {nameof(directiveAttributeType)}");
}
var reg = new DirectiveRegistration()
{
Name = name, AttributeType = directiveAttributeType, Locations = locations, Description = description,
ListInSchema = listInSchema, Handler = handler
};
module.RegisteredDirectives.Add(reg);
}
private void CreateRegisterTypeDef(Type type, GraphQLModule module, TypeKind typeKind)
{
try {
var typeDef = CreateTypeDef(type, typeKind, module);
if (typeDef == null)
{
return;
}
var hideAttr = typeDef.Attributes.Find <HiddenAttribute>();
if (hideAttr != null)
{
typeDef.Hidden = true;
}
if (typeDef.ClrType != null && typeDef.Kind != TypeKind.Scalar) //schema has no CLR type
{
typeDef.Description = _docLoader.GetDocString(typeDef.ClrType, typeDef.ClrType);
}
RegisterTypeDef(typeDef);
} catch (Exception ex) {
AddError($"FATAL: Failed to register type {type}, error: {ex}. ");
}
}
public ObjectTypeDef(string name, Type clrType, IList <Attribute> attrs, GraphQLModule module,
TypeRole typeRole = TypeRole.Data)
: base(name, TypeKind.Object, clrType, attrs, module, typeRole)
{
_possibleOutTypes = new ObjectTypeDef[] { this };
}
public ScalarTypeDef(Scalar scalar, GraphQLModule module)
: base(scalar.Name, TypeKind.Scalar, scalar.DefaultClrType, EmptyAttributeList, module)
{
Scalar = scalar;
base.IsDefaultForClrType = Scalar.IsDefaultForClrType;
}
public UnionTypeDef(string name, Type clrType, IList <Attribute> attrs, GraphQLModule module)
: base(name, TypeKind.Union, clrType, attrs, module)
{
}
public InputObjectTypeDef(string name, Type clrType, IList <Attribute> attrs, GraphQLModule module)
: base(name, TypeKind.InputObject, clrType, attrs, module)
{
}
public ObjectTypeDef(string name, Type clrType, IList <Attribute> attrs, GraphQLModule module, ObjectTypeRole typeRole = ObjectTypeRole.Data)
: base(name, TypeKind.Object, clrType, attrs, module)
{
this.TypeRole = typeRole;
}
public InterfaceTypeDef(string name, Type clrType, IList <Attribute> attrs, GraphQLModule module)
: base(name, TypeKind.Interface, clrType, attrs, module)
{
}
public ComplexTypeDef(string name, TypeKind kind, Type clrType, IList <Attribute> attrs, GraphQLModule module)
: base(name, kind, clrType, attrs, module)
{
}
public EnumTypeDef(Type type, IList <Attribute> attrs, GraphQLModule module)
: base(type.Name, TypeKind.Enum, type, attrs, module)
{
}
} //method
private void RegisterSpecialObjectTypeIfProvided(Type type, TypeRole typeRole, GraphQLModule module)
{
if (type == null)
{
return;
}
var typeName = $"{module.Name}_{type.Name}";
var typeDef = new ObjectTypeDef(typeName, type, GraphQLModelObject.EmptyAttributeList, module, typeRole);
_model.Types.Add(typeDef);
_model.TypesByClrType.Add(type, typeDef);
}
public ComplexTypeDef(string name, TypeKind kind, Type clrType, IList <Attribute> attrs, GraphQLModule module,
TypeRole typeRole = TypeRole.Data)
: base(name, kind, clrType, attrs, module)
{
this.TypeRole = typeRole;
}
public EnumTypeDef(string name, Type enumType, bool isFlagSet, IList <Attribute> attrs, GraphQLModule module)
: base(name, TypeKind.Enum, enumType, attrs, module)
{
base.ClrType = enumType;
IsFlagSet = isFlagSet;
EnumBaseType = Enum.GetUnderlyingType(enumType);
NoneValue = Activator.CreateInstance(enumType);
ToLong = ReflectionHelper.GetEnumToLongConverter(enumType);
}
