1 | function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
|
2 |
|
3 | function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
4 |
|
5 | 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; }
|
6 |
|
7 | import objectValues from "../polyfills/objectValues.mjs";
|
8 | import keyMap from "../jsutils/keyMap.mjs";
|
9 | import inspect from "../jsutils/inspect.mjs";
|
10 | import mapValue from "../jsutils/mapValue.mjs";
|
11 | import invariant from "../jsutils/invariant.mjs";
|
12 | import devAssert from "../jsutils/devAssert.mjs";
|
13 | import { Kind } from "../language/kinds.mjs";
|
14 | import { TokenKind } from "../language/tokenKind.mjs";
|
15 | import { dedentBlockStringValue } from "../language/blockString.mjs";
|
16 | import { isTypeDefinitionNode, isTypeExtensionNode } from "../language/predicates.mjs";
|
17 | import { assertValidSDLExtension } from "../validation/validate.mjs";
|
18 | import { getDirectiveValues } from "../execution/values.mjs";
|
19 | import { assertSchema, GraphQLSchema } from "../type/schema.mjs";
|
20 | import { specifiedScalarTypes, isSpecifiedScalarType } from "../type/scalars.mjs";
|
21 | import { introspectionTypes, isIntrospectionType } from "../type/introspection.mjs";
|
22 | import { GraphQLDirective, GraphQLDeprecatedDirective, GraphQLSpecifiedByDirective } from "../type/directives.mjs";
|
23 | import { isScalarType, isObjectType, isInterfaceType, isUnionType, isListType, isNonNullType, isEnumType, isInputObjectType, GraphQLList, GraphQLNonNull, GraphQLScalarType, GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType, GraphQLEnumType, GraphQLInputObjectType } from "../type/definition.mjs";
|
24 | import { valueFromAST } from "./valueFromAST.mjs";
|
25 |
|
26 |
|
27 |
|
28 |
|
29 |
|
30 |
|
31 |
|
32 |
|
33 |
|
34 |
|
35 |
|
36 |
|
37 |
|
38 |
|
39 |
|
40 |
|
41 |
|
42 |
|
43 |
|
44 | export function extendSchema(schema, documentAST, options) {
|
45 | assertSchema(schema);
|
46 | documentAST != null && documentAST.kind === Kind.DOCUMENT || devAssert(0, 'Must provide valid Document AST.');
|
47 |
|
48 | if ((options === null || options === void 0 ? void 0 : options.assumeValid) !== true && (options === null || options === void 0 ? void 0 : options.assumeValidSDL) !== true) {
|
49 | assertValidSDLExtension(documentAST, schema);
|
50 | }
|
51 |
|
52 | var schemaConfig = schema.toConfig();
|
53 | var extendedConfig = extendSchemaImpl(schemaConfig, documentAST, options);
|
54 | return schemaConfig === extendedConfig ? schema : new GraphQLSchema(extendedConfig);
|
55 | }
|
56 |
|
57 |
|
58 |
|
59 |
|
60 | export function extendSchemaImpl(schemaConfig, documentAST, options) {
|
61 | var _schemaDef, _schemaDef$descriptio, _schemaDef2, _options$assumeValid;
|
62 |
|
63 |
|
64 | var typeDefs = [];
|
65 | var typeExtensionsMap = Object.create(null);
|
66 |
|
67 |
|
68 | var directiveDefs = [];
|
69 | var schemaDef;
|
70 |
|
71 | var schemaExtensions = [];
|
72 |
|
73 | for (var _i2 = 0, _documentAST$definiti2 = documentAST.definitions; _i2 < _documentAST$definiti2.length; _i2++) {
|
74 | var def = _documentAST$definiti2[_i2];
|
75 |
|
76 | if (def.kind === Kind.SCHEMA_DEFINITION) {
|
77 | schemaDef = def;
|
78 | } else if (def.kind === Kind.SCHEMA_EXTENSION) {
|
79 | schemaExtensions.push(def);
|
80 | } else if (isTypeDefinitionNode(def)) {
|
81 | typeDefs.push(def);
|
82 | } else if (isTypeExtensionNode(def)) {
|
83 | var extendedTypeName = def.name.value;
|
84 | var existingTypeExtensions = typeExtensionsMap[extendedTypeName];
|
85 | typeExtensionsMap[extendedTypeName] = existingTypeExtensions ? existingTypeExtensions.concat([def]) : [def];
|
86 | } else if (def.kind === Kind.DIRECTIVE_DEFINITION) {
|
87 | directiveDefs.push(def);
|
88 | }
|
89 | }
|
90 |
|
91 |
|
92 |
|
93 | if (Object.keys(typeExtensionsMap).length === 0 && typeDefs.length === 0 && directiveDefs.length === 0 && schemaExtensions.length === 0 && schemaDef == null) {
|
94 | return schemaConfig;
|
95 | }
|
96 |
|
97 | var typeMap = Object.create(null);
|
98 |
|
99 | for (var _i4 = 0, _schemaConfig$types2 = schemaConfig.types; _i4 < _schemaConfig$types2.length; _i4++) {
|
100 | var existingType = _schemaConfig$types2[_i4];
|
101 | typeMap[existingType.name] = extendNamedType(existingType);
|
102 | }
|
103 |
|
104 | for (var _i6 = 0; _i6 < typeDefs.length; _i6++) {
|
105 | var _stdTypeMap$name;
|
106 |
|
107 | var typeNode = typeDefs[_i6];
|
108 | var name = typeNode.name.value;
|
109 | typeMap[name] = (_stdTypeMap$name = stdTypeMap[name]) !== null && _stdTypeMap$name !== void 0 ? _stdTypeMap$name : buildType(typeNode);
|
110 | }
|
111 |
|
112 | var operationTypes = _objectSpread(_objectSpread({
|
113 |
|
114 | query: schemaConfig.query && replaceNamedType(schemaConfig.query),
|
115 | mutation: schemaConfig.mutation && replaceNamedType(schemaConfig.mutation),
|
116 | subscription: schemaConfig.subscription && replaceNamedType(schemaConfig.subscription)
|
117 | }, schemaDef && getOperationTypes([schemaDef])), getOperationTypes(schemaExtensions));
|
118 |
|
119 |
|
120 | return _objectSpread(_objectSpread({
|
121 | description: (_schemaDef = schemaDef) === null || _schemaDef === void 0 ? void 0 : (_schemaDef$descriptio = _schemaDef.description) === null || _schemaDef$descriptio === void 0 ? void 0 : _schemaDef$descriptio.value
|
122 | }, operationTypes), {}, {
|
123 | types: objectValues(typeMap),
|
124 | directives: [].concat(schemaConfig.directives.map(replaceDirective), directiveDefs.map(buildDirective)),
|
125 | extensions: undefined,
|
126 | astNode: (_schemaDef2 = schemaDef) !== null && _schemaDef2 !== void 0 ? _schemaDef2 : schemaConfig.astNode,
|
127 | extensionASTNodes: schemaConfig.extensionASTNodes.concat(schemaExtensions),
|
128 | assumeValid: (_options$assumeValid = options === null || options === void 0 ? void 0 : options.assumeValid) !== null && _options$assumeValid !== void 0 ? _options$assumeValid : false
|
129 | });
|
130 |
|
131 |
|
132 | function replaceType(type) {
|
133 | if (isListType(type)) {
|
134 |
|
135 | return new GraphQLList(replaceType(type.ofType));
|
136 | }
|
137 |
|
138 | if (isNonNullType(type)) {
|
139 |
|
140 | return new GraphQLNonNull(replaceType(type.ofType));
|
141 | }
|
142 |
|
143 | return replaceNamedType(type);
|
144 | }
|
145 |
|
146 | function replaceNamedType(type) {
|
147 |
|
148 |
|
149 |
|
150 | return typeMap[type.name];
|
151 | }
|
152 |
|
153 | function replaceDirective(directive) {
|
154 | var config = directive.toConfig();
|
155 | return new GraphQLDirective(_objectSpread(_objectSpread({}, config), {}, {
|
156 | args: mapValue(config.args, extendArg)
|
157 | }));
|
158 | }
|
159 |
|
160 | function extendNamedType(type) {
|
161 | if (isIntrospectionType(type) || isSpecifiedScalarType(type)) {
|
162 |
|
163 | return type;
|
164 | }
|
165 |
|
166 | if (isScalarType(type)) {
|
167 | return extendScalarType(type);
|
168 | }
|
169 |
|
170 | if (isObjectType(type)) {
|
171 | return extendObjectType(type);
|
172 | }
|
173 |
|
174 | if (isInterfaceType(type)) {
|
175 | return extendInterfaceType(type);
|
176 | }
|
177 |
|
178 | if (isUnionType(type)) {
|
179 | return extendUnionType(type);
|
180 | }
|
181 |
|
182 | if (isEnumType(type)) {
|
183 | return extendEnumType(type);
|
184 | }
|
185 |
|
186 |
|
187 | if (isInputObjectType(type)) {
|
188 | return extendInputObjectType(type);
|
189 | }
|
190 |
|
191 |
|
192 | false || invariant(0, 'Unexpected type: ' + inspect(type));
|
193 | }
|
194 |
|
195 | function extendInputObjectType(type) {
|
196 | var _typeExtensionsMap$co;
|
197 |
|
198 | var config = type.toConfig();
|
199 | var extensions = (_typeExtensionsMap$co = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co !== void 0 ? _typeExtensionsMap$co : [];
|
200 | return new GraphQLInputObjectType(_objectSpread(_objectSpread({}, config), {}, {
|
201 | fields: function fields() {
|
202 | return _objectSpread(_objectSpread({}, mapValue(config.fields, function (field) {
|
203 | return _objectSpread(_objectSpread({}, field), {}, {
|
204 | type: replaceType(field.type)
|
205 | });
|
206 | })), buildInputFieldMap(extensions));
|
207 | },
|
208 | extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
209 | }));
|
210 | }
|
211 |
|
212 | function extendEnumType(type) {
|
213 | var _typeExtensionsMap$ty;
|
214 |
|
215 | var config = type.toConfig();
|
216 | var extensions = (_typeExtensionsMap$ty = typeExtensionsMap[type.name]) !== null && _typeExtensionsMap$ty !== void 0 ? _typeExtensionsMap$ty : [];
|
217 | return new GraphQLEnumType(_objectSpread(_objectSpread({}, config), {}, {
|
218 | values: _objectSpread(_objectSpread({}, config.values), buildEnumValueMap(extensions)),
|
219 | extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
220 | }));
|
221 | }
|
222 |
|
223 | function extendScalarType(type) {
|
224 | var _typeExtensionsMap$co2;
|
225 |
|
226 | var config = type.toConfig();
|
227 | var extensions = (_typeExtensionsMap$co2 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co2 !== void 0 ? _typeExtensionsMap$co2 : [];
|
228 | var specifiedByUrl = config.specifiedByUrl;
|
229 |
|
230 | for (var _i8 = 0; _i8 < extensions.length; _i8++) {
|
231 | var _getSpecifiedByUrl;
|
232 |
|
233 | var extensionNode = extensions[_i8];
|
234 | specifiedByUrl = (_getSpecifiedByUrl = getSpecifiedByUrl(extensionNode)) !== null && _getSpecifiedByUrl !== void 0 ? _getSpecifiedByUrl : specifiedByUrl;
|
235 | }
|
236 |
|
237 | return new GraphQLScalarType(_objectSpread(_objectSpread({}, config), {}, {
|
238 | specifiedByUrl: specifiedByUrl,
|
239 | extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
240 | }));
|
241 | }
|
242 |
|
243 | function extendObjectType(type) {
|
244 | var _typeExtensionsMap$co3;
|
245 |
|
246 | var config = type.toConfig();
|
247 | var extensions = (_typeExtensionsMap$co3 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co3 !== void 0 ? _typeExtensionsMap$co3 : [];
|
248 | return new GraphQLObjectType(_objectSpread(_objectSpread({}, config), {}, {
|
249 | interfaces: function interfaces() {
|
250 | return [].concat(type.getInterfaces().map(replaceNamedType), buildInterfaces(extensions));
|
251 | },
|
252 | fields: function fields() {
|
253 | return _objectSpread(_objectSpread({}, mapValue(config.fields, extendField)), buildFieldMap(extensions));
|
254 | },
|
255 | extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
256 | }));
|
257 | }
|
258 |
|
259 | function extendInterfaceType(type) {
|
260 | var _typeExtensionsMap$co4;
|
261 |
|
262 | var config = type.toConfig();
|
263 | var extensions = (_typeExtensionsMap$co4 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co4 !== void 0 ? _typeExtensionsMap$co4 : [];
|
264 | return new GraphQLInterfaceType(_objectSpread(_objectSpread({}, config), {}, {
|
265 | interfaces: function interfaces() {
|
266 | return [].concat(type.getInterfaces().map(replaceNamedType), buildInterfaces(extensions));
|
267 | },
|
268 | fields: function fields() {
|
269 | return _objectSpread(_objectSpread({}, mapValue(config.fields, extendField)), buildFieldMap(extensions));
|
270 | },
|
271 | extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
272 | }));
|
273 | }
|
274 |
|
275 | function extendUnionType(type) {
|
276 | var _typeExtensionsMap$co5;
|
277 |
|
278 | var config = type.toConfig();
|
279 | var extensions = (_typeExtensionsMap$co5 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co5 !== void 0 ? _typeExtensionsMap$co5 : [];
|
280 | return new GraphQLUnionType(_objectSpread(_objectSpread({}, config), {}, {
|
281 | types: function types() {
|
282 | return [].concat(type.getTypes().map(replaceNamedType), buildUnionTypes(extensions));
|
283 | },
|
284 | extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
285 | }));
|
286 | }
|
287 |
|
288 | function extendField(field) {
|
289 | return _objectSpread(_objectSpread({}, field), {}, {
|
290 | type: replaceType(field.type),
|
291 |
|
292 | args: mapValue(field.args, extendArg)
|
293 | });
|
294 | }
|
295 |
|
296 | function extendArg(arg) {
|
297 | return _objectSpread(_objectSpread({}, arg), {}, {
|
298 | type: replaceType(arg.type)
|
299 | });
|
300 | }
|
301 |
|
302 | function getOperationTypes(nodes) {
|
303 | var opTypes = {};
|
304 |
|
305 | for (var _i10 = 0; _i10 < nodes.length; _i10++) {
|
306 | var _node$operationTypes;
|
307 |
|
308 | var node = nodes[_i10];
|
309 |
|
310 | var operationTypesNodes = (_node$operationTypes = node.operationTypes) !== null && _node$operationTypes !== void 0 ? _node$operationTypes : [];
|
311 |
|
312 | for (var _i12 = 0; _i12 < operationTypesNodes.length; _i12++) {
|
313 | var operationType = operationTypesNodes[_i12];
|
314 | opTypes[operationType.operation] = getNamedType(operationType.type);
|
315 | }
|
316 | }
|
317 |
|
318 |
|
319 |
|
320 |
|
321 | return opTypes;
|
322 | }
|
323 |
|
324 | function getNamedType(node) {
|
325 | var _stdTypeMap$name2;
|
326 |
|
327 | var name = node.name.value;
|
328 | var type = (_stdTypeMap$name2 = stdTypeMap[name]) !== null && _stdTypeMap$name2 !== void 0 ? _stdTypeMap$name2 : typeMap[name];
|
329 |
|
330 | if (type === undefined) {
|
331 | throw new Error("Unknown type: \"".concat(name, "\"."));
|
332 | }
|
333 |
|
334 | return type;
|
335 | }
|
336 |
|
337 | function getWrappedType(node) {
|
338 | if (node.kind === Kind.LIST_TYPE) {
|
339 | return new GraphQLList(getWrappedType(node.type));
|
340 | }
|
341 |
|
342 | if (node.kind === Kind.NON_NULL_TYPE) {
|
343 | return new GraphQLNonNull(getWrappedType(node.type));
|
344 | }
|
345 |
|
346 | return getNamedType(node);
|
347 | }
|
348 |
|
349 | function buildDirective(node) {
|
350 | var locations = node.locations.map(function (_ref) {
|
351 | var value = _ref.value;
|
352 | return value;
|
353 | });
|
354 | return new GraphQLDirective({
|
355 | name: node.name.value,
|
356 | description: getDescription(node, options),
|
357 | locations: locations,
|
358 | isRepeatable: node.repeatable,
|
359 | args: buildArgumentMap(node.arguments),
|
360 | astNode: node
|
361 | });
|
362 | }
|
363 |
|
364 | function buildFieldMap(nodes) {
|
365 | var fieldConfigMap = Object.create(null);
|
366 |
|
367 | for (var _i14 = 0; _i14 < nodes.length; _i14++) {
|
368 | var _node$fields;
|
369 |
|
370 | var node = nodes[_i14];
|
371 |
|
372 | var nodeFields = (_node$fields = node.fields) !== null && _node$fields !== void 0 ? _node$fields : [];
|
373 |
|
374 | for (var _i16 = 0; _i16 < nodeFields.length; _i16++) {
|
375 | var field = nodeFields[_i16];
|
376 | fieldConfigMap[field.name.value] = {
|
377 |
|
378 |
|
379 |
|
380 | type: getWrappedType(field.type),
|
381 | description: getDescription(field, options),
|
382 | args: buildArgumentMap(field.arguments),
|
383 | deprecationReason: getDeprecationReason(field),
|
384 | astNode: field
|
385 | };
|
386 | }
|
387 | }
|
388 |
|
389 | return fieldConfigMap;
|
390 | }
|
391 |
|
392 | function buildArgumentMap(args) {
|
393 |
|
394 | var argsNodes = args !== null && args !== void 0 ? args : [];
|
395 | var argConfigMap = Object.create(null);
|
396 |
|
397 | for (var _i18 = 0; _i18 < argsNodes.length; _i18++) {
|
398 | var arg = argsNodes[_i18];
|
399 |
|
400 |
|
401 |
|
402 | var type = getWrappedType(arg.type);
|
403 | argConfigMap[arg.name.value] = {
|
404 | type: type,
|
405 | description: getDescription(arg, options),
|
406 | defaultValue: valueFromAST(arg.defaultValue, type),
|
407 | deprecationReason: getDeprecationReason(arg),
|
408 | astNode: arg
|
409 | };
|
410 | }
|
411 |
|
412 | return argConfigMap;
|
413 | }
|
414 |
|
415 | function buildInputFieldMap(nodes) {
|
416 | var inputFieldMap = Object.create(null);
|
417 |
|
418 | for (var _i20 = 0; _i20 < nodes.length; _i20++) {
|
419 | var _node$fields2;
|
420 |
|
421 | var node = nodes[_i20];
|
422 |
|
423 | var fieldsNodes = (_node$fields2 = node.fields) !== null && _node$fields2 !== void 0 ? _node$fields2 : [];
|
424 |
|
425 | for (var _i22 = 0; _i22 < fieldsNodes.length; _i22++) {
|
426 | var field = fieldsNodes[_i22];
|
427 |
|
428 |
|
429 |
|
430 | var type = getWrappedType(field.type);
|
431 | inputFieldMap[field.name.value] = {
|
432 | type: type,
|
433 | description: getDescription(field, options),
|
434 | defaultValue: valueFromAST(field.defaultValue, type),
|
435 | deprecationReason: getDeprecationReason(field),
|
436 | astNode: field
|
437 | };
|
438 | }
|
439 | }
|
440 |
|
441 | return inputFieldMap;
|
442 | }
|
443 |
|
444 | function buildEnumValueMap(nodes) {
|
445 | var enumValueMap = Object.create(null);
|
446 |
|
447 | for (var _i24 = 0; _i24 < nodes.length; _i24++) {
|
448 | var _node$values;
|
449 |
|
450 | var node = nodes[_i24];
|
451 |
|
452 | var valuesNodes = (_node$values = node.values) !== null && _node$values !== void 0 ? _node$values : [];
|
453 |
|
454 | for (var _i26 = 0; _i26 < valuesNodes.length; _i26++) {
|
455 | var value = valuesNodes[_i26];
|
456 | enumValueMap[value.name.value] = {
|
457 | description: getDescription(value, options),
|
458 | deprecationReason: getDeprecationReason(value),
|
459 | astNode: value
|
460 | };
|
461 | }
|
462 | }
|
463 |
|
464 | return enumValueMap;
|
465 | }
|
466 |
|
467 | function buildInterfaces(nodes) {
|
468 | var interfaces = [];
|
469 |
|
470 | for (var _i28 = 0; _i28 < nodes.length; _i28++) {
|
471 | var _node$interfaces;
|
472 |
|
473 | var node = nodes[_i28];
|
474 |
|
475 | var interfacesNodes = (_node$interfaces = node.interfaces) !== null && _node$interfaces !== void 0 ? _node$interfaces : [];
|
476 |
|
477 | for (var _i30 = 0; _i30 < interfacesNodes.length; _i30++) {
|
478 | var type = interfacesNodes[_i30];
|
479 |
|
480 |
|
481 |
|
482 |
|
483 | interfaces.push(getNamedType(type));
|
484 | }
|
485 | }
|
486 |
|
487 | return interfaces;
|
488 | }
|
489 |
|
490 | function buildUnionTypes(nodes) {
|
491 | var types = [];
|
492 |
|
493 | for (var _i32 = 0; _i32 < nodes.length; _i32++) {
|
494 | var _node$types;
|
495 |
|
496 | var node = nodes[_i32];
|
497 |
|
498 | var typeNodes = (_node$types = node.types) !== null && _node$types !== void 0 ? _node$types : [];
|
499 |
|
500 | for (var _i34 = 0; _i34 < typeNodes.length; _i34++) {
|
501 | var type = typeNodes[_i34];
|
502 |
|
503 |
|
504 |
|
505 |
|
506 | types.push(getNamedType(type));
|
507 | }
|
508 | }
|
509 |
|
510 | return types;
|
511 | }
|
512 |
|
513 | function buildType(astNode) {
|
514 | var _typeExtensionsMap$na;
|
515 |
|
516 | var name = astNode.name.value;
|
517 | var description = getDescription(astNode, options);
|
518 | var extensionNodes = (_typeExtensionsMap$na = typeExtensionsMap[name]) !== null && _typeExtensionsMap$na !== void 0 ? _typeExtensionsMap$na : [];
|
519 |
|
520 | switch (astNode.kind) {
|
521 | case Kind.OBJECT_TYPE_DEFINITION:
|
522 | {
|
523 | var extensionASTNodes = extensionNodes;
|
524 | var allNodes = [astNode].concat(extensionASTNodes);
|
525 | return new GraphQLObjectType({
|
526 | name: name,
|
527 | description: description,
|
528 | interfaces: function interfaces() {
|
529 | return buildInterfaces(allNodes);
|
530 | },
|
531 | fields: function fields() {
|
532 | return buildFieldMap(allNodes);
|
533 | },
|
534 | astNode: astNode,
|
535 | extensionASTNodes: extensionASTNodes
|
536 | });
|
537 | }
|
538 |
|
539 | case Kind.INTERFACE_TYPE_DEFINITION:
|
540 | {
|
541 | var _extensionASTNodes = extensionNodes;
|
542 |
|
543 | var _allNodes = [astNode].concat(_extensionASTNodes);
|
544 |
|
545 | return new GraphQLInterfaceType({
|
546 | name: name,
|
547 | description: description,
|
548 | interfaces: function interfaces() {
|
549 | return buildInterfaces(_allNodes);
|
550 | },
|
551 | fields: function fields() {
|
552 | return buildFieldMap(_allNodes);
|
553 | },
|
554 | astNode: astNode,
|
555 | extensionASTNodes: _extensionASTNodes
|
556 | });
|
557 | }
|
558 |
|
559 | case Kind.ENUM_TYPE_DEFINITION:
|
560 | {
|
561 | var _extensionASTNodes2 = extensionNodes;
|
562 |
|
563 | var _allNodes2 = [astNode].concat(_extensionASTNodes2);
|
564 |
|
565 | return new GraphQLEnumType({
|
566 | name: name,
|
567 | description: description,
|
568 | values: buildEnumValueMap(_allNodes2),
|
569 | astNode: astNode,
|
570 | extensionASTNodes: _extensionASTNodes2
|
571 | });
|
572 | }
|
573 |
|
574 | case Kind.UNION_TYPE_DEFINITION:
|
575 | {
|
576 | var _extensionASTNodes3 = extensionNodes;
|
577 |
|
578 | var _allNodes3 = [astNode].concat(_extensionASTNodes3);
|
579 |
|
580 | return new GraphQLUnionType({
|
581 | name: name,
|
582 | description: description,
|
583 | types: function types() {
|
584 | return buildUnionTypes(_allNodes3);
|
585 | },
|
586 | astNode: astNode,
|
587 | extensionASTNodes: _extensionASTNodes3
|
588 | });
|
589 | }
|
590 |
|
591 | case Kind.SCALAR_TYPE_DEFINITION:
|
592 | {
|
593 | var _extensionASTNodes4 = extensionNodes;
|
594 | return new GraphQLScalarType({
|
595 | name: name,
|
596 | description: description,
|
597 | specifiedByUrl: getSpecifiedByUrl(astNode),
|
598 | astNode: astNode,
|
599 | extensionASTNodes: _extensionASTNodes4
|
600 | });
|
601 | }
|
602 |
|
603 | case Kind.INPUT_OBJECT_TYPE_DEFINITION:
|
604 | {
|
605 | var _extensionASTNodes5 = extensionNodes;
|
606 |
|
607 | var _allNodes4 = [astNode].concat(_extensionASTNodes5);
|
608 |
|
609 | return new GraphQLInputObjectType({
|
610 | name: name,
|
611 | description: description,
|
612 | fields: function fields() {
|
613 | return buildInputFieldMap(_allNodes4);
|
614 | },
|
615 | astNode: astNode,
|
616 | extensionASTNodes: _extensionASTNodes5
|
617 | });
|
618 | }
|
619 | }
|
620 |
|
621 |
|
622 | false || invariant(0, 'Unexpected type definition node: ' + inspect(astNode));
|
623 | }
|
624 | }
|
625 | var stdTypeMap = keyMap(specifiedScalarTypes.concat(introspectionTypes), function (type) {
|
626 | return type.name;
|
627 | });
|
628 |
|
629 |
|
630 |
|
631 |
|
632 |
|
633 | function getDeprecationReason(node) {
|
634 | var deprecated = getDirectiveValues(GraphQLDeprecatedDirective, node);
|
635 | return deprecated === null || deprecated === void 0 ? void 0 : deprecated.reason;
|
636 | }
|
637 |
|
638 |
|
639 |
|
640 |
|
641 |
|
642 | function getSpecifiedByUrl(node) {
|
643 | var specifiedBy = getDirectiveValues(GraphQLSpecifiedByDirective, node);
|
644 | return specifiedBy === null || specifiedBy === void 0 ? void 0 : specifiedBy.url;
|
645 | }
|
646 |
|
647 |
|
648 |
|
649 |
|
650 |
|
651 |
|
652 |
|
653 |
|
654 |
|
655 |
|
656 |
|
657 |
|
658 | export function getDescription(node, options) {
|
659 | if (node.description) {
|
660 | return node.description.value;
|
661 | }
|
662 |
|
663 | if ((options === null || options === void 0 ? void 0 : options.commentDescriptions) === true) {
|
664 | var rawValue = getLeadingCommentBlock(node);
|
665 |
|
666 | if (rawValue !== undefined) {
|
667 | return dedentBlockStringValue('\n' + rawValue);
|
668 | }
|
669 | }
|
670 | }
|
671 |
|
672 | function getLeadingCommentBlock(node) {
|
673 | var loc = node.loc;
|
674 |
|
675 | if (!loc) {
|
676 | return;
|
677 | }
|
678 |
|
679 | var comments = [];
|
680 | var token = loc.startToken.prev;
|
681 |
|
682 | while (token != null && token.kind === TokenKind.COMMENT && token.next && token.prev && token.line + 1 === token.next.line && token.line !== token.prev.line) {
|
683 | var value = String(token.value);
|
684 | comments.push(value);
|
685 | token = token.prev;
|
686 | }
|
687 |
|
688 | return comments.length > 0 ? comments.reverse().join('\n') : undefined;
|
689 | }
|