-
-
Notifications
You must be signed in to change notification settings - Fork 0
/
InputObjectTypeDescriptor.cs
155 lines (131 loc) · 4.75 KB
/
InputObjectTypeDescriptor.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
using System;
using System.Collections.Generic;
using System.Reflection;
using HotChocolate.Language;
using HotChocolate.Types.Descriptors.Definitions;
using System.Linq;
namespace HotChocolate.Types.Descriptors
{
public class InputObjectTypeDescriptor
: DescriptorBase<InputObjectTypeDefinition>
, IInputObjectTypeDescriptor
{
protected InputObjectTypeDescriptor(
IDescriptorContext context,
Type clrType)
: base(context)
{
if (clrType == null)
{
throw new ArgumentNullException(nameof(clrType));
}
Definition.ClrType = clrType;
Definition.Name = context.Naming.GetTypeName(
clrType, TypeKind.InputObject);
Definition.Description = context.Naming.GetTypeDescription(
clrType, TypeKind.InputObject);
}
protected InputObjectTypeDescriptor(IDescriptorContext context)
: base(context)
{
Definition.ClrType = typeof(object);
}
internal protected override InputObjectTypeDefinition Definition { get; } =
new InputObjectTypeDefinition();
protected List<InputFieldDescriptor> Fields { get; } =
new List<InputFieldDescriptor>();
protected override void OnCreateDefinition(
InputObjectTypeDefinition definition)
{
if (Definition.ClrType is { })
{
Context.Inspector.ApplyAttributes(
Context,
this,
Definition.ClrType);
}
var fields = new Dictionary<NameString, InputFieldDefinition>();
var handledProperties = new HashSet<PropertyInfo>();
FieldDescriptorUtilities.AddExplicitFields(
Fields.Select(t => t.CreateDefinition()),
f => f.Property,
fields,
handledProperties);
OnCompleteFields(fields, handledProperties);
Definition.Fields.AddRange(fields.Values);
base.OnCreateDefinition(definition);
}
protected virtual void OnCompleteFields(
IDictionary<NameString, InputFieldDefinition> fields,
ISet<PropertyInfo> handledProperties)
{
}
public IInputObjectTypeDescriptor SyntaxNode(
InputObjectTypeDefinitionNode inputObjectTypeDefinitionNode)
{
Definition.SyntaxNode = inputObjectTypeDefinitionNode;
return this;
}
public IInputObjectTypeDescriptor Name(NameString value)
{
Definition.Name = value.EnsureNotEmpty(nameof(value));
return this;
}
public IInputObjectTypeDescriptor Description(string value)
{
Definition.Description = value;
return this;
}
public IInputFieldDescriptor Field(NameString name)
{
InputFieldDescriptor fieldDescriptor =
Fields.FirstOrDefault(t => t.Definition.Name.Equals(name));
if (fieldDescriptor is { })
{
return fieldDescriptor;
}
fieldDescriptor = new InputFieldDescriptor(
Context,
name.EnsureNotEmpty(nameof(name)));
Fields.Add(fieldDescriptor);
return fieldDescriptor;
}
public IInputObjectTypeDescriptor Directive<T>(T directive)
where T : class
{
Definition.AddDirective(directive);
return this;
}
public IInputObjectTypeDescriptor Directive<T>()
where T : class, new()
{
Definition.AddDirective(new T());
return this;
}
public IInputObjectTypeDescriptor Directive(
NameString name,
params ArgumentNode[] arguments)
{
Definition.AddDirective(name, arguments);
return this;
}
public static InputObjectTypeDescriptor New(
IDescriptorContext context) =>
new InputObjectTypeDescriptor(context);
public static InputObjectTypeDescriptor New(
IDescriptorContext context,
Type clrType) =>
new InputObjectTypeDescriptor(context, clrType);
public static InputObjectTypeDescriptor<T> New<T>(
IDescriptorContext context) =>
new InputObjectTypeDescriptor<T>(context);
public static InputObjectTypeDescriptor FromSchemaType(
IDescriptorContext context,
Type schemaType)
{
var descriptor = New(context, schemaType);
descriptor.Definition.ClrType = typeof(object);
return descriptor;
}
}
}