graphql 17.0.0-beta.1 → 17.0.0-beta.2

package/type/definition.js

@@ -81,9 +81,6 @@ function assertType(type) {
     return type;
 }
 const scalarSymbol = Symbol('Scalar');
-/**
- * There are predicates for each GraphQL schema element.
- */
 function isScalarType(type) {
     return (0, instanceOf_ts_1.instanceOf)(type, scalarSymbol, GraphQLScalarType);
 }
@@ -256,25 +253,6 @@ function assertAbstractType(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;
@@ -380,81 +337,6 @@ 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;
@@ -518,46 +400,6 @@ 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;
@@ -662,6 +504,7 @@ class GraphQLArgument {
         this.type = config.type;
         this.defaultValue = config.defaultValue;
         this.default = config.default;
+        this._memoizedCoercedDefaultValue = undefined;
         this.deprecationReason = config.deprecationReason;
         this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;
@@ -693,25 +536,6 @@ 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;
@@ -759,30 +583,6 @@ 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;
@@ -825,30 +625,7 @@ 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_ts_1.assertName)(config.name);
@@ -873,11 +650,10 @@ class GraphQLEnumType /* <T> */ {
         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) {
@@ -885,7 +661,6 @@ class GraphQLEnumType /* <T> */ {
         }
         return enumValue.name;
     }
-    /** @deprecated use `coerceInputValue()` instead, `parseValue()` will be removed in v18 */
     parseValue(inputValue, hideSuggestions) {
         return this.coerceInputValue(inputValue, hideSuggestions);
     }
@@ -902,9 +677,7 @@ class GraphQLEnumType /* <T> */ {
         }
         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) {
@@ -984,27 +757,6 @@ 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;
@@ -1059,6 +811,7 @@ class GraphQLInputField {
         this.type = config.type;
         this.defaultValue = config.defaultValue;
         this.default = config.default;
+        this._memoizedCoercedDefaultValue = undefined;
         this.deprecationReason = config.deprecationReason;
         this.extensions = (0, toObjMap_ts_1.toObjMapWithSymbols)(config.extensions);
         this.astNode = config.astNode;