graphql

TypesSource
Search for an npm package
import { devAssert } from '../jsutils/devAssert.mjs';
import { inspect } from '../jsutils/inspect.mjs';
import { invariant } from '../jsutils/invariant.mjs';
import { keyMap } from '../jsutils/keyMap.mjs';
import { mapValue } from '../jsutils/mapValue.mjs';
import { Kind } from '../language/kinds.mjs';
import {
isTypeDefinitionNode,
isTypeExtensionNode,
} from '../language/predicates.mjs';
import {
GraphQLEnumType,
GraphQLInputObjectType,
GraphQLInterfaceType,
GraphQLList,
GraphQLNonNull,
GraphQLObjectType,
GraphQLScalarType,
GraphQLUnionType,
isEnumType,
isInputObjectType,
isInterfaceType,
isListType,
isNonNullType,
isObjectType,
isScalarType,
isUnionType,
} from '../type/definition.mjs';
import {
GraphQLDeprecatedDirective,
GraphQLDirective,
GraphQLOneOfDirective,
GraphQLSpecifiedByDirective,
} from '../type/directives.mjs';
import {
introspectionTypes,
isIntrospectionType,
} from '../type/introspection.mjs';
import {
isSpecifiedScalarType,
specifiedScalarTypes,
} from '../type/scalars.mjs';
import { assertSchema, GraphQLSchema } from '../type/schema.mjs';
import { assertValidSDLExtension } from '../validation/validate.mjs';
import { getDirectiveValues } from '../execution/values.mjs';
import { valueFromAST } from './valueFromAST.mjs';
/**
* 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.
*/
export function extendSchema(schema, documentAST, options) {
assertSchema(schema);
(documentAST != null && documentAST.kind === Kind.DOCUMENT) ||
devAssert(false, '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
) {
assertValidSDLExtension(documentAST, schema);
}
const schemaConfig = schema.toConfig();
const extendedConfig = extendSchemaImpl(schemaConfig, documentAST, options);
return schemaConfig === extendedConfig
? schema
: new GraphQLSchema(extendedConfig);
}
/**
* @internal
*/
export function extendSchemaImpl(schemaConfig, documentAST, options) {
var _schemaDef, _schemaDef$descriptio, _schemaDef2, _options$assumeValid;
// Collect the type definitions and extensions found in the document.
const typeDefs = [];
const 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".
const directiveDefs = [];
let schemaDef; // Schema extensions are collected which may add additional operation types.
const schemaExtensions = [];
for (const def of documentAST.definitions) {
if (def.kind === Kind.SCHEMA_DEFINITION) {
schemaDef = def;
} else if (def.kind === Kind.SCHEMA_EXTENSION) {
schemaExtensions.push(def);
} else if (isTypeDefinitionNode(def)) {
typeDefs.push(def);
} else if (isTypeExtensionNode(def)) {
const extendedTypeName = def.name.value;
const existingTypeExtensions = typeExtensionsMap[extendedTypeName];
typeExtensionsMap[extendedTypeName] = existingTypeExtensions
? existingTypeExtensions.concat([def])
: [def];
} else if (def.kind === 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;
}
const typeMap = Object.create(null);
for (const existingType of schemaConfig.types) {
typeMap[existingType.name] = extendNamedType(existingType);
}
for (const typeNode of typeDefs) {
var _stdTypeMap$name;
const name = typeNode.name.value;
typeMap[name] =
(_stdTypeMap$name = stdTypeMap[name]) !== null &&
_stdTypeMap$name !== void 0
? _stdTypeMap$name
: buildType(typeNode);
}
const operationTypes = {
// Get the extended root operation types.
query: schemaConfig.query && replaceNamedType(schemaConfig.query),
mutation: schemaConfig.mutation && replaceNamedType(schemaConfig.mutation),
subscription:
schemaConfig.subscription && replaceNamedType(schemaConfig.subscription),
// Then, incorporate schema definition and all schema extensions.
...(schemaDef && getOperationTypes([schemaDef])),
...getOperationTypes(schemaExtensions),
}; // Then produce and return a Schema config with these types.
return {
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: Object.values(typeMap),
directives: [
...schemaConfig.directives.map(replaceDirective),
...directiveDefs.map(buildDirective),
],
extensions: Object.create(null),
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 (isListType(type)) {
// @ts-expect-error
return new GraphQLList(replaceType(type.ofType));
}
if (isNonNullType(type)) {
// @ts-expect-error
return new GraphQLNonNull(replaceType(type.ofType));
} // @ts-expect-error FIXME
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) {
const config = directive.toConfig();
return new GraphQLDirective({
...config,
args: mapValue(config.args, extendArg),
});
}
function extendNamedType(type) {
if (isIntrospectionType(type) || isSpecifiedScalarType(type)) {
// Builtin types are not extended.
return type;
}
if (isScalarType(type)) {
return extendScalarType(type);
}
if (isObjectType(type)) {
return extendObjectType(type);
}
if (isInterfaceType(type)) {
return extendInterfaceType(type);
}
if (isUnionType(type)) {
return extendUnionType(type);
}
if (isEnumType(type)) {
return extendEnumType(type);
}
if (isInputObjectType(type)) {
return extendInputObjectType(type);
}
/* c8 ignore next 3 */
// Not reachable, all possible type definition nodes have been considered.
false || invariant(false, 'Unexpected type: ' + inspect(type));
}
function extendInputObjectType(type) {
var _typeExtensionsMap$co;
const config = type.toConfig();
const extensions =
(_typeExtensionsMap$co = typeExtensionsMap[config.name]) !== null &&
_typeExtensionsMap$co !== void 0
? _typeExtensionsMap$co
: [];
return new GraphQLInputObjectType({
...config,
fields: () => ({
...mapValue(config.fields, (field) => ({
...field,
type: replaceType(field.type),
})),
...buildInputFieldMap(extensions),
}),
extensionASTNodes: config.extensionASTNodes.concat(extensions),
});
}
function extendEnumType(type) {
var _typeExtensionsMap$ty;
const config = type.toConfig();
const extensions =
(_typeExtensionsMap$ty = typeExtensionsMap[type.name]) !== null &&
_typeExtensionsMap$ty !== void 0
? _typeExtensionsMap$ty
: [];
return new GraphQLEnumType({
...config,
values: { ...config.values, ...buildEnumValueMap(extensions) },
extensionASTNodes: config.extensionASTNodes.concat(extensions),
});
}
function extendScalarType(type) {
var _typeExtensionsMap$co2;
const config = type.toConfig();
const extensions =
(_typeExtensionsMap$co2 = typeExtensionsMap[config.name]) !== null &&
_typeExtensionsMap$co2 !== void 0
? _typeExtensionsMap$co2
: [];
let specifiedByURL = config.specifiedByURL;
for (const extensionNode of extensions) {
var _getSpecifiedByURL;
specifiedByURL =
(_getSpecifiedByURL = getSpecifiedByURL(extensionNode)) !== null &&
_getSpecifiedByURL !== void 0
? _getSpecifiedByURL
: specifiedByURL;
}
return new GraphQLScalarType({
...config,
specifiedByURL,
extensionASTNodes: config.extensionASTNodes.concat(extensions),
});
}
function extendObjectType(type) {
var _typeExtensionsMap$co3;
const config = type.toConfig();
const extensions =
(_typeExtensionsMap$co3 = typeExtensionsMap[config.name]) !== null &&
_typeExtensionsMap$co3 !== void 0
? _typeExtensionsMap$co3
: [];
return new GraphQLObjectType({
...config,
interfaces: () => [
...type.getInterfaces().map(replaceNamedType),
...buildInterfaces(extensions),
],
fields: () => ({
...mapValue(config.fields, extendField),
...buildFieldMap(extensions),
}),
extensionASTNodes: config.extensionASTNodes.concat(extensions),
});
}
function extendInterfaceType(type) {
var _typeExtensionsMap$co4;
const config = type.toConfig();
const extensions =
(_typeExtensionsMap$co4 = typeExtensionsMap[config.name]) !== null &&
_typeExtensionsMap$co4 !== void 0
? _typeExtensionsMap$co4
: [];
return new GraphQLInterfaceType({
...config,
interfaces: () => [
...type.getInterfaces().map(replaceNamedType),
...buildInterfaces(extensions),
],
fields: () => ({
...mapValue(config.fields, extendField),
...buildFieldMap(extensions),
}),
extensionASTNodes: config.extensionASTNodes.concat(extensions),
});
}
function extendUnionType(type) {
var _typeExtensionsMap$co5;
const config = type.toConfig();
const extensions =
(_typeExtensionsMap$co5 = typeExtensionsMap[config.name]) !== null &&
_typeExtensionsMap$co5 !== void 0
? _typeExtensionsMap$co5
: [];
return new GraphQLUnionType({
...config,
types: () => [
...type.getTypes().map(replaceNamedType),
...buildUnionTypes(extensions),
],
extensionASTNodes: config.extensionASTNodes.concat(extensions),
});
}
function extendField(field) {
return {
...field,
type: replaceType(field.type),
args: field.args && mapValue(field.args, extendArg),
};
}
function extendArg(arg) {
return { ...arg, type: replaceType(arg.type) };
}
function getOperationTypes(nodes) {
const opTypes = {};
for (const node of nodes) {
var _node$operationTypes;
// FIXME: https://github.com/graphql/graphql-js/issues/2203
const operationTypesNodes =
/* c8 ignore next */
(_node$operationTypes = node.operationTypes) !== null &&
_node$operationTypes !== void 0
? _node$operationTypes
: [];
for (const operationType of operationTypesNodes) {
// 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.
// @ts-expect-error
opTypes[operationType.operation] = getNamedType(operationType.type);
}
}
return opTypes;
}
function getNamedType(node) {
var _stdTypeMap$name2;
const name = node.name.value;
const type =
(_stdTypeMap$name2 = stdTypeMap[name]) !== null &&
_stdTypeMap$name2 !== void 0
? _stdTypeMap$name2
: typeMap[name];
if (type === undefined) {
throw new Error(`Unknown type: "${name}".`);
}
return type;
}
function getWrappedType(node) {
if (node.kind === Kind.LIST_TYPE) {
return new GraphQLList(getWrappedType(node.type));
}
if (node.kind === Kind.NON_NULL_TYPE) {
return new GraphQLNonNull(getWrappedType(node.type));
}
return getNamedType(node);
}
function buildDirective(node) {
var _node$description;
return new GraphQLDirective({
name: node.name.value,
description:
(_node$description = node.description) === null ||
_node$description === void 0
? void 0
: _node$description.value,
// @ts-expect-error
locations: node.locations.map(({ value }) => value),
isRepeatable: node.repeatable,
args: buildArgumentMap(node.arguments),
astNode: node,
});
}
function buildFieldMap(nodes) {
const fieldConfigMap = Object.create(null);
for (const node of nodes) {
var _node$fields;
// FIXME: https://github.com/graphql/graphql-js/issues/2203
const nodeFields =
/* c8 ignore next */
(_node$fields = node.fields) !== null && _node$fields !== void 0
? _node$fields
: [];
for (const field of nodeFields) {
var _field$description;
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:
(_field$description = field.description) === null ||
_field$description === void 0
? void 0
: _field$description.value,
args: buildArgumentMap(field.arguments),
deprecationReason: getDeprecationReason(field),
astNode: field,
};
}
}
return fieldConfigMap;
}
function buildArgumentMap(args) {
// FIXME: https://github.com/graphql/graphql-js/issues/2203
const argsNodes =
/* c8 ignore next */
args !== null && args !== void 0 ? args : [];
const argConfigMap = Object.create(null);
for (const arg of argsNodes) {
var _arg$description;
// 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.
const type = getWrappedType(arg.type);
argConfigMap[arg.name.value] = {
type,
description:
(_arg$description = arg.description) === null ||
_arg$description === void 0
? void 0
: _arg$description.value,
defaultValue: valueFromAST(arg.defaultValue, type),
deprecationReason: getDeprecationReason(arg),
astNode: arg,
};
}
return argConfigMap;
}
function buildInputFieldMap(nodes) {
const inputFieldMap = Object.create(null);
for (const node of nodes) {
var _node$fields2;
// FIXME: https://github.com/graphql/graphql-js/issues/2203
const fieldsNodes =
/* c8 ignore next */
(_node$fields2 = node.fields) !== null && _node$fields2 !== void 0
? _node$fields2
: [];
for (const field of fieldsNodes) {
var _field$description2;
// 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.
const type = getWrappedType(field.type);
inputFieldMap[field.name.value] = {
type,
description:
(_field$description2 = field.description) === null ||
_field$description2 === void 0
? void 0
: _field$description2.value,
defaultValue: valueFromAST(field.defaultValue, type),
deprecationReason: getDeprecationReason(field),
astNode: field,
};
}
}
return inputFieldMap;
}
function buildEnumValueMap(nodes) {
const enumValueMap = Object.create(null);
for (const node of nodes) {
var _node$values;
// FIXME: https://github.com/graphql/graphql-js/issues/2203
const valuesNodes =
/* c8 ignore next */
(_node$values = node.values) !== null && _node$values !== void 0
? _node$values
: [];
for (const value of valuesNodes) {
var _value$description;
enumValueMap[value.name.value] = {
description:
(_value$description = value.description) === null ||
_value$description === void 0
? void 0
: _value$description.value,
deprecationReason: getDeprecationReason(value),
astNode: value,
};
}
}
return enumValueMap;
}
function buildInterfaces(nodes) {
// 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.
// @ts-expect-error
return nodes.flatMap(
// FIXME: https://github.com/graphql/graphql-js/issues/2203
(node) => {
var _node$interfaces$map, _node$interfaces;
return (
/* c8 ignore next */
(_node$interfaces$map =
(_node$interfaces = node.interfaces) === null ||
_node$interfaces === void 0
? void 0
: _node$interfaces.map(getNamedType)) !== null &&
_node$interfaces$map !== void 0
? _node$interfaces$map
: []
);
},
);
}
function buildUnionTypes(nodes) {
// 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.
// @ts-expect-error
return nodes.flatMap(
// FIXME: https://github.com/graphql/graphql-js/issues/2203
(node) => {
var _node$types$map, _node$types;
return (
/* c8 ignore next */
(_node$types$map =
(_node$types = node.types) === null || _node$types === void 0
? void 0
: _node$types.map(getNamedType)) !== null &&
_node$types$map !== void 0
? _node$types$map
: []
);
},
);
}
function buildType(astNode) {
var _typeExtensionsMap$na;
const name = astNode.name.value;
const extensionASTNodes =
(_typeExtensionsMap$na = typeExtensionsMap[name]) !== null &&
_typeExtensionsMap$na !== void 0
? _typeExtensionsMap$na
: [];
switch (astNode.kind) {
case Kind.OBJECT_TYPE_DEFINITION: {
var _astNode$description;
const allNodes = [astNode, ...extensionASTNodes];
return new GraphQLObjectType({
name,
description:
(_astNode$description = astNode.description) === null ||
_astNode$description === void 0
? void 0
: _astNode$description.value,
interfaces: () => buildInterfaces(allNodes),
fields: () => buildFieldMap(allNodes),
astNode,
extensionASTNodes,
});
}
case Kind.INTERFACE_TYPE_DEFINITION: {
var _astNode$description2;
const allNodes = [astNode, ...extensionASTNodes];
return new GraphQLInterfaceType({
name,
description:
(_astNode$description2 = astNode.description) === null ||
_astNode$description2 === void 0
? void 0
: _astNode$description2.value,
interfaces: () => buildInterfaces(allNodes),
fields: () => buildFieldMap(allNodes),
astNode,
extensionASTNodes,
});
}
case Kind.ENUM_TYPE_DEFINITION: {
var _astNode$description3;
const allNodes = [astNode, ...extensionASTNodes];
return new GraphQLEnumType({
name,
description:
(_astNode$description3 = astNode.description) === null ||
_astNode$description3 === void 0
? void 0
: _astNode$description3.value,
values: buildEnumValueMap(allNodes),
astNode,
extensionASTNodes,
});
}
case Kind.UNION_TYPE_DEFINITION: {
var _astNode$description4;
const allNodes = [astNode, ...extensionASTNodes];
return new GraphQLUnionType({
name,
description:
(_astNode$description4 = astNode.description) === null ||
_astNode$description4 === void 0
? void 0
: _astNode$description4.value,
types: () => buildUnionTypes(allNodes),
astNode,
extensionASTNodes,
});
}
case Kind.SCALAR_TYPE_DEFINITION: {
var _astNode$description5;
return new GraphQLScalarType({
name,
description:
(_astNode$description5 = astNode.description) === null ||
_astNode$description5 === void 0
? void 0
: _astNode$description5.value,
specifiedByURL: getSpecifiedByURL(astNode),
astNode,
extensionASTNodes,
});
}
case Kind.INPUT_OBJECT_TYPE_DEFINITION: {
var _astNode$description6;
const allNodes = [astNode, ...extensionASTNodes];
return new GraphQLInputObjectType({
name,
description:
(_astNode$description6 = astNode.description) === null ||
_astNode$description6 === void 0
? void 0
: _astNode$description6.value,
fields: () => buildInputFieldMap(allNodes),
astNode,
extensionASTNodes,
isOneOf: isOneOf(astNode),
});
}
}
}
}
const stdTypeMap = keyMap(
[...specifiedScalarTypes, ...introspectionTypes],
(type) => type.name,
);
/**
* Given a field or enum value node, returns the string value for the
* deprecation reason.
*/
function getDeprecationReason(node) {
const deprecated = getDirectiveValues(GraphQLDeprecatedDirective, node); // @ts-expect-error validated by `getDirectiveValues`
return deprecated === null || deprecated === void 0
? void 0
: deprecated.reason;
}
/**
* Given a scalar node, returns the string value for the specifiedByURL.
*/
function getSpecifiedByURL(node) {
const specifiedBy = getDirectiveValues(GraphQLSpecifiedByDirective, node); // @ts-expect-error validated by `getDirectiveValues`
return specifiedBy === null || specifiedBy === void 0
? void 0
: specifiedBy.url;
}
/**
* Given an input object node, returns if the node should be OneOf.
*/
function isOneOf(node) {
return Boolean(getDirectiveValues(GraphQLOneOfDirective, node));
}