public FullObjectGraphTraversalStrategy(Serializer serializer, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention)
{
if (maxRecursion <= 0)
{
throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
}
this.serializer = serializer;
if (typeDescriptor == null)
{
throw new ArgumentNullException("typeDescriptor");
}
this.typeDescriptor = typeDescriptor;
if (typeResolver == null)
{
throw new ArgumentNullException("typeResolver");
}
this.typeResolver = typeResolver;
this.maxRecursion = maxRecursion;
this.namingConvention = namingConvention;
}
public CachedTypeInspector(ITypeInspector innerTypeDescriptor)
{
if (innerTypeDescriptor == null)
{
throw new ArgumentNullException("innerTypeDescriptor");
}
_innerTypeDescriptor = innerTypeDescriptor;
}
//--- Constructors ---
public IsolatedTypeInspector() {
_log.Debug("set up appdomain");
var appDomainSetup = new AppDomainSetup();
string currentBase = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory);
appDomainSetup.ApplicationBase = currentBase;
_assemblyInspectorDomain = AppDomain.CreateDomain("assembly-inspector", null, appDomainSetup);
_typeInspector = (ITypeInspector)_assemblyInspectorDomain.CreateInstanceAndUnwrap("mindtouch.reflection", "MindTouch.Reflection.TypeInspector");
_log.Debug("app domain created");
}
public NamingConventionTypeInspector(ITypeInspector innerTypeDescriptor, INamingConvention namingConvention)
{
if (innerTypeDescriptor == null)
{
throw new ArgumentNullException("innerTypeDescriptor");
}
this.innerTypeDescriptor = innerTypeDescriptor;
if (namingConvention == null)
{
throw new ArgumentNullException("namingConvention");
}
this.namingConvention = namingConvention;
}
public NamingConventionTypeInspector(ITypeInspector innerTypeDescriptor, INamingConvention namingConvention)
{
if (innerTypeDescriptor == null)
{
throw new ArgumentNullException("innerTypeDescriptor");
}
this.innerTypeDescriptor = innerTypeDescriptor;
if (namingConvention == null)
{
throw new ArgumentNullException("namingConvention");
}
this.namingConvention = namingConvention;
}
protected override void OnComplete(
IConventionContext context,
SortConventionDefinition definition)
{
if (definition.Provider is null)
{
throw SortConvention_NoProviderFound(GetType(), definition.Scope);
}
if (definition.ProviderInstance is null)
{
_provider =
context.Services.GetOrCreateService <ISortProvider>(definition.Provider) ??
throw SortConvention_NoProviderFound(GetType(), definition.Scope);
}
else
{
_provider = definition.ProviderInstance;
}
_namingConventions = context.DescriptorContext.Naming;
_operations = definition.Operations.ToDictionary(
x => x.Id,
SortOperation.FromDefinition);
foreach (var operation in _operations.Values)
{
if (!operation.Name.HasValue)
{
throw SortConvention_OperationIsNotNamed(this, operation);
}
}
_bindings = definition.Bindings;
_defaultBinding = definition.DefaultBinding;
_inputTypeConfigs = definition.Configurations;
_enumTypeConfigs = definition.EnumConfigurations;
_argumentName = definition.ArgumentName;
if (_provider is ISortProviderConvention init)
{
init.Initialize(context);
}
_typeInspector = context.DescriptorContext.TypeInspector;
}
public TypeDescriptorHelper(
INamingConventions namingConventions,
ITypeInspector typeInspector
)
{
this.namingConventions = namingConventions;
this.typeInspector = typeInspector;
typeRegistrar = new DefaultTypeRegistrar <IType>(
placeholderGenerator: MockITypeGenerator,
interceptor: TryGetScalarType
);
xmlDocumentationProvider = new XmlDocumentationProvider(
new XmlDocumentationFileResolver()
);
}
private DescriptorContext(
INamingConventions naming,
ITypeInspector inspector)
{
if (naming == null)
{
throw new ArgumentNullException(nameof(naming));
}
if (inspector == null)
{
throw new ArgumentNullException(nameof(inspector));
}
Naming = naming;
Inspector = inspector;
}
public FullObjectGraphTraversalStrategy(ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention)
{
if (maxRecursion <= 0)
{
throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
}
if (typeDescriptor == null)
{
throw new ArgumentNullException("typeDescriptor");
}
this.typeDescriptor = typeDescriptor;
if (typeResolver == null)
{
throw new ArgumentNullException("typeResolver");
}
this.typeResolver = typeResolver;
this.maxRecursion = maxRecursion;
this.namingConvention = namingConvention;
}
/// <inheritdoc />
protected override void Complete(IConventionContext context)
{
if (Definition?.Provider is null)
{
throw FilterConvention_NoProviderFound(GetType(), Definition?.Scope);
}
if (Definition.ProviderInstance is null)
{
_provider =
context.Services.GetOrCreateService <IFilterProvider>(Definition.Provider) ??
throw FilterConvention_NoProviderFound(GetType(), Definition.Scope);
}
else
{
_provider = Definition.ProviderInstance;
}
_namingConventions = context.DescriptorContext.Naming;
_operations =
Definition.Operations.ToDictionary(x => x.Id, FilterOperation.FromDefinition);
_bindings = Definition.Bindings;
_configs = Definition.Configurations;
_argumentName = Definition.ArgumentName;
_useAnd = Definition.UseAnd;
_useOr = Definition.UseOr;
if (_provider is IFilterProviderConvention init)
{
IReadOnlyList <IFilterProviderExtension> extensions =
CollectExtensions(context.Services, Definition);
init.Initialize(context, this);
MergeExtensions(context, init, extensions);
init.Complete(context);
}
_typeInspector = context.DescriptorContext.TypeInspector;
// It is important to always call base to continue the cleanup and the disposal of the
// definition
base.Complete(context);
}
private void AddImplicitResolverBindings(
ITypeInspector inspector,
INamingConventions naming,
ResolverTypeBindingInfo binding)
{
var names = new HashSet <NameString>(
binding.Fields.Select(t => t.FieldName));
foreach (MemberInfo member in inspector.GetMembers(binding.ResolverType))
{
NameString fieldName =
naming.GetMemberName(member, MemberKind.ObjectField);
if (names.Add(fieldName))
{
var builder = ResolverFieldBindingBuilder.New();
builder.SetResolver(member);
builder.SetField(fieldName);
binding.Fields = binding.Fields.Add(builder.Create());
}
}
}
private static IExtendedType RewriteType(ITypeInspector typeInspector, ITypeInfo typeInfo)
{
Type current = typeof(IdType);
if (typeInfo.Components.Count > 1)
{
foreach (TypeComponent component in typeInfo.Components.Reverse().Skip(1))
{
if (component.Kind == TypeComponentKind.NonNull)
{
current = typeof(NonNullType <>).MakeGenericType(current);
}
else if (component.Kind == TypeComponentKind.List)
{
current = typeof(ListType <>).MakeGenericType(current);
}
}
}
return(typeInspector.GetType(current));
}
private static bool IsOperationType(
ObjectType objectType,
OperationType operationType,
ITypeInspector typeInspector,
Dictionary <OperationType, ITypeReference> operations)
{
if (operations.TryGetValue(operationType, out ITypeReference? typeRef))
{
if (typeRef is SchemaTypeReference sr)
{
return(sr.Type == objectType);
}
if (typeRef is ExtendedTypeReference cr)
{
return(cr.Type == typeInspector.GetType(objectType.GetType()) ||
cr.Type == typeInspector.GetType(objectType.RuntimeType));
}
if (typeRef is SyntaxTypeReference str)
{
return(objectType.Name.Equals(str.Type.NamedType().Name.Value));
}
}
else if (operationType == OperationType.Query)
{
return(objectType.Name.Equals(OperationTypeNames.Query));
}
else if (operationType == OperationType.Mutation)
{
return(objectType.Name.Equals(OperationTypeNames.Mutation));
}
else if (operationType == OperationType.Subscription)
{
return(objectType.Name.Equals(OperationTypeNames.Subscription));
}
return(false);
}
public override void OnBeforeCompleteType(
ITypeCompletionContext completionContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
if ((completionContext.IsQueryType ?? false) &&
definition is ObjectTypeDefinition objectTypeDefinition)
{
ITypeInspector typeInspector = completionContext.TypeInspector;
IIdSerializer serializer =
completionContext.Services.GetService <IIdSerializer>() ??
new IdSerializer();
ObjectFieldDefinition typeNameField = objectTypeDefinition.Fields.First(
t => t.Name.Equals(IntrospectionFields.TypeName) && t.IsIntrospectionField);
var index = objectTypeDefinition.Fields.IndexOf(typeNameField);
CreateNodeField(typeInspector, serializer, objectTypeDefinition.Fields, index + 1);
CreateNodesField(serializer, objectTypeDefinition.Fields, index + 2);
}
}
private static Type GetArgumentType(
ObjectFieldDefinition definition,
Type?filterType,
ITypeInspector typeInspector)
{
Type?argumentType = filterType;
if (argumentType is null)
{
if (definition.ResultType is null ||
definition.ResultType == typeof(object) ||
!typeInspector.TryCreateTypeInfo(
definition.ResultType, out ITypeInfo? typeInfo))
{
throw new SchemaException(
SchemaErrorBuilder.New()
.SetMessage("Cannot handle the specified type.")
.SetExtension("fieldName", definition.Name)
.Build());
}
argumentType = typeof(SortInputType <>).MakeGenericType(typeInfo.NamedType);
}
if (argumentType == typeof(object))
{
// TODO : resources
throw new SchemaException(
SchemaErrorBuilder.New()
.SetMessage(
"The sort type cannot be " +
"inferred from `System.Object`.")
.SetCode(ErrorCodes.Filtering.FilterObjectType)
.Build());
}
return(argumentType);
}
private static void CreateNodeField(
ITypeInspector typeInspector,
IIdSerializer serializer,
IList <ObjectFieldDefinition> fields,
int index)
{
ExtendedTypeReference node = typeInspector.GetTypeRef(typeof(NodeType));
ExtendedTypeReference id = typeInspector.GetTypeRef(typeof(NonNullType <IdType>));
var field = new ObjectFieldDefinition(
Node,
Relay_NodeField_Description,
node,
ResolveNodeAsync)
{
Arguments = { new(Id, Relay_NodeField_Id_Description, id) }
};
fields.Insert(index, field);
ValueTask <object?> ResolveNodeAsync(IResolverContext ctx)
=> ResolveSingleNode(ctx, serializer, Id);
}
private static RootTypeKind GetOperationKind(
TypeSystemObjectBase type,
ITypeInspector typeInspector,
Dictionary <OperationType, ITypeReference> operations)
{
if (type is ObjectType objectType)
{
if (IsOperationType(
objectType,
OperationType.Query,
typeInspector,
operations))
{
return(RootTypeKind.Query);
}
if (IsOperationType(
objectType,
OperationType.Mutation,
typeInspector,
operations))
{
return(RootTypeKind.Mutation);
}
if (IsOperationType(
objectType,
OperationType.Subscription,
typeInspector,
operations))
{
return(RootTypeKind.Subscription);
}
}
return(RootTypeKind.None);
}
private static IExtendedType GetSourceType(
ITypeInspector typeInspector,
ObjectFieldDefinition definition,
Type entityType)
{
// if an explicit result type is defined we will type it since it expresses the
// intend.
if (definition.ResultType is not null)
{
return(typeInspector.GetType(definition.ResultType));
}
// Otherwise we will look at specified members and extract the return type.
MemberInfo?member = definition.ResolverMember ?? definition.Member;
if (member is not null)
{
return(typeInspector.GetReturnType(member, true));
}
// if we were not able to resolve the source type we will assume that it is
// an enumerable of the entity type.
return(typeInspector.GetType(typeof(IEnumerable <>).MakeGenericType(entityType)));
}
/// <summary>
/// Overrides the default ExceptionTypeInspector.
/// </summary>
/// <returns>this</returns>
public TypeInspectorsRegistration OverrideExceptionInspector(ITypeInspector exceptionTypeInspector)
{
_exceptionTypeInspector = exceptionTypeInspector;
return this;
}
public MEXTypeInspector(ITypeInspector innerTypeDescriptor)
{
_innerTypeDescriptor = innerTypeDescriptor;
}
public ReadableAndWritablePropertiesTypeInspector(ITypeInspector innerTypeDescriptor)
{
_innerTypeDescriptor = innerTypeDescriptor;
}
public YamlAttributesTypeInspector(ITypeInspector innerTypeDescriptor)
{
this.innerTypeDescriptor = innerTypeDescriptor;
}
/// <summary>
/// Overrides the default EnumTypeInspector.
/// </summary>
/// <returns>this</returns>
public TypeInspectorsRegistration OverrideEnumInspector(ITypeInspector enumTypeInspector)
{
_enumTypeInspector = enumTypeInspector;
return this;
}
public StringQuotingTypeInspector(ITypeInspector typeInspector)
{
_typeInspector = typeInspector ?? throw new ArgumentNullException(nameof(typeInspector));
}
/// <summary>
/// Initializes a new instance of the <see cref="CommentGatheringTypeInspector"/> class.
/// </summary>
/// <param name="innerTypeDescriptor">The inner type description instance.</param>
public CommentGatheringTypeInspector(ITypeInspector innerTypeDescriptor)
{
this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
}
public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeDescriptor, bool ignoreUnmatched)
{
_objectFactory = objectFactory;
_typeDescriptor = typeDescriptor;
_ignoreUnmatched = ignoreUnmatched;
}
public static ITypeReference GetInputReturnTypeRef(
this ITypeInspector typeInspector,
MemberInfo member)
{
return(typeInspector.GetReturnTypeRef(member, TypeContext.Input));
}
static TypeInspector()
{
All = new AnnotationInspectorAll();
Default = new AnnotationInspectorDefault();
}
/// <summary>Inspectors to be used run before the CatchAll inspector</summary>
public TypeInspectorsRegistration RegisterInspector(ITypeInspector inspector)
{
if (inspector == null) throw new ArgumentNullException("inspector");
_inspectors.Add(inspector);
return this;
}
public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeDescriptor)
{
_objectFactory = objectFactory;
_typeDescriptor = typeDescriptor;
}
public QueryableSpatialOverlapsOperationHandlerBase(
IFilterConvention convention,
ITypeInspector inspector)
: base(convention, inspector, _overlap)
{
}
public QueryableSimpleMethodTest(ITypeInspector typeInspector)
{
_extendedType = typeInspector.GetReturnType(Method);
}
public static DecisionServiceClient <TContext> Create <TContext>(DecisionServiceConfiguration config, ITypeInspector typeInspector = null, ApplicationClientMetadata metaData = null)
{
return(new DecisionServiceClient <TContext>(
config,
DownloadMetadata(config, metaData),
new VWExplorer <TContext>(config.ModelStream, typeInspector, config.DevelopmentMode)));
}
public HtmlDocumentationBuilder(ITypeInspector typeInspector) {
_typeInspector = typeInspector;
}
public QueryableSpatialIntersectsOperationHandler(
IFilterConvention convention,
ITypeInspector inspector)
: base(convention, inspector)
{
}
static JsonTypeInspector()
{
Default = new JsonTypeInspectorImpl();
}
private static void AddSerializerToObjectField(
ITypeCompletionContext completionContext,
ObjectFieldDefinition definition,
FieldMiddleware placeholder,
NameString typeName)
{
ITypeInspector typeInspector = completionContext.TypeInspector;
IExtendedType? resultType;
if (definition.ResultType is not null)
{
resultType = typeInspector.GetType(definition.ResultType);
}
else if (definition.Type is ExtendedTypeReference typeReference)
{
resultType = typeReference.Type;
}
else
{
throw new SchemaException(SchemaErrorBuilder.New()
.SetMessage("Unable to resolve type from field `{0}`.", definition.Name)
.SetTypeSystemObject(completionContext.Type)
.Build());
}
NameString schemaName = default;
completionContext.DescriptorContext.SchemaCompleted += (sender, args) =>
schemaName = args.Schema.Name;
IIdSerializer serializer =
completionContext.Services.GetService <IIdSerializer>() ??
new IdSerializer();
var index = definition.MiddlewareComponents.IndexOf(placeholder);
if (typeName.IsEmpty)
{
typeName = completionContext.Type.Name;
}
definition.MiddlewareComponents[index] = next => async context =>
{
await next(context).ConfigureAwait(false);
if (context.Result is not null)
{
if (resultType.IsArrayOrList)
{
var list = new List <object?>();
foreach (object?element in (IEnumerable)context.Result)
{
list.Add(element is null
? element
: serializer.Serialize(schemaName, typeName, element));
}
context.Result = list;
}
else
{
context.Result = serializer.Serialize(schemaName, typeName, context.Result);
}
}
};
}
public FilterPropertiesInspector(ITypeInspector innerTypeDescriptor)
{
_innerTypeDescriptor = innerTypeDescriptor;
}
public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeDescriptor, bool ignoreUnmatched)
{
_objectFactory = objectFactory;
_typeDescriptor = typeDescriptor;
_ignoreUnmatched = ignoreUnmatched;
}
//--- Constructors ---
public HtmlDocumentationBuilder() {
_typeInspector = new IsolatedTypeInspector();
}
public AutoRestTypeInspector(ITypeInspector inner)
{
_inner = inner;
}
public YamlAttributesTypeInspector(ITypeInspector innerTypeDescriptor)
{
this.innerTypeDescriptor = innerTypeDescriptor;
}
public SortedTypeInspector(ITypeInspector innerTypeInspector)
{
_innerTypeInspector = innerTypeInspector;
}
public RoundtripObjectGraphTraversalStrategy(Serializer serializer, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion)
: base(serializer, typeDescriptor, typeResolver, maxRecursion, null)
{
}
public ReadableAndWritablePropertiesTypeInspector(ITypeInspector innerTypeDescriptor)
{
_innerTypeDescriptor = innerTypeDescriptor;
}
public RoundtripObjectGraphTraversalStrategy(Serializer serializer, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion)
: base(serializer, typeDescriptor, typeResolver, maxRecursion)
{
}
