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

package/type/definition.mjs

@@ -30,9 +30,6 @@ export function assertType(type) {
     return type;
 }
 const scalarSymbol = Symbol('Scalar');
-/**
- * There are predicates for each GraphQL schema element.
- */
 export function isScalarType(type) {
     return instanceOf(type, scalarSymbol, GraphQLScalarType);
 }
@@ -205,25 +202,6 @@ export 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) },
- *   })
- * })
- * ```
- */
 export class GraphQLList {
     constructor(ofType) {
         this.__kind = listSymbol;
@@ -239,27 +217,6 @@ export class GraphQLList {
         return this.toString();
     }
 }
-/**
- * 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.
- */
 export class GraphQLNonNull {
     constructor(ofType) {
         this.__kind = nonNullSymbol;
@@ -327,81 +284,6 @@ export function resolveReadonlyArrayThunk(thunk) {
 export 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.
- *
- */
 export class GraphQLScalarType {
     constructor(config) {
         this.__kind = scalarSymbol;
@@ -464,46 +346,6 @@ export class GraphQLScalarType {
         return this.toString();
     }
 }
-/**
- * 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 },
- *   })
- * });
- * ```
- */
 export class GraphQLObjectType {
     constructor(config) {
         this.__kind = objectSymbol;
@@ -606,6 +448,7 @@ export class GraphQLArgument {
         this.type = config.type;
         this.defaultValue = config.defaultValue;
         this.default = config.default;
+        this._memoizedCoercedDefaultValue = undefined;
         this.deprecationReason = config.deprecationReason;
         this.extensions = toObjMapWithSymbols(config.extensions);
         this.astNode = config.astNode;
@@ -636,25 +479,6 @@ export 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 }
- *   }
- * });
- * ```
- */
 export class GraphQLInterfaceType {
     constructor(config) {
         this.__kind = interfaceSymbol;
@@ -701,30 +525,6 @@ export class GraphQLInterfaceType {
         return this.toString();
     }
 }
-/**
- * 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;
- *     }
- *   }
- * });
- * ```
- */
 export class GraphQLUnionType {
     constructor(config) {
         this.__kind = unionSymbol;
@@ -766,30 +566,7 @@ export class 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.
- */
-export class GraphQLEnumType /* <T> */ {
+export class GraphQLEnumType {
     constructor(config) {
         this.__kind = enumSymbol;
         this.name = assertName(config.name);
@@ -814,11 +591,10 @@ export class GraphQLEnumType /* <T> */ {
         this._nameLookup ??= 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) {
@@ -826,7 +602,6 @@ export class GraphQLEnumType /* <T> */ {
         }
         return enumValue.name;
     }
-    /** @deprecated use `coerceInputValue()` instead, `parseValue()` will be removed in v18 */
     parseValue(inputValue, hideSuggestions) {
         return this.coerceInputValue(inputValue, hideSuggestions);
     }
@@ -843,9 +618,7 @@ export 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) {
@@ -923,27 +696,6 @@ export class GraphQLEnumValue {
         return this.toString();
     }
 }
-/**
- * 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 },
- *   }
- * });
- * ```
- */
 export class GraphQLInputObjectType {
     constructor(config) {
         this.__kind = inputObjectSymbol;
@@ -997,6 +749,7 @@ export class GraphQLInputField {
         this.type = config.type;
         this.defaultValue = config.defaultValue;
         this.default = config.default;
+        this._memoizedCoercedDefaultValue = undefined;
         this.deprecationReason = config.deprecationReason;
         this.extensions = toObjMapWithSymbols(config.extensions);
         this.astNode = config.astNode;