private static bool TryCheckForQueryTypes(
            this ParameterInfo parameter,
            out FieldResolverArgumentKind argumentKind)
        {
            if (parameter.ParameterType == typeof(DocumentNode))
            {
                argumentKind = FieldResolverArgumentKind.QueryDocument;
                return(true);
            }

            if (parameter.ParameterType == typeof(OperationDefinitionNode))
            {
                argumentKind = FieldResolverArgumentKind.OperationDefinition;
                return(true);
            }

            if (parameter.ParameterType == typeof(FieldNode))
            {
                argumentKind = FieldResolverArgumentKind.FieldSelection;
                return(true);
            }

            argumentKind = default(FieldResolverArgumentKind);
            return(false);
        }
Example #2
0
 private FieldResolverArgumentDescriptor(
     string name, FieldResolverArgumentKind kind, Type type)
 {
     Name = name;
     Kind = kind;
     Type = type;
 }
        private static bool TryCheckForResolverArguments(
            this ParameterInfo parameter,
            Type sourceType,
            out FieldResolverArgumentKind argumentKind)
        {
            if (parameter.ParameterType == sourceType)
            {
                argumentKind = FieldResolverArgumentKind.Source;
                return(true);
            }

            if (parameter.ParameterType == typeof(IResolverContext))
            {
                argumentKind = FieldResolverArgumentKind.Context;
                return(true);
            }

            if (parameter.ParameterType == typeof(CancellationToken))
            {
                argumentKind = FieldResolverArgumentKind.CancellationToken;
                return(true);
            }

            argumentKind = default(FieldResolverArgumentKind);
            return(false);
        }
        private static bool TryCheckForExtensions(
            this ParameterInfo parameter,
            out FieldResolverArgumentKind argumentKind)
        {
            if (parameter.IsDataLoader())
            {
                argumentKind = FieldResolverArgumentKind.DataLoader;
                return(true);
            }

            if (parameter.IsState())
            {
                argumentKind = FieldResolverArgumentKind.CustomContext;
                return(true);
            }

            if (parameter.IsService())
            {
                argumentKind = FieldResolverArgumentKind.Service;
                return(true);
            }

            argumentKind = default(FieldResolverArgumentKind);
            return(false);
        }
 internal FieldResolverArgumentDescriptor(
     string name, string variableName,
     FieldResolverArgumentKind kind, Type type)
 {
     Name         = name;
     VariableName = variableName;
     Kind         = kind;
     Type         = type;
 }
Example #6
0
        public static FieldResolverArgumentDescriptor Create(
            string name, FieldResolverArgumentKind kind, Type type)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException(nameof(name));
            }

            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }

            return(new FieldResolverArgumentDescriptor(name, kind, type));
        }
        internal static IReadOnlyCollection <FieldResolverArgumentDescriptor> CreateResolverArgumentDescriptors(
            MethodInfo method, Type resolverType, Type sourceType)
        {
            List <FieldResolverArgumentDescriptor> arguments =
                new List <FieldResolverArgumentDescriptor>();

            foreach (ParameterInfo parameter in method.GetParameters())
            {
                FieldResolverArgumentKind kind = FieldResolverArgumentDescriptor
                                                 .LookupKind(parameter.ParameterType, sourceType);
                arguments.Add(FieldResolverArgumentDescriptor.Create(
                                  parameter.Name, kind, parameter.ParameterType));
            }

            return(arguments);
        }
        internal static IReadOnlyCollection <FieldResolverArgumentDescriptor> CreateResolverArgumentDescriptors(
            MethodInfo method, Type sourceType)
        {
            var arguments = new List <FieldResolverArgumentDescriptor>();
            int i         = 0;

            foreach (ParameterInfo parameter in method.GetParameters())
            {
                FieldResolverArgumentKind kind = FieldResolverArgumentDescriptor
                                                 .LookupKind(parameter.ParameterType, sourceType);
                string variableName = $"v{i++}_{parameter.Name}";
                arguments.Add(new FieldResolverArgumentDescriptor(
                                  parameter.Name, variableName, kind, parameter.ParameterType));
            }

            return(arguments);
        }
        private static bool TryCheckForSchemaTypes(
            this ParameterInfo parameter,
            out FieldResolverArgumentKind argumentKind)
        {
            if (parameter.ParameterType == typeof(ISchema))
            {
                argumentKind = FieldResolverArgumentKind.Schema;
                return(true);
            }

            if (parameter.ParameterType == typeof(Schema))
            {
                argumentKind = FieldResolverArgumentKind.Schema;
                return(true);
            }

            if (parameter.ParameterType == typeof(ObjectType))
            {
                argumentKind = FieldResolverArgumentKind.ObjectType;
                return(true);
            }

            if (parameter.ParameterType == typeof(IOutputField))
            {
                argumentKind = FieldResolverArgumentKind.Field;
                return(true);
            }

            if (parameter.ParameterType == typeof(ObjectField))
            {
                argumentKind = FieldResolverArgumentKind.Field;
                return(true);
            }

            argumentKind = default(FieldResolverArgumentKind);
            return(false);
        }