graphql 17.0.0-beta.0 → 17.0.0-beta.1

package/type/validate.js

@@ -3,25 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateSchema = validateSchema;
 exports.assertValidSchema = assertValidSchema;
 exports.validateDefaultInput = validateDefaultInput;
-const AccumulatorMap_js_1 = require("../jsutils/AccumulatorMap.js");
-const capitalize_js_1 = require("../jsutils/capitalize.js");
-const formatList_js_1 = require("../jsutils/formatList.js");
-const inspect_js_1 = require("../jsutils/inspect.js");
-const invariant_js_1 = require("../jsutils/invariant.js");
-const isIterableObject_js_1 = require("../jsutils/isIterableObject.js");
-const isObjectLike_js_1 = require("../jsutils/isObjectLike.js");
-const keyMap_js_1 = require("../jsutils/keyMap.js");
-const mapValue_js_1 = require("../jsutils/mapValue.js");
-const printPathArray_js_1 = require("../jsutils/printPathArray.js");
-const GraphQLError_js_1 = require("../error/GraphQLError.js");
-const ast_js_1 = require("../language/ast.js");
-const kinds_js_1 = require("../language/kinds.js");
-const typeComparators_js_1 = require("../utilities/typeComparators.js");
-const validateInputValue_js_1 = require("../utilities/validateInputValue.js");
-const definition_js_1 = require("./definition.js");
-const directives_js_1 = require("./directives.js");
-const introspection_js_1 = require("./introspection.js");
-const schema_js_1 = require("./schema.js");
+const AccumulatorMap_ts_1 = require("../jsutils/AccumulatorMap.js");
+const capitalize_ts_1 = require("../jsutils/capitalize.js");
+const formatList_ts_1 = require("../jsutils/formatList.js");
+const inspect_ts_1 = require("../jsutils/inspect.js");
+const invariant_ts_1 = require("../jsutils/invariant.js");
+const isIterableObject_ts_1 = require("../jsutils/isIterableObject.js");
+const isObjectLike_ts_1 = require("../jsutils/isObjectLike.js");
+const keyMap_ts_1 = require("../jsutils/keyMap.js");
+const mapValue_ts_1 = require("../jsutils/mapValue.js");
+const printPathArray_ts_1 = require("../jsutils/printPathArray.js");
+const GraphQLError_ts_1 = require("../error/GraphQLError.js");
+const ast_ts_1 = require("../language/ast.js");
+const kinds_ts_1 = require("../language/kinds.js");
+const typeComparators_ts_1 = require("../utilities/typeComparators.js");
+const validateInputValue_ts_1 = require("../utilities/validateInputValue.js");
+const definition_ts_1 = require("./definition.js");
+const directives_ts_1 = require("./directives.js");
+const introspection_ts_1 = require("./introspection.js");
+const schema_ts_1 = require("./schema.js");
 /**
  * Implements the "Type Validation" sub-sections of the specification's
  * "Type System" section.
@@ -31,7 +31,7 @@ const schema_js_1 = require("./schema.js");
  */
 function validateSchema(schema) {
     // First check to ensure the provided value is in fact a GraphQLSchema.
-    (0, schema_js_1.assertSchema)(schema);
+    (0, schema_ts_1.assertSchema)(schema);
     // If this Schema has already been validated, return the previous results.
     if (schema.__validationErrors) {
         return schema.__validationErrors;
@@ -66,7 +66,7 @@ class SchemaValidationContext {
         const _nodes = Array.isArray(nodes)
             ? nodes.filter(Boolean)
             : nodes;
-        this._errors.push(new GraphQLError_js_1.GraphQLError(message, { nodes: _nodes }));
+        this._errors.push(new GraphQLError_ts_1.GraphQLError(message, { nodes: _nodes }));
     }
     getErrors() {
         return this._errors;
@@ -77,14 +77,14 @@ function validateRootTypes(context) {
     if (schema.getQueryType() == null) {
         context.reportError('Query root type must be provided.', schema.astNode);
     }
-    const rootTypesMap = new AccumulatorMap_js_1.AccumulatorMap();
-    for (const operationType of Object.values(ast_js_1.OperationTypeNode)) {
+    const rootTypesMap = new AccumulatorMap_ts_1.AccumulatorMap();
+    for (const operationType of Object.values(ast_ts_1.OperationTypeNode)) {
         const rootType = schema.getRootType(operationType);
         if (rootType != null) {
-            if (!(0, definition_js_1.isObjectType)(rootType)) {
-                const operationTypeStr = (0, capitalize_js_1.capitalize)(operationType);
-                const rootTypeStr = (0, inspect_js_1.inspect)(rootType);
-                context.reportError(operationType === ast_js_1.OperationTypeNode.QUERY
+            if (!(0, definition_ts_1.isObjectType)(rootType)) {
+                const operationTypeStr = (0, capitalize_ts_1.capitalize)(operationType);
+                const rootTypeStr = (0, inspect_ts_1.inspect)(rootType);
+                context.reportError(operationType === ast_ts_1.OperationTypeNode.QUERY
                     ? `${operationTypeStr} root type must be Object type, it cannot be ${rootTypeStr}.`
                     : `${operationTypeStr} root type must be Object type if provided, it cannot be ${rootTypeStr}.`, getOperationTypeNode(schema, operationType) ??
                     rootType.astNode);
@@ -96,7 +96,7 @@ function validateRootTypes(context) {
     }
     for (const [rootType, operationTypes] of rootTypesMap) {
         if (operationTypes.length > 1) {
-            const operationList = (0, formatList_js_1.andList)(operationTypes);
+            const operationList = (0, formatList_ts_1.andList)(operationTypes);
             context.reportError(`All root types must be different, "${rootType}" type is used as ${operationList} root types.`, operationTypes.map((operationType) => getOperationTypeNode(schema, operationType)));
         }
     }
@@ -109,8 +109,8 @@ function getOperationTypeNode(schema, operation) {
 function validateDirectives(context) {
     for (const directive of context.schema.getDirectives()) {
         // Ensure all directives are in fact GraphQL directives.
-        if (!(0, directives_js_1.isDirective)(directive)) {
-            context.reportError(`Expected directive but got: ${(0, inspect_js_1.inspect)(directive)}.`, directive?.astNode);
+        if (!(0, directives_ts_1.isDirective)(directive)) {
+            context.reportError(`Expected directive but got: ${(0, inspect_ts_1.inspect)(directive)}.`, directive?.astNode);
             continue;
         }
         // Ensure they are named correctly.
@@ -123,11 +123,11 @@ function validateDirectives(context) {
             // Ensure they are named correctly.
             validateName(context, arg);
             // Ensure the type is an input type.
-            if (!(0, definition_js_1.isInputType)(arg.type)) {
+            if (!(0, definition_ts_1.isInputType)(arg.type)) {
                 context.reportError(`The type of ${arg} must be Input Type ` +
-                    `but got: ${(0, inspect_js_1.inspect)(arg.type)}.`, arg.astNode);
+                    `but got: ${(0, inspect_ts_1.inspect)(arg.type)}.`, arg.astNode);
             }
-            if ((0, definition_js_1.isRequiredArgument)(arg) && arg.deprecationReason != null) {
+            if ((0, definition_ts_1.isRequiredArgument)(arg) && arg.deprecationReason != null) {
                 context.reportError(`Required argument ${arg} cannot be deprecated.`, [
                     getDeprecatedDirectiveNode(arg.astNode),
                     arg.astNode?.type,
@@ -156,11 +156,11 @@ function validateDefaultValue(context, inputValue) {
         try {
             const uncoercedValue = uncoerceDefaultValue(defaultInput.value, inputValue.type);
             const uncoercedErrors = [];
-            (0, validateInputValue_js_1.validateInputValue)(uncoercedValue, inputValue.type, (error, path) => {
+            (0, validateInputValue_ts_1.validateInputValue)(uncoercedValue, inputValue.type, (error, path) => {
                 uncoercedErrors.push([error, path]);
             });
             if (uncoercedErrors.length === 0) {
-                context.reportError(`${inputValue} has invalid default value: ${(0, inspect_js_1.inspect)(defaultInput.value)}. Did you mean: ${(0, inspect_js_1.inspect)(uncoercedValue)}?`, inputValue.astNode?.defaultValue);
+                context.reportError(`${inputValue} has invalid default value: ${(0, inspect_ts_1.inspect)(defaultInput.value)}. Did you mean: ${(0, inspect_ts_1.inspect)(uncoercedValue)}?`, inputValue.astNode?.defaultValue);
                 return;
             }
         }
@@ -170,7 +170,7 @@ function validateDefaultValue(context, inputValue) {
     }
     // Otherwise report the original set of errors.
     for (const [error, path] of errors) {
-        context.reportError(`${inputValue} has invalid default value${(0, printPathArray_js_1.printPathArray)(path)}: ${error.message}`, error.nodes ?? inputValue.astNode?.defaultValue);
+        context.reportError(`${inputValue} has invalid default value${(0, printPathArray_ts_1.printPathArray)(path)}: ${error.message}`, error.nodes ?? inputValue.astNode?.defaultValue);
     }
 }
 /**
@@ -178,10 +178,10 @@ function validateDefaultValue(context, inputValue) {
  */
 function validateDefaultInput(defaultInput, inputType, onError, hideSuggestions) {
     if (defaultInput.literal) {
-        (0, validateInputValue_js_1.validateInputLiteral)(defaultInput.literal, inputType, onError, undefined, undefined, hideSuggestions);
+        (0, validateInputValue_ts_1.validateInputLiteral)(defaultInput.literal, inputType, onError, undefined, undefined, hideSuggestions);
         return;
     }
-    (0, validateInputValue_js_1.validateInputValue)(defaultInput.value, inputType, onError, hideSuggestions);
+    (0, validateInputValue_ts_1.validateInputValue)(defaultInput.value, inputType, onError, hideSuggestions);
 }
 /**
  * Historically GraphQL.js allowed default values to be provided as
@@ -193,29 +193,29 @@ function validateDefaultInput(defaultInput, inputType, onError, hideSuggestions)
  * coerced value, reverse the process to provide an "external" uncoerced value.
  */
 function uncoerceDefaultValue(value, type) {
-    if ((0, definition_js_1.isNonNullType)(type)) {
+    if ((0, definition_ts_1.isNonNullType)(type)) {
         return uncoerceDefaultValue(value, type.ofType);
     }
     if (value === null) {
         return null;
     }
-    if ((0, definition_js_1.isListType)(type)) {
-        if ((0, isIterableObject_js_1.isIterableObject)(value)) {
+    if ((0, definition_ts_1.isListType)(type)) {
+        if ((0, isIterableObject_ts_1.isIterableObject)(value)) {
             return Array.from(value, (itemValue) => uncoerceDefaultValue(itemValue, type.ofType));
         }
         return [uncoerceDefaultValue(value, type.ofType)];
     }
-    if ((0, definition_js_1.isInputObjectType)(type)) {
-        if (!((0, isObjectLike_js_1.isObjectLike)(value)))
-            (0, invariant_js_1.invariant)(false);
+    if ((0, definition_ts_1.isInputObjectType)(type)) {
+        if (!((0, isObjectLike_ts_1.isObjectLike)(value)))
+            (0, invariant_ts_1.invariant)(false);
         const fieldDefs = type.getFields();
-        return (0, mapValue_js_1.mapValue)(value, (fieldValue, fieldName) => {
+        return (0, mapValue_ts_1.mapValue)(value, (fieldValue, fieldName) => {
             if (!(fieldName in fieldDefs))
-                (0, invariant_js_1.invariant)(false);
+                (0, invariant_ts_1.invariant)(false);
             return uncoerceDefaultValue(fieldValue, fieldDefs[fieldName].type);
         });
     }
-    (0, definition_js_1.assertLeafType)(type);
+    (0, definition_ts_1.assertLeafType)(type);
     // For most leaf types (Scalars, Enums), output value coercion ("serialize") is
     // the inverse of input coercion ("parseValue") and will produce an
     // "external" value. Historically, this method was also used as part of the
@@ -235,35 +235,35 @@ function validateTypes(context) {
     const typeMap = context.schema.getTypeMap();
     for (const type of Object.values(typeMap)) {
         // Ensure all provided types are in fact GraphQL type.
-        if (!(0, definition_js_1.isNamedType)(type)) {
-            context.reportError(`Expected GraphQL named type but got: ${(0, inspect_js_1.inspect)(type)}.`, type.astNode);
+        if (!(0, definition_ts_1.isNamedType)(type)) {
+            context.reportError(`Expected GraphQL named type but got: ${(0, inspect_ts_1.inspect)(type)}.`, type.astNode);
             continue;
         }
         // Ensure it is named correctly (excluding introspection types).
-        if (!(0, introspection_js_1.isIntrospectionType)(type)) {
+        if (!(0, introspection_ts_1.isIntrospectionType)(type)) {
             validateName(context, type);
         }
-        if ((0, definition_js_1.isObjectType)(type)) {
+        if ((0, definition_ts_1.isObjectType)(type)) {
             // Ensure fields are valid
             validateFields(context, type);
             // Ensure objects implement the interfaces they claim to.
             validateInterfaces(context, type);
         }
-        else if ((0, definition_js_1.isInterfaceType)(type)) {
+        else if ((0, definition_ts_1.isInterfaceType)(type)) {
             // Ensure fields are valid.
             validateFields(context, type);
             // Ensure interfaces implement the interfaces they claim to.
             validateInterfaces(context, type);
         }
-        else if ((0, definition_js_1.isUnionType)(type)) {
+        else if ((0, definition_ts_1.isUnionType)(type)) {
             // Ensure Unions include valid member types.
             validateUnionMembers(context, type);
         }
-        else if ((0, definition_js_1.isEnumType)(type)) {
+        else if ((0, definition_ts_1.isEnumType)(type)) {
             // Ensure Enums have valid values.
             validateEnumValues(context, type);
         }
-        else if ((0, definition_js_1.isInputObjectType)(type)) {
+        else if ((0, definition_ts_1.isInputObjectType)(type)) {
             // Ensure Input Object fields are valid.
             validateInputFields(context, type);
             // Ensure Input Objects do not contain invalid field circular references.
@@ -287,19 +287,19 @@ function validateFields(context, type) {
         // Ensure they are named correctly.
         validateName(context, field);
         // Ensure the type is an output type
-        if (!(0, definition_js_1.isOutputType)(field.type)) {
+        if (!(0, definition_ts_1.isOutputType)(field.type)) {
             context.reportError(`The type of ${field} must be Output Type ` +
-                `but got: ${(0, inspect_js_1.inspect)(field.type)}.`, field.astNode?.type);
+                `but got: ${(0, inspect_ts_1.inspect)(field.type)}.`, field.astNode?.type);
         }
         // Ensure the arguments are valid
         for (const arg of field.args) {
             // Ensure they are named correctly.
             validateName(context, arg);
             // Ensure the type is an input type
-            if (!(0, definition_js_1.isInputType)(arg.type)) {
-                context.reportError(`The type of ${arg} must be Input Type but got: ${(0, inspect_js_1.inspect)(arg.type)}.`, arg.astNode?.type);
+            if (!(0, definition_ts_1.isInputType)(arg.type)) {
+                context.reportError(`The type of ${arg} must be Input Type but got: ${(0, inspect_ts_1.inspect)(arg.type)}.`, arg.astNode?.type);
             }
-            if ((0, definition_js_1.isRequiredArgument)(arg) && arg.deprecationReason != null) {
+            if ((0, definition_ts_1.isRequiredArgument)(arg) && arg.deprecationReason != null) {
                 context.reportError(`Required argument ${arg} cannot be deprecated.`, [
                     getDeprecatedDirectiveNode(arg.astNode),
                     arg.astNode?.type,
@@ -312,9 +312,9 @@ function validateFields(context, type) {
 function validateInterfaces(context, type) {
     const ifaceTypeNames = new Set();
     for (const iface of type.getInterfaces()) {
-        if (!(0, definition_js_1.isInterfaceType)(iface)) {
+        if (!(0, definition_ts_1.isInterfaceType)(iface)) {
             context.reportError(`Type ${type} must only implement Interface types, ` +
-                `it cannot implement ${(0, inspect_js_1.inspect)(iface)}.`, getAllImplementsInterfaceNodes(type, iface));
+                `it cannot implement ${(0, inspect_ts_1.inspect)(iface)}.`, getAllImplementsInterfaceNodes(type, iface));
             continue;
         }
         if (type === iface) {
@@ -342,7 +342,7 @@ function validateTypeImplementsInterface(context, type, iface) {
         }
         // Assert interface field type is satisfied by type field type, by being
         // a valid subtype. (covariant)
-        if (!(0, typeComparators_js_1.isTypeSubTypeOf)(context.schema, typeField.type, ifaceField.type)) {
+        if (!(0, typeComparators_ts_1.isTypeSubTypeOf)(context.schema, typeField.type, ifaceField.type)) {
             context.reportError(`Interface field ${ifaceField} expects type ${ifaceField.type} ` +
                 `but ${typeField} is type ${typeField.type}.`, [ifaceField.astNode?.type, typeField.astNode?.type]);
         }
@@ -357,14 +357,14 @@ function validateTypeImplementsInterface(context, type, iface) {
             // Assert interface field arg type matches object field arg type.
             // (invariant)
             // TODO: change to contravariant?
-            if (!(0, typeComparators_js_1.isEqualType)(ifaceArg.type, typeArg.type)) {
+            if (!(0, typeComparators_ts_1.isEqualType)(ifaceArg.type, typeArg.type)) {
                 context.reportError(`Interface field argument ${ifaceArg} expects type ${ifaceArg.type} ` +
                     `but ${typeArg} is type ${typeArg.type}.`, [ifaceArg.astNode?.type, typeArg.astNode?.type]);
             }
         }
         // Assert additional arguments must not be required.
         for (const typeArg of typeField.args) {
-            if ((0, definition_js_1.isRequiredArgument)(typeArg)) {
+            if ((0, definition_ts_1.isRequiredArgument)(typeArg)) {
                 const ifaceArg = ifaceField.args.find((arg) => arg.name === typeArg.name);
                 if (!ifaceArg) {
                     context.reportError(`Argument "${typeArg}" must not be required type "${typeArg.type}" ` +
@@ -408,9 +408,9 @@ function validateUnionMembers(context, union) {
             continue;
         }
         includedTypeNames.add(memberType.name);
-        if (!(0, definition_js_1.isObjectType)(memberType)) {
+        if (!(0, definition_ts_1.isObjectType)(memberType)) {
             context.reportError(`Union type ${union} can only include Object types, ` +
-                `it cannot include ${(0, inspect_js_1.inspect)(memberType)}.`, getUnionMemberTypeNodes(union, String(memberType)));
+                `it cannot include ${(0, inspect_ts_1.inspect)(memberType)}.`, getUnionMemberTypeNodes(union, String(memberType)));
         }
     }
 }
@@ -434,11 +434,11 @@ function validateInputFields(context, inputObj) {
         // Ensure they are named correctly.
         validateName(context, field);
         // Ensure the type is an input type
-        if (!(0, definition_js_1.isInputType)(field.type)) {
+        if (!(0, definition_ts_1.isInputType)(field.type)) {
             context.reportError(`The type of ${field} must be Input Type ` +
-                `but got: ${(0, inspect_js_1.inspect)(field.type)}.`, field.astNode?.type);
+                `but got: ${(0, inspect_ts_1.inspect)(field.type)}.`, field.astNode?.type);
         }
-        if ((0, definition_js_1.isRequiredInputField)(field) && field.deprecationReason != null) {
+        if ((0, definition_ts_1.isRequiredInputField)(field) && field.deprecationReason != null) {
             context.reportError(`Required input field ${field} cannot be deprecated.`, [getDeprecatedDirectiveNode(field.astNode), field.astNode?.type]);
         }
         validateDefaultValue(context, field);
@@ -448,7 +448,7 @@ function validateInputFields(context, inputObj) {
     }
 }
 function validateOneOfInputObjectField(type, field, context) {
-    if ((0, definition_js_1.isNonNullType)(field.type)) {
+    if ((0, definition_ts_1.isNonNullType)(field.type)) {
         context.reportError(`OneOf input field ${type}.${field.name} must be nullable.`, field.astNode?.type);
     }
     if (field.default !== undefined || field.defaultValue !== undefined) {
@@ -476,7 +476,7 @@ function createInputObjectNonNullCircularRefsValidator(context) {
         fieldPathIndexByTypeName[inputObj.name] = fieldPath.length;
         const fields = Object.values(inputObj.getFields());
         for (const field of fields) {
-            if ((0, definition_js_1.isNonNullType)(field.type) && (0, definition_js_1.isInputObjectType)(field.type.ofType)) {
+            if ((0, definition_ts_1.isNonNullType)(field.type) && (0, definition_ts_1.isInputObjectType)(field.type.ofType)) {
                 const fieldType = field.type.ofType;
                 const cycleIndex = fieldPathIndexByTypeName[fieldType.name];
                 fieldPath.push({
@@ -521,20 +521,20 @@ function createInputObjectDefaultValueCircularRefsValidator(context) {
     function detectValueDefaultValueCycle(inputObj, defaultValue) {
         // If the value is a List, recursively check each entry for a cycle.
         // Otherwise, only object values can contain a cycle.
-        if ((0, isIterableObject_js_1.isIterableObject)(defaultValue)) {
+        if ((0, isIterableObject_ts_1.isIterableObject)(defaultValue)) {
             for (const itemValue of defaultValue) {
                 detectValueDefaultValueCycle(inputObj, itemValue);
             }
             return;
         }
-        else if (!(0, isObjectLike_js_1.isObjectLike)(defaultValue)) {
+        else if (!(0, isObjectLike_ts_1.isObjectLike)(defaultValue)) {
             return;
         }
         // Check each defined field for a cycle.
         for (const field of Object.values(inputObj.getFields())) {
-            const namedFieldType = (0, definition_js_1.getNamedType)(field.type);
+            const namedFieldType = (0, definition_ts_1.getNamedType)(field.type);
             // Only input object type fields can result in a cycle.
-            if (!(0, definition_js_1.isInputObjectType)(namedFieldType)) {
+            if (!(0, definition_ts_1.isInputObjectType)(namedFieldType)) {
                 continue;
             }
             if (Object.hasOwn(defaultValue, field.name)) {
@@ -551,21 +551,21 @@ function createInputObjectDefaultValueCircularRefsValidator(context) {
     function detectLiteralDefaultValueCycle(inputObj, defaultValue) {
         // If the value is a List, recursively check each entry for a cycle.
         // Otherwise, only object values can contain a cycle.
-        if (defaultValue.kind === kinds_js_1.Kind.LIST) {
+        if (defaultValue.kind === kinds_ts_1.Kind.LIST) {
             for (const itemLiteral of defaultValue.values) {
                 detectLiteralDefaultValueCycle(inputObj, itemLiteral);
             }
             return;
         }
-        else if (defaultValue.kind !== kinds_js_1.Kind.OBJECT) {
+        else if (defaultValue.kind !== kinds_ts_1.Kind.OBJECT) {
             return;
         }
         // Check each defined field for a cycle.
-        const fieldNodes = (0, keyMap_js_1.keyMap)(defaultValue.fields, (field) => field.name.value);
+        const fieldNodes = (0, keyMap_ts_1.keyMap)(defaultValue.fields, (field) => field.name.value);
         for (const field of Object.values(inputObj.getFields())) {
-            const namedFieldType = (0, definition_js_1.getNamedType)(field.type);
+            const namedFieldType = (0, definition_ts_1.getNamedType)(field.type);
             // Only input object type fields can result in a cycle.
-            if (!(0, definition_js_1.isInputObjectType)(namedFieldType)) {
+            if (!(0, definition_ts_1.isInputObjectType)(namedFieldType)) {
                 continue;
             }
             if (Object.hasOwn(fieldNodes, field.name)) {
@@ -625,10 +625,10 @@ function getUnionMemberTypeNodes(union, typeName) {
     const { astNode, extensionASTNodes } = union;
     const nodes = astNode != null ? [astNode, ...extensionASTNodes] : extensionASTNodes;
     return nodes
-        .flatMap((unionNode) => /* c8 ignore next */ unionNode.types ?? [])
+        .flatMap((unionNode) => unionNode.types ?? [])
         .filter((typeNode) => typeNode.name.value === typeName);
 }
 function getDeprecatedDirectiveNode(definitionNode) {
-    return definitionNode?.directives?.find((node) => node.name.value === directives_js_1.GraphQLDeprecatedDirective.name);
+    return definitionNode?.directives?.find((node) => node.name.value === directives_ts_1.GraphQLDeprecatedDirective.name);
 }
 //# sourceMappingURL=validate.js.map