graphql 17.0.0-beta.0 → 17.0.0-beta.2

package/type/definition.js

@@ -49,21 +49,21 @@ exports.resolveReadonlyArrayThunk = resolveReadonlyArrayThunk;
 exports.resolveObjMapThunk = resolveObjMapThunk;
 exports.isRequiredArgument = isRequiredArgument;
 exports.isRequiredInputField = isRequiredInputField;
-const devAssert_js_1 = require("../jsutils/devAssert.js");
-const didYouMean_js_1 = require("../jsutils/didYouMean.js");
-const identityFunc_js_1 = require("../jsutils/identityFunc.js");
-const inspect_js_1 = require("../jsutils/inspect.js");
-const instanceOf_js_1 = require("../jsutils/instanceOf.js");
-const keyMap_js_1 = require("../jsutils/keyMap.js");
-const keyValMap_js_1 = require("../jsutils/keyValMap.js");
-const mapValue_js_1 = require("../jsutils/mapValue.js");
-const suggestionList_js_1 = require("../jsutils/suggestionList.js");
-const toObjMap_js_1 = require("../jsutils/toObjMap.js");
-const GraphQLError_js_1 = require("../error/GraphQLError.js");
-const kinds_js_1 = require("../language/kinds.js");
-const printer_js_1 = require("../language/printer.js");
-const valueFromASTUntyped_js_1 = require("../utilities/valueFromASTUntyped.js");
-const assertName_js_1 = require("./assertName.js");
+const devAssert_ts_1 = require("../jsutils/devAssert.js");
+const didYouMean_ts_1 = require("../jsutils/didYouMean.js");
+const identityFunc_ts_1 = require("../jsutils/identityFunc.js");
+const inspect_ts_1 = require("../jsutils/inspect.js");
+const instanceOf_ts_1 = require("../jsutils/instanceOf.js");
+const keyMap_ts_1 = require("../jsutils/keyMap.js");
+const keyValMap_ts_1 = require("../jsutils/keyValMap.js");
+const mapValue_ts_1 = require("../jsutils/mapValue.js");
+const suggestionList_ts_1 = require("../jsutils/suggestionList.js");
+const toObjMap_ts_1 = require("../jsutils/toObjMap.js");
+const GraphQLError_ts_1 = require("../error/GraphQLError.js");
+const kinds_ts_1 = require("../language/kinds.js");
+const printer_ts_1 = require("../language/printer.js");
+const valueFromASTUntyped_ts_1 = require("../utilities/valueFromASTUntyped.js");
+const assertName_ts_1 = require("./assertName.js");
 function isType(type) {
     return (isScalarType(type) ||
         isObjectType(type) ||
@@ -76,130 +76,127 @@ function isType(type) {
 }
 function assertType(type) {
     if (!isType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL type.`);
     }
     return type;
 }
 const scalarSymbol = Symbol('Scalar');
-/**
- * There are predicates for each GraphQL schema element.
- */
 function isScalarType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, scalarSymbol, GraphQLScalarType);
+    return (0, instanceOf_ts_1.instanceOf)(type, scalarSymbol, GraphQLScalarType);
 }
 function assertScalarType(type) {
     if (!isScalarType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL Scalar type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL Scalar type.`);
     }
     return type;
 }
 const objectSymbol = Symbol('Object');
 function isObjectType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, objectSymbol, GraphQLObjectType);
+    return (0, instanceOf_ts_1.instanceOf)(type, objectSymbol, GraphQLObjectType);
 }
 function assertObjectType(type) {
     if (!isObjectType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL Object type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL Object type.`);
     }
     return type;
 }
 const fieldSymbol = Symbol('Field');
 function isField(field) {
-    return (0, instanceOf_js_1.instanceOf)(field, fieldSymbol, GraphQLField);
+    return (0, instanceOf_ts_1.instanceOf)(field, fieldSymbol, GraphQLField);
 }
 function assertField(field) {
     if (!isField(field)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(field)} to be a GraphQL field.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(field)} to be a GraphQL field.`);
     }
     return field;
 }
 const argumentSymbol = Symbol('Argument');
 function isArgument(arg) {
-    return (0, instanceOf_js_1.instanceOf)(arg, argumentSymbol, GraphQLArgument);
+    return (0, instanceOf_ts_1.instanceOf)(arg, argumentSymbol, GraphQLArgument);
 }
 function assertArgument(arg) {
     if (!isArgument(arg)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(arg)} to be a GraphQL argument.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(arg)} to be a GraphQL argument.`);
     }
     return arg;
 }
 const interfaceSymbol = Symbol('Interface');
 function isInterfaceType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, interfaceSymbol, GraphQLInterfaceType);
+    return (0, instanceOf_ts_1.instanceOf)(type, interfaceSymbol, GraphQLInterfaceType);
 }
 function assertInterfaceType(type) {
     if (!isInterfaceType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL Interface type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL Interface type.`);
     }
     return type;
 }
 const unionSymbol = Symbol('Union');
 function isUnionType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, unionSymbol, GraphQLUnionType);
