graphql 17.0.0-alpha.8 → 17.0.0-beta.0

package/utilities/resolveSchemaCoordinate.mjs

@@ -0,0 +1,163 @@
+import { inspect } from "../jsutils/inspect.mjs";
+import { Kind } from "../language/kinds.mjs";
+import { parseSchemaCoordinate } from "../language/parser.mjs";
+import { isEnumType, isInputObjectType, isInterfaceType, isObjectType, } from "../type/definition.mjs";
+/**
+ * A schema coordinate is resolved in the context of a GraphQL schema to
+ * uniquely identify a schema element. It returns undefined if the schema
+ * coordinate does not resolve to a schema element, meta-field, or introspection
+ * schema element. It will throw if the containing schema element (if
+ * applicable) does not exist.
+ *
+ * https://spec.graphql.org/draft/#sec-Schema-Coordinates.Semantics
+ */
+export function resolveSchemaCoordinate(schema, schemaCoordinate) {
+    return resolveASTSchemaCoordinate(schema, parseSchemaCoordinate(schemaCoordinate));
+}
+/**
+ * TypeCoordinate : Name
+ */
+function resolveTypeCoordinate(schema, schemaCoordinate) {
+    // 1. Let {typeName} be the value of {Name}.
+    const typeName = schemaCoordinate.name.value;
+    const type = schema.getType(typeName);
+    // 2. Return the type in the {schema} named {typeName} if it exists.
+    if (type == null) {
+        return;
+    }
+    return { kind: 'NamedType', type };
+}
+/**
+ * MemberCoordinate : Name . Name
+ */
+function resolveMemberCoordinate(schema, schemaCoordinate) {
+    // 1. Let {typeName} be the value of the first {Name}.
+    // 2. Let {type} be the type in the {schema} named {typeName}.
+    const typeName = schemaCoordinate.name.value;
+    const type = schema.getType(typeName);
+    // 3. Assert: {type} must exist, and must be an Enum, Input Object, Object or Interface type.
+    if (!type) {
+        throw new Error(`Expected ${inspect(typeName)} to be defined as a type in the schema.`);
+    }
+    if (!isEnumType(type) &&
+        !isInputObjectType(type) &&
+        !isObjectType(type) &&
+        !isInterfaceType(type)) {
+        throw new Error(`Expected ${inspect(typeName)} to be an Enum, Input Object, Object or Interface type.`);
+    }
+    // 4. If {type} is an Enum type:
+    if (isEnumType(type)) {
+        // 1. Let {enumValueName} be the value of the second {Name}.
+        const enumValueName = schemaCoordinate.memberName.value;
+        const enumValue = type.getValue(enumValueName);
+        // 2. Return the enum value of {type} named {enumValueName} if it exists.
+        if (enumValue == null) {
+            return;
+        }
+        return { kind: 'EnumValue', type, enumValue };
+    }
+    // 5. Otherwise, if {type} is an Input Object type:
+    if (isInputObjectType(type)) {
+        // 1. Let {inputFieldName} be the value of the second {Name}.
+        const inputFieldName = schemaCoordinate.memberName.value;
+        const inputField = type.getFields()[inputFieldName];
+        // 2. Return the input field of {type} named {inputFieldName} if it exists.
+        if (inputField == null) {
+            return;
+        }
+        return { kind: 'InputField', type, inputField };
+    }
+    // 6. Otherwise:
+    // 1. Let {fieldName} be the value of the second {Name}.
+    const fieldName = schemaCoordinate.memberName.value;
+    const field = schema.getField(type, fieldName);
+    // 2. Return the field of {type} named {fieldName} if it exists.
+    if (field == null) {
+        return;
+    }
+    return { kind: 'Field', type, field };
+}
+/**
+ * ArgumentCoordinate : Name . Name ( Name : )
+ */
+function resolveArgumentCoordinate(schema, schemaCoordinate) {
+    // 1. Let {typeName} be the value of the first {Name}.
+    // 2. Let {type} be the type in the {schema} named {typeName}.
+    const typeName = schemaCoordinate.name.value;
+    const type = schema.getType(typeName);
+    // 3. Assert: {type} must exist, and be an Object or Interface type.
+    if (type == null) {
+        throw new Error(`Expected ${inspect(typeName)} to be defined as a type in the schema.`);
+    }
+    if (!isObjectType(type) && !isInterfaceType(type)) {
+        throw new Error(`Expected ${inspect(typeName)} to be an object type or interface type.`);
+    }
+    // 4. Let {fieldName} be the value of the second {Name}.
+    // 5. Let {field} be the field of {type} named {fieldName}.
+    const fieldName = schemaCoordinate.fieldName.value;
+    const field = schema.getField(type, fieldName);
+    // 7. Assert: {field} must exist.
+    if (field == null) {
+        throw new Error(`Expected ${inspect(fieldName)} to exist as a field of type ${inspect(typeName)} in the schema.`);
+    }
+    // 7. Let {fieldArgumentName} be the value of the third {Name}.
+    const fieldArgumentName = schemaCoordinate.argumentName.value;
+    const fieldArgument = field.args.find((arg) => arg.name === fieldArgumentName);
+    // 8. Return the argument of {field} named {fieldArgumentName} if it exists.
+    if (fieldArgument == null) {
+        return;
+    }
+    return { kind: 'FieldArgument', type, field, fieldArgument };
+}
+/**
+ * DirectiveCoordinate : @ Name
+ */
+function resolveDirectiveCoordinate(schema, schemaCoordinate) {
+    // 1. Let {directiveName} be the value of {Name}.
+    const directiveName = schemaCoordinate.name.value;
+    const directive = schema.getDirective(directiveName);
+    // 2. Return the directive in the {schema} named {directiveName} if it exists.
+    if (!directive) {
+        return;
+    }
+    return { kind: 'Directive', directive };
+}
+/**
+ * DirectiveArgumentCoordinate : @ Name ( Name : )
+ */
+function resolveDirectiveArgumentCoordinate(schema, schemaCoordinate) {
+    // 1. Let {directiveName} be the value of the first {Name}.
+    // 2. Let {directive} be the directive in the {schema} named {directiveName}.
+    const directiveName = schemaCoordinate.name.value;
+    const directive = schema.getDirective(directiveName);
+    // 3. Assert {directive} must exist.
+    if (!directive) {
+        throw new Error(`Expected ${inspect(directiveName)} to be defined as a directive in the schema.`);
+    }
+    // 4. Let {directiveArgumentName} be the value of the second {Name}.
+    const { argumentName: { value: directiveArgumentName }, } = schemaCoordinate;
+    const directiveArgument = directive.args.find((arg) => arg.name === directiveArgumentName);
+    // 5. Return the argument of {directive} named {directiveArgumentName} if it exists.
+    if (!directiveArgument) {
+        return;
+    }
+    return { kind: 'DirectiveArgument', directive, directiveArgument };
+}
+/**
+ * Resolves schema coordinate from a parsed SchemaCoordinate node.
+ */
+export function resolveASTSchemaCoordinate(schema, schemaCoordinate) {
+    switch (schemaCoordinate.kind) {
+        case Kind.TYPE_COORDINATE:
+            return resolveTypeCoordinate(schema, schemaCoordinate);
+        case Kind.MEMBER_COORDINATE:
+            return resolveMemberCoordinate(schema, schemaCoordinate);
+        case Kind.ARGUMENT_COORDINATE:
+            return resolveArgumentCoordinate(schema, schemaCoordinate);
+        case Kind.DIRECTIVE_COORDINATE:
+            return resolveDirectiveCoordinate(schema, schemaCoordinate);
+        case Kind.DIRECTIVE_ARGUMENT_COORDINATE:
+            return resolveDirectiveArgumentCoordinate(schema, schemaCoordinate);
+    }
+}
+//# sourceMappingURL=resolveSchemaCoordinate.js.map

