1 | function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
|
2 |
|
3 | function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 |
|
12 |
|
13 | import objectValues from '../polyfills/objectValues';
|
14 | import invariant from '../jsutils/invariant';
|
15 | import mapValue from '../jsutils/mapValue';
|
16 | import keyValMap from '../jsutils/keyValMap';
|
17 | import { ASTDefinitionBuilder } from './buildASTSchema';
|
18 | import { assertValidSDLExtension } from '../validation/validate';
|
19 | import { assertSchema, GraphQLSchema } from '../type/schema';
|
20 | import { isIntrospectionType } from '../type/introspection';
|
21 | import { isSpecifiedScalarType } from '../type/scalars';
|
22 | import { isScalarType, isObjectType, isInterfaceType, isUnionType, isListType, isNonNullType, isEnumType, isInputObjectType, GraphQLList, GraphQLNonNull, GraphQLScalarType, GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, GraphQLEnumType, GraphQLInputObjectType } from '../type/definition';
|
23 | import { GraphQLDirective } from '../type/directives';
|
24 | import { Kind } from '../language/kinds';
|
25 | import { isTypeDefinitionNode, isTypeExtensionNode } from '../language/predicates';
|
26 |
|
27 |
|
28 |
|
29 |
|
30 |
|
31 |
|
32 |
|
33 |
|
34 |
|
35 |
|
36 |
|
37 |
|
38 |
|
39 |
|
40 |
|
41 |
|
42 |
|
43 |
|
44 |
|
45 | export function extendSchema(schema, documentAST, options) {
|
46 | assertSchema(schema);
|
47 | !(documentAST && documentAST.kind === Kind.DOCUMENT) ? invariant(0, 'Must provide valid Document AST') : void 0;
|
48 |
|
49 | if (!options || !(options.assumeValid || options.assumeValidSDL)) {
|
50 | assertValidSDLExtension(documentAST, schema);
|
51 | }
|
52 |
|
53 |
|
54 | var typeDefinitionMap = Object.create(null);
|
55 | var typeExtensionsMap = Object.create(null);
|
56 |
|
57 |
|
58 | var directiveDefinitions = [];
|
59 | var schemaDef;
|
60 |
|
61 | var schemaExtensions = [];
|
62 | var _iteratorNormalCompletion = true;
|
63 | var _didIteratorError = false;
|
64 | var _iteratorError = undefined;
|
65 |
|
66 | try {
|
67 | for (var _iterator = documentAST.definitions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
68 | var def = _step.value;
|
69 |
|
70 | if (def.kind === Kind.SCHEMA_DEFINITION) {
|
71 | schemaDef = def;
|
72 | } else if (def.kind === Kind.SCHEMA_EXTENSION) {
|
73 | schemaExtensions.push(def);
|
74 | } else if (isTypeDefinitionNode(def)) {
|
75 | var typeName = def.name.value;
|
76 | typeDefinitionMap[typeName] = def;
|
77 | } else if (isTypeExtensionNode(def)) {
|
78 | var extendedTypeName = def.name.value;
|
79 | var existingTypeExtensions = typeExtensionsMap[extendedTypeName];
|
80 | typeExtensionsMap[extendedTypeName] = existingTypeExtensions ? existingTypeExtensions.concat([def]) : [def];
|
81 | } else if (def.kind === Kind.DIRECTIVE_DEFINITION) {
|
82 | directiveDefinitions.push(def);
|
83 | }
|
84 | }
|
85 |
|
86 |
|
87 | } catch (err) {
|
88 | _didIteratorError = true;
|
89 | _iteratorError = err;
|
90 | } finally {
|
91 | try {
|
92 | if (!_iteratorNormalCompletion && _iterator.return != null) {
|
93 | _iterator.return();
|
94 | }
|
95 | } finally {
|
96 | if (_didIteratorError) {
|
97 | throw _iteratorError;
|
98 | }
|
99 | }
|
100 | }
|
101 |
|
102 | if (Object.keys(typeExtensionsMap).length === 0 && Object.keys(typeDefinitionMap).length === 0 && directiveDefinitions.length === 0 && schemaExtensions.length === 0 && !schemaDef) {
|
103 | return schema;
|
104 | }
|
105 |
|
106 | var astBuilder = new ASTDefinitionBuilder(typeDefinitionMap, options, function (typeName) {
|
107 | var existingType = schema.getType(typeName);
|
108 | !existingType ? invariant(0, "Unknown type: \"".concat(typeName, "\".")) : void 0;
|
109 | return extendNamedType(existingType);
|
110 | });
|
111 | var extendTypeCache = Object.create(null);
|
112 |
|
113 | var operationTypes = {
|
114 | query: extendMaybeNamedType(schema.getQueryType()),
|
115 | mutation: extendMaybeNamedType(schema.getMutationType()),
|
116 | subscription: extendMaybeNamedType(schema.getSubscriptionType())
|
117 | };
|
118 |
|
119 | if (schemaDef) {
|
120 | var _iteratorNormalCompletion2 = true;
|
121 | var _didIteratorError2 = false;
|
122 | var _iteratorError2 = undefined;
|
123 |
|
124 | try {
|
125 | for (var _iterator2 = schemaDef.operationTypes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
|
126 | var _ref2 = _step2.value;
|
127 | var operation = _ref2.operation;
|
128 | var type = _ref2.type;
|
129 |
|
130 |
|
131 |
|
132 | operationTypes[operation] = astBuilder.buildType(type);
|
133 | }
|
134 | } catch (err) {
|
135 | _didIteratorError2 = true;
|
136 | _iteratorError2 = err;
|
137 | } finally {
|
138 | try {
|
139 | if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
|
140 | _iterator2.return();
|
141 | }
|
142 | } finally {
|
143 | if (_didIteratorError2) {
|
144 | throw _iteratorError2;
|
145 | }
|
146 | }
|
147 | }
|
148 | }
|
149 |
|
150 |
|
151 | for (var _i = 0; _i < schemaExtensions.length; _i++) {
|
152 | var schemaExtension = schemaExtensions[_i];
|
153 |
|
154 | if (schemaExtension.operationTypes) {
|
155 | var _iteratorNormalCompletion14 = true;
|
156 | var _didIteratorError14 = false;
|
157 | var _iteratorError14 = undefined;
|
158 |
|
159 | try {
|
160 | for (var _iterator14 = schemaExtension.operationTypes[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true) {
|
161 | var _ref4 = _step14.value;
|
162 | var _operation = _ref4.operation;
|
163 | var _type = _ref4.type;
|
164 |
|
165 |
|
166 |
|
167 | operationTypes[_operation] = astBuilder.buildType(_type);
|
168 | }
|
169 | } catch (err) {
|
170 | _didIteratorError14 = true;
|
171 | _iteratorError14 = err;
|
172 | } finally {
|
173 | try {
|
174 | if (!_iteratorNormalCompletion14 && _iterator14.return != null) {
|
175 | _iterator14.return();
|
176 | }
|
177 | } finally {
|
178 | if (_didIteratorError14) {
|
179 | throw _iteratorError14;
|
180 | }
|
181 | }
|
182 | }
|
183 | }
|
184 | }
|
185 |
|
186 | var schemaExtensionASTNodes = schemaExtensions ? schema.extensionASTNodes ? schema.extensionASTNodes.concat(schemaExtensions) : schemaExtensions : schema.extensionASTNodes;
|
187 | var types = [].concat(objectValues(schema.getTypeMap()).map(function (type) {
|
188 | return extendNamedType(type);
|
189 | }), objectValues(typeDefinitionMap).map(function (type) {
|
190 | return astBuilder.buildType(type);
|
191 | }));
|
192 |
|
193 | var allowedLegacyNames = schema.__allowedLegacyNames.concat(options && options.allowedLegacyNames || []);
|
194 |
|
195 |
|
196 | return new GraphQLSchema(_objectSpread({}, operationTypes, {
|
197 | types: types,
|
198 | directives: getMergedDirectives(),
|
199 | astNode: schema.astNode,
|
200 | extensionASTNodes: schemaExtensionASTNodes,
|
201 | allowedLegacyNames: allowedLegacyNames
|
202 | }));
|
203 |
|
204 |
|
205 | function getMergedDirectives() {
|
206 | var existingDirectives = schema.getDirectives().map(extendDirective);
|
207 | !existingDirectives ? invariant(0, 'schema must have default directives') : void 0;
|
208 | return existingDirectives.concat(directiveDefinitions.map(function (node) {
|
209 | return astBuilder.buildDirective(node);
|
210 | }));
|
211 | }
|
212 |
|
213 | function extendMaybeNamedType(type) {
|
214 | return type ? extendNamedType(type) : null;
|
215 | }
|
216 |
|
217 | function extendNamedType(type) {
|
218 | if (isIntrospectionType(type) || isSpecifiedScalarType(type)) {
|
219 |
|
220 | return type;
|
221 | }
|
222 |
|
223 | var name = type.name;
|
224 |
|
225 | if (!extendTypeCache[name]) {
|
226 | if (isScalarType(type)) {
|
227 | extendTypeCache[name] = extendScalarType(type);
|
228 | } else if (isObjectType(type)) {
|
229 | extendTypeCache[name] = extendObjectType(type);
|
230 | } else if (isInterfaceType(type)) {
|
231 | extendTypeCache[name] = extendInterfaceType(type);
|
232 | } else if (isUnionType(type)) {
|
233 | extendTypeCache[name] = extendUnionType(type);
|
234 | } else if (isEnumType(type)) {
|
235 | extendTypeCache[name] = extendEnumType(type);
|
236 | } else if (isInputObjectType(type)) {
|
237 | extendTypeCache[name] = extendInputObjectType(type);
|
238 | }
|
239 | }
|
240 |
|
241 | return extendTypeCache[name];
|
242 | }
|
243 |
|
244 | function extendDirective(directive) {
|
245 | return new GraphQLDirective({
|
246 | name: directive.name,
|
247 | description: directive.description,
|
248 | locations: directive.locations,
|
249 | args: extendArgs(directive.args),
|
250 | astNode: directive.astNode
|
251 | });
|
252 | }
|
253 |
|
254 | function extendInputObjectType(type) {
|
255 | var name = type.name;
|
256 | var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
|
257 | return new GraphQLInputObjectType({
|
258 | name: name,
|
259 | description: type.description,
|
260 | fields: function fields() {
|
261 | return extendInputFieldMap(type);
|
262 | },
|
263 | astNode: type.astNode,
|
264 | extensionASTNodes: extensionASTNodes
|
265 | });
|
266 | }
|
267 |
|
268 | function extendInputFieldMap(type) {
|
269 | var newFieldMap = mapValue(type.getFields(), function (field) {
|
270 | return {
|
271 | description: field.description,
|
272 | type: extendType(field.type),
|
273 | defaultValue: field.defaultValue,
|
274 | astNode: field.astNode
|
275 | };
|
276 | });
|
277 |
|
278 | var extensions = typeExtensionsMap[type.name];
|
279 |
|
280 | if (extensions) {
|
281 | var _iteratorNormalCompletion3 = true;
|
282 | var _didIteratorError3 = false;
|
283 | var _iteratorError3 = undefined;
|
284 |
|
285 | try {
|
286 | for (var _iterator3 = extensions[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
|
287 | var extension = _step3.value;
|
288 | var _iteratorNormalCompletion4 = true;
|
289 | var _didIteratorError4 = false;
|
290 | var _iteratorError4 = undefined;
|
291 |
|
292 | try {
|
293 | for (var _iterator4 = extension.fields[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
|
294 | var field = _step4.value;
|
295 | newFieldMap[field.name.value] = astBuilder.buildInputField(field);
|
296 | }
|
297 | } catch (err) {
|
298 | _didIteratorError4 = true;
|
299 | _iteratorError4 = err;
|
300 | } finally {
|
301 | try {
|
302 | if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
|
303 | _iterator4.return();
|
304 | }
|
305 | } finally {
|
306 | if (_didIteratorError4) {
|
307 | throw _iteratorError4;
|
308 | }
|
309 | }
|
310 | }
|
311 | }
|
312 | } catch (err) {
|
313 | _didIteratorError3 = true;
|
314 | _iteratorError3 = err;
|
315 | } finally {
|
316 | try {
|
317 | if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
|
318 | _iterator3.return();
|
319 | }
|
320 | } finally {
|
321 | if (_didIteratorError3) {
|
322 | throw _iteratorError3;
|
323 | }
|
324 | }
|
325 | }
|
326 | }
|
327 |
|
328 | return newFieldMap;
|
329 | }
|
330 |
|
331 | function extendEnumType(type) {
|
332 | var name = type.name;
|
333 | var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
|
334 | return new GraphQLEnumType({
|
335 | name: name,
|
336 | description: type.description,
|
337 | values: extendValueMap(type),
|
338 | astNode: type.astNode,
|
339 | extensionASTNodes: extensionASTNodes
|
340 | });
|
341 | }
|
342 |
|
343 | function extendValueMap(type) {
|
344 | var newValueMap = Object.create(null);
|
345 | var _iteratorNormalCompletion5 = true;
|
346 | var _didIteratorError5 = false;
|
347 | var _iteratorError5 = undefined;
|
348 |
|
349 | try {
|
350 | for (var _iterator5 = type.getValues()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
|
351 | var _value = _step5.value;
|
352 | newValueMap[_value.name] = {
|
353 | description: _value.description,
|
354 | value: _value.value,
|
355 | deprecationReason: _value.deprecationReason,
|
356 | astNode: _value.astNode
|
357 | };
|
358 | }
|
359 |
|
360 | } catch (err) {
|
361 | _didIteratorError5 = true;
|
362 | _iteratorError5 = err;
|
363 | } finally {
|
364 | try {
|
365 | if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
|
366 | _iterator5.return();
|
367 | }
|
368 | } finally {
|
369 | if (_didIteratorError5) {
|
370 | throw _iteratorError5;
|
371 | }
|
372 | }
|
373 | }
|
374 |
|
375 | var extensions = typeExtensionsMap[type.name];
|
376 |
|
377 | if (extensions) {
|
378 | var _iteratorNormalCompletion6 = true;
|
379 | var _didIteratorError6 = false;
|
380 | var _iteratorError6 = undefined;
|
381 |
|
382 | try {
|
383 | for (var _iterator6 = extensions[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
|
384 | var extension = _step6.value;
|
385 | var _iteratorNormalCompletion7 = true;
|
386 | var _didIteratorError7 = false;
|
387 | var _iteratorError7 = undefined;
|
388 |
|
389 | try {
|
390 | for (var _iterator7 = extension.values[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
|
391 | var value = _step7.value;
|
392 | newValueMap[value.name.value] = astBuilder.buildEnumValue(value);
|
393 | }
|
394 | } catch (err) {
|
395 | _didIteratorError7 = true;
|
396 | _iteratorError7 = err;
|
397 | } finally {
|
398 | try {
|
399 | if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
|
400 | _iterator7.return();
|
401 | }
|
402 | } finally {
|
403 | if (_didIteratorError7) {
|
404 | throw _iteratorError7;
|
405 | }
|
406 | }
|
407 | }
|
408 | }
|
409 | } catch (err) {
|
410 | _didIteratorError6 = true;
|
411 | _iteratorError6 = err;
|
412 | } finally {
|
413 | try {
|
414 | if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
|
415 | _iterator6.return();
|
416 | }
|
417 | } finally {
|
418 | if (_didIteratorError6) {
|
419 | throw _iteratorError6;
|
420 | }
|
421 | }
|
422 | }
|
423 | }
|
424 |
|
425 | return newValueMap;
|
426 | }
|
427 |
|
428 | function extendScalarType(type) {
|
429 | var name = type.name;
|
430 | var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
|
431 | return new GraphQLScalarType({
|
432 | name: name,
|
433 | description: type.description,
|
434 | astNode: type.astNode,
|
435 | extensionASTNodes: extensionASTNodes,
|
436 | serialize: type.serialize,
|
437 | parseValue: type.parseValue,
|
438 | parseLiteral: type.parseLiteral
|
439 | });
|
440 | }
|
441 |
|
442 | function extendObjectType(type) {
|
443 | var name = type.name;
|
444 | var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
|
445 | return new GraphQLObjectType({
|
446 | name: name,
|
447 | description: type.description,
|
448 | interfaces: function interfaces() {
|
449 | return extendImplementedInterfaces(type);
|
450 | },
|
451 | fields: function fields() {
|
452 | return extendFieldMap(type);
|
453 | },
|
454 | astNode: type.astNode,
|
455 | extensionASTNodes: extensionASTNodes,
|
456 | isTypeOf: type.isTypeOf
|
457 | });
|
458 | }
|
459 |
|
460 | function extendArgs(args) {
|
461 | return keyValMap(args, function (arg) {
|
462 | return arg.name;
|
463 | }, function (arg) {
|
464 | return {
|
465 | type: extendType(arg.type),
|
466 | defaultValue: arg.defaultValue,
|
467 | description: arg.description,
|
468 | astNode: arg.astNode
|
469 | };
|
470 | });
|
471 | }
|
472 |
|
473 | function extendInterfaceType(type) {
|
474 | var name = type.name;
|
475 | var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
|
476 | return new GraphQLInterfaceType({
|
477 | name: type.name,
|
478 | description: type.description,
|
479 | fields: function fields() {
|
480 | return extendFieldMap(type);
|
481 | },
|
482 | astNode: type.astNode,
|
483 | extensionASTNodes: extensionASTNodes,
|
484 | resolveType: type.resolveType
|
485 | });
|
486 | }
|
487 |
|
488 | function extendUnionType(type) {
|
489 | var name = type.name;
|
490 | var extensionASTNodes = typeExtensionsMap[name] ? type.extensionASTNodes ? type.extensionASTNodes.concat(typeExtensionsMap[name]) : typeExtensionsMap[name] : type.extensionASTNodes;
|
491 | return new GraphQLUnionType({
|
492 | name: name,
|
493 | description: type.description,
|
494 | types: function types() {
|
495 | return extendPossibleTypes(type);
|
496 | },
|
497 | astNode: type.astNode,
|
498 | resolveType: type.resolveType,
|
499 | extensionASTNodes: extensionASTNodes
|
500 | });
|
501 | }
|
502 |
|
503 | function extendPossibleTypes(type) {
|
504 | var possibleTypes = type.getTypes().map(extendNamedType);
|
505 |
|
506 | var extensions = typeExtensionsMap[type.name];
|
507 |
|
508 | if (extensions) {
|
509 | var _iteratorNormalCompletion8 = true;
|
510 | var _didIteratorError8 = false;
|
511 | var _iteratorError8 = undefined;
|
512 |
|
513 | try {
|
514 | for (var _iterator8 = extensions[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
|
515 | var extension = _step8.value;
|
516 | var _iteratorNormalCompletion9 = true;
|
517 | var _didIteratorError9 = false;
|
518 | var _iteratorError9 = undefined;
|
519 |
|
520 | try {
|
521 | for (var _iterator9 = extension.types[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
|
522 | var namedType = _step9.value;
|
523 |
|
524 |
|
525 |
|
526 | possibleTypes.push(astBuilder.buildType(namedType));
|
527 | }
|
528 | } catch (err) {
|
529 | _didIteratorError9 = true;
|
530 | _iteratorError9 = err;
|
531 | } finally {
|
532 | try {
|
533 | if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
|
534 | _iterator9.return();
|
535 | }
|
536 | } finally {
|
537 | if (_didIteratorError9) {
|
538 | throw _iteratorError9;
|
539 | }
|
540 | }
|
541 | }
|
542 | }
|
543 | } catch (err) {
|
544 | _didIteratorError8 = true;
|
545 | _iteratorError8 = err;
|
546 | } finally {
|
547 | try {
|
548 | if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
|
549 | _iterator8.return();
|
550 | }
|
551 | } finally {
|
552 | if (_didIteratorError8) {
|
553 | throw _iteratorError8;
|
554 | }
|
555 | }
|
556 | }
|
557 | }
|
558 |
|
559 | return possibleTypes;
|
560 | }
|
561 |
|
562 | function extendImplementedInterfaces(type) {
|
563 | var interfaces = type.getInterfaces().map(extendNamedType);
|
564 |
|
565 | var extensions = typeExtensionsMap[type.name];
|
566 |
|
567 | if (extensions) {
|
568 | var _iteratorNormalCompletion10 = true;
|
569 | var _didIteratorError10 = false;
|
570 | var _iteratorError10 = undefined;
|
571 |
|
572 | try {
|
573 | for (var _iterator10 = extensions[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
|
574 | var extension = _step10.value;
|
575 | var _iteratorNormalCompletion11 = true;
|
576 | var _didIteratorError11 = false;
|
577 | var _iteratorError11 = undefined;
|
578 |
|
579 | try {
|
580 | for (var _iterator11 = extension.interfaces[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
|
581 | var namedType = _step11.value;
|
582 |
|
583 |
|
584 |
|
585 | interfaces.push(astBuilder.buildType(namedType));
|
586 | }
|
587 | } catch (err) {
|
588 | _didIteratorError11 = true;
|
589 | _iteratorError11 = err;
|
590 | } finally {
|
591 | try {
|
592 | if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
|
593 | _iterator11.return();
|
594 | }
|
595 | } finally {
|
596 | if (_didIteratorError11) {
|
597 | throw _iteratorError11;
|
598 | }
|
599 | }
|
600 | }
|
601 | }
|
602 | } catch (err) {
|
603 | _didIteratorError10 = true;
|
604 | _iteratorError10 = err;
|
605 | } finally {
|
606 | try {
|
607 | if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
|
608 | _iterator10.return();
|
609 | }
|
610 | } finally {
|
611 | if (_didIteratorError10) {
|
612 | throw _iteratorError10;
|
613 | }
|
614 | }
|
615 | }
|
616 | }
|
617 |
|
618 | return interfaces;
|
619 | }
|
620 |
|
621 | function extendFieldMap(type) {
|
622 | var newFieldMap = mapValue(type.getFields(), function (field) {
|
623 | return {
|
624 | description: field.description,
|
625 | deprecationReason: field.deprecationReason,
|
626 | type: extendType(field.type),
|
627 | args: extendArgs(field.args),
|
628 | astNode: field.astNode,
|
629 | resolve: field.resolve
|
630 | };
|
631 | });
|
632 |
|
633 | var extensions = typeExtensionsMap[type.name];
|
634 |
|
635 | if (extensions) {
|
636 | var _iteratorNormalCompletion12 = true;
|
637 | var _didIteratorError12 = false;
|
638 | var _iteratorError12 = undefined;
|
639 |
|
640 | try {
|
641 | for (var _iterator12 = extensions[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
|
642 | var extension = _step12.value;
|
643 | var _iteratorNormalCompletion13 = true;
|
644 | var _didIteratorError13 = false;
|
645 | var _iteratorError13 = undefined;
|
646 |
|
647 | try {
|
648 | for (var _iterator13 = extension.fields[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
|
649 | var field = _step13.value;
|
650 | newFieldMap[field.name.value] = astBuilder.buildField(field);
|
651 | }
|
652 | } catch (err) {
|
653 | _didIteratorError13 = true;
|
654 | _iteratorError13 = err;
|
655 | } finally {
|
656 | try {
|
657 | if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
|
658 | _iterator13.return();
|
659 | }
|
660 | } finally {
|
661 | if (_didIteratorError13) {
|
662 | throw _iteratorError13;
|
663 | }
|
664 | }
|
665 | }
|
666 | }
|
667 | } catch (err) {
|
668 | _didIteratorError12 = true;
|
669 | _iteratorError12 = err;
|
670 | } finally {
|
671 | try {
|
672 | if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
|
673 | _iterator12.return();
|
674 | }
|
675 | } finally {
|
676 | if (_didIteratorError12) {
|
677 | throw _iteratorError12;
|
678 | }
|
679 | }
|
680 | }
|
681 | }
|
682 |
|
683 | return newFieldMap;
|
684 | }
|
685 |
|
686 | function extendType(typeDef) {
|
687 | if (isListType(typeDef)) {
|
688 | return GraphQLList(extendType(typeDef.ofType));
|
689 | }
|
690 |
|
691 | if (isNonNullType(typeDef)) {
|
692 | return GraphQLNonNull(extendType(typeDef.ofType));
|
693 | }
|
694 |
|
695 | return extendNamedType(typeDef);
|
696 | }
|
697 | } |
\ | No newline at end of file |