+    return (0, instanceOf_ts_1.instanceOf)(type, unionSymbol, GraphQLUnionType);
 }
 function assertUnionType(type) {
     if (!isUnionType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL Union type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL Union type.`);
     }
     return type;
 }
 const enumSymbol = Symbol('Enum');
 function isEnumType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, enumSymbol, GraphQLEnumType);
+    return (0, instanceOf_ts_1.instanceOf)(type, enumSymbol, GraphQLEnumType);
 }
 function assertEnumType(type) {
     if (!isEnumType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL Enum type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL Enum type.`);
     }
     return type;
 }
 const enumValueSymbol = Symbol('EnumValue');
 function isEnumValue(value) {
-    return (0, instanceOf_js_1.instanceOf)(value, enumValueSymbol, GraphQLEnumValue);
+    return (0, instanceOf_ts_1.instanceOf)(value, enumValueSymbol, GraphQLEnumValue);
 }
 function assertEnumValue(value) {
     if (!isEnumValue(value)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(value)} to be a GraphQL Enum value.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(value)} to be a GraphQL Enum value.`);
     }
     return value;
 }
 const inputObjectSymbol = Symbol('InputObject');
 function isInputObjectType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, inputObjectSymbol, GraphQLInputObjectType);
+    return (0, instanceOf_ts_1.instanceOf)(type, inputObjectSymbol, GraphQLInputObjectType);
 }
 function assertInputObjectType(type) {
     if (!isInputObjectType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL Input Object type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL Input Object type.`);
     }
     return type;
 }
 const inputFieldSymbol = Symbol('InputField');
 function isInputField(field) {
-    return (0, instanceOf_js_1.instanceOf)(field, inputFieldSymbol, GraphQLInputField);
+    return (0, instanceOf_ts_1.instanceOf)(field, inputFieldSymbol, GraphQLInputField);
 }
 function assertInputField(field) {
     if (!isInputField(field)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(field)} to be a GraphQL input field.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(field)} to be a GraphQL input field.`);
     }
     return field;
 }
 const listSymbol = Symbol('List');
 function isListType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, listSymbol, GraphQLList);
+    return (0, instanceOf_ts_1.instanceOf)(type, listSymbol, GraphQLList);
 }
 function assertListType(type) {
     if (!isListType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL List type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL List type.`);
     }
     return type;
 }
 const nonNullSymbol = Symbol('NonNull');
 function isNonNullType(type) {
-    return (0, instanceOf_js_1.instanceOf)(type, nonNullSymbol, GraphQLNonNull);
+    return (0, instanceOf_ts_1.instanceOf)(type, nonNullSymbol, GraphQLNonNull);
 }
 function assertNonNullType(type) {
     if (!isNonNullType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL Non-Null type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL Non-Null type.`);
     }
     return type;
 }
@@ -211,7 +208,7 @@ function isInputType(type) {
 }
 function assertInputType(type) {
     if (!isInputType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL input type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL input type.`);
     }
     return type;
 }
@@ -225,7 +222,7 @@ function isOutputType(type) {
 }
 function assertOutputType(type) {
     if (!isOutputType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL output type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL output type.`);
     }
     return type;
 }
@@ -234,7 +231,7 @@ function isLeafType(type) {
 }
 function assertLeafType(type) {
     if (!isLeafType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL leaf type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL leaf type.`);
     }
     return type;
 }
