1 | Object.defineProperty(exports, "__esModule", { value: true });
|
2 | var graphql_1 = require("graphql");
|
3 | var isSpecifiedScalarType_1 = require("../isSpecifiedScalarType");
|
4 | var resolveFromParentTypename_1 = require("./resolveFromParentTypename");
|
5 | var defaultMergedResolver_1 = require("./defaultMergedResolver");
|
6 | function recreateType(type, resolveType, keepResolvers) {
|
7 | if (type instanceof graphql_1.GraphQLObjectType) {
|
8 | var fields_1 = type.getFields();
|
9 | var interfaces_1 = type.getInterfaces();
|
10 | return new graphql_1.GraphQLObjectType({
|
11 | name: type.name,
|
12 | description: type.description,
|
13 | astNode: type.astNode,
|
14 | isTypeOf: keepResolvers ? type.isTypeOf : undefined,
|
15 | fields: function () {
|
16 | return fieldMapToFieldConfigMap(fields_1, resolveType, keepResolvers);
|
17 | },
|
18 | interfaces: function () { return interfaces_1.map(function (iface) { return resolveType(iface); }); },
|
19 | });
|
20 | }
|
21 | else if (type instanceof graphql_1.GraphQLInterfaceType) {
|
22 | var fields_2 = type.getFields();
|
23 | return new graphql_1.GraphQLInterfaceType({
|
24 | name: type.name,
|
25 | description: type.description,
|
26 | astNode: type.astNode,
|
27 | fields: function () {
|
28 | return fieldMapToFieldConfigMap(fields_2, resolveType, keepResolvers);
|
29 | },
|
30 | resolveType: keepResolvers
|
31 | ? type.resolveType
|
32 | : function (parent, context, info) {
|
33 | return resolveFromParentTypename_1.default(parent, info.schema);
|
34 | },
|
35 | });
|
36 | }
|
37 | else if (type instanceof graphql_1.GraphQLUnionType) {
|
38 | return new graphql_1.GraphQLUnionType({
|
39 | name: type.name,
|
40 | description: type.description,
|
41 | astNode: type.astNode,
|
42 | types: function () { return type.getTypes().map(function (unionMember) { return resolveType(unionMember); }); },
|
43 | resolveType: keepResolvers
|
44 | ? type.resolveType
|
45 | : function (parent, context, info) {
|
46 | return resolveFromParentTypename_1.default(parent, info.schema);
|
47 | },
|
48 | });
|
49 | }
|
50 | else if (type instanceof graphql_1.GraphQLInputObjectType) {
|
51 | return new graphql_1.GraphQLInputObjectType({
|
52 | name: type.name,
|
53 | description: type.description,
|
54 | astNode: type.astNode,
|
55 | fields: function () {
|
56 | return inputFieldMapToFieldConfigMap(type.getFields(), resolveType);
|
57 | },
|
58 | });
|
59 | }
|
60 | else if (type instanceof graphql_1.GraphQLEnumType) {
|
61 | var values = type.getValues();
|
62 | var newValues_1 = {};
|
63 | values.forEach(function (value) {
|
64 | newValues_1[value.name] = {
|
65 | value: value.value,
|
66 | deprecationReason: value.deprecationReason,
|
67 | description: value.description,
|
68 | astNode: value.astNode,
|
69 | };
|
70 | });
|
71 | return new graphql_1.GraphQLEnumType({
|
72 | name: type.name,
|
73 | description: type.description,
|
74 | astNode: type.astNode,
|
75 | values: newValues_1,
|
76 | });
|
77 | }
|
78 | else if (type instanceof graphql_1.GraphQLScalarType) {
|
79 | if (keepResolvers || isSpecifiedScalarType_1.default(type)) {
|
80 | return type;
|
81 | }
|
82 | else {
|
83 | return new graphql_1.GraphQLScalarType({
|
84 | name: type.name,
|
85 | description: type.description,
|
86 | astNode: type.astNode,
|
87 | serialize: function (value) {
|
88 | return value;
|
89 | },
|
90 | parseValue: function (value) {
|
91 | return value;
|
92 | },
|
93 | parseLiteral: function (ast) {
|
94 | return parseLiteral(ast);
|
95 | },
|
96 | });
|
97 | }
|
98 | }
|
99 | else {
|
100 | throw new Error("Invalid type " + type);
|
101 | }
|
102 | }
|
103 | exports.recreateType = recreateType;
|
104 | function recreateDirective(directive, resolveType) {
|
105 | return new graphql_1.GraphQLDirective({
|
106 | name: directive.name,
|
107 | description: directive.description,
|
108 | locations: directive.locations,
|
109 | args: argsToFieldConfigArgumentMap(directive.args, resolveType),
|
110 | astNode: directive.astNode,
|
111 | });
|
112 | }
|
113 | exports.recreateDirective = recreateDirective;
|
114 | function parseLiteral(ast) {
|
115 | switch (ast.kind) {
|
116 | case graphql_1.Kind.STRING:
|
117 | case graphql_1.Kind.BOOLEAN: {
|
118 | return ast.value;
|
119 | }
|
120 | case graphql_1.Kind.INT:
|
121 | case graphql_1.Kind.FLOAT: {
|
122 | return parseFloat(ast.value);
|
123 | }
|
124 | case graphql_1.Kind.OBJECT: {
|
125 | var value_1 = Object.create(null);
|
126 | ast.fields.forEach(function (field) {
|
127 | value_1[field.name.value] = parseLiteral(field.value);
|
128 | });
|
129 | return value_1;
|
130 | }
|
131 | case graphql_1.Kind.LIST: {
|
132 | return ast.values.map(parseLiteral);
|
133 | }
|
134 | default:
|
135 | return null;
|
136 | }
|
137 | }
|
138 | function fieldMapToFieldConfigMap(fields, resolveType, keepResolvers) {
|
139 | var result = {};
|
140 | Object.keys(fields).forEach(function (name) {
|
141 | var field = fields[name];
|
142 | var type = resolveType(field.type);
|
143 | if (type !== null) {
|
144 | result[name] = fieldToFieldConfig(fields[name], resolveType, keepResolvers);
|
145 | }
|
146 | });
|
147 | return result;
|
148 | }
|
149 | exports.fieldMapToFieldConfigMap = fieldMapToFieldConfigMap;
|
150 | function createResolveType(getType) {
|
151 | var resolveType = function (type) {
|
152 | if (type instanceof graphql_1.GraphQLList) {
|
153 | var innerType = resolveType(type.ofType);
|
154 | if (innerType === null) {
|
155 | return null;
|
156 | }
|
157 | else {
|
158 | return new graphql_1.GraphQLList(innerType);
|
159 | }
|
160 | }
|
161 | else if (type instanceof graphql_1.GraphQLNonNull) {
|
162 | var innerType = resolveType(type.ofType);
|
163 | if (innerType === null) {
|
164 | return null;
|
165 | }
|
166 | else {
|
167 | return new graphql_1.GraphQLNonNull(innerType);
|
168 | }
|
169 | }
|
170 | else if (graphql_1.isNamedType(type)) {
|
171 | var typeName = graphql_1.getNamedType(type).name;
|
172 | switch (typeName) {
|
173 | case graphql_1.GraphQLInt.name:
|
174 | return graphql_1.GraphQLInt;
|
175 | case graphql_1.GraphQLFloat.name:
|
176 | return graphql_1.GraphQLFloat;
|
177 | case graphql_1.GraphQLString.name:
|
178 | return graphql_1.GraphQLString;
|
179 | case graphql_1.GraphQLBoolean.name:
|
180 | return graphql_1.GraphQLBoolean;
|
181 | case graphql_1.GraphQLID.name:
|
182 | return graphql_1.GraphQLID;
|
183 | default:
|
184 | return getType(typeName, type);
|
185 | }
|
186 | }
|
187 | else {
|
188 | return type;
|
189 | }
|
190 | };
|
191 | return resolveType;
|
192 | }
|
193 | exports.createResolveType = createResolveType;
|
194 | function fieldToFieldConfig(field, resolveType, keepResolvers) {
|
195 | return {
|
196 | type: resolveType(field.type),
|
197 | args: argsToFieldConfigArgumentMap(field.args, resolveType),
|
198 | resolve: keepResolvers ? field.resolve : defaultMergedResolver_1.default,
|
199 | subscribe: keepResolvers ? field.subscribe : null,
|
200 | description: field.description,
|
201 | deprecationReason: field.deprecationReason,
|
202 | astNode: field.astNode,
|
203 | };
|
204 | }
|
205 | exports.fieldToFieldConfig = fieldToFieldConfig;
|
206 | function argsToFieldConfigArgumentMap(args, resolveType) {
|
207 | var result = {};
|
208 | args.forEach(function (arg) {
|
209 | var newArg = argumentToArgumentConfig(arg, resolveType);
|
210 | if (newArg) {
|
211 | result[newArg[0]] = newArg[1];
|
212 | }
|
213 | });
|
214 | return result;
|
215 | }
|
216 | exports.argsToFieldConfigArgumentMap = argsToFieldConfigArgumentMap;
|
217 | function argumentToArgumentConfig(argument, resolveType) {
|
218 | var type = resolveType(argument.type);
|
219 | if (type === null) {
|
220 | return null;
|
221 | }
|
222 | else {
|
223 | return [
|
224 | argument.name,
|
225 | {
|
226 | type: type,
|
227 | defaultValue: argument.defaultValue,
|
228 | description: argument.description,
|
229 | astNode: argument.astNode,
|
230 | },
|
231 | ];
|
232 | }
|
233 | }
|
234 | exports.argumentToArgumentConfig = argumentToArgumentConfig;
|
235 | function inputFieldMapToFieldConfigMap(fields, resolveType) {
|
236 | var result = {};
|
237 | Object.keys(fields).forEach(function (name) {
|
238 | var field = fields[name];
|
239 | var type = resolveType(field.type);
|
240 | if (type !== null) {
|
241 | result[name] = inputFieldToFieldConfig(fields[name], resolveType);
|
242 | }
|
243 | });
|
244 | return result;
|
245 | }
|
246 | exports.inputFieldMapToFieldConfigMap = inputFieldMapToFieldConfigMap;
|
247 | function inputFieldToFieldConfig(field, resolveType) {
|
248 | return {
|
249 | type: resolveType(field.type),
|
250 | defaultValue: field.defaultValue,
|
251 | description: field.description,
|
252 | astNode: field.astNode,
|
253 | };
|
254 | }
|
255 | exports.inputFieldToFieldConfig = inputFieldToFieldConfig;
|
256 |
|
\ | No newline at end of file |