package/utilities/resolveSchemaCoordinate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveSchemaCoordinate.js","sourceRoot":"","sources":["../../src/utilities/resolveSchemaCoordinate.ts"],"names":[],"mappings":"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","sourcesContent":["import { inspect } from '../jsutils/inspect.js';\n\nimport type {\n  ArgumentCoordinateNode,\n  DirectiveArgumentCoordinateNode,\n  DirectiveCoordinateNode,\n  MemberCoordinateNode,\n  SchemaCoordinateNode,\n  TypeCoordinateNode,\n} from '../language/ast.js';\nimport { Kind } from '../language/kinds.js';\nimport { parseSchemaCoordinate } from '../language/parser.js';\nimport type { Source } from '../language/source.js';\n\nimport type {\n  GraphQLArgument,\n  GraphQLEnumType,\n  GraphQLEnumValue,\n  GraphQLField,\n  GraphQLInputField,\n  GraphQLInputObjectType,\n  GraphQLInterfaceType,\n  GraphQLNamedType,\n  GraphQLObjectType,\n} from '../type/definition.js';\nimport {\n  isEnumType,\n  isInputObjectType,\n  isInterfaceType,\n  isObjectType,\n} from '../type/definition.js';\nimport type { GraphQLDirective } from '../type/directives.js';\nimport type { GraphQLSchema } from '../type/schema.js';\n\n/**\n * A resolved schema element may be one of the following kinds:\n */\nexport interface ResolvedNamedType {\n  readonly kind: 'NamedType';\n  readonly type: GraphQLNamedType;\n}\n\nexport interface ResolvedField {\n  readonly kind: 'Field';\n  readonly type: GraphQLObjectType | GraphQLInterfaceType;\n  readonly field: GraphQLField<unknown, unknown>;\n}\n\nexport interface ResolvedInputField {\n  readonly kind: 'InputField';\n  readonly type: GraphQLInputObjectType;\n  readonly inputField: GraphQLInputField;\n}\n\nexport interface ResolvedEnumValue {\n  readonly kind: 'EnumValue';\n  readonly type: GraphQLEnumType;\n  readonly enumValue: GraphQLEnumValue;\n}\n\nexport interface ResolvedFieldArgument {\n  readonly kind: 'FieldArgument';\n  readonly type: GraphQLObjectType | GraphQLInterfaceType;\n  readonly field: GraphQLField<unknown, unknown>;\n  readonly fieldArgument: GraphQLArgument;\n}\n\nexport interface ResolvedDirective {\n  readonly kind: 'Directive';\n  readonly directive: GraphQLDirective;\n}\n\nexport interface ResolvedDirectiveArgument {\n  readonly kind: 'DirectiveArgument';\n  readonly directive: GraphQLDirective;\n  readonly directiveArgument: GraphQLArgument;\n}\n\nexport type ResolvedSchemaElement =\n  | ResolvedNamedType\n  | ResolvedField\n  | ResolvedInputField\n  | ResolvedEnumValue\n  | ResolvedFieldArgument\n  | ResolvedDirective\n  | ResolvedDirectiveArgument;\n\n/**\n * A schema coordinate is resolved in the context of a GraphQL schema to\n * uniquely identify a schema element. It returns undefined if the schema\n * coordinate does not resolve to a schema element, meta-field, or introspection\n * schema element. It will throw if the containing schema element (if\n * applicable) does not exist.\n *\n * https://spec.graphql.org/draft/#sec-Schema-Coordinates.Semantics\n */\nexport function resolveSchemaCoordinate(\n  schema: GraphQLSchema,\n  schemaCoordinate: string | Source,\n): ResolvedSchemaElement | undefined {\n  return resolveASTSchemaCoordinate(\n    schema,\n    parseSchemaCoordinate(schemaCoordinate),\n  );\n}\n\n/**\n * TypeCoordinate : Name\n */\nfunction resolveTypeCoordinate(\n  schema: GraphQLSchema,\n  schemaCoordinate: TypeCoordinateNode,\n): ResolvedNamedType | undefined {\n  // 1. Let {typeName} be the value of {Name}.\n  const typeName = schemaCoordinate.name.value;\n  const type = schema.getType(typeName);\n\n  // 2. Return the type in the {schema} named {typeName} if it exists.\n  if (type == null) {\n    return;\n  }\n\n  return { kind: 'NamedType', type };\n}\n\n/**\n * MemberCoordinate : Name . Name\n */\nfunction resolveMemberCoordinate(\n  schema: GraphQLSchema,\n  schemaCoordinate: MemberCoordinateNode,\n): ResolvedField | ResolvedInputField | ResolvedEnumValue | undefined {\n  // 1. Let {typeName} be the value of the first {Name}.\n  // 2. Let {type} be the type in the {schema} named {typeName}.\n  const typeName = schemaCoordinate.name.value;\n  const type = schema.getType(typeName);\n\n  // 3. Assert: {type} must exist, and must be an Enum, Input Object, Object or Interface type.\n  if (!type) {\n    throw new Error(\n      `Expected ${inspect(typeName)} to be defined as a type in the schema.`,\n    );\n  }\n  if (\n    !isEnumType(type) &&\n    !isInputObjectType(type) &&\n    !isObjectType(type) &&\n    !isInterfaceType(type)\n  ) {\n    throw new Error(\n      `Expected ${inspect(typeName)} to be an Enum, Input Object, Object or Interface type.`,\n    );\n  }\n\n  // 4. If {type} is an Enum type:\n  if (isEnumType(type)) {\n    // 1. Let {enumValueName} be the value of the second {Name}.\n    const enumValueName = schemaCoordinate.memberName.value;\n    const enumValue = type.getValue(enumValueName);\n\n    // 2. Return the enum value of {type} named {enumValueName} if it exists.\n    if (enumValue == null) {\n      return;\n    }\n\n    return { kind: 'EnumValue', type, enumValue };\n  }\n\n  // 5. Otherwise, if {type} is an Input Object type:\n  if (isInputObjectType(type)) {\n    // 1. Let {inputFieldName} be the value of the second {Name}.\n    const inputFieldName = schemaCoordinate.memberName.value;\n    const inputField = type.getFields()[inputFieldName];\n\n    // 2. Return the input field of {type} named {inputFieldName} if it exists.\n    if (inputField == null) {\n      return;\n    }\n\n    return { kind: 'InputField', type, inputField };\n  }\n\n  // 6. Otherwise:\n  // 1. Let {fieldName} be the value of the second {Name}.\n  const fieldName = schemaCoordinate.memberName.value;\n  const field = schema.getField(type, fieldName);\n\n  // 2. Return the field of {type} named {fieldName} if it exists.\n  if (field == null) {\n    return;\n  }\n\n  return { kind: 'Field', type, field };\n}\n\n/**\n * ArgumentCoordinate : Name . Name ( Name : )\n */\nfunction resolveArgumentCoordinate(\n  schema: GraphQLSchema,\n  schemaCoordinate: ArgumentCoordinateNode,\n): ResolvedFieldArgument | undefined {\n  // 1. Let {typeName} be the value of the first {Name}.\n  // 2. Let {type} be the type in the {schema} named {typeName}.\n  const typeName = schemaCoordinate.name.value;\n  const type = schema.getType(typeName);\n\n  // 3. Assert: {type} must exist, and be an Object or Interface type.\n  if (type == null) {\n    throw new Error(\n      `Expected ${inspect(typeName)} to be defined as a type in the schema.`,\n    );\n  }\n  if (!isObjectType(type) && !isInterfaceType(type)) {\n    throw new Error(\n      `Expected ${inspect(typeName)} to be an object type or interface type.`,\n    );\n  }\n\n  // 4. Let {fieldName} be the value of the second {Name}.\n  // 5. Let {field} be the field of {type} named {fieldName}.\n  const fieldName = schemaCoordinate.fieldName.value;\n  const field = schema.getField(type, fieldName);\n\n  // 7. Assert: {field} must exist.\n  if (field == null) {\n    throw new Error(\n      `Expected ${inspect(fieldName)} to exist as a field of type ${inspect(typeName)} in the schema.`,\n    );\n  }\n\n  // 7. Let {fieldArgumentName} be the value of the third {Name}.\n  const fieldArgumentName = schemaCoordinate.argumentName.value;\n  const fieldArgument = field.args.find(\n    (arg) => arg.name === fieldArgumentName,\n  );\n\n  // 8. Return the argument of {field} named {fieldArgumentName} if it exists.\n  if (fieldArgument == null) {\n    return;\n  }\n\n  return { kind: 'FieldArgument', type, field, fieldArgument };\n}\n\n/**\n * DirectiveCoordinate : @ Name\n */\nfunction resolveDirectiveCoordinate(\n  schema: GraphQLSchema,\n  schemaCoordinate: DirectiveCoordinateNode,\n): ResolvedDirective | undefined {\n  // 1. Let {directiveName} be the value of {Name}.\n  const directiveName = schemaCoordinate.name.value;\n  const directive = schema.getDirective(directiveName);\n\n  // 2. Return the directive in the {schema} named {directiveName} if it exists.\n  if (!directive) {\n    return;\n  }\n\n  return { kind: 'Directive', directive };\n}\n\n/**\n * DirectiveArgumentCoordinate : @ Name ( Name : )\n */\nfunction resolveDirectiveArgumentCoordinate(\n  schema: GraphQLSchema,\n  schemaCoordinate: DirectiveArgumentCoordinateNode,\n): ResolvedDirectiveArgument | undefined {\n  // 1. Let {directiveName} be the value of the first {Name}.\n  // 2. Let {directive} be the directive in the {schema} named {directiveName}.\n  const directiveName = schemaCoordinate.name.value;\n  const directive = schema.getDirective(directiveName);\n\n  // 3. Assert {directive} must exist.\n  if (!directive) {\n    throw new Error(\n      `Expected ${inspect(directiveName)} to be defined as a directive in the schema.`,\n    );\n  }\n\n  // 4. Let {directiveArgumentName} be the value of the second {Name}.\n  const {\n    argumentName: { value: directiveArgumentName },\n  } = schemaCoordinate;\n  const directiveArgument = directive.args.find(\n    (arg) => arg.name === directiveArgumentName,\n  );\n\n  // 5. Return the argument of {directive} named {directiveArgumentName} if it exists.\n  if (!directiveArgument) {\n    return;\n  }\n\n  return { kind: 'DirectiveArgument', directive, directiveArgument };\n}\n\n/**\n * Resolves schema coordinate from a parsed SchemaCoordinate node.\n */\nexport function resolveASTSchemaCoordinate(\n  schema: GraphQLSchema,\n  schemaCoordinate: SchemaCoordinateNode,\n): ResolvedSchemaElement | undefined {\n  switch (schemaCoordinate.kind) {\n    case Kind.TYPE_COORDINATE:\n      return resolveTypeCoordinate(schema, schemaCoordinate);\n    case Kind.MEMBER_COORDINATE:\n      return resolveMemberCoordinate(schema, schemaCoordinate);\n    case Kind.ARGUMENT_COORDINATE:\n      return resolveArgumentCoordinate(schema, schemaCoordinate);\n    case Kind.DIRECTIVE_COORDINATE:\n      return resolveDirectiveCoordinate(schema, schemaCoordinate);\n    case Kind.DIRECTIVE_ARGUMENT_COORDINATE:\n      return resolveDirectiveArgumentCoordinate(schema, schemaCoordinate);\n  }\n}\n"]}

package/utilities/separateOperations.d.mts

@@ -0,0 +1,9 @@
+import type { ObjMap } from '../jsutils/ObjMap.js';
+import type { DocumentNode } from '../language/ast.js';
+/**
+ * separateOperations accepts a single AST document which may contain many
+ * operations and fragments and returns a collection of AST documents each of
+ * which contains a single operation as well the fragment definitions it
+ * refers to.
+ */
+export declare function separateOperations(documentAST: DocumentNode): ObjMap<DocumentNode>;

package/utilities/sortValueNode.d.mts

@@ -0,0 +1,9 @@
+import type { ValueNode } from '../language/ast.js';
+/**
+ * Sort ValueNode.
+ *
+ * This function returns a sorted copy of the given ValueNode.
+ *
+ * @internal
+ */
+export declare function sortValueNode(valueNode: ValueNode): ValueNode;

package/utilities/stripIgnoredCharacters.d.mts

@@ -0,0 +1,62 @@
+import { Source } from '../language/source.js';
+/**
+ * Strips characters that are not significant to the validity or execution
+ * of a GraphQL document:
+ *   - UnicodeBOM
+ *   - WhiteSpace
+ *   - LineTerminator
+ *   - Comment
+ *   - Comma
+ *   - BlockString indentation
+ *
+ * Note: It is required to have a delimiter character between neighboring
+ * non-punctuator tokens and this function always uses single space as delimiter.
+ *
+ * It is guaranteed that both input and output documents if parsed would result
+ * in the exact same AST except for nodes location.
+ *
+ * Warning: It is guaranteed that this function will always produce stable results.
+ * However, it's not guaranteed that it will stay the same between different
+ * releases due to bugfixes or changes in the GraphQL specification.
+ *
+ * Query example:
+ *
+ * ```graphql
+ * query SomeQuery($foo: String!, $bar: String) {
+ *   someField(foo: $foo, bar: $bar) {
+ *     a
+ *     b {
+ *       c
+ *       d
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql
+ * query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}
+ * ```
+ *
+ * SDL example:
+ *
+ * ```graphql
+ * """
+ * Type description
+ * """
+ * type Foo {
+ *   """
+ *   Field description
+ *   """
+ *   bar: String
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql
+ * """Type description""" type Foo{"""Field description""" bar:String}
+ * ```
+ */
+export declare function stripIgnoredCharacters(source: string | Source): string;

package/utilities/typeComparators.d.mts

@@ -0,0 +1,21 @@
+import type { GraphQLCompositeType, GraphQLType } from '../type/definition.js';
+import type { GraphQLSchema } from '../type/schema.js';
+/**
+ * Provided two types, return true if the types are equal (invariant).
+ */
+export declare function isEqualType(typeA: GraphQLType, typeB: GraphQLType): boolean;
+/**
+ * Provided a type and a super type, return true if the first type is either
+ * equal or a subset of the second super type (covariant).
+ */
+export declare function isTypeSubTypeOf(schema: GraphQLSchema, maybeSubType: GraphQLType, superType: GraphQLType): boolean;
+/**
+ * Provided two composite types, determine if they "overlap". Two composite
+ * types overlap when the Sets of possible concrete types for each intersect.
+ *
+ * This is often used to determine if a fragment of a given type could possibly
+ * be visited in a context of another type.
+ *
+ * This function is commutative.
+ */
+export declare function doTypesOverlap(schema: GraphQLSchema, typeA: GraphQLCompositeType, typeB: GraphQLCompositeType): boolean;

package/utilities/typeFromAST.d.mts

@@ -0,0 +1,15 @@
+import type { ListTypeNode, NamedTypeNode, NonNullTypeNode, TypeNode } from '../language/ast.js';
+import type { GraphQLNamedType, GraphQLType } from '../type/definition.js';
+import { GraphQLList, GraphQLNonNull } from '../type/definition.js';
+import type { GraphQLSchema } from '../type/schema.js';
+/**
+ * Given a Schema and an AST node describing a type, return a GraphQLType
+ * definition which applies to that type. For example, if provided the parsed
+ * AST node for `[User]`, a GraphQLList instance will be returned, containing
+ * the type called "User" found in the schema. If a type called "User" is not
+ * found in the schema, then undefined will be returned.
+ */
+export declare function typeFromAST(schema: GraphQLSchema, typeNode: NamedTypeNode): GraphQLNamedType | undefined;
+export declare function typeFromAST(schema: GraphQLSchema, typeNode: ListTypeNode): GraphQLList<any> | undefined;
+export declare function typeFromAST(schema: GraphQLSchema, typeNode: NonNullTypeNode): GraphQLNonNull<any> | undefined;
+export declare function typeFromAST(schema: GraphQLSchema, typeNode: TypeNode): GraphQLType | undefined;

package/utilities/typedQueryDocumentNode.d.mts

@@ -0,0 +1,17 @@
+import type { DocumentNode, ExecutableDefinitionNode } from '../language/ast.js';
+/**
+ * Wrapper type that contains DocumentNode and types that can be deduced from it.
+ */
+export interface TypedQueryDocumentNode<TResponseData = {
+    [key: string]: any;
+}, TRequestVariables = {
+    [key: string]: any;
+}> extends DocumentNode {
+    readonly definitions: ReadonlyArray<ExecutableDefinitionNode>;
+    /**
+     * This type is used to ensure that the variables you pass in to the query are assignable to Variables
+     * and that the Result is assignable to whatever you pass your result to. The method is never actually
+     * implemented, but the type is valid because we list it as optional
+     */
+    __ensureTypesOfVariablesAndResultMatching?: (variables: TRequestVariables) => TResponseData;
+}

package/utilities/validateInputValue.d.mts

@@ -0,0 +1,19 @@
+import type { Maybe } from '../jsutils/Maybe.js';
+import { GraphQLError } from '../error/GraphQLError.js';
+import type { ValueNode } from '../language/ast.js';
+import type { GraphQLInputType } from '../type/definition.js';
+import type { FragmentVariableValues } from '../execution/collectFields.js';
+import type { VariableValues } from '../execution/values.js';
+/**
+ * Validate that the provided input value is allowed for this type, collecting
+ * all errors via a callback function.
+ */
+export declare function validateInputValue(inputValue: unknown, type: GraphQLInputType, onError: (error: GraphQLError, path: ReadonlyArray<string | number>) => void, hideSuggestions?: Maybe<boolean>): void;
+/**
+ * Validate that the provided input literal is allowed for this type, collecting
+ * all errors via a callback function.
+ *
+ * If variable values are not provided, the literal is validated statically
+ * (not assuming that those variables are missing runtime values).
+ */
+export declare function validateInputLiteral(valueNode: ValueNode, type: GraphQLInputType, onError: (error: GraphQLError, path: ReadonlyArray<string | number>) => void, variables?: Maybe<VariableValues>, fragmentVariableValues?: Maybe<FragmentVariableValues>, hideSuggestions?: Maybe<boolean>): void;

package/utilities/validateInputValue.d.ts

@@ -2,6 +2,7 @@ import type { Maybe } from '../jsutils/Maybe.js';
 import { GraphQLError } from '../error/GraphQLError.js';
 import type { ValueNode } from '../language/ast.js';
 import type { GraphQLInputType } from '../type/definition.js';
+import type { FragmentVariableValues } from '../execution/collectFields.js';
 import type { VariableValues } from '../execution/values.js';
 /**
  * Validate that the provided input value is allowed for this type, collecting
@@ -15,4 +16,4 @@ export declare function validateInputValue(inputValue: unknown, type: GraphQLInp
  * If variable values are not provided, the literal is validated statically
  * (not assuming that those variables are missing runtime values).
  */
-export declare function validateInputLiteral(valueNode: ValueNode, type: GraphQLInputType, onError: (error: GraphQLError, path: ReadonlyArray<string | number>) => void, variables?: Maybe<VariableValues>, fragmentVariableValues?: Maybe<VariableValues>, hideSuggestions?: Maybe<boolean>): void;
+export declare function validateInputLiteral(valueNode: ValueNode, type: GraphQLInputType, onError: (error: GraphQLError, path: ReadonlyArray<string | number>) => void, variables?: Maybe<VariableValues>, fragmentVariableValues?: Maybe<FragmentVariableValues>, hideSuggestions?: Maybe<boolean>): void;

package/utilities/validateInputValue.js

@@ -9,6 +9,7 @@ const isObjectLike_js_1 = require("../jsutils/isObjectLike.js");
 const keyMap_js_1 = require("../jsutils/keyMap.js");
 const Path_js_1 = require("../jsutils/Path.js");
 const suggestionList_js_1 = require("../jsutils/suggestionList.js");
+const ensureGraphQLError_js_1 = require("../error/ensureGraphQLError.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");
@@ -49,7 +50,7 @@ function validateInputValueImpl(inputValue, type, onError, hideSuggestions, path
         }
     }
     else if ((0, definition_js_1.isInputObjectType)(type)) {
-        if (!(0, isObjectLike_js_1.isObjectLike)(inputValue)) {
+        if (!(0, isObjectLike_js_1.isObjectLike)(inputValue) || Array.isArray(inputValue)) {
             reportInvalidValue(onError, `Expected value of type "${type}" to be an object, found: ${(0, inspect_js_1.inspect)(inputValue)}.`, path);
             return;
         }
@@ -65,24 +66,29 @@ function validateInputValueImpl(inputValue, type, onError, hideSuggestions, path
                 validateInputValueImpl(fieldValue, field.type, onError, hideSuggestions, (0, Path_js_1.addPath)(path, field.name, type.name));
             }
         }
-        const fields = Object.keys(inputValue);
+        const fields = [];
         // Ensure every provided field is defined.
-        for (const fieldName of fields) {
+        for (const fieldName of Object.keys(inputValue)) {
+            if (inputValue[fieldName] === undefined) {
+                continue;
+            }
             if (!Object.hasOwn(fieldDefs, fieldName)) {
                 const suggestion = hideSuggestions
                     ? ''
                     : (0, didYouMean_js_1.didYouMean)((0, suggestionList_js_1.suggestionList)(fieldName, Object.keys(fieldDefs)));
                 reportInvalidValue(onError, `Expected value of type "${type}" not to include unknown field "${fieldName}"${suggestion ? `.${suggestion} Found` : ', found'}: ${(0, inspect_js_1.inspect)(inputValue)}.`, path);
+                continue;
             }
+            fields.push(fieldName);
         }
         if (type.isOneOf) {
             if (fields.length !== 1) {
-                reportInvalidValue(onError, `Exactly one key must be specified for OneOf type "${type}".`, path);
+                reportInvalidValue(onError, getOneOfInputObjectErrorMessage(type), path);
             }
             const field = fields[0];
             const value = inputValue[field];
             if (value === null) {
-                reportInvalidValue(onError, `Field "${field}" for OneOf type "${type}" must be non-null.`, path);
+                reportInvalidValue(onError, getOneOfInputObjectErrorMessage(type), (0, Path_js_1.addPath)(path, field, type.name));
             }
         }
     }
@@ -102,8 +108,8 @@ function validateInputValueImpl(inputValue, type, onError, hideSuggestions, path
         }
         if (result === undefined) {
             reportInvalidValue(onError, `Expected value of type "${type}"${caughtError != null
-                ? `, but encountered error "${caughtError.message != null && caughtError.message !== '' ? caughtError.message : caughtError}"; found`
-                : ', found'}: ${(0, inspect_js_1.inspect)(inputValue)}.`, path, caughtError);
+                ? `, but encountered error "${getCaughtErrorMessage(caughtError)}"; found`
+                : ', found'}: ${(0, inspect_js_1.inspect)(inputValue)}.`, path, (0, ensureGraphQLError_js_1.ensureGraphQLError)(caughtError));
         }
     }
 }
@@ -117,7 +123,7 @@ function reportInvalidValue(onError, message, path, originalError) {
  * If variable values are not provided, the literal is validated statically
  * (not assuming that those variables are missing runtime values).
  */
-// eslint-disable-next-line @typescript-eslint/max-params
+// eslint-disable-next-line max-params
 function validateInputLiteral(valueNode, type, onError, variables, fragmentVariableValues, hideSuggestions) {
     const context = {
         static: !variables && !fragmentVariableValues,
@@ -206,6 +212,7 @@ function validateInputLiteralImpl(context, valueNode, type, hideSuggestions, pat
             }
         }
         const fields = valueNode.fields;
+        const knownFields = [];
         // Ensure every provided field is defined.
         for (const fieldNode of fields) {
             const fieldName = fieldNode.name.value;
@@ -215,17 +222,20 @@ function validateInputLiteralImpl(context, valueNode, type, hideSuggestions, pat
                     : (0, didYouMean_js_1.didYouMean)((0, suggestionList_js_1.suggestionList)(fieldName, Object.keys(fieldDefs)));
                 reportInvalidLiteral(context.onError, `Expected value of type "${type}" not to include unknown field "${fieldName}"${suggestion ? `.${suggestion} Found` : ', found'}: ${(0, printer_js_1.print)(valueNode)}.`, fieldNode, path);
             }
+            else {
+                knownFields.push(fieldNode);
+            }
         }
         if (type.isOneOf) {
-            const isNotExactlyOneField = fields.length !== 1;
+            const isNotExactlyOneField = knownFields.length !== 1;
             if (isNotExactlyOneField) {
-                reportInvalidLiteral(context.onError, `OneOf Input Object "${type}" must specify exactly one key.`, valueNode, path);
+                reportInvalidLiteral(context.onError, getOneOfInputObjectErrorMessage(type), valueNode, path);
                 return;
             }
-            const fieldValueNode = fields[0].value;
+            const fieldValueNode = knownFields[0].value;
             if (fieldValueNode.kind === kinds_js_1.Kind.NULL) {
-                const fieldName = fields[0].name.value;
-                reportInvalidLiteral(context.onError, `Field "${type}.${fieldName}" used for OneOf Input Object must be non-null.`, valueNode, (0, Path_js_1.addPath)(path, fieldName, undefined));
+                const fieldName = knownFields[0].name.value;
+                reportInvalidLiteral(context.onError, getOneOfInputObjectErrorMessage(type), valueNode, (0, Path_js_1.addPath)(path, fieldName, undefined));
             }
         }
     }
@@ -235,7 +245,7 @@ function validateInputLiteralImpl(context, valueNode, type, hideSuggestions, pat
         let caughtError;
         try {
             result = type.coerceInputLiteral
-                ? type.coerceInputLiteral((0, replaceVariables_js_1.replaceVariables)(valueNode), hideSuggestions)
+                ? type.coerceInputLiteral((0, replaceVariables_js_1.replaceVariables)(valueNode, context.variables, context.fragmentVariableValues), hideSuggestions)
                 : type.parseLiteral(valueNode, undefined, hideSuggestions);
         }
         catch (error) {
@@ -247,8 +257,8 @@ function validateInputLiteralImpl(context, valueNode, type, hideSuggestions, pat
         }
         if (result === undefined) {
             reportInvalidLiteral(context.onError, `Expected value of type "${type}"${caughtError != null
-                ? `, but encountered error "${caughtError.message != null && caughtError.message !== '' ? caughtError.message : caughtError}"; found`
-                : ', found'}: ${(0, printer_js_1.print)(valueNode)}.`, valueNode, path, caughtError);
+                ? `, but encountered error "${getCaughtErrorMessage(caughtError)}"; found`
+                : ', found'}: ${(0, printer_js_1.print)(valueNode)}.`, valueNode, path, (0, ensureGraphQLError_js_1.ensureGraphQLError)(caughtError));
         }
     }
 }
@@ -260,6 +270,21 @@ function getScopedVariableValues(context, valueNode) {
         : variables;
 }
 function reportInvalidLiteral(onError, message, valueNode, path, originalError) {
-    onError(new GraphQLError_js_1.GraphQLError(message, { nodes: valueNode, originalError }), (0, Path_js_1.pathToArray)(path));
+    onError(new GraphQLError_js_1.GraphQLError(message, {
+        nodes: valueNode,
+        originalError,
+    }), (0, Path_js_1.pathToArray)(path));
+}
+function getCaughtErrorMessage(caughtError) {
+    if ((0, isObjectLike_js_1.isObjectLike)(caughtError)) {
+        const message = caughtError.message;
+        if (typeof message === 'string' && message !== '') {
+            return message;
+        }
+    }
+    return String(caughtError);
+}
+function getOneOfInputObjectErrorMessage(type) {
+    return `Within OneOf Input Object type "${type}", exactly one field must be specified, and the value for that field must be non-null.`;
 }
 //# sourceMappingURL=validateInputValue.js.map