@@ -243,7 +240,7 @@ function isCompositeType(type) {
 }
 function assertCompositeType(type) {
     if (!isCompositeType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL composite type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL composite type.`);
     }
     return type;
 }
@@ -252,29 +249,10 @@ function isAbstractType(type) {
 }
 function assertAbstractType(type) {
     if (!isAbstractType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL abstract type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL abstract type.`);
     }
     return type;
 }
-/**
- * List Type Wrapper
- *
- * A list is a wrapping type which points to another type.
- * Lists are often created within the context of defining the fields of
- * an object type.
- *
- * Example:
- *
- * ```ts
- * const PersonType = new GraphQLObjectType({
- *   name: 'Person',
- *   fields: () => ({
- *     parents: { type: new GraphQLList(PersonType) },
- *     children: { type: new GraphQLList(PersonType) },
- *   })
- * })
- * ```
- */
 class GraphQLList {
     constructor(ofType) {
         this.__kind = listSymbol;
@@ -291,27 +269,6 @@ class GraphQLList {
     }
 }
 exports.GraphQLList = GraphQLList;
-/**
- * Non-Null Type Wrapper
- *
- * A non-null is a wrapping type which points to another type.
- * Non-null types enforce that their values are never null and can ensure
- * an error is raised if this ever occurs during a request. It is useful for
- * fields which you can make a strong guarantee on non-nullability, for example
- * usually the id field of a database row will never be null.
- *
- * Example:
- *
- * ```ts
- * const RowType = new GraphQLObjectType({
- *   name: 'Row',
- *   fields: () => ({
- *     id: { type: new GraphQLNonNull(GraphQLString) },
- *   })
- * })
- * ```
- * Note: the enforcement of non-nullability occurs within the executor.
- */
 class GraphQLNonNull {
     constructor(ofType) {
         this.__kind = nonNullSymbol;
@@ -333,7 +290,7 @@ function isWrappingType(type) {
 }
 function assertWrappingType(type) {
     if (!isWrappingType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL wrapping type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL wrapping type.`);
     }
     return type;
 }
@@ -342,7 +299,7 @@ function isNullableType(type) {
 }
 function assertNullableType(type) {
     if (!isNullableType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL nullable type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL nullable type.`);
     }
     return type;
 }
@@ -361,7 +318,7 @@ function isNamedType(type) {
 }
 function assertNamedType(type) {
     if (!isNamedType(type)) {
-        throw new Error(`Expected ${(0, inspect_js_1.inspect)(type)} to be a GraphQL named type.`);
+        throw new Error(`Expected ${(0, inspect_ts_1.inspect)(type)} to be a GraphQL named type.`);
     }
     return type;
 }
@@ -380,114 +337,39 @@ function resolveReadonlyArrayThunk(thunk) {
 function resolveObjMapThunk(thunk) {
     return typeof thunk === 'function' ? thunk() : thunk;
 }
-/**
- * Scalar Type Definition
- *
- * The leaf values of any request and input values to arguments are
- * Scalars (or Enums) and are defined with a name and a series of functions
- * used to parse input from ast or variables and to ensure validity.
- *
- * If a type's coerceOutputValue function returns `null` or does not return a
- * value (i.e. it returns `undefined`) then an error will be raised and a
- * `null` value will be returned in the response. It is always better to
- * validate.
- *
- * Example:
- *
- * ```ts
- * function ensureOdd(value) {
- *   if (!Number.isFinite(value)) {
- *     throw new Error(
- *       `Scalar "Odd" cannot represent "${value}" since it is not a finite number.`,
- *     );
- *   }
- *
- *   if (value % 2 === 0) {
- *     throw new Error(`Scalar "Odd" cannot represent "${value}" since it is even.`);
- *   }
- * }
- *
- * const OddType = new GraphQLScalarType({
- *   name: 'Odd',
- *   coerceOutputValue(value) {
- *     return ensureOdd(value);
- *   },
- *   coerceInputValue(value) {
- *     return ensureOdd(value);
- *   }
- *   valueToLiteral(value) {
- *    return parse(`${ensureOdd(value)`);
- *   }
- * });
- * ```
- *
- * Custom scalars behavior is defined via the following functions:
- *
- *  - coerceOutputValue(value): Implements "Result Coercion". Given an internal value,
- *    produces an external value valid for this type. Returns undefined or
- *    throws an error to indicate invalid values.
- *
- *  - coerceInputValue(value): Implements "Input Coercion" for values. Given an
- *    external value (for example, variable values), produces an internal value
- *    valid for this type. Returns undefined or throws an error to indicate
- *    invalid values.
- *
- *  - coerceInputLiteral(ast): Implements "Input Coercion" for constant literals.
- *    Given an GraphQL literal (AST) (for example, an argument value), produces
- *    an internal value valid for this type. Returns undefined or throws an
- *    error to indicate invalid values.
- *
- *  - valueToLiteral(value): Converts an external value to a GraphQL
- *    literal (AST). Returns undefined or throws an error to indicate
- *    invalid values.
- *
- *  Deprecated, to be removed in v18:
- *
- *  - serialize(value): Implements "Result Coercion". Renamed to
- *    `coerceOutputValue()`.
- *
- *  - parseValue(value): Implements "Input Coercion" for values. Renamed to
- *    `coerceInputValue()`.
- *
- *  - parseLiteral(ast): Implements "Input Coercion" for literals including
- *    non-specified replacement of variables embedded within complex scalars.
- *    Replaced by the combination of the `replaceVariables()` utility and the
- *    `coerceInputLiteral()` method.
- *
- */
 class GraphQLScalarType {
     constructor(config) {
         this.__kind = scalarSymbol;
-        this.name = (0, assertName_js_1.assertName)(config.name);
+        this.name = (0, assertName_ts_1.assertName)(config.name);
         this.description = config.description;
         this.specifiedByURL = config.specifiedByURL;
         this.serialize =
             config.serialize ??
                 config.coerceOutputValue ??
-                identityFunc_js_1.identityFunc;
+                identityFunc_ts_1.identityFunc;
         this.parseValue =
             config.parseValue ??
                 config.coerceInputValue ??
-                identityFunc_js_1.identityFunc;
+                identityFunc_ts_1.identityFunc;
         this.parseLiteral =
             config.parseLiteral ??
-                ((node, variables) => this.coerceInputValue((0, valueFromASTUntyped_js_1.valueFromASTUntyped)(node, variables)));
+                ((node, variables) => this.coerceInputValue((0, valueFromASTUntyped_ts_1.valueFromASTUntyped)(node, variables)));
         this.coerceOutputValue = config.coerceOutputValue ?? this.serialize;
         this.coerceInputValue = config.coerceInputValue ?? this.parseValue;
         this.coerceInputLiteral = config.coerceInputLiteral;
         this.valueToLiteral = config.valueToLiteral;
-        this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
+        this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
         this.extensionASTNodes = config.extensionASTNodes ?? [];
         if (config.parseLiteral) {
             if (!(typeof config.parseValue === 'function' &&
                 typeof config.parseLiteral === 'function'))
-                (0, devAssert_js_1.devAssert)(false, `${this.name} must provide both "parseValue" and "parseLiteral" functions.`);
+                (0, devAssert_ts_1.devAssert)(false, `${this.name} must provide both "parseValue" and "parseLiteral" functions.`);
         }
         if (config.coerceInputLiteral) {
             if (!(typeof config.coerceInputValue === 'function' &&
                 typeof config.coerceInputLiteral === 'function'))
-                (0, devAssert_js_1.devAssert)(false, `${this.name} must provide both "coerceInputValue" and "coerceInputLiteral" functions.`);
+                (0, devAssert_ts_1.devAssert)(false, `${this.name} must provide both "coerceInputValue" and "coerceInputLiteral" functions.`);
         }
     }
     get [Symbol.toStringTag]() {
@@ -518,54 +400,14 @@ class GraphQLScalarType {
     }
 }
 exports.GraphQLScalarType = GraphQLScalarType;
-/**
- * Object Type Definition
- *
- * Almost all of the GraphQL types you define will be object types. Object types
- * have a name, but most importantly describe their fields.
- *
- * Example:
- *
- * ```ts
- * const AddressType = new GraphQLObjectType({
- *   name: 'Address',
- *   fields: {
- *     street: { type: GraphQLString },
- *     number: { type: GraphQLInt },
- *     formatted: {
- *       type: GraphQLString,
- *       resolve(obj) {
- *         return obj.number + ' ' + obj.street
- *       }
- *     }
- *   }
- * });
- * ```
- *
- * When two types need to refer to each other, or a type needs to refer to
- * itself in a field, you can use a function expression (aka a closure or a
- * thunk) to supply the fields lazily.
- *
- * Example:
- *
- * ```ts
- * const PersonType = new GraphQLObjectType({
- *   name: 'Person',
- *   fields: () => ({
- *     name: { type: GraphQLString },
- *     bestFriend: { type: PersonType },
- *   })
- * });
- * ```
- */
 class GraphQLObjectType {
     constructor(config) {
         this.__kind = objectSymbol;
         this.__kind = objectSymbol;
-        this.name = (0, assertName_js_1.assertName)(config.name);
+        this.name = (0, assertName_ts_1.assertName)(config.name);
         this.description = config.description;
         this.isTypeOf = config.isTypeOf;
-        this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
+        this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
         this.extensionASTNodes = config.extensionASTNodes ?? [];
         this._fields = (defineFieldMap).bind(undefined, this, config.fields);
@@ -591,7 +433,7 @@ class GraphQLObjectType {
             name: this.name,
             description: this.description,
             interfaces: this.getInterfaces(),
-            fields: (0, mapValue_js_1.mapValue)(this.getFields(), (field) => field.toConfig()),
+            fields: (0, mapValue_ts_1.mapValue)(this.getFields(), (field) => field.toConfig()),
             isTypeOf: this.isTypeOf,
             extensions: this.extensions,
             astNode: this.astNode,
@@ -611,13 +453,13 @@ function defineInterfaces(interfaces) {
 }
 function defineFieldMap(parentType, fields) {
     const fieldMap = resolveObjMapThunk(fields);
-    return (0, mapValue_js_1.mapValue)(fieldMap, (fieldConfig, fieldName) => new GraphQLField(parentType, fieldName, fieldConfig));
+    return (0, mapValue_ts_1.mapValue)(fieldMap, (fieldConfig, fieldName) => new GraphQLField(parentType, fieldName, fieldConfig));
 }
 class GraphQLField {
     constructor(parentType, name, config) {
         this.__kind = fieldSymbol;
         this.parentType = parentType;
-        this.name = (0, assertName_js_1.assertName)(name);
+        this.name = (0, assertName_ts_1.assertName)(name);
         this.description = config.description;
         this.type = config.type;
         const argsConfig = config.args;
@@ -627,7 +469,7 @@ class GraphQLField {
         this.resolve = config.resolve;
         this.subscribe = config.subscribe;
         this.deprecationReason = config.deprecationReason;
-        this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
+        this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
     }
     get [Symbol.toStringTag]() {
@@ -637,7 +479,7 @@ class GraphQLField {
         return {
             description: this.description,
             type: this.type,
-            args: (0, keyValMap_js_1.keyValMap)(this.args, (arg) => arg.name, (arg) => arg.toConfig()),
+            args: (0, keyValMap_ts_1.keyValMap)(this.args, (arg) => arg.name, (arg) => arg.toConfig()),
             resolve: this.resolve,
             subscribe: this.subscribe,
             deprecationReason: this.deprecationReason,
@@ -657,13 +499,14 @@ class GraphQLArgument {
     constructor(parent, name, config) {
         this.__kind = argumentSymbol;
         this.parent = parent;
-        this.name = (0, assertName_js_1.assertName)(name);
+        this.name = (0, assertName_ts_1.assertName)(name);
         this.description = config.description;
         this.type = config.type;
         this.defaultValue = config.defaultValue;
         this.default = config.default;
+        this._memoizedCoercedDefaultValue = undefined;
         this.deprecationReason = config.deprecationReason;
-        this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
+        this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
     }
     get [Symbol.toStringTag]() {
@@ -693,32 +536,13 @@ function isRequiredArgument(arg) {
         arg.default === undefined &&
         arg.defaultValue === undefined);
 }
-/**
- * Interface Type Definition
- *
- * When a field can return one of a heterogeneous set of types, a Interface type
- * is used to describe what types are possible, what fields are in common across
- * all types, as well as a function to determine which type is actually used
- * when the field is resolved.
- *
- * Example:
- *
- * ```ts
- * const EntityType = new GraphQLInterfaceType({
- *   name: 'Entity',
- *   fields: {
- *     name: { type: GraphQLString }
- *   }
- * });
- * ```
- */
 class GraphQLInterfaceType {
     constructor(config) {
         this.__kind = interfaceSymbol;
-        this.name = (0, assertName_js_1.assertName)(config.name);
+        this.name = (0, assertName_ts_1.assertName)(config.name);
         this.description = config.description;
         this.resolveType = config.resolveType;
-        this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
+        this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
         this.extensionASTNodes = config.extensionASTNodes ?? [];
         this._fields = (defineFieldMap).bind(undefined, this, config.fields);
@@ -744,7 +568,7 @@ class GraphQLInterfaceType {
             name: this.name,
             description: this.description,
             interfaces: this.getInterfaces(),
-            fields: (0, mapValue_js_1.mapValue)(this.getFields(), (field) => field.toConfig()),
+            fields: (0, mapValue_ts_1.mapValue)(this.getFields(), (field) => field.toConfig()),
             resolveType: this.resolveType,
             extensions: this.extensions,
             astNode: this.astNode,
@@ -759,37 +583,13 @@ class GraphQLInterfaceType {
     }
 }
 exports.GraphQLInterfaceType = GraphQLInterfaceType;
-/**
- * Union Type Definition
- *
- * When a field can return one of a heterogeneous set of types, a Union type
- * is used to describe what types are possible as well as providing a function
- * to determine which type is actually used when the field is resolved.
- *
- * Example:
- *
- * ```ts
- * const PetType = new GraphQLUnionType({
- *   name: 'Pet',
- *   types: [ DogType, CatType ],
- *   resolveType(value) {
- *     if (value instanceof Dog) {
- *       return DogType;
- *     }
- *     if (value instanceof Cat) {
- *       return CatType;
- *     }
- *   }
- * });
- * ```
- */
 class GraphQLUnionType {
     constructor(config) {
         this.__kind = unionSymbol;
-        this.name = (0, assertName_js_1.assertName)(config.name);
+        this.name = (0, assertName_ts_1.assertName)(config.name);
         this.description = config.description;
         this.resolveType = config.resolveType;
-        this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
+        this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
         this.extensionASTNodes = config.extensionASTNodes ?? [];
         this._types = defineTypes.bind(undefined, config.types);
@@ -825,35 +625,12 @@ exports.GraphQLUnionType = GraphQLUnionType;
 function defineTypes(types) {
     return resolveReadonlyArrayThunk(types);
 }
-/**
- * Enum Type Definition
- *
- * Some leaf values of requests and input values are Enums. GraphQL coerces
- * Enum values as strings, however internally Enums can be represented by any
- * kind of type, often integers.
- *
- * Example:
- *
- * ```ts
- * const RGBType = new GraphQLEnumType({
- *   name: 'RGB',
- *   values: {
- *     RED: { value: 0 },
- *     GREEN: { value: 1 },
- *     BLUE: { value: 2 }
- *   }
- * });
- * ```
- *
- * Note: If a value is not provided in a definition, the name of the enum value
- * will be used as its internal value.
- */
-class GraphQLEnumType /* <T> */ {
+class GraphQLEnumType {
     constructor(config) {
         this.__kind = enumSymbol;
-        this.name = (0, assertName_js_1.assertName)(config.name);
+        this.name = (0, assertName_ts_1.assertName)(config.name);
         this.description = config.description;
-        this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
+        this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
         this.extensionASTNodes = config.extensionASTNodes ?? [];
         this._values = defineEnumValues.bind(undefined, this, config.values);
@@ -870,67 +647,63 @@ class GraphQLEnumType /* <T> */ {
         return this._values;
     }
     getValue(name) {
-        this._nameLookup ??= (0, keyMap_js_1.keyMap)(this.getValues(), (value) => value.name);
+        this._nameLookup ??= (0, keyMap_ts_1.keyMap)(this.getValues(), (value) => value.name);
         return this._nameLookup[name];
     }
-    /** @deprecated use `coerceOutputValue()` instead, `serialize()` will be removed in v18 */
-    serialize(outputValue /* T */) {
+    serialize(outputValue) {
         return this.coerceOutputValue(outputValue);
     }
-    coerceOutputValue(outputValue /* T */) {
+    coerceOutputValue(outputValue) {
         this._valueLookup ??= new Map(this.getValues().map((enumValue) => [enumValue.value, enumValue]));
         const enumValue = this._valueLookup.get(outputValue);
         if (enumValue === undefined) {
-            throw new GraphQLError_js_1.GraphQLError(`Enum "${this.name}" cannot represent value: ${(0, inspect_js_1.inspect)(outputValue)}`);
+            throw new GraphQLError_ts_1.GraphQLError(`Enum "${this.name}" cannot represent value: ${(0, inspect_ts_1.inspect)(outputValue)}`);
         }
         return enumValue.name;
     }
-    /** @deprecated use `coerceInputValue()` instead, `parseValue()` will be removed in v18 */
     parseValue(inputValue, hideSuggestions) {
         return this.coerceInputValue(inputValue, hideSuggestions);
     }
     coerceInputValue(inputValue, hideSuggestions) {
         if (typeof inputValue !== 'string') {
-            const valueStr = (0, inspect_js_1.inspect)(inputValue);
-            throw new GraphQLError_js_1.GraphQLError(`Enum "${this.name}" cannot represent non-string value: ${valueStr}.` +
+            const valueStr = (0, inspect_ts_1.inspect)(inputValue);
+            throw new GraphQLError_ts_1.GraphQLError(`Enum "${this.name}" cannot represent non-string value: ${valueStr}.` +
                 (hideSuggestions ? '' : didYouMeanEnumValue(this, valueStr)));
         }
         const enumValue = this.getValue(inputValue);
         if (enumValue == null) {
-            throw new GraphQLError_js_1.GraphQLError(`Value "${inputValue}" does not exist in "${this.name}" enum.` +
+            throw new GraphQLError_ts_1.GraphQLError(`Value "${inputValue}" does not exist in "${this.name}" enum.` +
                 (hideSuggestions ? '' : didYouMeanEnumValue(this, inputValue)));
         }
         return enumValue.value;
     }
-    /** @deprecated use `coerceInputLiteral()` instead, `parseLiteral()` will be removed in v18 */
     parseLiteral(valueNode, _variables, hideSuggestions) {
-        // Note: variables will be resolved to a value before calling this function.
         return this.coerceInputLiteral(valueNode, hideSuggestions);
     }
     coerceInputLiteral(valueNode, hideSuggestions) {
-        if (valueNode.kind !== kinds_js_1.Kind.ENUM) {
-            const valueStr = (0, printer_js_1.print)(valueNode);
-            throw new GraphQLError_js_1.GraphQLError(`Enum "${this.name}" cannot represent non-enum value: ${valueStr}.` +
+        if (valueNode.kind !== kinds_ts_1.Kind.ENUM) {
+            const valueStr = (0, printer_ts_1.print)(valueNode);
+            throw new GraphQLError_ts_1.GraphQLError(`Enum "${this.name}" cannot represent non-enum value: ${valueStr}.` +
                 (hideSuggestions ? '' : didYouMeanEnumValue(this, valueStr)), { nodes: valueNode });
         }
         const enumValue = this.getValue(valueNode.value);
         if (enumValue == null) {
-            const valueStr = (0, printer_js_1.print)(valueNode);
-            throw new GraphQLError_js_1.GraphQLError(`Value "${valueStr}" does not exist in "${this.name}" enum.` +
+            const valueStr = (0, printer_ts_1.print)(valueNode);
+            throw new GraphQLError_ts_1.GraphQLError(`Value "${valueStr}" does not exist in "${this.name}" enum.` +
                 (hideSuggestions ? '' : didYouMeanEnumValue(this, valueStr)), { nodes: valueNode });
         }
         return enumValue.value;
     }
     valueToLiteral(value) {
         if (typeof value === 'string' && this.getValue(value)) {
-            return { kind: kinds_js_1.Kind.ENUM, value };
+            return { kind: kinds_ts_1.Kind.ENUM, value };
         }
     }
     toConfig() {
         return {
             name: this.name,
             description: this.description,
-            values: (0, keyValMap_js_1.keyValMap)(this.getValues(), (value) => value.name, (value) => value.toConfig()),
+            values: (0, keyValMap_ts_1.keyValMap)(this.getValues(), (value) => value.name, (value) => value.toConfig()),
             extensions: this.extensions,
             astNode: this.astNode,
             extensionASTNodes: this.extensionASTNodes,
@@ -950,18 +723,18 @@ function defineEnumValues(parentEnum, values) {
 }
 function didYouMeanEnumValue(enumType, unknownValueStr) {
     const allNames = enumType.getValues().map((value) => value.name);
-    const suggestedValues = (0, suggestionList_js_1.suggestionList)(unknownValueStr, allNames);
-    return (0, didYouMean_js_1.didYouMean)('the enum value', suggestedValues);
+    const suggestedValues = (0, suggestionList_ts_1.suggestionList)(unknownValueStr, allNames);
+    return (0, didYouMean_ts_1.didYouMean)('the enum value', suggestedValues);
 }
 class GraphQLEnumValue {
     constructor(parentEnum, name, config) {
         this.__kind = enumValueSymbol;
         this.parentEnum = parentEnum;
-        this.name = (0, assertName_js_1.assertEnumValueName)(name);
+        this.name = (0, assertName_ts_1.assertEnumValueName)(name);
         this.description = config.description;
         this.value = config.value !== undefined ? config.value : name;
         this.deprecationReason = config.deprecationReason;
-        this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
+        this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
     }
     get [Symbol.toStringTag]() {
@@ -984,33 +757,12 @@ class GraphQLEnumValue {
     }
 }
 exports.GraphQLEnumValue = GraphQLEnumValue;
-/**
- * Input Object Type Definition
- *
- * An input object defines a structured collection of fields which may be
- * supplied to a field argument.
- *
- * Using `NonNull` will ensure that a value must be provided by the query
- *
- * Example:
- *
- * ```ts
- * const GeoPoint = new GraphQLInputObjectType({
- *   name: 'GeoPoint',
- *   fields: {
- *     lat: { type: new GraphQLNonNull(GraphQLFloat) },
- *     lon: { type: new GraphQLNonNull(GraphQLFloat) },
- *     alt: { type: GraphQLFloat, defaultValue: 0 },
- *   }
- * });
- * ```
- */
 class GraphQLInputObjectType {
     constructor(config) {
         this.__kind = inputObjectSymbol;
-        this.name = (0, assertName_js_1.assertName)(config.name);
+        this.name = (0, assertName_ts_1.assertName)(config.name);
         this.description = config.description;
-        this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
+        this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
         this.extensionASTNodes = config.extensionASTNodes ?? [];
         this.isOneOf = config.isOneOf ?? false;
@@ -1029,7 +781,7 @@ class GraphQLInputObjectType {
         return {
             name: this.name,
             description: this.description,
-            fields: (0, mapValue_js_1.mapValue)(this.getFields(), (field) => field.toConfig()),
+            fields: (0, mapValue_ts_1.mapValue)(this.getFields(), (field) => field.toConfig()),
             extensions: this.extensions,
             astNode: this.astNode,
             extensionASTNodes: this.extensionASTNodes,
@@ -1046,21 +798,22 @@ class GraphQLInputObjectType {
 exports.GraphQLInputObjectType = GraphQLInputObjectType;
 function defineInputFieldMap(parentType, fields) {
     const fieldMap = resolveObjMapThunk(fields);
-    return (0, mapValue_js_1.mapValue)(fieldMap, (fieldConfig, fieldName) => new GraphQLInputField(parentType, fieldName, fieldConfig));
+    return (0, mapValue_ts_1.mapValue)(fieldMap, (fieldConfig, fieldName) => new GraphQLInputField(parentType, fieldName, fieldConfig));
 }
 class GraphQLInputField {
     constructor(parentType, name, config) {
         if (!(!('resolve' in config)))
-            (0, devAssert_js_1.devAssert)(false, `${parentType}.${name} field has a resolve property, but Input Types cannot define resolvers.`);
+            (0, devAssert_ts_1.devAssert)(false, `${parentType}.${name} field has a resolve property, but Input Types cannot define resolvers.`);
         this.__kind = inputFieldSymbol;
         this.parentType = parentType;
-        this.name = (0, assertName_js_1.assertName)(name);
+        this.name = (0, assertName_ts_1.assertName)(name);
         this.description = config.description;
         this.type = config.type;
         this.defaultValue = config.defaultValue;
         this.default = config.default;
+        this._memoizedCoercedDefaultValue = undefined;
         this.deprecationReason = config.deprecationReason;
-        this.extensions = (0, toObjMap_js_1.toObjMapWithSymbols)(config.extensions);
+        this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
     }
     get [Symbol.toStringTag]() {