import find from "../polyfills/find.mjs"; import objectValues from "../polyfills/objectValues.mjs"; import inspect from "../jsutils/inspect.mjs"; import { GraphQLError } from "../error/GraphQLError.mjs"; import { locatedError } from "../error/locatedError.mjs"; import { isValidNameError } from "../utilities/assertValidName.mjs"; import { isEqualType, isTypeSubTypeOf } from "../utilities/typeComparators.mjs"; import { assertSchema } from "./schema.mjs"; import { isIntrospectionType } from "./introspection.mjs"; import { isDirective, GraphQLDeprecatedDirective } from "./directives.mjs"; import { isObjectType, isInterfaceType, isUnionType, isEnumType, isInputObjectType, isNamedType, isNonNullType, isInputType, isOutputType, isRequiredArgument, isRequiredInputField } from "./definition.mjs"; /** * Implements the "Type Validation" sub-sections of the specification's * "Type System" section. * * Validation runs synchronously, returning an array of encountered errors, or * an empty array if no errors were encountered and the Schema is valid. */ export function validateSchema(schema) { // First check to ensure the provided value is in fact a GraphQLSchema. assertSchema(schema); // If this Schema has already been validated, return the previous results. if (schema.__validationErrors) { return schema.__validationErrors; } // Validate the schema, producing a list of errors. var context = new SchemaValidationContext(schema); validateRootTypes(context); validateDirectives(context); validateTypes(context); // Persist the results of validation before returning to ensure validation // does not run multiple times for this schema. var errors = context.getErrors(); schema.__validationErrors = errors; return errors; } /** * Utility function which asserts a schema is valid by throwing an error if * it is invalid. */ export function assertValidSchema(schema) { var errors = validateSchema(schema); if (errors.length !== 0) { throw new Error(errors.map(function (error) { return error.message; }).join('\n\n')); } } var SchemaValidationContext = /*#__PURE__*/function () { function SchemaValidationContext(schema) { this._errors = []; this.schema = schema; } var _proto = SchemaValidationContext.prototype; _proto.reportError = function reportError(message, nodes) { var _nodes = Array.isArray(nodes) ? nodes.filter(Boolean) : nodes; this.addError(new GraphQLError(message, _nodes)); }; _proto.addError = function addError(error) { this._errors.push(error); }; _proto.getErrors = function getErrors() { return this._errors; }; return SchemaValidationContext; }(); function validateRootTypes(context) { var schema = context.schema; var queryType = schema.getQueryType(); if (!queryType) { context.reportError('Query root type must be provided.', schema.astNode); } else if (!isObjectType(queryType)) { var _getOperationTypeNode; context.reportError("Query root type must be Object type, it cannot be ".concat(inspect(queryType), "."), (_getOperationTypeNode = getOperationTypeNode(schema, 'query')) !== null && _getOperationTypeNode !== void 0 ? _getOperationTypeNode : queryType.astNode); } var mutationType = schema.getMutationType(); if (mutationType && !isObjectType(mutationType)) { var _getOperationTypeNode2; context.reportError('Mutation root type must be Object type if provided, it cannot be ' + "".concat(inspect(mutationType), "."), (_getOperationTypeNode2 = getOperationTypeNode(schema, 'mutation')) !== null && _getOperationTypeNode2 !== void 0 ? _getOperationTypeNode2 : mutationType.astNode); } var subscriptionType = schema.getSubscriptionType(); if (subscriptionType && !isObjectType(subscriptionType)) { var _getOperationTypeNode3; context.reportError('Subscription root type must be Object type if provided, it cannot be ' + "".concat(inspect(subscriptionType), "."), (_getOperationTypeNode3 = getOperationTypeNode(schema, 'subscription')) !== null && _getOperationTypeNode3 !== void 0 ? _getOperationTypeNode3 : subscriptionType.astNode); } } function getOperationTypeNode(schema, operation) { var operationNodes = getAllSubNodes(schema, function (node) { return node.operationTypes; }); for (var _i2 = 0; _i2 < operationNodes.length; _i2++) { var node = operationNodes[_i2]; if (node.operation === operation) { return node.type; } } return undefined; } function validateDirectives(context) { for (var _i4 = 0, _context$schema$getDi2 = context.schema.getDirectives(); _i4 < _context$schema$getDi2.length; _i4++) { var directive = _context$schema$getDi2[_i4]; // Ensure all directives are in fact GraphQL directives. if (!isDirective(directive)) { context.reportError("Expected directive but got: ".concat(inspect(directive), "."), directive === null || directive === void 0 ? void 0 : directive.astNode); continue; } // Ensure they are named correctly. validateName(context, directive); // TODO: Ensure proper locations. // Ensure the arguments are valid. for (var _i6 = 0, _directive$args2 = directive.args; _i6 < _directive$args2.length; _i6++) { var arg = _directive$args2[_i6]; // Ensure they are named correctly. validateName(context, arg); // Ensure the type is an input type. if (!isInputType(arg.type)) { context.reportError("The type of @".concat(directive.name, "(").concat(arg.name, ":) must be Input Type ") + "but got: ".concat(inspect(arg.type), "."), arg.astNode); } if (isRequiredArgument(arg) && arg.deprecationReason != null) { var _arg$astNode; context.reportError("Required argument @".concat(directive.name, "(").concat(arg.name, ":) cannot be deprecated."), [getDeprecatedDirectiveNode(arg.astNode), // istanbul ignore next (TODO need to write coverage tests) (_arg$astNode = arg.astNode) === null || _arg$astNode === void 0 ? void 0 : _arg$astNode.type]); } } } } function validateName(context, node) { // Ensure names are valid, however introspection types opt out. var error = isValidNameError(node.name); if (error) { context.addError(locatedError(error, node.astNode)); } } function validateTypes(context) { var validateInputObjectCircularRefs = createInputObjectCircularRefsValidator(context); var typeMap = context.schema.getTypeMap(); for (var _i8 = 0, _objectValues2 = objectValues(typeMap); _i8 < _objectValues2.length; _i8++) { var type = _objectValues2[_i8]; // Ensure all provided types are in fact GraphQL type. if (!isNamedType(type)) { context.reportError("Expected GraphQL named type but got: ".concat(inspect(type), "."), type.astNode); continue; } // Ensure it is named correctly (excluding introspection types). if (!isIntrospectionType(type)) { validateName(context, type); } if (isObjectType(type)) { // Ensure fields are valid validateFields(context, type); // Ensure objects implement the interfaces they claim to. validateInterfaces(context, type); } else if (isInterfaceType(type)) { // Ensure fields are valid. validateFields(context, type); // Ensure interfaces implement the interfaces they claim to. validateInterfaces(context, type); } else if (isUnionType(type)) { // Ensure Unions include valid member types. validateUnionMembers(context, type); } else if (isEnumType(type)) { // Ensure Enums have valid values. validateEnumValues(context, type); } else if (isInputObjectType(type)) { // Ensure Input Object fields are valid. validateInputFields(context, type); // Ensure Input Objects do not contain non-nullable circular references validateInputObjectCircularRefs(type); } } } function validateFields(context, type) { var fields = objectValues(type.getFields()); // Objects and Interfaces both must define one or more fields. if (fields.length === 0) { context.reportError("Type ".concat(type.name, " must define one or more fields."), getAllNodes(type)); } for (var _i10 = 0; _i10 < fields.length; _i10++) { var field = fields[_i10]; // Ensure they are named correctly. validateName(context, field); // Ensure the type is an output type if (!isOutputType(field.type)) { var _field$astNode; context.reportError("The type of ".concat(type.name, ".").concat(field.name, " must be Output Type ") + "but got: ".concat(inspect(field.type), "."), (_field$astNode = field.astNode) === null || _field$astNode === void 0 ? void 0 : _field$astNode.type); } // Ensure the arguments are valid for (var _i12 = 0, _field$args2 = field.args; _i12 < _field$args2.length; _i12++) { var arg = _field$args2[_i12]; var argName = arg.name; // Ensure they are named correctly. validateName(context, arg); // Ensure the type is an input type if (!isInputType(arg.type)) { var _arg$astNode2; context.reportError("The type of ".concat(type.name, ".").concat(field.name, "(").concat(argName, ":) must be Input ") + "Type but got: ".concat(inspect(arg.type), "."), (_arg$astNode2 = arg.astNode) === null || _arg$astNode2 === void 0 ? void 0 : _arg$astNode2.type); } if (isRequiredArgument(arg) && arg.deprecationReason != null) { var _arg$astNode3; context.reportError("Required argument ".concat(type.name, ".").concat(field.name, "(").concat(argName, ":) cannot be deprecated."), [getDeprecatedDirectiveNode(arg.astNode), // istanbul ignore next (TODO need to write coverage tests) (_arg$astNode3 = arg.astNode) === null || _arg$astNode3 === void 0 ? void 0 : _arg$astNode3.type]); } } } } function validateInterfaces(context, type) { var ifaceTypeNames = Object.create(null); for (var _i14 = 0, _type$getInterfaces2 = type.getInterfaces(); _i14 < _type$getInterfaces2.length; _i14++) { var iface = _type$getInterfaces2[_i14]; if (!isInterfaceType(iface)) { context.reportError("Type ".concat(inspect(type), " must only implement Interface types, ") + "it cannot implement ".concat(inspect(iface), "."), getAllImplementsInterfaceNodes(type, iface)); continue; } if (type === iface) { context.reportError("Type ".concat(type.name, " cannot implement itself because it would create a circular reference."), getAllImplementsInterfaceNodes(type, iface)); continue; } if (ifaceTypeNames[iface.name]) { context.reportError("Type ".concat(type.name, " can only implement ").concat(iface.name, " once."), getAllImplementsInterfaceNodes(type, iface)); continue; } ifaceTypeNames[iface.name] = true; validateTypeImplementsAncestors(context, type, iface); validateTypeImplementsInterface(context, type, iface); } } function validateTypeImplementsInterface(context, type, iface) { var typeFieldMap = type.getFields(); // Assert each interface field is implemented. for (var _i16 = 0, _objectValues4 = objectValues(iface.getFields()); _i16 < _objectValues4.length; _i16++) { var ifaceField = _objectValues4[_i16]; var fieldName = ifaceField.name; var typeField = typeFieldMap[fieldName]; // Assert interface field exists on type. if (!typeField) { context.reportError("Interface field ".concat(iface.name, ".").concat(fieldName, " expected but ").concat(type.name, " does not provide it."), [ifaceField.astNode].concat(getAllNodes(type))); continue; } // Assert interface field type is satisfied by type field type, by being // a valid subtype. (covariant) if (!isTypeSubTypeOf(context.schema, typeField.type, ifaceField.type)) { var _ifaceField$astNode, _typeField$astNode; context.reportError("Interface field ".concat(iface.name, ".").concat(fieldName, " expects type ") + "".concat(inspect(ifaceField.type), " but ").concat(type.name, ".").concat(fieldName, " ") + "is type ".concat(inspect(typeField.type), "."), [// istanbul ignore next (TODO need to write coverage tests) (_ifaceField$astNode = ifaceField.astNode) === null || _ifaceField$astNode === void 0 ? void 0 : _ifaceField$astNode.type, // istanbul ignore next (TODO need to write coverage tests) (_typeField$astNode = typeField.astNode) === null || _typeField$astNode === void 0 ? void 0 : _typeField$astNode.type]); } // Assert each interface field arg is implemented. var _loop = function _loop(_i18, _ifaceField$args2) { var ifaceArg = _ifaceField$args2[_i18]; var argName = ifaceArg.name; var typeArg = find(typeField.args, function (arg) { return arg.name === argName; }); // Assert interface field arg exists on object field. if (!typeArg) { context.reportError("Interface field argument ".concat(iface.name, ".").concat(fieldName, "(").concat(argName, ":) expected but ").concat(type.name, ".").concat(fieldName, " does not provide it."), [ifaceArg.astNode, typeField.astNode]); return "continue"; } // Assert interface field arg type matches object field arg type. // (invariant) // TODO: change to contravariant? if (!isEqualType(ifaceArg.type, typeArg.type)) { var _ifaceArg$astNode, _typeArg$astNode; context.reportError("Interface field argument ".concat(iface.name, ".").concat(fieldName, "(").concat(argName, ":) ") + "expects type ".concat(inspect(ifaceArg.type), " but ") + "".concat(type.name, ".").concat(fieldName, "(").concat(argName, ":) is type ") + "".concat(inspect(typeArg.type), "."), [// istanbul ignore next (TODO need to write coverage tests) (_ifaceArg$astNode = ifaceArg.astNode) === null || _ifaceArg$astNode === void 0 ? void 0 : _ifaceArg$astNode.type, // istanbul ignore next (TODO need to write coverage tests) (_typeArg$astNode = typeArg.astNode) === null || _typeArg$astNode === void 0 ? void 0 : _typeArg$astNode.type]); } // TODO: validate default values? }; for (var _i18 = 0, _ifaceField$args2 = ifaceField.args; _i18 < _ifaceField$args2.length; _i18++) { var _ret = _loop(_i18, _ifaceField$args2); if (_ret === "continue") continue; } // Assert additional arguments must not be required. var _loop2 = function _loop2(_i20, _typeField$args2) { var typeArg = _typeField$args2[_i20]; var argName = typeArg.name; var ifaceArg = find(ifaceField.args, function (arg) { return arg.name === argName; }); if (!ifaceArg && isRequiredArgument(typeArg)) { context.reportError("Object field ".concat(type.name, ".").concat(fieldName, " includes required argument ").concat(argName, " that is missing from the Interface field ").concat(iface.name, ".").concat(fieldName, "."), [typeArg.astNode, ifaceField.astNode]); } }; for (var _i20 = 0, _typeField$args2 = typeField.args; _i20 < _typeField$args2.length; _i20++) { _loop2(_i20, _typeField$args2); } } } function validateTypeImplementsAncestors(context, type, iface) { var ifaceInterfaces = type.getInterfaces(); for (var _i22 = 0, _iface$getInterfaces2 = iface.getInterfaces(); _i22 < _iface$getInterfaces2.length; _i22++) { var transitive = _iface$getInterfaces2[_i22]; if (ifaceInterfaces.indexOf(transitive) === -1) { context.reportError(transitive === type ? "Type ".concat(type.name, " cannot implement ").concat(iface.name, " because it would create a circular reference.") : "Type ".concat(type.name, " must implement ").concat(transitive.name, " because it is implemented by ").concat(iface.name, "."), [].concat(getAllImplementsInterfaceNodes(iface, transitive), getAllImplementsInterfaceNodes(type, iface))); } } } function validateUnionMembers(context, union) { var memberTypes = union.getTypes(); if (memberTypes.length === 0) { context.reportError("Union type ".concat(union.name, " must define one or more member types."), getAllNodes(union)); } var includedTypeNames = Object.create(null); for (var _i24 = 0; _i24 < memberTypes.length; _i24++) { var memberType = memberTypes[_i24]; if (includedTypeNames[memberType.name]) { context.reportError("Union type ".concat(union.name, " can only include type ").concat(memberType.name, " once."), getUnionMemberTypeNodes(union, memberType.name)); continue; } includedTypeNames[memberType.name] = true; if (!isObjectType(memberType)) { context.reportError("Union type ".concat(union.name, " can only include Object types, ") + "it cannot include ".concat(inspect(memberType), "."), getUnionMemberTypeNodes(union, String(memberType))); } } } function validateEnumValues(context, enumType) { var enumValues = enumType.getValues(); if (enumValues.length === 0) { context.reportError("Enum type ".concat(enumType.name, " must define one or more values."), getAllNodes(enumType)); } for (var _i26 = 0; _i26 < enumValues.length; _i26++) { var enumValue = enumValues[_i26]; var valueName = enumValue.name; // Ensure valid name. validateName(context, enumValue); if (valueName === 'true' || valueName === 'false' || valueName === 'null') { context.reportError("Enum type ".concat(enumType.name, " cannot include value: ").concat(valueName, "."), enumValue.astNode); } } } function validateInputFields(context, inputObj) { var fields = objectValues(inputObj.getFields()); if (fields.length === 0) { context.reportError("Input Object type ".concat(inputObj.name, " must define one or more fields."), getAllNodes(inputObj)); } // Ensure the arguments are valid for (var _i28 = 0; _i28 < fields.length; _i28++) { var field = fields[_i28]; // Ensure they are named correctly. validateName(context, field); // Ensure the type is an input type if (!isInputType(field.type)) { var _field$astNode2; context.reportError("The type of ".concat(inputObj.name, ".").concat(field.name, " must be Input Type ") + "but got: ".concat(inspect(field.type), "."), (_field$astNode2 = field.astNode) === null || _field$astNode2 === void 0 ? void 0 : _field$astNode2.type); } if (isRequiredInputField(field) && field.deprecationReason != null) { var _field$astNode3; context.reportError("Required input field ".concat(inputObj.name, ".").concat(field.name, " cannot be deprecated."), [getDeprecatedDirectiveNode(field.astNode), // istanbul ignore next (TODO need to write coverage tests) (_field$astNode3 = field.astNode) === null || _field$astNode3 === void 0 ? void 0 : _field$astNode3.type]); } } } function createInputObjectCircularRefsValidator(context) { // Modified copy of algorithm from 'src/validation/rules/NoFragmentCycles.js'. // Tracks already visited types to maintain O(N) and to ensure that cycles // are not redundantly reported. var visitedTypes = Object.create(null); // Array of types nodes used to produce meaningful errors var fieldPath = []; // Position in the type path var fieldPathIndexByTypeName = Object.create(null); return detectCycleRecursive; // This does a straight-forward DFS to find cycles. // It does not terminate when a cycle was found but continues to explore // the graph to find all possible cycles. function detectCycleRecursive(inputObj) { if (visitedTypes[inputObj.name]) { return; } visitedTypes[inputObj.name] = true; fieldPathIndexByTypeName[inputObj.name] = fieldPath.length; var fields = objectValues(inputObj.getFields()); for (var _i30 = 0; _i30 < fields.length; _i30++) { var field = fields[_i30]; if (isNonNullType(field.type) && isInputObjectType(field.type.ofType)) { var fieldType = field.type.ofType; var cycleIndex = fieldPathIndexByTypeName[fieldType.name]; fieldPath.push(field); if (cycleIndex === undefined) { detectCycleRecursive(fieldType); } else { var cyclePath = fieldPath.slice(cycleIndex); var pathStr = cyclePath.map(function (fieldObj) { return fieldObj.name; }).join('.'); context.reportError("Cannot reference Input Object \"".concat(fieldType.name, "\" within itself through a series of non-null fields: \"").concat(pathStr, "\"."), cyclePath.map(function (fieldObj) { return fieldObj.astNode; })); } fieldPath.pop(); } } fieldPathIndexByTypeName[inputObj.name] = undefined; } } function getAllNodes(object) { var astNode = object.astNode, extensionASTNodes = object.extensionASTNodes; return astNode ? extensionASTNodes ? [astNode].concat(extensionASTNodes) : [astNode] : extensionASTNodes !== null && extensionASTNodes !== void 0 ? extensionASTNodes : []; } function getAllSubNodes(object, getter) { var subNodes = []; for (var _i32 = 0, _getAllNodes2 = getAllNodes(object); _i32 < _getAllNodes2.length; _i32++) { var _getter; var node = _getAllNodes2[_i32]; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203') subNodes = subNodes.concat((_getter = getter(node)) !== null && _getter !== void 0 ? _getter : []); } return subNodes; } function getAllImplementsInterfaceNodes(type, iface) { return getAllSubNodes(type, function (typeNode) { return typeNode.interfaces; }).filter(function (ifaceNode) { return ifaceNode.name.value === iface.name; }); } function getUnionMemberTypeNodes(union, typeName) { return getAllSubNodes(union, function (unionNode) { return unionNode.types; }).filter(function (typeNode) { return typeNode.name.value === typeName; }); } function getDeprecatedDirectiveNode(definitionNode) { var _definitionNode$direc; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203') return definitionNode === null || definitionNode === void 0 ? void 0 : (_definitionNode$direc = definitionNode.directives) === null || _definitionNode$direc === void 0 ? void 0 : _definitionNode$direc.find(function (node) { return node.name.value === GraphQLDeprecatedDirective.name; }); }