mirror of
https://github.com/CamHenlin/MessagesForMacintosh.git
synced 2024-11-26 05:49:24 +00:00
720 lines
26 KiB
JavaScript
720 lines
26 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.extendSchema = extendSchema;
|
|
exports.extendSchemaImpl = extendSchemaImpl;
|
|
exports.getDescription = getDescription;
|
|
|
|
var _objectValues = _interopRequireDefault(require("../polyfills/objectValues.js"));
|
|
|
|
var _keyMap = _interopRequireDefault(require("../jsutils/keyMap.js"));
|
|
|
|
var _inspect = _interopRequireDefault(require("../jsutils/inspect.js"));
|
|
|
|
var _mapValue = _interopRequireDefault(require("../jsutils/mapValue.js"));
|
|
|
|
var _invariant = _interopRequireDefault(require("../jsutils/invariant.js"));
|
|
|
|
var _devAssert = _interopRequireDefault(require("../jsutils/devAssert.js"));
|
|
|
|
var _kinds = require("../language/kinds.js");
|
|
|
|
var _tokenKind = require("../language/tokenKind.js");
|
|
|
|
var _blockString = require("../language/blockString.js");
|
|
|
|
var _predicates = require("../language/predicates.js");
|
|
|
|
var _validate = require("../validation/validate.js");
|
|
|
|
var _values = require("../execution/values.js");
|
|
|
|
var _schema = require("../type/schema.js");
|
|
|
|
var _scalars = require("../type/scalars.js");
|
|
|
|
var _introspection = require("../type/introspection.js");
|
|
|
|
var _directives = require("../type/directives.js");
|
|
|
|
var _definition = require("../type/definition.js");
|
|
|
|
var _valueFromAST = require("./valueFromAST.js");
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
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; }
|
|
|
|
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; }
|
|
|
|
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; }
|
|
|
|
/**
|
|
* Produces a new schema given an existing schema and a document which may
|
|
* contain GraphQL type extensions and definitions. The original schema will
|
|
* remain unaltered.
|
|
*
|
|
* Because a schema represents a graph of references, a schema cannot be
|
|
* extended without effectively making an entire copy. We do not know until it's
|
|
* too late if subgraphs remain unchanged.
|
|
*
|
|
* This algorithm copies the provided schema, applying extensions while
|
|
* producing the copy. The original schema remains unaltered.
|
|
*
|
|
* Accepts options as a third argument:
|
|
*
|
|
* - commentDescriptions:
|
|
* Provide true to use preceding comments as the description.
|
|
*
|
|
*/
|
|
function extendSchema(schema, documentAST, options) {
|
|
(0, _schema.assertSchema)(schema);
|
|
documentAST != null && documentAST.kind === _kinds.Kind.DOCUMENT || (0, _devAssert.default)(0, 'Must provide valid Document AST.');
|
|
|
|
if ((options === null || options === void 0 ? void 0 : options.assumeValid) !== true && (options === null || options === void 0 ? void 0 : options.assumeValidSDL) !== true) {
|
|
(0, _validate.assertValidSDLExtension)(documentAST, schema);
|
|
}
|
|
|
|
var schemaConfig = schema.toConfig();
|
|
var extendedConfig = extendSchemaImpl(schemaConfig, documentAST, options);
|
|
return schemaConfig === extendedConfig ? schema : new _schema.GraphQLSchema(extendedConfig);
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
|
|
|
|
function extendSchemaImpl(schemaConfig, documentAST, options) {
|
|
var _schemaDef, _schemaDef$descriptio, _schemaDef2, _options$assumeValid;
|
|
|
|
// Collect the type definitions and extensions found in the document.
|
|
var typeDefs = [];
|
|
var typeExtensionsMap = Object.create(null); // New directives and types are separate because a directives and types can
|
|
// have the same name. For example, a type named "skip".
|
|
|
|
var directiveDefs = [];
|
|
var schemaDef; // Schema extensions are collected which may add additional operation types.
|
|
|
|
var schemaExtensions = [];
|
|
|
|
for (var _i2 = 0, _documentAST$definiti2 = documentAST.definitions; _i2 < _documentAST$definiti2.length; _i2++) {
|
|
var def = _documentAST$definiti2[_i2];
|
|
|
|
if (def.kind === _kinds.Kind.SCHEMA_DEFINITION) {
|
|
schemaDef = def;
|
|
} else if (def.kind === _kinds.Kind.SCHEMA_EXTENSION) {
|
|
schemaExtensions.push(def);
|
|
} else if ((0, _predicates.isTypeDefinitionNode)(def)) {
|
|
typeDefs.push(def);
|
|
} else if ((0, _predicates.isTypeExtensionNode)(def)) {
|
|
var extendedTypeName = def.name.value;
|
|
var existingTypeExtensions = typeExtensionsMap[extendedTypeName];
|
|
typeExtensionsMap[extendedTypeName] = existingTypeExtensions ? existingTypeExtensions.concat([def]) : [def];
|
|
} else if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) {
|
|
directiveDefs.push(def);
|
|
}
|
|
} // If this document contains no new types, extensions, or directives then
|
|
// return the same unmodified GraphQLSchema instance.
|
|
|
|
|
|
if (Object.keys(typeExtensionsMap).length === 0 && typeDefs.length === 0 && directiveDefs.length === 0 && schemaExtensions.length === 0 && schemaDef == null) {
|
|
return schemaConfig;
|
|
}
|
|
|
|
var typeMap = Object.create(null);
|
|
|
|
for (var _i4 = 0, _schemaConfig$types2 = schemaConfig.types; _i4 < _schemaConfig$types2.length; _i4++) {
|
|
var existingType = _schemaConfig$types2[_i4];
|
|
typeMap[existingType.name] = extendNamedType(existingType);
|
|
}
|
|
|
|
for (var _i6 = 0; _i6 < typeDefs.length; _i6++) {
|
|
var _stdTypeMap$name;
|
|
|
|
var typeNode = typeDefs[_i6];
|
|
var name = typeNode.name.value;
|
|
typeMap[name] = (_stdTypeMap$name = stdTypeMap[name]) !== null && _stdTypeMap$name !== void 0 ? _stdTypeMap$name : buildType(typeNode);
|
|
}
|
|
|
|
var operationTypes = _objectSpread(_objectSpread({
|
|
// Get the extended root operation types.
|
|
query: schemaConfig.query && replaceNamedType(schemaConfig.query),
|
|
mutation: schemaConfig.mutation && replaceNamedType(schemaConfig.mutation),
|
|
subscription: schemaConfig.subscription && replaceNamedType(schemaConfig.subscription)
|
|
}, schemaDef && getOperationTypes([schemaDef])), getOperationTypes(schemaExtensions)); // Then produce and return a Schema config with these types.
|
|
|
|
|
|
return _objectSpread(_objectSpread({
|
|
description: (_schemaDef = schemaDef) === null || _schemaDef === void 0 ? void 0 : (_schemaDef$descriptio = _schemaDef.description) === null || _schemaDef$descriptio === void 0 ? void 0 : _schemaDef$descriptio.value
|
|
}, operationTypes), {}, {
|
|
types: (0, _objectValues.default)(typeMap),
|
|
directives: [].concat(schemaConfig.directives.map(replaceDirective), directiveDefs.map(buildDirective)),
|
|
extensions: undefined,
|
|
astNode: (_schemaDef2 = schemaDef) !== null && _schemaDef2 !== void 0 ? _schemaDef2 : schemaConfig.astNode,
|
|
extensionASTNodes: schemaConfig.extensionASTNodes.concat(schemaExtensions),
|
|
assumeValid: (_options$assumeValid = options === null || options === void 0 ? void 0 : options.assumeValid) !== null && _options$assumeValid !== void 0 ? _options$assumeValid : false
|
|
}); // Below are functions used for producing this schema that have closed over
|
|
// this scope and have access to the schema, cache, and newly defined types.
|
|
|
|
function replaceType(type) {
|
|
if ((0, _definition.isListType)(type)) {
|
|
// $FlowFixMe[incompatible-return]
|
|
return new _definition.GraphQLList(replaceType(type.ofType));
|
|
}
|
|
|
|
if ((0, _definition.isNonNullType)(type)) {
|
|
// $FlowFixMe[incompatible-return]
|
|
return new _definition.GraphQLNonNull(replaceType(type.ofType));
|
|
}
|
|
|
|
return replaceNamedType(type);
|
|
}
|
|
|
|
function replaceNamedType(type) {
|
|
// Note: While this could make early assertions to get the correctly
|
|
// typed values, that would throw immediately while type system
|
|
// validation with validateSchema() will produce more actionable results.
|
|
return typeMap[type.name];
|
|
}
|
|
|
|
function replaceDirective(directive) {
|
|
var config = directive.toConfig();
|
|
return new _directives.GraphQLDirective(_objectSpread(_objectSpread({}, config), {}, {
|
|
args: (0, _mapValue.default)(config.args, extendArg)
|
|
}));
|
|
}
|
|
|
|
function extendNamedType(type) {
|
|
if ((0, _introspection.isIntrospectionType)(type) || (0, _scalars.isSpecifiedScalarType)(type)) {
|
|
// Builtin types are not extended.
|
|
return type;
|
|
}
|
|
|
|
if ((0, _definition.isScalarType)(type)) {
|
|
return extendScalarType(type);
|
|
}
|
|
|
|
if ((0, _definition.isObjectType)(type)) {
|
|
return extendObjectType(type);
|
|
}
|
|
|
|
if ((0, _definition.isInterfaceType)(type)) {
|
|
return extendInterfaceType(type);
|
|
}
|
|
|
|
if ((0, _definition.isUnionType)(type)) {
|
|
return extendUnionType(type);
|
|
}
|
|
|
|
if ((0, _definition.isEnumType)(type)) {
|
|
return extendEnumType(type);
|
|
} // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2618')
|
|
|
|
|
|
if ((0, _definition.isInputObjectType)(type)) {
|
|
return extendInputObjectType(type);
|
|
} // istanbul ignore next (Not reachable. All possible types have been considered)
|
|
|
|
|
|
false || (0, _invariant.default)(0, 'Unexpected type: ' + (0, _inspect.default)(type));
|
|
}
|
|
|
|
function extendInputObjectType(type) {
|
|
var _typeExtensionsMap$co;
|
|
|
|
var config = type.toConfig();
|
|
var extensions = (_typeExtensionsMap$co = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co !== void 0 ? _typeExtensionsMap$co : [];
|
|
return new _definition.GraphQLInputObjectType(_objectSpread(_objectSpread({}, config), {}, {
|
|
fields: function fields() {
|
|
return _objectSpread(_objectSpread({}, (0, _mapValue.default)(config.fields, function (field) {
|
|
return _objectSpread(_objectSpread({}, field), {}, {
|
|
type: replaceType(field.type)
|
|
});
|
|
})), buildInputFieldMap(extensions));
|
|
},
|
|
extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
|
}));
|
|
}
|
|
|
|
function extendEnumType(type) {
|
|
var _typeExtensionsMap$ty;
|
|
|
|
var config = type.toConfig();
|
|
var extensions = (_typeExtensionsMap$ty = typeExtensionsMap[type.name]) !== null && _typeExtensionsMap$ty !== void 0 ? _typeExtensionsMap$ty : [];
|
|
return new _definition.GraphQLEnumType(_objectSpread(_objectSpread({}, config), {}, {
|
|
values: _objectSpread(_objectSpread({}, config.values), buildEnumValueMap(extensions)),
|
|
extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
|
}));
|
|
}
|
|
|
|
function extendScalarType(type) {
|
|
var _typeExtensionsMap$co2;
|
|
|
|
var config = type.toConfig();
|
|
var extensions = (_typeExtensionsMap$co2 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co2 !== void 0 ? _typeExtensionsMap$co2 : [];
|
|
var specifiedByUrl = config.specifiedByUrl;
|
|
|
|
for (var _i8 = 0; _i8 < extensions.length; _i8++) {
|
|
var _getSpecifiedByUrl;
|
|
|
|
var extensionNode = extensions[_i8];
|
|
specifiedByUrl = (_getSpecifiedByUrl = getSpecifiedByUrl(extensionNode)) !== null && _getSpecifiedByUrl !== void 0 ? _getSpecifiedByUrl : specifiedByUrl;
|
|
}
|
|
|
|
return new _definition.GraphQLScalarType(_objectSpread(_objectSpread({}, config), {}, {
|
|
specifiedByUrl: specifiedByUrl,
|
|
extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
|
}));
|
|
}
|
|
|
|
function extendObjectType(type) {
|
|
var _typeExtensionsMap$co3;
|
|
|
|
var config = type.toConfig();
|
|
var extensions = (_typeExtensionsMap$co3 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co3 !== void 0 ? _typeExtensionsMap$co3 : [];
|
|
return new _definition.GraphQLObjectType(_objectSpread(_objectSpread({}, config), {}, {
|
|
interfaces: function interfaces() {
|
|
return [].concat(type.getInterfaces().map(replaceNamedType), buildInterfaces(extensions));
|
|
},
|
|
fields: function fields() {
|
|
return _objectSpread(_objectSpread({}, (0, _mapValue.default)(config.fields, extendField)), buildFieldMap(extensions));
|
|
},
|
|
extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
|
}));
|
|
}
|
|
|
|
function extendInterfaceType(type) {
|
|
var _typeExtensionsMap$co4;
|
|
|
|
var config = type.toConfig();
|
|
var extensions = (_typeExtensionsMap$co4 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co4 !== void 0 ? _typeExtensionsMap$co4 : [];
|
|
return new _definition.GraphQLInterfaceType(_objectSpread(_objectSpread({}, config), {}, {
|
|
interfaces: function interfaces() {
|
|
return [].concat(type.getInterfaces().map(replaceNamedType), buildInterfaces(extensions));
|
|
},
|
|
fields: function fields() {
|
|
return _objectSpread(_objectSpread({}, (0, _mapValue.default)(config.fields, extendField)), buildFieldMap(extensions));
|
|
},
|
|
extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
|
}));
|
|
}
|
|
|
|
function extendUnionType(type) {
|
|
var _typeExtensionsMap$co5;
|
|
|
|
var config = type.toConfig();
|
|
var extensions = (_typeExtensionsMap$co5 = typeExtensionsMap[config.name]) !== null && _typeExtensionsMap$co5 !== void 0 ? _typeExtensionsMap$co5 : [];
|
|
return new _definition.GraphQLUnionType(_objectSpread(_objectSpread({}, config), {}, {
|
|
types: function types() {
|
|
return [].concat(type.getTypes().map(replaceNamedType), buildUnionTypes(extensions));
|
|
},
|
|
extensionASTNodes: config.extensionASTNodes.concat(extensions)
|
|
}));
|
|
}
|
|
|
|
function extendField(field) {
|
|
return _objectSpread(_objectSpread({}, field), {}, {
|
|
type: replaceType(field.type),
|
|
// $FlowFixMe[incompatible-call]
|
|
args: (0, _mapValue.default)(field.args, extendArg)
|
|
});
|
|
}
|
|
|
|
function extendArg(arg) {
|
|
return _objectSpread(_objectSpread({}, arg), {}, {
|
|
type: replaceType(arg.type)
|
|
});
|
|
}
|
|
|
|
function getOperationTypes(nodes) {
|
|
var opTypes = {};
|
|
|
|
for (var _i10 = 0; _i10 < nodes.length; _i10++) {
|
|
var _node$operationTypes;
|
|
|
|
var node = nodes[_i10];
|
|
// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
|
|
var operationTypesNodes = (_node$operationTypes = node.operationTypes) !== null && _node$operationTypes !== void 0 ? _node$operationTypes : [];
|
|
|
|
for (var _i12 = 0; _i12 < operationTypesNodes.length; _i12++) {
|
|
var operationType = operationTypesNodes[_i12];
|
|
opTypes[operationType.operation] = getNamedType(operationType.type);
|
|
}
|
|
} // Note: While this could make early assertions to get the correctly
|
|
// typed values below, that would throw immediately while type system
|
|
// validation with validateSchema() will produce more actionable results.
|
|
|
|
|
|
return opTypes;
|
|
}
|
|
|
|
function getNamedType(node) {
|
|
var _stdTypeMap$name2;
|
|
|
|
var name = node.name.value;
|
|
var type = (_stdTypeMap$name2 = stdTypeMap[name]) !== null && _stdTypeMap$name2 !== void 0 ? _stdTypeMap$name2 : typeMap[name];
|
|
|
|
if (type === undefined) {
|
|
throw new Error("Unknown type: \"".concat(name, "\"."));
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
function getWrappedType(node) {
|
|
if (node.kind === _kinds.Kind.LIST_TYPE) {
|
|
return new _definition.GraphQLList(getWrappedType(node.type));
|
|
}
|
|
|
|
if (node.kind === _kinds.Kind.NON_NULL_TYPE) {
|
|
return new _definition.GraphQLNonNull(getWrappedType(node.type));
|
|
}
|
|
|
|
return getNamedType(node);
|
|
}
|
|
|
|
function buildDirective(node) {
|
|
var locations = node.locations.map(function (_ref) {
|
|
var value = _ref.value;
|
|
return value;
|
|
});
|
|
return new _directives.GraphQLDirective({
|
|
name: node.name.value,
|
|
description: getDescription(node, options),
|
|
locations: locations,
|
|
isRepeatable: node.repeatable,
|
|
args: buildArgumentMap(node.arguments),
|
|
astNode: node
|
|
});
|
|
}
|
|
|
|
function buildFieldMap(nodes) {
|
|
var fieldConfigMap = Object.create(null);
|
|
|
|
for (var _i14 = 0; _i14 < nodes.length; _i14++) {
|
|
var _node$fields;
|
|
|
|
var node = nodes[_i14];
|
|
// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
|
|
var nodeFields = (_node$fields = node.fields) !== null && _node$fields !== void 0 ? _node$fields : [];
|
|
|
|
for (var _i16 = 0; _i16 < nodeFields.length; _i16++) {
|
|
var field = nodeFields[_i16];
|
|
fieldConfigMap[field.name.value] = {
|
|
// Note: While this could make assertions to get the correctly typed
|
|
// value, that would throw immediately while type system validation
|
|
// with validateSchema() will produce more actionable results.
|
|
type: getWrappedType(field.type),
|
|
description: getDescription(field, options),
|
|
args: buildArgumentMap(field.arguments),
|
|
deprecationReason: getDeprecationReason(field),
|
|
astNode: field
|
|
};
|
|
}
|
|
}
|
|
|
|
return fieldConfigMap;
|
|
}
|
|
|
|
function buildArgumentMap(args) {
|
|
// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
|
|
var argsNodes = args !== null && args !== void 0 ? args : [];
|
|
var argConfigMap = Object.create(null);
|
|
|
|
for (var _i18 = 0; _i18 < argsNodes.length; _i18++) {
|
|
var arg = argsNodes[_i18];
|
|
// Note: While this could make assertions to get the correctly typed
|
|
// value, that would throw immediately while type system validation
|
|
// with validateSchema() will produce more actionable results.
|
|
var type = getWrappedType(arg.type);
|
|
argConfigMap[arg.name.value] = {
|
|
type: type,
|
|
description: getDescription(arg, options),
|
|
defaultValue: (0, _valueFromAST.valueFromAST)(arg.defaultValue, type),
|
|
deprecationReason: getDeprecationReason(arg),
|
|
astNode: arg
|
|
};
|
|
}
|
|
|
|
return argConfigMap;
|
|
}
|
|
|
|
function buildInputFieldMap(nodes) {
|
|
var inputFieldMap = Object.create(null);
|
|
|
|
for (var _i20 = 0; _i20 < nodes.length; _i20++) {
|
|
var _node$fields2;
|
|
|
|
var node = nodes[_i20];
|
|
// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
|
|
var fieldsNodes = (_node$fields2 = node.fields) !== null && _node$fields2 !== void 0 ? _node$fields2 : [];
|
|
|
|
for (var _i22 = 0; _i22 < fieldsNodes.length; _i22++) {
|
|
var field = fieldsNodes[_i22];
|
|
// Note: While this could make assertions to get the correctly typed
|
|
// value, that would throw immediately while type system validation
|
|
// with validateSchema() will produce more actionable results.
|
|
var type = getWrappedType(field.type);
|
|
inputFieldMap[field.name.value] = {
|
|
type: type,
|
|
description: getDescription(field, options),
|
|
defaultValue: (0, _valueFromAST.valueFromAST)(field.defaultValue, type),
|
|
deprecationReason: getDeprecationReason(field),
|
|
astNode: field
|
|
};
|
|
}
|
|
}
|
|
|
|
return inputFieldMap;
|
|
}
|
|
|
|
function buildEnumValueMap(nodes) {
|
|
var enumValueMap = Object.create(null);
|
|
|
|
for (var _i24 = 0; _i24 < nodes.length; _i24++) {
|
|
var _node$values;
|
|
|
|
var node = nodes[_i24];
|
|
// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
|
|
var valuesNodes = (_node$values = node.values) !== null && _node$values !== void 0 ? _node$values : [];
|
|
|
|
for (var _i26 = 0; _i26 < valuesNodes.length; _i26++) {
|
|
var value = valuesNodes[_i26];
|
|
enumValueMap[value.name.value] = {
|
|
description: getDescription(value, options),
|
|
deprecationReason: getDeprecationReason(value),
|
|
astNode: value
|
|
};
|
|
}
|
|
}
|
|
|
|
return enumValueMap;
|
|
}
|
|
|
|
function buildInterfaces(nodes) {
|
|
var interfaces = [];
|
|
|
|
for (var _i28 = 0; _i28 < nodes.length; _i28++) {
|
|
var _node$interfaces;
|
|
|
|
var node = nodes[_i28];
|
|
// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
|
|
var interfacesNodes = (_node$interfaces = node.interfaces) !== null && _node$interfaces !== void 0 ? _node$interfaces : [];
|
|
|
|
for (var _i30 = 0; _i30 < interfacesNodes.length; _i30++) {
|
|
var type = interfacesNodes[_i30];
|
|
// Note: While this could make assertions to get the correctly typed
|
|
// values below, that would throw immediately while type system
|
|
// validation with validateSchema() will produce more actionable
|
|
// results.
|
|
interfaces.push(getNamedType(type));
|
|
}
|
|
}
|
|
|
|
return interfaces;
|
|
}
|
|
|
|
function buildUnionTypes(nodes) {
|
|
var types = [];
|
|
|
|
for (var _i32 = 0; _i32 < nodes.length; _i32++) {
|
|
var _node$types;
|
|
|
|
var node = nodes[_i32];
|
|
// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
|
|
var typeNodes = (_node$types = node.types) !== null && _node$types !== void 0 ? _node$types : [];
|
|
|
|
for (var _i34 = 0; _i34 < typeNodes.length; _i34++) {
|
|
var type = typeNodes[_i34];
|
|
// Note: While this could make assertions to get the correctly typed
|
|
// values below, that would throw immediately while type system
|
|
// validation with validateSchema() will produce more actionable
|
|
// results.
|
|
types.push(getNamedType(type));
|
|
}
|
|
}
|
|
|
|
return types;
|
|
}
|
|
|
|
function buildType(astNode) {
|
|
var _typeExtensionsMap$na;
|
|
|
|
var name = astNode.name.value;
|
|
var description = getDescription(astNode, options);
|
|
var extensionNodes = (_typeExtensionsMap$na = typeExtensionsMap[name]) !== null && _typeExtensionsMap$na !== void 0 ? _typeExtensionsMap$na : [];
|
|
|
|
switch (astNode.kind) {
|
|
case _kinds.Kind.OBJECT_TYPE_DEFINITION:
|
|
{
|
|
var extensionASTNodes = extensionNodes;
|
|
var allNodes = [astNode].concat(extensionASTNodes);
|
|
return new _definition.GraphQLObjectType({
|
|
name: name,
|
|
description: description,
|
|
interfaces: function interfaces() {
|
|
return buildInterfaces(allNodes);
|
|
},
|
|
fields: function fields() {
|
|
return buildFieldMap(allNodes);
|
|
},
|
|
astNode: astNode,
|
|
extensionASTNodes: extensionASTNodes
|
|
});
|
|
}
|
|
|
|
case _kinds.Kind.INTERFACE_TYPE_DEFINITION:
|
|
{
|
|
var _extensionASTNodes = extensionNodes;
|
|
|
|
var _allNodes = [astNode].concat(_extensionASTNodes);
|
|
|
|
return new _definition.GraphQLInterfaceType({
|
|
name: name,
|
|
description: description,
|
|
interfaces: function interfaces() {
|
|
return buildInterfaces(_allNodes);
|
|
},
|
|
fields: function fields() {
|
|
return buildFieldMap(_allNodes);
|
|
},
|
|
astNode: astNode,
|
|
extensionASTNodes: _extensionASTNodes
|
|
});
|
|
}
|
|
|
|
case _kinds.Kind.ENUM_TYPE_DEFINITION:
|
|
{
|
|
var _extensionASTNodes2 = extensionNodes;
|
|
|
|
var _allNodes2 = [astNode].concat(_extensionASTNodes2);
|
|
|
|
return new _definition.GraphQLEnumType({
|
|
name: name,
|
|
description: description,
|
|
values: buildEnumValueMap(_allNodes2),
|
|
astNode: astNode,
|
|
extensionASTNodes: _extensionASTNodes2
|
|
});
|
|
}
|
|
|
|
case _kinds.Kind.UNION_TYPE_DEFINITION:
|
|
{
|
|
var _extensionASTNodes3 = extensionNodes;
|
|
|
|
var _allNodes3 = [astNode].concat(_extensionASTNodes3);
|
|
|
|
return new _definition.GraphQLUnionType({
|
|
name: name,
|
|
description: description,
|
|
types: function types() {
|
|
return buildUnionTypes(_allNodes3);
|
|
},
|
|
astNode: astNode,
|
|
extensionASTNodes: _extensionASTNodes3
|
|
});
|
|
}
|
|
|
|
case _kinds.Kind.SCALAR_TYPE_DEFINITION:
|
|
{
|
|
var _extensionASTNodes4 = extensionNodes;
|
|
return new _definition.GraphQLScalarType({
|
|
name: name,
|
|
description: description,
|
|
specifiedByUrl: getSpecifiedByUrl(astNode),
|
|
astNode: astNode,
|
|
extensionASTNodes: _extensionASTNodes4
|
|
});
|
|
}
|
|
|
|
case _kinds.Kind.INPUT_OBJECT_TYPE_DEFINITION:
|
|
{
|
|
var _extensionASTNodes5 = extensionNodes;
|
|
|
|
var _allNodes4 = [astNode].concat(_extensionASTNodes5);
|
|
|
|
return new _definition.GraphQLInputObjectType({
|
|
name: name,
|
|
description: description,
|
|
fields: function fields() {
|
|
return buildInputFieldMap(_allNodes4);
|
|
},
|
|
astNode: astNode,
|
|
extensionASTNodes: _extensionASTNodes5
|
|
});
|
|
}
|
|
} // istanbul ignore next (Not reachable. All possible type definition nodes have been considered)
|
|
|
|
|
|
false || (0, _invariant.default)(0, 'Unexpected type definition node: ' + (0, _inspect.default)(astNode));
|
|
}
|
|
}
|
|
|
|
var stdTypeMap = (0, _keyMap.default)(_scalars.specifiedScalarTypes.concat(_introspection.introspectionTypes), function (type) {
|
|
return type.name;
|
|
});
|
|
/**
|
|
* Given a field or enum value node, returns the string value for the
|
|
* deprecation reason.
|
|
*/
|
|
|
|
function getDeprecationReason(node) {
|
|
var deprecated = (0, _values.getDirectiveValues)(_directives.GraphQLDeprecatedDirective, node);
|
|
return deprecated === null || deprecated === void 0 ? void 0 : deprecated.reason;
|
|
}
|
|
/**
|
|
* Given a scalar node, returns the string value for the specifiedByUrl.
|
|
*/
|
|
|
|
|
|
function getSpecifiedByUrl(node) {
|
|
var specifiedBy = (0, _values.getDirectiveValues)(_directives.GraphQLSpecifiedByDirective, node);
|
|
return specifiedBy === null || specifiedBy === void 0 ? void 0 : specifiedBy.url;
|
|
}
|
|
/**
|
|
* Given an ast node, returns its string description.
|
|
* @deprecated: provided to ease adoption and will be removed in v16.
|
|
*
|
|
* Accepts options as a second argument:
|
|
*
|
|
* - commentDescriptions:
|
|
* Provide true to use preceding comments as the description.
|
|
*
|
|
*/
|
|
|
|
|
|
function getDescription(node, options) {
|
|
if (node.description) {
|
|
return node.description.value;
|
|
}
|
|
|
|
if ((options === null || options === void 0 ? void 0 : options.commentDescriptions) === true) {
|
|
var rawValue = getLeadingCommentBlock(node);
|
|
|
|
if (rawValue !== undefined) {
|
|
return (0, _blockString.dedentBlockStringValue)('\n' + rawValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
function getLeadingCommentBlock(node) {
|
|
var loc = node.loc;
|
|
|
|
if (!loc) {
|
|
return;
|
|
}
|
|
|
|
var comments = [];
|
|
var token = loc.startToken.prev;
|
|
|
|
while (token != null && token.kind === _tokenKind.TokenKind.COMMENT && token.next && token.prev && token.line + 1 === token.next.line && token.line !== token.prev.line) {
|
|
var value = String(token.value);
|
|
comments.push(value);
|
|
token = token.prev;
|
|
}
|
|
|
|
return comments.length > 0 ? comments.reverse().join('\n') : undefined;
|
|
}
|