errors.ts

import { Kind, type OperationTypeNode } from 'graphql';
import {
  type EntityInterfaceFederationData,
  type FieldData,
  type InputValueData,
  type ObjectDefinitionData,
} from '../schema-building/types/types';
import {
  type InvalidEntityReturnTypeErrorParams,
  type IncompatibleMergedTypesErrorParams,
  type IncompatibleParentTypeMergeErrorParams,
  type IncompatibleTypeWithProvidesErrorMessageParams,
  type InvalidArgumentValueErrorParams,
  type InvalidCustomDirectiveErrorParams,
  type InvalidDirectiveLocationErrorParams,
  type InvalidLinkDirectiveImportObjectErrorParams,
  type InvalidNamedTypeErrorParams,
  type InvalidRepeatedDirectiveErrorParams,
  type InvalidSubValueFieldLinkDirectiveImportErrorParams,
  type invalidVersionLinkDirectiveUrlErrorParams,
  type MaxAgeNotPositiveIntegerErrorParams,
  type NonExternalConditionalFieldErrorParams,
  type OneOfRequiredFieldsErrorParams,
  type SemanticNonNullLevelsIndexOutOfBoundsErrorParams,
  type SemanticNonNullLevelsNonNullErrorParams,
} from './types/params';
import { type UnresolvableFieldData } from '../resolvability-graph/utils/utils';
import {
  AND_UPPER,
  ARGUMENT,
  FIELD,
  FIELD_PATH,
  IN_UPPER,
  INPUT_FIELD,
  INTERFACE,
  LEVELS,
  LITERAL_NEW_LINE,
  LITERAL_PERIOD,
  NOT_UPPER,
  OR_UPPER,
  QUOTATION_JOIN,
  SUBSCRIPTION_FIELD_CONDITION,
  SUBSCRIPTION_FILTER,
  SUBSCRIPTION_FILTER_CONDITION,
  SUBSCRIPTION_FILTER_VALUE,
  TYPENAME,
  UNION,
  VALUES,
} from '../utils/string-constants';
import { MAX_SUBSCRIPTION_FILTER_DEPTH, MAXIMUM_TYPE_NESTING } from '../utils/integer-constants';
import { getEntriesNotInHashSet, getOrThrowError, kindToNodeType } from '../utils/utils';
import {
  type ImplementationErrors,
  type InvalidEntityInterface,
  type InvalidRequiredInputValueData,
} from '../utils/types';
import { isFieldData } from '../schema-building/utils';
import { printTypeNode } from '@graphql-tools/merge';
import {
  type ArgumentName,
  type DirectiveArgumentCoords,
  type DirectiveLocation,
  type DirectiveName,
  type FieldName,
  type NodeType,
  type SubgraphName,
  type TypeName,
} from '../types/types';
import { type InvalidRootTypeFieldEventsDirectiveData } from './types/types';

export const minimumSubgraphRequirementError = new Error('At least one subgraph is required for federation.');

export function multipleNamedTypeDefinitionError(
  typeName: string,
  firstTypeString: string,
  secondTypeString: string,
): Error {
  return new Error(
    `The named type "${typeName}" is defined as both types "${firstTypeString}" and "${secondTypeString}".` +
      `\nHowever, there must be only one type named "${typeName}".`,
  );
}

export function incompatibleInputValueDefaultValueTypeError(
  prefix: string,
  coords: string,
  typeString: string,
  defaultValue: string,
): Error {
  return new Error(
    `The ${prefix} of type "${typeString}" defined on coords "${coords}" is` +
      ` incompatible with the default value of "${defaultValue}".`,
  );
}

export function incompatibleMergedTypesError({
  actualType,
  coords,
  expectedType,
  isArgument,
}: IncompatibleMergedTypesErrorParams): Error {
  return new Error(
    `Incompatible types when merging two instances of ${isArgument ? 'field argument' : FIELD} "${coords}":\n` +
      ` Expected type "${expectedType}" but received "${actualType}".`,
  );
}

export function incompatibleInputValueDefaultValuesError(
  prefix: string,
  path: string,
  subgraphNames: string[],
  expectedDefaultValue: string,
  actualDefaultValue: string,
) {
  return new Error(
    `Expected the ${prefix} defined on path "${path}" to define the default value "${expectedDefaultValue}".\n"` +
      `However, the default value "${actualDefaultValue}" is defined in the following subgraph` +
      (subgraphNames.length > 1 ? 's' : '') +
      `:\n "` +
      subgraphNames.join(QUOTATION_JOIN) +
      `"\n` +
      'If an instance defines a default value, that default value must be consistently defined across all subgraphs.',
  );
}

export function incompatibleSharedEnumError(parentName: string): Error {
  return new Error(
    `Enum "${parentName}" was used as both an input and output but was inconsistently defined across inclusive subgraphs. To update an Enum used as both an input and output, add any new Enum values with the @inaccessible directive in the origin subgraph. Next, add those new Enum values to all other subgraphs that define the Enum—this time without the @inaccessible directive. Finally, once all subgraphs have been updated, remove @inaccessible from the Enum values in the origin subgraph.`,
  );
}

export function invalidSubgraphNamesError(names: string[], invalidNameErrorMessages: string[]): Error {
  let message = 'Subgraphs to be federated must each have a unique, non-empty name.';
  if (names.length > 0) {
    message += '\n The following subgraph names are not unique:\n  "' + names.join('", "') + `"`;
  }
  for (const invalidNameErrorMessage of invalidNameErrorMessages) {
    message += `\n ${invalidNameErrorMessage}`;
  }
  return new Error(message);
}

export function duplicateDirectiveDefinitionError(directiveName: string) {
  return new Error(`The directive "${directiveName}" must only be defined once.`);
}

export function duplicateEnumValueDefinitionError(enumTypeName: string, valueName: string): Error {
  return new Error(`The Enum "${enumTypeName}" must only define the Enum value definition "${valueName}" once.`);
}

export function duplicateFieldDefinitionError(typeString: string, typeName: string, fieldName: string): Error {
  return new Error(`The ${typeString} "${typeName}" must only define the field definition "${fieldName}" once.`);
}

export function duplicateInputFieldDefinitionError(inputObjectTypeName: string, fieldName: string): Error {
  return new Error(
    `The Input Object "${inputObjectTypeName}" must only define the Input field definition "${fieldName}" once.`,
  );
}

export function duplicateImplementedInterfaceError(typeString: string, typeName: string, interfaceName: string): Error {
  return new Error(`The ${typeString} "${typeName}" must only implement the Interface "${interfaceName}" once.`);
}

export function duplicateUnionMemberDefinitionError(unionTypeName: string, memberName: string): Error {
  return new Error(`The Union "${unionTypeName}" must only define the Union member "${memberName}" once.`);
}

export function duplicateTypeDefinitionError(type: string, typeName: string): Error {
  return new Error(`The ${type} "${typeName}" must only be defined once.`);
}

export function duplicateOperationTypeDefinitionError(
  operationTypeName: OperationTypeNode,
  newTypeName: string,
  oldTypeName: string,
): Error {
  return new Error(
    `The operation type "${operationTypeName}" cannot be defined as "${newTypeName}"` +
      ` because it has already been defined as "${oldTypeName}".`,
  );
}

export function noBaseDefinitionForExtensionError(typeString: string, typeName: string): Error {
  return new Error(
    `The ${typeString} "${typeName}" is an extension,` +
      ` but no base ${typeString} definition of "${typeName}" is defined in any subgraph.`,
  );
}

export function noBaseScalarDefinitionError(typeName: string): Error {
  return new Error(
    `The Scalar extension "${typeName}" is invalid because no base Scalar definition` +
      ` of "${typeName} is defined in the subgraph.`,
  );
}

export function noDefinedUnionMembersError(unionTypeName: string): Error {
  return new Error(`The Union "${unionTypeName}" must define at least one Union member.`);
}

export function noDefinedEnumValuesError(enumTypeName: string): Error {
  return new Error(`The Enum "${enumTypeName}" must define at least one Enum value.`);
}

export function operationDefinitionError(typeName: string, operationType: OperationTypeNode, actualType: Kind): Error {
  return new Error(
    `Expected the response type "${typeName}" for operation "${operationType}" to be type Object but received "${actualType}.`,
  );
}

export function invalidFieldShareabilityError(objectData: ObjectDefinitionData, invalidFieldNames: Set<string>): Error {
  const parentTypeName = objectData.name;
  const errorMessages: string[] = [];
  for (const [fieldName, fieldData] of objectData.fieldDataByName) {
    if (!invalidFieldNames.has(fieldName)) {
      continue;
    }
    const shareableSubgraphs: string[] = [];
    const nonShareableSubgraphs: string[] = [];
    for (const [subgraphName, isShareable] of fieldData.isShareableBySubgraphName) {
      isShareable ? shareableSubgraphs.push(subgraphName) : nonShareableSubgraphs.push(subgraphName);
    }
    if (shareableSubgraphs.length < 1) {
      errorMessages.push(
        `\n The field "${fieldName}" is defined in the following subgraphs: "${[...fieldData.subgraphNames].join(
          '", "',
        )}".` + `\n However, it is not declared "@shareable" in any of them.`,
      );
    } else {
      errorMessages.push(
        `\n The field "${fieldName}" is defined and declared "@shareable" in the following subgraph` +
          (shareableSubgraphs.length > 1 ? 's' : '') +
          `: "` +
          shareableSubgraphs.join(QUOTATION_JOIN) +
          `".` +
          `\n However, it is not declared "@shareable" in the following subgraph` +
          (nonShareableSubgraphs.length > 1 ? 's' : '') +
          `: "${nonShareableSubgraphs.join(QUOTATION_JOIN)}".`,
      );
    }
  }
  return new Error(
    `The Object "${parentTypeName}" defines the same fields in multiple subgraphs without the "@shareable" directive:` +
      `${errorMessages.join('\n')}`,
  );
}

export function undefinedDirectiveError(directiveName: string, directiveCoords: string): Error {
  return new Error(
    `The directive "@${directiveName}" declared on coordinates "${directiveCoords}" is not defined in the schema.`,
  );
}
export function undefinedTypeError(typeName: string): Error {
  return new Error(` The type "${typeName}" was referenced in the schema, but it was never defined.`);
}

export function invalidRepeatedDirectiveErrorMessage(directiveName: string): string {
  return `The definition for the directive "@${directiveName}" does not define it as repeatable, but it is declared more than once on these coordinates.`;
}

export function invalidDirectiveError(
  directiveName: string,
  directiveCoords: string,
  ordinal: string,
  errorMessages: Array<string>,
): Error {
  return new Error(
    `The ${ordinal} instance of the directive "@${directiveName}" declared on coordinates "${directiveCoords}" is invalid for the following reason` +
      (errorMessages.length > 1 ? 's:\n' : ':\n') +
      errorMessages.join('\n'),
  );
}

export function invalidCustomDirectiveError({
  directiveCoords,
  directiveName,
  errors,
  ordinal,
}: InvalidCustomDirectiveErrorParams) {
  return new Error(
    `The ${ordinal} post-federation instance of the directive "@${directiveName}" declared on coordinates` +
      ` "${directiveCoords}" is invalid for the following reason` +
      (errors.length > 1 ? 's:\n' : ':\n - ') +
      errors.map((error) => error.message).join('\n - '),
  );
}

export function invalidDirectiveLocationErrorMessage(directiveName: string, location: string): string {
  return ` The definition for "@${directiveName}" does not define "${location}" as a valid location.`;
}

export function invalidDirectiveLocationError({
  directiveCoords,
  directiveName,
  location,
}: InvalidDirectiveLocationErrorParams): Error {
  return new Error(
    `The directive "@${directiveName}" declared on "${directiveCoords}" is invalid because the` +
      ` directive definition for "@${directiveName}" does not define "${location}" as a valid location.`,
  );
}

export function invalidRepeatedDirectiveError({
  directiveCoords,
  directiveName,
}: InvalidRepeatedDirectiveErrorParams): Error {
  return new Error(
    `The multiple instances of directive "@${directiveName}" declared on "${directiveCoords}" are invalid because` +
      ` the directive definition for "@${directiveName}" does not define it as repeatable.`,
  );
}

export function undefinedRequiredArgumentsError(requiredArgumentNames: Array<ArgumentName>): Error {
  return new Error(
    ` The following ` +
      requiredArgumentNames.length +
      ` required argument` +
      (requiredArgumentNames.length > 1 ? 's are' : ' is') +
      ` not defined: "` +
      requiredArgumentNames.join(QUOTATION_JOIN) +
      `"`,
  );
}

export function undefinedRequiredArgumentsErrorMessage(
  directiveName: string,
  requiredArgumentNames: string[],
  undefinedArgumentNames: string[],
): string {
  let message =
    ` The definition for "@${directiveName}" defines the following ` +
    requiredArgumentNames.length +
    ` required argument` +
    (requiredArgumentNames.length > 1 ? 's: ' : ': ') +
    `"` +
    requiredArgumentNames.join('", "') +
    `"` +
    `.\n However,`;
  if (undefinedArgumentNames.length < 1) {
    return message + ` no arguments are defined on this instance.`;
  }
  return (
    message +
    ` the following required argument` +
    (undefinedArgumentNames.length > 1 ? `s are` : ` is`) +
    ` not defined on this instance: "` +
    undefinedArgumentNames.join(QUOTATION_JOIN) +
    `".`
  );
}

export function unexpectedArgumentProvisionError(argumentNames: Array<string>): Error {
  return new Error(
    `The following unexpected argument` +
      (argumentNames.length > 1 ? 's are' : ' is') +
      ` provided: "` +
      argumentNames.join(QUOTATION_JOIN) +
      `".`,
  );
}

export function unexpectedDirectiveArgumentErrorMessage(directiveName: string, argumentNames: string[]): string {
  return (
    ` The definition for "@${directiveName}" does not define the following argument` +
    (argumentNames.length > 1 ? 's that are' : ' that is') +
    ` provided: "` +
    argumentNames.join(QUOTATION_JOIN) +
    `".`
  );
}

export function duplicateArgumentDefinitionError(argumentNames: Array<ArgumentName>): Error {
  return new Error(
    `The following argument` +
      (argumentNames.length > 1 ? 's are' : ' is') +
      ` defined more than once: "` +
      argumentNames.join(QUOTATION_JOIN) +
      `".`,
  );
}
export function duplicateDirectiveArgumentDefinitionsErrorMessage(argumentNames: string[]): string {
  return (
    ` The following argument` +
    (argumentNames.length > 1 ? 's are' : ' is') +
    ` defined more than once: "` +
    argumentNames.join(QUOTATION_JOIN) +
    `"`
  );
}

export function invalidArgumentValueError({
  argumentName,
  expectedTypeString,
  value,
}: InvalidArgumentValueErrorParams): Error {
  return new Error(
    ` The value "${value}" provided to argument "${argumentName}" is not a valid "${expectedTypeString}" type.`,
  );
}

export function invalidArgumentValueErrorMessage(
  value: string,
  hostName: string,
  argumentName: ArgumentName,
  expectedTypeString: string,
): string {
  return ` The value "${value}" provided to argument "${hostName}(${argumentName}: ...)" is not a valid "${expectedTypeString}" type.`;
}

export function maximumTypeNestingExceededError(path: string): Error {
  return new Error(
    ` The type defined at path "${path}" has more than ${MAXIMUM_TYPE_NESTING} layers of nesting,` +
      ` or there is a cyclical error.`,
  );
}

export function unexpectedKindFatalError(typeName: string) {
  return new Error(`Fatal: Unexpected type for "${typeName}"`);
}

export function incompatibleParentKindFatalError(parentTypeName: string, expectedKind: Kind, actualKind: Kind): Error {
  return new Error(
    `Fatal: Expected "${parentTypeName}" to be type ${kindToNodeType(expectedKind)}` +
      ` but received "${kindToNodeType(actualKind)}".`,
  );
}

export function unexpectedEdgeFatalError(typeName: string, edgeNames: Array<string>): Error {
  return new Error(
    `Fatal: The type "${typeName}" visited the following unexpected edge` +
      (edgeNames.length > 1 ? 's' : '') +
      `:\n "${edgeNames.join(QUOTATION_JOIN)}".`,
  );
}

const interfaceObject = `"Interface Object" (an "Object" type that also defines the "@interfaceObject" directive)`;

export function incompatibleParentTypeMergeError({
  existingData,
  incomingNodeType,
  incomingSubgraphName,
}: IncompatibleParentTypeMergeErrorParams): Error {
  const existingSubgraphNames = [...existingData.subgraphNames];
  const nodeType = incomingNodeType ? `"${incomingNodeType}"` : interfaceObject;
  return new Error(
    ` "${existingData.name}" is defined using incompatible types across subgraphs.` +
      ` It is defined as type "${kindToNodeType(existingData.kind)}" in subgraph` +
      (existingSubgraphNames.length > 1 ? 's' : '') +
      ` "${existingSubgraphNames.join(QUOTATION_JOIN)}" but type ${nodeType} in subgraph` +
      ` "${incomingSubgraphName}".`,
  );
}

export function unexpectedTypeNodeKindFatalError(typePath: string): Error {
  return new Error(
    `Fatal: Expected all constituent types at path "${typePath}" to be one of the following: ` +
      `"LIST_TYPE", "NAMED_TYPE", or "NON_NULL_TYPE".`,
  );
}

export function invalidKeyFatalError<K>(key: K, mapName: string): Error {
  return new Error(`Fatal: Expected key "${key}" to exist in the map "${mapName}".`);
}

export function unexpectedParentKindForChildError(
  parentTypeName: string,
  expectedTypeString: string,
  actualTypeString: string,
  childName: string,
  childTypeString: string,
): Error {
  return new Error(
    ` Expected "${parentTypeName}" to be type "${expectedTypeString}" but received "${actualTypeString}"` +
      ` when handling child "${childName}" of type "${childTypeString}".`,
  );
}

export function subgraphValidationError(subgraphName: string, errors: Error[]): Error {
  return new Error(
    `The subgraph "${subgraphName}" could not be federated for the following reason` +
      (errors.length > 1 ? 's' : '') +
      `:\n` +
      errors.map((error) => error.message).join('\n'),
  );
}

export const noSubgraphNameError = new Error(
  `Federation could not be attempted because at least one subgraph does not define a name.`,
);

export function duplicateSubgraphNamesError(subgraphNames: Array<SubgraphName>): Error {
  return new Error(
    `Federation could not be attempted because the following subgraph names are defined more` +
      ` than once: "${subgraphNames.join(QUOTATION_JOIN)}".`,
  );
}

export function invalidOperationTypeDefinitionError(
  existingOperationType: OperationTypeNode,
  typeName: string,
  newOperationType: OperationTypeNode,
): Error {
  return new Error(
    `The schema definition defines the "${existingOperationType}" operation as type "${typeName}".` +
      ` However, "${typeName}" was also used for the "${newOperationType}" operation.\n` +
      ` If explicitly defined, each operation type must be a unique and valid Object type.`,
  );
}

export function invalidRootTypeDefinitionError(
  operationType: OperationTypeNode,
  typeName: string,
  defaultTypeName: string,
): Error {
  return new Error(
    `The schema definition defines the "${operationType}" operation as type "${typeName}".` +
      ` However, the schema also defines another type named "${defaultTypeName}",` +
      ` which is the default (root) type name for the "${operationType}" operation.\n` +
      `For federation, it is only possible to use the default root types names ("Mutation", "Query", "Subscription") as` +
      ` operation definitions. No other definitions with these default root type names are valid.`,
  );
}

export function subgraphInvalidSyntaxError(error?: Error): Error {
  let message = `The subgraph has syntax errors and could not be parsed.`;
  if (error) {
    message += `\n The reason provided was: ` + error.message;
  }
  return new Error(message);
}

export function invalidInterfaceImplementationError(
  parentTypeName: TypeName,
  parentNodeType: NodeType,
  implementationErrorsByInterfaceTypeName: Map<TypeName, ImplementationErrors>,
): Error {
  const messages: string[] = [];
  for (const [interfaceName, implementationErrors] of implementationErrorsByInterfaceTypeName) {
    let message =
      ` The implementation of Interface "${interfaceName}" by "${parentTypeName}"` + ` is invalid because:\n`;
    const unimplementedFieldsLength = implementationErrors.unimplementedFields.length;
    if (unimplementedFieldsLength) {
      message +=
        `  The following field${unimplementedFieldsLength > 1 ? 's are' : ' is'} not implemented: "` +
        implementationErrors.unimplementedFields.join('", "') +
        '"\n';
    }
    for (const [fieldName, invalidFieldImplementation] of implementationErrors.invalidFieldImplementations) {
      const unimplementedArgumentsSize = invalidFieldImplementation.unimplementedArguments.size;
      const invalidArgumentsLength = invalidFieldImplementation.invalidImplementedArguments.length;
      const invalidAdditionalArgumentsSize = invalidFieldImplementation.invalidAdditionalArguments.size;
      message += `  The field "${fieldName}" is invalid because:\n`;
      if (unimplementedArgumentsSize) {
        message +=
          `   The following argument${unimplementedArgumentsSize > 1 ? 's are' : ' is'} not implemented: "` +
          [...invalidFieldImplementation.unimplementedArguments].join('", "') +
          '"\n';
      }
      if (invalidArgumentsLength) {
        message += `   The following implemented argument${invalidArgumentsLength > 1 ? 's are' : ' is'} invalid:\n`;
        for (const invalidArgument of invalidFieldImplementation.invalidImplementedArguments) {
          message +=
            `    The argument "${invalidArgument.argumentName}" must define type "` +
            invalidArgument.expectedType +
            `" and not "${invalidArgument.actualType}"\n`;
        }
      }
      if (invalidAdditionalArgumentsSize) {
        message +=
          `   If a field from an Interface is implemented, any additional Arguments that were not defined` +
          ` on the original Interface field must be optional (nullable).\n`;
        message +=
          `    The following additional argument` +
          (invalidFieldImplementation.invalidAdditionalArguments.size > 1 ? `s are` : ` is`) +
          ` not defined as optional: "` +
          [...invalidFieldImplementation.invalidAdditionalArguments].join(`", "`) +
          `"\n`;
      }
      if (invalidFieldImplementation.implementedResponseType) {
        message +=
          `   The implemented response type "${invalidFieldImplementation.implementedResponseType}" is not` +
          ` a valid subtype (equally or more restrictive) of the response type "` +
          invalidFieldImplementation.originalResponseType +
          `" for "${interfaceName}.${fieldName}".\n`;
      }
      if (invalidFieldImplementation.isInaccessible) {
        message +=
          `   The field has been declared "@inaccessible"; however, the same field has not been declared "@inaccessible"` +
          ` on the Interface definition.\n   Consequently, the Interface implementation cannot be satisfied.\n`;
      }
    }
    messages.push(message);
  }
  return new Error(
    `The ${parentNodeType} "${parentTypeName}" has the following Interface implementation errors:\n` +
      messages.join('\n'),
  );
}

export function invalidRequiredInputValueError(
  typeString: string,
  path: string,
  errors: InvalidRequiredInputValueData[],
  isArgument = true,
): Error {
  const inputValueTypeString = isArgument ? ARGUMENT : INPUT_FIELD;
  let message = `The ${typeString} "${path}" could not be federated because:\n`;
  for (const error of errors) {
    message +=
      ` The ${inputValueTypeString} "${error.inputValueName}" is required in the following subgraph` +
      (error.requiredSubgraphs.length > 1 ? 's' : '') +
      ': "' +
      error.requiredSubgraphs.join(`", "`) +
      `"\n` +
      ` However, the ${inputValueTypeString} "${error.inputValueName}" is not defined in the following subgraph` +
      (error.missingSubgraphs.length > 1 ? 's' : '') +
      ': "' +
      error.missingSubgraphs.join(`", "`) +
      `"\n` +
      ` If an ${inputValueTypeString} is required on a ${typeString} in any one subgraph, it must be at least defined` +
      ` as optional on all other definitions of that ${typeString} in all other subgraphs.\n`;
  }
  return new Error(message);
}

export function duplicateArgumentsError(fieldPath: string, duplicatedArguments: string[]): Error {
  return new Error(
    `The field "${fieldPath}" is invalid because:\n` +
      ` The following argument` +
      (duplicatedArguments.length > 1 ? 's are' : ' is') +
      ` defined more than once: "` +
      duplicatedArguments.join(QUOTATION_JOIN) +
      `"\n`,
  );
}

export function noQueryRootTypeError(isRouterSchema = true): Error {
  return new Error(
    `The ${isRouterSchema ? 'router' : 'client'} schema does not define at least one accessible query root` +
      ` type field after federation was completed, which is necessary for a federated graph to be valid.\n` +
      ` For example:\n` +
      `  type Query {\n` +
      `    dummy: String\n` +
      `  }`,
  );
}

export const inaccessibleQueryRootTypeError = new Error(
  `The root query type "Query" must be present in the client schema;` +
    ` consequently, it must not be declared "@inaccessible".`,
);

export function expectedEntityError(typeName: string): Error {
  return new Error(`Expected object "${typeName}" to define a "key" directive, but it defines no directives.`);
}

export const inlineFragmentInFieldSetErrorMessage = ` Inline fragments are not currently supported within a field set argument.`;

export function abstractTypeInKeyFieldSetErrorMessage(
  fieldSet: string,
  fieldCoords: string,
  abstractTypeName: string,
  abstractTypeString: string,
): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because "${fieldCoords}" returns "${abstractTypeName}", which is type "${abstractTypeString}".\n` +
    ` Fields that return abstract types (Interfaces and Unions)` +
    ` cannot be included in the field set of "@key" directives.`
  );
}

export function unknownTypeInFieldSetErrorMessage(
  fieldSet: string,
  fieldCoords: string,
  responseTypeName: string,
): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because "${fieldCoords}" returns the unknown type "${responseTypeName}".`
  );
}

export function invalidSelectionSetErrorMessage(
  fieldSet: string,
  fieldCoordinatesPath: Array<string>,
  selectionSetTypeName: string,
  fieldTypeString: string,
): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because of the selection set corresponding to the ` +
    getSelectionSetLocationWithTypeString(fieldCoordinatesPath, selectionSetTypeName, fieldTypeString) +
    ` Composite types such as "${fieldTypeString}" types must define a selection set with at least one field selection.`
  );
}

export function invalidSelectionSetDefinitionErrorMessage(
  fieldSet: string,
  fieldCoordinatesPath: Array<string>,
  selectionSetTypeName: string,
  fieldTypeString: string,
): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because of the selection set corresponding to the ` +
    getSelectionSetLocationWithTypeString(fieldCoordinatesPath, selectionSetTypeName, fieldTypeString) +
    ` Non-composite types such as "${fieldTypeString}" cannot define a selection set.`
  );
}

export function undefinedFieldInFieldSetErrorMessage(
  fieldSet: string,
  parentTypeName: string,
  fieldName: string,
): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because of the selection set corresponding to the field coordinates "${parentTypeName}.${fieldName}".\n` +
    ` The type "${parentTypeName}" does not define a field named "${fieldName}".`
  );
}

export function unparsableFieldSetErrorMessage(fieldSet: string, error?: Error): string {
  let message = ` The following field set is invalid:\n  "${fieldSet}"\n` + ` The field set could not be parsed.`;
  if (error) {
    message += `\n The reason provided was: ` + error.message;
  }
  return message;
}

export function unparsableFieldSetSelectionErrorMessage(fieldSet: string, fieldName: string): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because the selection set defined on "${fieldName}" could not be parsed.`
  );
}

export function undefinedCompositeOutputTypeError(parentTypeName: string): Error {
  return new Error(` Expected an object/interface or object/interface extension named "${parentTypeName}" to exist.`);
}

export function unexpectedArgumentErrorMessage(fieldSet: string, fieldPath: string, argumentName: string): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because "${fieldPath}" does not define an argument named "${argumentName}".`
  );
}

export function argumentsInKeyFieldSetErrorMessage(fieldSet: string, fieldPath: string): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because "${fieldPath}" defines arguments.\n` +
    ` Fields that define arguments cannot be included in the field set of @key directives.`
  );
}

export function invalidProvidesOrRequiresDirectivesError(directiveName: string, errorMessages: string[]): Error {
  return new Error(
    `The following "${directiveName}" directive` +
      (errorMessages.length > 1 ? 's are' : ' is') +
      ` invalid:\n` +
      errorMessages.join(`\n`),
  );
}

export function duplicateFieldInFieldSetErrorMessage(fieldSet: string, fieldPath: string): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because "${fieldPath}" was included in the field set more than once.`
  );
}

export function incompatibleTypeWithProvidesErrorMessage({
  fieldCoords,
  responseType,
  subgraphName,
}: IncompatibleTypeWithProvidesErrorMessageParams): string {
  return (
    ` A "@provides" directive is declared on field "${fieldCoords}" in subgraph "${subgraphName}".\n` +
    ` However, the response type "${responseType}" is not an Object nor Interface.`
  );
}

function getSelectionSetLocation(
  fieldCoordinatesPath: Array<string>,
  selectionSetTypeName: string,
  withReturnType: boolean = false,
): string {
  /* fieldCoordinatesPath can have length 0 if it's a @requires directive,
   * in which case the first part of the field set refers to the enclosing parent type.
   * */
  if (fieldCoordinatesPath.length < 1) {
    return `enclosing type name "${selectionSetTypeName}".\n`;
  }
  return (
    `field coordinates "${fieldCoordinatesPath[fieldCoordinatesPath.length - 1]}"` +
    (withReturnType ? ` that returns "${selectionSetTypeName}"` : '') +
    `.\n`
  );
}

function getSelectionSetLocationWithTypeString(
  fieldCoordinatesPath: Array<string>,
  selectionSetTypeName: string,
  typeString: string,
): string {
  /* fieldCoordinatesPath can have length 0 if it's a @requires directive,
   * in which case the first part of the field set refers to the enclosing parent type.
   * */
  if (fieldCoordinatesPath.length < 1) {
    return `enclosing type name "${selectionSetTypeName}", which is type "${typeString}".\n`;
  }
  return (
    `field coordinates "${fieldCoordinatesPath[fieldCoordinatesPath.length - 1]}"` +
    ` that returns "${selectionSetTypeName}", which is type "${typeString}".\n`
  );
}

export function invalidInlineFragmentTypeErrorMessage(
  fieldSet: string,
  fieldCoordinatesPath: Array<string>,
  typeConditionName: string,
  selectionSetTypeName: string,
): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because an inline fragment with the type condition "${typeConditionName}" is defined on the` +
    ` selection set corresponding to the ` +
    getSelectionSetLocation(fieldCoordinatesPath, selectionSetTypeName, true) +
    ` However, "${selectionSetTypeName}" is not an abstract (Interface or Union) type.\n` +
    ` Consequently, the only valid type condition at this selection set would be "${selectionSetTypeName}".`
  );
}

export function inlineFragmentWithoutTypeConditionErrorMessage(fieldSet: string, fieldPath: string): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because "${fieldPath}" defines an inline fragment without a type condition.`
  );
}

export function unknownInlineFragmentTypeConditionErrorMessage(
  fieldSet: string,
  fieldCoordinatesPath: Array<string>,
  selectionSetTypeName: string,
  typeConditionName: string,
): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because an inline fragment with the unknown type condition "${typeConditionName}" is defined on the` +
    ` selection set corresponding to the ` +
    getSelectionSetLocation(fieldCoordinatesPath, selectionSetTypeName)
  );
}

export function invalidInlineFragmentTypeConditionTypeErrorMessage(
  fieldSet: string,
  fieldCoordinatesPath: Array<string>,
  selectionSetTypeName: string,
  typeConditionName: string,
  typeConditionTypeString: string,
): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because an inline fragment with the type condition "${typeConditionName}" is defined on the` +
    ` selection set corresponding to the ` +
    getSelectionSetLocation(fieldCoordinatesPath, selectionSetTypeName) +
    ` However, "${typeConditionName}" is type "${typeConditionTypeString}" when types "Interface" or "Object" would` +
    ` be expected.`
  );
}

export function invalidInlineFragmentTypeConditionErrorMessage(
  fieldSet: string,
  fieldCoordinatesPath: Array<string>,
  typeConditionName: string,
  parentTypeString: string,
  selectionSetTypeName: string,
): string {
  const message =
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because an inline fragment with the type condition "${typeConditionName}" is defined on the` +
    ` selection set corresponding to the ` +
    getSelectionSetLocationWithTypeString(fieldCoordinatesPath, selectionSetTypeName, parentTypeString);
  if (parentTypeString === INTERFACE) {
    return message + ` However, "${typeConditionName}" does not implement "${selectionSetTypeName}"`;
  }
  return message + ` However, "${typeConditionName}" is not a member of "${selectionSetTypeName}".`;
}

export function invalidSelectionOnUnionErrorMessage(
  fieldSet: string,
  fieldCoordinatesPath: Array<string>,
  selectionSetTypeName: string,
): string {
  return (
    ` The following field set is invalid:\n  "${fieldSet}"\n` +
    ` This is because of the selection set corresponding to the ` +
    getSelectionSetLocationWithTypeString(fieldCoordinatesPath, selectionSetTypeName, UNION) +
    ` Union types such as "${selectionSetTypeName}" must define field selections (besides "__typename") on an` +
    ` inline fragment whose type condition corresponds to a constituent union member.`
  );
}

export function duplicateOverriddenFieldErrorMessage(fieldPath: string, subgraphNames: string[]): string {
  return (
    ` The field "${fieldPath}" declares an @override directive in the following subgraphs: "` +
    subgraphNames.join(QUOTATION_JOIN) +
    `".`
  );
}

export function duplicateOverriddenFieldsError(errorMessages: string[]): Error {
  return new Error(
    `The "@override" directive must only be declared on one single instance of a field.` +
      ` However, an "@override" directive was declared on more than one instance of the following field` +
      (errorMessages.length > 1 ? 's' : '') +
      `: "` +
      errorMessages.join(QUOTATION_JOIN) +
      `".\n`,
  );
}

export function noFieldDefinitionsError(typeString: string, typeName: string): Error {
  return new Error(`The ${typeString} "${typeName}" is invalid because it does not define any fields.`);
}

export function noInputValueDefinitionsError(inputTypeName: string): Error {
  return new Error(`The Input Object "${inputTypeName}" is invalid because it does not define any input values.`);
}

export function allChildDefinitionsAreInaccessibleError(
  typeString: string,
  typeName: string,
  childType: string,
): Error {
  return new Error(
    `The ${typeString} "${typeName}" is invalid because all its ${childType} definitions are declared "@inaccessible".`,
  );
}

export function equivalentSourceAndTargetOverrideErrorMessage(subgraphName: string, hostPath: string): string {
  return `Cannot override field "${hostPath}" because the source and target subgraph names are both "${subgraphName}"`;
}

export function undefinedEntityInterfaceImplementationsError(
  invalidEntityInterfacesByTypeName: Map<string, InvalidEntityInterface[]>,
  entityInterfaceFederationDataByTypeName: Map<string, EntityInterfaceFederationData>,
): Error {
  let message =
    `Federation was unsuccessful because any one subgraph that defines a specific entity Interface` +
    ` must also define each and every entity Object that implements that entity Interface.\n` +
    `Each entity Object must also explicitly define its implementation of the entity Interface.\n`;
  for (const [typeName, undefinedImplementations] of invalidEntityInterfacesByTypeName) {
    const entityInterfaceDatas = getOrThrowError(
      entityInterfaceFederationDataByTypeName,
      typeName,
      'entityInterfaceFederationDataByTypeName',
    );
    const implementedConcreteTypeNames = entityInterfaceDatas.concreteTypeNames!;
    message +=
      ` Across all subgraphs, the entity interface "${typeName}" is implemented by the following entit` +
      (implementedConcreteTypeNames.size > 1 ? `ies` : `y`) +
      `:\n  "` +
      Array.from(implementedConcreteTypeNames).join(QUOTATION_JOIN) +
      `"\n` +
      ` However, the definition of at least one of these implementations is missing in a subgraph that` +
      ` defines the entity interface "${typeName}":\n`;
    for (const { subgraphName, definedConcreteTypeNames } of undefinedImplementations) {
      const disparities = getEntriesNotInHashSet(implementedConcreteTypeNames, definedConcreteTypeNames);
      message +=
        `  Subgraph "${subgraphName}" does not define the following implementations: "` +
        disparities.join(QUOTATION_JOIN) +
        `"\n`;
    }
  }
  return new Error(message);
}

export function orScopesLimitError(maxOrScopes: number, directiveCoords: string[]): Error {
  return new Error(
    `The maximum number of OR scopes that can be defined by @requiresScopes on a single field is ${maxOrScopes}.` +
      ` However, the following coordinates attempt to define more:\n "` +
      directiveCoords.join(QUOTATION_JOIN) +
      `"\nIf you require more, please contact support.`,
  );
}

export function invalidEventDrivenGraphError(errorMessages: string[]): Error {
  return new Error(
    `An "Event Driven" graph—a subgraph that defines event driven directives—must not define any resolvers.\n` +
      `Consequently, any "@key" definitions must also include the "resolvable: false" argument.\n` +
      `Moreover, only fields that compose part of an entity's (composite) key and are` +
      ` declared "@external" are permitted.\n` +
      errorMessages.join('\n'),
  );
}

export function invalidRootTypeFieldEventsDirectivesErrorMessage(
  invalidEventsDirectiveDataByRootFieldPath: Map<string, InvalidRootTypeFieldEventsDirectiveData>,
): string {
  let message =
    ` Root type fields defined in an Event Driven graph must define a valid events` +
    ` directive:\n  Mutation type fields must define either a edfs publish or request directive."\n` +
    `  Query type fields must define "@edfs__natsRequest"\n  Subscription type fields must define an edfs subscribe` +
    ` directive\n The following root field path` +
    (invalidEventsDirectiveDataByRootFieldPath.size > 1 ? 's are' : ' is') +
    ` invalid:\n`;
  for (const [fieldPath, data] of invalidEventsDirectiveDataByRootFieldPath) {
    if (!data.definesDirectives) {
      message += `  The root field path "${fieldPath}" does not define any valid events directives.\n`;
    } else {
      message +=
        `  The root field path "${fieldPath}" defines the following invalid events directive` +
        (data.invalidDirectiveNames.length > 1 ? `s` : ``) +
        `: "@` +
        data.invalidDirectiveNames.join(`", "@`) +
        `"\n`;
    }
  }
  return message;
}

export function invalidEventDrivenMutationResponseTypeErrorMessage(
  invalidResponseTypeStringByMutationPath: Map<string, string>,
): string {
  let message =
    ` Mutation type fields defined in an Event Driven graph must return the non-nullable type` +
    ` "edfs__PublishResult!", which has the following definition:\n  type edfs__PublishResult {\n` +
    `   success: Boolean!\n  }\n However, the following mutation field path` +
    (invalidResponseTypeStringByMutationPath.size > 1 ? `s are` : ` is`) +
    ` invalid:\n`;
  for (const [path, responseTypeString] of invalidResponseTypeStringByMutationPath) {
    message += `  The mutation field path "${path}" returns "${responseTypeString}".\n`;
  }
  return message;
}

export function invalidRootTypeFieldResponseTypesEventDrivenErrorMessage(
  invalidResponseTypeStringByRootFieldPath: Map<string, string>,
): string {
  let message =
    ` The named response type of root type fields defined in an Event Driven graph must be a` +
    ` non-nullable, non-list named type that is either an entity, an interface implemented by` +
    ` an entity, or a union of which an entity is a member.\n Consequently, the following root field path` +
    (invalidResponseTypeStringByRootFieldPath.size > 1 ? 's are' : ' is') +
    ` invalid:\n`;
  for (const [fieldPath, responseTypeString] of invalidResponseTypeStringByRootFieldPath) {
    message += `  The root field path "${fieldPath}", which returns the invalid type "${responseTypeString}"\n`;
  }
  return message;
}

export const invalidNatsStreamInputErrorMessage =
  `The "streamConfiguration" argument must be a valid input object with the following form:\n` +
  `  input edfs__NatsStreamConfiguration {\n    consumerInactiveThreshold: Int! = 30\n    consumerName: String!\n    streamName: String!\n  }`;

export function invalidNatsStreamInputFieldsErrorMessage(
  missingRequiredFieldNames: string[],
  duplicateRequiredFieldNames: string[],
  invalidRequiredFieldNames: string[],
  invalidFieldNames: string[],
): string {
  let message = invalidNatsStreamInputErrorMessage;
  const errorMessages: string[] = [];
  if (missingRequiredFieldNames.length > 0) {
    errorMessages.push(
      `The following required field` +
        (missingRequiredFieldNames.length > 1 ? `s were` : ` was`) +
        ` not defined: "` +
        missingRequiredFieldNames.join(QUOTATION_JOIN) +
        `".`,
    );
  }
  if (duplicateRequiredFieldNames.length > 0) {
    errorMessages.push(
      `The following required field` +
        (duplicateRequiredFieldNames.length > 1 ? `s were` : ` was`) +
        ` defined more than once: "` +
        duplicateRequiredFieldNames.join(QUOTATION_JOIN) +
        `".`,
    );
  }
  if (invalidRequiredFieldNames.length > 0) {
    errorMessages.push(
      `The following required field` +
        (invalidRequiredFieldNames.length > 1 ? `s were` : ` was`) +
        ` not type "String!" with a minimum length of 1: "` +
        invalidRequiredFieldNames.join(QUOTATION_JOIN) +
        `".`,
    );
  }
  if (invalidFieldNames.length > 0) {
    errorMessages.push(
      `The following field` +
        (invalidFieldNames.length > 1 ? `s are` : ` is`) +
        ` not part of a valid "edfs__NatsStreamConfiguration" input definition: "` +
        invalidFieldNames.join(QUOTATION_JOIN) +
        `".`,
    );
  }
  message +=
    `\n However, the provided input was invalid for the following reason` +
    (errorMessages.length > 1 ? `s` : ``) +
    `:\n  ` +
    errorMessages.join(`\n  `);
  return message;
}

export function invalidKeyFieldSetsEventDrivenErrorMessage(
  invalidKeyFieldSetsByEntityTypeName = new Map<string, string[]>(),
): string {
  let message = '';
  for (const [typeName, keyFieldSets] of invalidKeyFieldSetsByEntityTypeName) {
    message +=
      ` The following "@key" field set` +
      (keyFieldSets.length > 1 ? 's are' : ' is') +
      ` defined on the entity "${typeName}" without a "resolvable: false" argument:\n` +
      `  "` +
      keyFieldSets.join(QUOTATION_JOIN) +
      `"\n`;
  }
  return message;
}

export function nonExternalKeyFieldNamesEventDrivenErrorMessage(
  nonExternalKeyFieldNameByFieldPath: Map<string, string>,
): string {
  let message =
    ` The following field` +
    (nonExternalKeyFieldNameByFieldPath.size > 1 ? 's are referenced' : ' is referenced') +
    ` within an entity "@key" field without an "@external" declaration:\n`;
  for (const [fieldPath, fieldName] of nonExternalKeyFieldNameByFieldPath) {
    message += `  field "${fieldName}" defined on path "${fieldPath}"\n`;
  }
  return message;
}

export function nonKeyFieldNamesEventDrivenErrorMessage(nonKeyFieldNameByFieldPath: Map<string, string>): string {
  let message =
    ` The following field` +
    (nonKeyFieldNameByFieldPath.size > 1 ? 's are' : ' is') +
    ` defined despite not composing part of a "@key" directive field set:\n`;
  for (const [fieldPath, fieldName] of nonKeyFieldNameByFieldPath) {
    message += `  Field "${fieldName}" defined on path "${fieldPath}"\n`;
  }
  return message;
}

export function nonEntityObjectExtensionsEventDrivenErrorMessage(typeNames: string[]): string {
  return (
    `Only root types and entities (objects that define one or more primary keys with the "@key" directive) may` +
    ` be defined as object extensions in an Event Driven graph.` +
    `\nConsequently, the following object extension` +
    ` definition` +
    (typeNames.length > 1 ? 's are' : ' is') +
    ` invalid:\n  "` +
    typeNames.join(QUOTATION_JOIN) +
    `"\n`
  );
}

export function nonKeyComposingObjectTypeNamesEventDrivenErrorMessage(typeNames: string[]): string {
  return (
    ` Only object definitions whose fields compose part of a "@key" directive's field set may be defined in an` +
    ` Event Driven graph. Consequently, the following object type definition` +
    (typeNames.length > 1 ? 's are' : ' is') +
    ` invalid:\n  "` +
    typeNames.join(QUOTATION_JOIN) +
    `"\n`
  );
}

export const invalidEdfsPublishResultObjectErrorMessage =
  ` The object "edfs__PublishResult" that was defined in the Event Driven graph is invalid and must instead have` +
  ` the following definition:\n  type edfs__PublishResult {\n   success: Boolean!\n  }`;

export const invalidNatsStreamConfigurationDefinitionErrorMessage =
  ` The input object "edfs__NatsStreamConfiguration" that was defined in the Event Driven graph is invalid and must` +
  ` instead have the following definition:\n  input edfs__NatsStreamConfiguration {\n   consumerInactiveThreshold: Int! = 30\n` +
  `   consumerName: String!\n   streamName: String!\n  }`;

export function invalidImplementedTypeError(
  typeName: string,
  invalidImplementationTypeStringByTypeName: Map<string, string>,
): Error {
  let message =
    ` Only interfaces can be implemented. However, the type "${typeName}" attempts to implement` +
    ` the following invalid type` +
    (invalidImplementationTypeStringByTypeName.size > 1 ? `s` : ``) +
    `:\n`;
  for (const [typeName, typeString] of invalidImplementationTypeStringByTypeName) {
    message += `  "${typeName}", which is type "${typeString}"\n`;
  }
  return new Error(message);
}

export function selfImplementationError(typeName: string): Error {
  return new Error(` The interface "${typeName}" must not implement itself.`);
}

export function invalidEventSubjectErrorMessage(argumentName: string): string {
  return `The "${argumentName}" argument must be string with a minimum length of one.`;
}

export function invalidEventSubjectsErrorMessage(argumentName: string): string {
  return `The "${argumentName}" argument must be a list of strings.`;
}

export function invalidEventSubjectsItemErrorMessage(argumentName: string): string {
  return (
    `Each item in the "${argumentName}" argument list must be a string with a minimum length of one.` +
    ` However, at least one value provided in the list was invalid.`
  );
}

export function invalidEventSubjectsArgumentErrorMessage(argumentName: string): string {
  return `An argument template references the invalid argument "${argumentName}".`;
}

export function undefinedEventSubjectsArgumentErrorMessage(argumentName: string): string {
  return `An argument template references the undefined argument "${argumentName}".`;
}

export const invalidEventProviderIdErrorMessage = `If explicitly defined, the "providerId" argument must be a string with a minimum length of one.`;

export function invalidEventDirectiveError(directiveName: string, fieldPath: string, errorMessages: string[]): Error {
  return new Error(
    `The event directive "${directiveName}" declared on "${fieldPath}" is invalid for the following` +
      ` reason` +
      (errorMessages.length > 1 ? `s` : ``) +
      `:\n ` +
      errorMessages.join(`\n `),
  );
}

export function invalidReferencesOfInaccessibleTypeError(
  typeString: string,
  typeName: string,
  invalidPaths: string[],
): Error {
  return new Error(
    `The ${typeString} "${typeName}" is declared "@inaccessible"; however, the ${typeString} is still referenced at` +
      ` the following paths:\n "` +
      invalidPaths.join(QUOTATION_JOIN) +
      `"\n`,
  );
}

export function inaccessibleRequiredInputValueError(data: InputValueData, parentCoords: string): Error {
  return new Error(
    `The ${data.kind === Kind.ARGUMENT ? 'argument' : 'Input field'} "${data.name}" defined at coordinates` +
      ` "${data.federatedCoords}" is declared "@inaccessible";  however, it is a required` +
      ` ${data.kind === Kind.ARGUMENT ? 'argument of field' : 'field of Input Object'} "${parentCoords}".`,
  );
}

export function invalidUnionMemberTypeError(typeName: string, invalidMembers: string[]): Error {
  return new Error(
    ` The union "${typeName}" defines the following member` +
      (invalidMembers.length > 1 ? `s that are not object types` : ` that is not an object type`) +
      `:\n  ` +
      invalidMembers.join(`\n  `),
  );
}

export function invalidRootTypeError(typeName: string): Error {
  return new Error(
    `Expected type "${typeName}" to be a root type but could not find its respective OperationTypeNode.`,
  );
}

export function invalidSubscriptionFilterLocationError(path: string): Error {
  return new Error(
    `The "@${SUBSCRIPTION_FILTER}" directive must only be defined on a subscription root field, but it was` +
      ` defined on the path "${path}".`,
  );
}

export function invalidSubscriptionFilterDirectiveError(fieldPath: string, errors: Error[]): Error {
  return new Error(
    `The "@${SUBSCRIPTION_FILTER}" directive defined on path "${fieldPath}" is invalid for the` +
      ` following reason` +
      (errors.length > 1 ? 's' : '') +
      `:\n` +
      errors.join(`\n`),
  );
}

export function subscriptionFilterNamedTypeError(namedTypeName: string): Error {
  return new Error(`Unknown type "${namedTypeName}".`);
}

export function subscriptionFilterUnionMemberInvalidError(
  unionTypeName: string,
  memberTypeName: string,
  detail: string,
): Error {
  return new Error(
    `The "@openfed__subscriptionFilter" condition is invalid for union member "${memberTypeName}" of union "${unionTypeName}":\n` +
      detail,
  );
}

export function subscriptionFilterInterfaceImplementationInvalidError(
  interfaceTypeName: string,
  implementerTypeName: string,
  detail: string,
): Error {
  return new Error(
    `The "@openfed__subscriptionFilter" condition is invalid for concrete type "${implementerTypeName}" implementing interface "${interfaceTypeName}":\n` +
      detail,
  );
}

export function subscriptionFilterNoAccessibleConcreteTypesError(
  abstractTypeName: string,
  abstractKind: string,
): Error {
  return new Error(
    `The ${abstractKind} "${abstractTypeName}" has no accessible concrete types against which the "@openfed__subscriptionFilter" condition can be validated.`,
  );
}

export function subscriptionFilterUnsupportedNamedTypeKindError(namedTypeName: string, kind: string): Error {
  return new Error(
    `The named type "${namedTypeName}" of kind "${kind}" is not supported by the "@${SUBSCRIPTION_FILTER}" directive.` +
      `Only object, union, and interface return types are supported.`,
  );
}

export function subscriptionFilterConditionDepthExceededError(inputPath: string): Error {
  return new Error(
    `The input path "${inputPath}" exceeds the maximum depth of ${MAX_SUBSCRIPTION_FILTER_DEPTH}` +
      ` for any one filter condition.\n` +
      ` If you require a larger maximum depth, please contact support.`,
  );
}

const subscriptionFilterConditionFieldsString =
  ` Each "${SUBSCRIPTION_FILTER_CONDITION}" input object must define exactly one of the following` +
  ` input value fields: "${AND_UPPER}", "${IN_UPPER}", "${NOT_UPPER}", or "${OR_UPPER}".\n`;

export function subscriptionFilterConditionInvalidInputFieldNumberError(inputPath: string, fieldNumber: number): Error {
  return new Error(
    subscriptionFilterConditionFieldsString + ` However, input path "${inputPath}" defines ${fieldNumber} fields.`,
  );
}

export function subscriptionFilterConditionInvalidInputFieldError(inputPath: string, invalidFieldName: string): Error {
  return new Error(
    subscriptionFilterConditionFieldsString +
      ` However, input path "${inputPath}" defines the invalid input value field "${invalidFieldName}".`,
  );
}

export function subscriptionFilterConditionInvalidInputFieldTypeError(
  inputPath: string,
  expectedTypeString: string,
  actualTypeString: string,
): Error {
  return new Error(
    ` Expected the value of input path "${inputPath}" to be type "${expectedTypeString}"` +
      ` but received type "${actualTypeString}"`,
  );
}

const subscriptionFilterConditionArrayString =
  ` An AND or OR input field defined on a "${SUBSCRIPTION_FILTER_CONDITION}" should define a list of 1–5` +
  ` nested conditions.\n`;

export function subscriptionFilterArrayConditionInvalidItemTypeErrorMessage(
  inputPath: string,
  invalidIndices: number[],
): Error {
  const isPlural = invalidIndices.length > 1;
  return new Error(
    subscriptionFilterConditionArrayString +
      ` However, the following ` +
      (isPlural ? `indices` : 'index') +
      ` defined on input path "${inputPath}" ` +
      (isPlural ? `are` : `is`) +
      ` not type "object": ` +
      invalidIndices.join(`, `),
  );
}

export function subscriptionFilterArrayConditionInvalidLengthError(inputPath: string, actualLength: number): Error {
  return new Error(
    subscriptionFilterConditionArrayString +
      ` However, the list defined on input path "${inputPath}" has a length of ${actualLength}.`,
  );
}

export function invalidInputFieldTypeErrorMessage(
  inputPath: string,
  expectedTypeString: string,
  actualTypeString: string,
): string {
  return (
    ` Expected the input path "${inputPath}" to be type "${expectedTypeString}"` +
    ` but received "${actualTypeString}".`
  );
}

export function subscriptionFieldConditionInvalidInputFieldError(
  inputPath: string,
  missingFieldNames: string[],
  duplicatedFieldNames: string[],
  invalidFieldNames: string[],
  fieldErrorMessages: string[],
): Error {
  let message =
    ` Each "${SUBSCRIPTION_FIELD_CONDITION}" input object must only define the following two` +
    ` input value fields: "${FIELD_PATH}" and "${VALUES}".\n However, input path "${inputPath}" is invalid because:`;
  if (missingFieldNames.length > 0) {
    message +=
      `\n  The following required field` +
      (missingFieldNames.length > 1 ? `s are` : ` is`) +
      ` not defined:\n   "` +
      missingFieldNames.join(QUOTATION_JOIN) +
      `"`;
  }
  if (duplicatedFieldNames.length > 0) {
    message +=
      `\n  The following required field` +
      (duplicatedFieldNames.length > 1 ? `s are` : ` is`) +
      ` defined more than once:\n   "` +
      duplicatedFieldNames.join(QUOTATION_JOIN) +
      `"`;
  }
  if (invalidFieldNames.length > 0) {
    message +=
      `\n  The following invalid field` +
      (invalidFieldNames.length > 1 ? `s are` : ` is`) +
      ` defined:\n   "` +
      invalidFieldNames.join(QUOTATION_JOIN) +
      `"`;
  }
  if (fieldErrorMessages.length > 0) {
    message += `\n ` + fieldErrorMessages.join(`\n `);
  }
  return new Error(message);
}

const subscriptionFieldConditionValuesString =
  ` A "${SUBSCRIPTION_FIELD_CONDITION}" input object must define a "values" input value field` +
  ` with a list of at least one valid "${SUBSCRIPTION_FILTER_VALUE}" kind (boolean, enum, float, int, null, or string).\n`;

export function subscriptionFieldConditionInvalidValuesArrayErrorMessage(
  inputPath: string,
  invalidIndices: number[],
): string {
  const isPlural = invalidIndices.length > 1;
  return (
    subscriptionFieldConditionValuesString +
    ` However, the following ` +
    (isPlural ? 'indices' : 'index') +
    ` defined on input path "${inputPath}" ` +
    (isPlural ? `are` : `is`) +
    ` not a valid "${SUBSCRIPTION_FILTER_VALUE}": ` +
    invalidIndices.join(`, `)
  );
}

export function subscriptionFieldConditionEmptyValuesArrayErrorMessage(inputPath: string): string {
  return subscriptionFieldConditionValuesString + ` However, the list defined on input path "${inputPath}" is empty.`;
}

export function unknownFieldSubgraphNameError(fieldPath: string) {
  return new Error(` Field "${fieldPath}" defined no subgraph names.`);
}

export function invalidSubscriptionFieldConditionFieldPathErrorMessage(inputPath: string, conditionFieldPath: string) {
  return ` Input path "${inputPath}" defines the value "${conditionFieldPath}", which is not a period (.) delimited field path.`;
}

export function invalidSubscriptionFieldConditionFieldPathParentErrorMessage(
  inputPath: string,
  fullConditionFieldPath: string,
  partialConditionFieldPath: string,
) {
  return (
    ` Input path "${inputPath}" defines the value "${fullConditionFieldPath}".` +
    `\n However, "${partialConditionFieldPath}" is not type "object"`
  );
}

export function undefinedSubscriptionFieldConditionFieldPathFieldErrorMessage(
  inputPath: string,
  fullConditionFieldPath: string,
  partialConditionFieldPath: string,
  fieldName: string,
  parentTypeName: string,
) {
  return (
    ` Input path "${inputPath}" defines the value "${fullConditionFieldPath}".` +
    `\n However, the path "${partialConditionFieldPath}" is invalid because no field named "${fieldName}"` +
    ` exists on type "${parentTypeName}".`
  );
}

export function invalidSubscriptionFieldConditionFieldPathFieldErrorMessage(
  inputPath: string,
  fullConditionFieldPath: string,
  partialConditionFieldPath: string,
  fieldPath: string,
  subgraphName: string,
) {
  return (
    `Input path "${inputPath}" defines the value "${fullConditionFieldPath}".` +
    `\n However, only fields that are defined in the same graph as the "@${SUBSCRIPTION_FILTER}" directive` +
    ` can compose part of an "IN" condition's "fieldPath" input value field.` +
    `\n Consequently, the path "${partialConditionFieldPath}" is invalid because field "${fieldPath}"` +
    ` is not defined in subgraph "${subgraphName}".`
  );
}

export function inaccessibleSubscriptionFieldConditionFieldPathFieldErrorMessage(
  inputPath: string,
  fullConditionFieldPath: string,
  partialConditionFieldPath: string,
  fieldPath: string,
) {
  return (
    ` Input path "${inputPath}" defines the value "${fullConditionFieldPath}".` +
    `\n  The path segment "${partialConditionFieldPath}" is invalid because it refers to "${fieldPath}",` +
    ` which is declared "@inaccessible".`
  );
}

export function nonLeafSubscriptionFieldConditionFieldPathFinalFieldErrorMessage(
  inputPath: string,
  fullConditionFieldPath: string,
  fieldName: string,
  typeString: string,
  namedTypeName: string,
) {
  return (
    ` Input path "${inputPath}" defines the value "${fullConditionFieldPath}".` +
    `\n However, the final field "${fieldName}" is ${typeString} "${namedTypeName}", which is not a leaf type;` +
    ` therefore, it requires further selections.`
  );
}

export function unresolvablePathError(
  { fieldName, selectionSet }: UnresolvableFieldData,
  reasons: Array<string>,
): Error {
  const message =
    `The field "${fieldName}" is unresolvable at the following path:\n${selectionSet}` +
    `\nThis is because:\n - ` +
    reasons.join(`\n - `);
  return new Error(message);
}

export function allExternalFieldInstancesError(
  typeName: string,
  subgraphNamesByFieldName: Map<string, Array<string>>,
): Error {
  let message =
    `The Object "${typeName}" is invalid because the following field definition` +
    (subgraphNamesByFieldName.size > 1 ? 's are' : ' is') +
    ` declared "@external" on all instances of that field:\n`;
  for (const [fieldName, subgraphNames] of subgraphNamesByFieldName) {
    message +=
      ` "${fieldName}" in subgraph` +
      (subgraphNames.length > 1 ? 's' : '') +
      ` "` +
      subgraphNames.join(QUOTATION_JOIN) +
      `"\n`;
  }
  message += `At least one instance of a field definition must always be resolvable (and therefore not declared "@external").`;
  return new Error(message);
}

export function externalInterfaceFieldsError(typeName: string, fieldNames: Array<string>): Error {
  return new Error(
    `The interface "${typeName}" is invalid because the following field definition` +
      (fieldNames.length > 1 ? 's are' : ' is') +
      ` declared "@external":\n "` +
      fieldNames.join(QUOTATION_JOIN) +
      `"\n` +
      `Interface fields should not be declared "@external". This is because interface fields do not resolve directly,` +
      ` but the "@external" directive relates to whether a field instance can be resolved` +
      ` by the subgraph in which it is defined.`,
  );
}

export function nonExternalConditionalFieldError({
  directiveCoords,
  fieldSet,
  directiveName,
  subgraphName,
  targetCoords,
}: NonExternalConditionalFieldErrorParams): Error {
  const segments = targetCoords.split(LITERAL_PERIOD);
  const isTypeName = segments[segments.length - 1] === TYPENAME;
  return new Error(
    `The field "${directiveCoords}" in subgraph "${subgraphName}" defines a "@${directiveName}"` +
      ` directive with the following field set:\n "${fieldSet}".` +
      (isTypeName
        ? `\nHowever, none of the field set ancestors of "__typename" is declared "@external".`
        : `\nHowever, neither the field "${targetCoords}" nor any of its field set ancestors are declared "@external".`) +
      `\nConsequently, "${targetCoords}" is already provided by subgraph "${subgraphName}" and should not form part of` +
      ` a "@${directiveName}" directive field set.`,
  );
}

export function incompatibleFederatedFieldNamedTypeError(
  fieldCoordinates: string,
  subgraphNamesByNamedTypeName: Map<string, Set<string>>,
): Error {
  const instances: Array<string> = [];
  for (const [namedTypeName, subgraphNames] of subgraphNamesByNamedTypeName) {
    const names = [...subgraphNames];
    instances.push(
      ` The named type "${namedTypeName}" is returned by the following subgraph` +
        (names.length > 1 ? `s` : ``) +
        `: "` +
        names.join(QUOTATION_JOIN) +
        `".`,
    );
  }
  return new Error(
    `Each instance of a shared field must resolve identically across subgraphs.\n` +
      `The field "${fieldCoordinates}" could not be federated due to incompatible types across subgraphs.\n` +
      `The discrepancies are as follows:\n` +
      instances.join(`\n`),
  );
}

export function unknownNamedTypeErrorMessage(fieldCoordinates: string, namedTypeName: string): string {
  return `The field "${fieldCoordinates}" returns the unknown named type "${namedTypeName}".`;
}

export function unknownNamedTypeError(fieldCoordinates: string, namedTypeName: string): Error {
  return new Error(unknownNamedTypeErrorMessage(fieldCoordinates, namedTypeName));
}

export function unknownFieldDataError(fieldCoordinates: string): Error {
  return new Error(
    `Could not find FieldData for field "${fieldCoordinates}"\n.` +
      `This should never happen. Please report this issue on GitHub.`,
  );
}

export function unexpectedNonCompositeOutputTypeError(namedTypeName: string, actualTypeString: string): Error {
  return new Error(
    `Expected named type "${namedTypeName}" to be a composite output type (Object or Interface)` +
      ` but received "${actualTypeString}".\nThis should never happen. Please report this issue on GitHub.`,
  );
}

export function invalidExternalDirectiveError(fieldCoords: string): Error {
  return new Error(
    `The Object field "${fieldCoords}" is invalidly declared "@external". An Object field should only` +
      ` be declared "@external" if it is part of a "@key", "@provides", or "@requires" field set, or the field is` +
      ` necessary to satisfy an Interface implementation. In the case that none of these conditions is true, the` +
      ` "@external" directive should be removed.`,
  );
}

export function configureDescriptionNoDescriptionError(typeString: string, typeName: string): Error {
  return new Error(
    `The "@openfed__configureDescription" directive defined on ${typeString} "${typeName}" is invalid` +
      ` because neither a description nor the "descriptionOverride" argument is defined.`,
  );
}

export function configureDescriptionPropagationError(coords: string, subgraphNames: Array<string>): Error {
  return new Error(
    `The coordinates "${coords}" declare "@openfed__configureDescription(propagate: true)" in the following subgraphs:\n "` +
      subgraphNames.join(QUOTATION_JOIN) +
      '"\n' +
      `A federated graph only supports a single description; consequently, only one subgraph may define argument "propagate" as true (this is the default value).`,
  );
}

export function duplicateDirectiveDefinitionArgumentErrorMessage(argumentNames: Array<string>): string {
  return (
    `- The following argument` +
    (argumentNames.length > 1 ? 's are' : ' is') +
    ' defined more than once:\n "' +
    argumentNames.join(QUOTATION_JOIN) +
    '"'
  );
}

export function duplicateDirectiveDefinitionLocationError(location: DirectiveLocation): Error {
  return new Error(`The location "${location}" is defined multiple times.`);
}

export function duplicateDirectiveDefinitionLocationErrorMessage(locationName: string): string {
  return `- The location "${locationName}" is defined multiple times.`;
}

export function invalidDirectiveDefinitionLocationError(locationName: string): Error {
  return new Error(`"${locationName}" is not a valid directive location.`);
}

export function invalidDirectiveDefinitionLocationErrorMessage(locationName: string): string {
  return `- "${locationName}" is not a valid directive location.`;
}

export function invalidDirectiveDefinitionError(directiveName: string, errorMessages: Array<string>): Error {
  return new Error(
    `The directive definition for "@${directiveName}" is invalid for the following reason` +
      (errorMessages.length > 1 ? 's' : '') +
      ':\n' +
      errorMessages.join(LITERAL_NEW_LINE) +
      '"',
  );
}

export function typeNameAlreadyProvidedErrorMessage(fieldCoords: string, subgraphName: string): string {
  return (
    ` The field "${fieldCoords}" is unconditionally provided by subgraph "${subgraphName}" and should not form` +
    ` part of any "@provides" field set.`
  );
}

export function fieldAlreadyProvidedErrorMessage(
  fieldCoords: string,
  subgraphName: string,
  directiveName: string,
): string {
  return (
    ` The field "${fieldCoords}" is unconditionally provided by subgraph "${subgraphName}" and should not form` +
    ` part of any "@${directiveName}" field set. Although "${fieldCoords}" is declared "@external", it is part of` +
    ` a "@key" directive on an extension type. Such fields are only declared "@external" for legacy syntactical` +
    ` reasons and are not internally considered "@external".`
  );
}

export function invalidInterfaceObjectImplementationDefinitionsError(
  typeName: string,
  subgraphName: string,
  implementationTypeNames: Array<string>,
): Error {
  return new Error(
    `The subgraph that defines an entity Interface Object (using "@interfaceObject") must not define any ` +
      ` implementation types of that interface. However, the subgraph "${subgraphName}" defines the entity Interface` +
      ` "${typeName}" as an Interface Object alongside the following implementation type` +
      (implementationTypeNames.length > 1 ? `s` : ``) +
      ` of "${typeName}":\n "` +
      implementationTypeNames.join(QUOTATION_JOIN) +
      `"`,
  );
}

export function invalidNamedTypeError({ data, namedTypeData, nodeType }: InvalidNamedTypeErrorParams): Error {
  const isOutputField = isFieldData(data);
  const coords = isOutputField ? `${data.originalParentTypeName}.${data.name}` : data.originalCoords;
  return new Error(
    `The ${nodeType} "${coords}" is invalid because it defines type ` +
      printTypeNode(data.type) +
      `; however, ${kindToNodeType(namedTypeData.kind)} "${namedTypeData.name}" is not a valid ` +
      (isOutputField ? 'output' : 'input') +
      ' type.',
  );
}

export function semanticNonNullLevelsNaNIndexErrorMessage(value: string) {
  return `Index "${value}" is not a valid integer.`;
}

export function semanticNonNullLevelsIndexOutOfBoundsErrorMessage({
  maxIndex,
  typeString,
  value,
}: SemanticNonNullLevelsIndexOutOfBoundsErrorParams) {
  return (
    `Index "${value}" is out of bounds for type ${typeString}; ` +
    (maxIndex > 0 ? `valid indices are 0-${maxIndex} inclusive.` : `the only valid index is 0.`)
  );
}

export function semanticNonNullLevelsNonNullErrorMessage({
  typeString,
  value,
}: SemanticNonNullLevelsNonNullErrorParams) {
  return `Index "${value}" of type ${typeString} is non-null but must be nullable.`;
}

export const semanticNonNullArgumentErrorMessage = `Argument "${LEVELS}" validation error.`;

export function semanticNonNullInconsistentLevelsError(data: FieldData): Error {
  const coords = `${data.renamedParentTypeName}.${data.name}`;
  let message =
    `The "@semanticNonNull" directive defined on field "${coords}"` +
    ` is invalid due to inconsistent values provided to the "levels" argument across the following subgraphs:\n`;
  for (const [subgraphName, levels] of data.nullLevelsBySubgraphName) {
    message += ` Subgraph "${subgraphName}" defines levels ${Array.from(levels).sort((a, b) => a - b)}.\n`;
  }
  message +=
    `The list value provided to the "levels" argument must be consistently defined across all subgraphs that` +
    ` define "@semanticNonNull" on field "${coords}".`;
  return new Error(message);
}

export function oneOfRequiredFieldsError({ requiredFieldNames, typeName }: OneOfRequiredFieldsErrorParams): Error {
  return new Error(
    `The "@oneOf" directive defined on Input Object "${typeName}" is invalid because all Input fields must be` +
      ` optional (nullable); however, the following Input field` +
      (requiredFieldNames.length > 1 ? `s are` : ` is`) +
      ` required (non-nullable): "` +
      requiredFieldNames.join(QUOTATION_JOIN) +
      `".`,
  );
}

export function listSizeInvalidSlicingArgumentErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  path: ArgumentName,
): string {
  return ` The "slicingArguments" value "${path}" on "${directiveCoords}" does not reference a defined argument on this field.`;
}

export function listSizeSlicingArgumentNotIntErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  path: ArgumentName,
  actualType: TypeName,
): string {
  return (
    ` The "slicingArguments" value "${path}" on "${directiveCoords}" references an argument of type` +
    ` "${actualType}", but slicing arguments must be of type "Int" or "Int!".`
  );
}

export function listSizeSlicingArgumentMalformedPathErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  path: string,
): string {
  return (
    ` The "slicingArguments" value "${path}" on "${directiveCoords}" is not a valid path.` +
    ` A path must be a non-empty argument name, optionally followed by ".<inputField>" segments,` +
    ` with no empty segments and no leading or trailing dots.`
  );
}

export function listSizeSlicingArgumentSegmentNotFoundErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  path: string,
  segment: string,
  parentTypeName: TypeName,
): string {
  return (
    ` The "slicingArguments" path "${path}" on "${directiveCoords}" references "${segment}",` +
    ` which is not a defined field on Input Object type "${parentTypeName}".`
  );
}

export function listSizeSlicingArgumentSegmentNotInputObjectErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  path: string,
  segment: string,
  typeName: TypeName,
): string {
  return (
    ` The "slicingArguments" path "${path}" on "${directiveCoords}" references "${segment}",` +
    ` whose type "${typeName}" is not an Input Object.`
  );
}

export function listSizeSizedFieldNotFoundErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  fieldName: FieldName,
  returnTypeName: TypeName,
): string {
  return ` The "sizedFields" value "${fieldName}" on "${directiveCoords}" does not reference a defined field on the return type "${returnTypeName}".`;
}

export function listSizeSizedFieldNotListErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  fieldName: FieldName,
  returnTypeName: TypeName,
  fieldReturnType: TypeName,
): string {
  return (
    ` The "sizedFields" value "${fieldName}" on "${directiveCoords}" references field "${returnTypeName}.${fieldName}",` +
    ` which returns type "${fieldReturnType}". Sized fields must return a list type.`
  );
}

export function listSizeFieldMustReturnListOrUseSizedFieldsErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  returnType: TypeName,
): string {
  return (
    ` The "@listSize" directive on "${directiveCoords}" is invalid because the field returns type "${returnType}",` +
    ` which is not a list type, and no "sizedFields" argument is provided.`
  );
}

export function listSizeSizedFieldsInvalidReturnTypeErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  returnTypeName: TypeName,
): string {
  return (
    ` The "sizedFields" argument on "${directiveCoords}" is invalid because` +
    ` the return type "${returnTypeName}" is not an object or interface type.`
  );
}

export function listSizeSizedFieldsOnListsErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  returnTypeName: TypeName,
): string {
  return (
    ` The "sizedFields" argument on "${directiveCoords}" is invalid because` +
    ` the return type "${returnTypeName}" must not be a list.`
  );
}

export function listSizeAssumedSizeWithRequiredSlicingArgumentErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
): string {
  return (
    ` The "@listSize" directive on "${directiveCoords}" defines both "assumedSize" and "slicingArguments".` +
    ` When both are used, "requireOneSlicingArgument" must be set to false.`
  );
}

export function listSizeAssumedSizeSlicingArgDefaultErrorMessage(
  directiveCoords: DirectiveArgumentCoords,
  slicingArgName: ArgumentName,
): string {
  return (
    ` The "@listSize" directive on "${directiveCoords}" defines both "assumedSize" and "slicingArguments",` +
    ` but slicing argument "${slicingArgName}" has a default value. When "assumedSize" is used as a fallback` +
    ` for missing slicing arguments, none of the slicing arguments may have default values.`
  );
}

export function costOnInterfaceFieldErrorMessage(directiveCoords: DirectiveArgumentCoords): string {
  return (
    ` The "@cost" directive at "${directiveCoords}" is not permitted on fields or arguments of an Interface type.` +
    ` The cost of an interface field is derived from the costs of the corresponding fields` +
    ` on the concrete types that implement the interface.`
  );
}

export function unknownComposeDirectiveNameError(directiveName: DirectiveName): Error {
  return new Error(
    ` A "@composeDirective" directive defines the "name" argument value "${directiveName}" without a` +
      ` corresponding directive definition in the schema.`,
  );
}

export function invalidComposeDirectiveNameError(directiveName: DirectiveName): Error {
  return new Error(
    ` A "@composeDirective" directive defines the "name" argument value "${directiveName}", which is not a` +
      ` custom, user-defined directive.`,
  );
}

export function noLeadingAtComposeDirectiveNameError(directiveName: DirectiveName) {
  return new Error(
    `A "@composeDirective" directive defines the "name" argument value "${directiveName}" without a leading "@".`,
  );
}

export function unimportedComposeDirectiveNameError(directiveName: DirectiveName): Error {
  return new Error(
    ` A "@composeDirective" directive defines the "name" argument value "${directiveName}",` +
      ` which is not a member of a core feature (imported through a "@link" directive).`,
  );
}

export const noLinkDirectiveUrlError = new Error(` A "@link" directive was defined without a "url" argument.`);

export function invalidLinkDirectiveUrlError(url: string): Error {
  return new Error(` A "@link" directive defines the "url" argument value with invalid URL "${url}".`);
}

export function noPathLinkDirectiveUrlError(url: string) {
  return new Error(` A "@link" directive defines the "url" argument value without a path in URL "${url}".`);
}

export function noFeatureNameLinkDirectiveUrlError(url: string): Error {
  return new Error(
    ` A "@link" directive defines the "url" argument value without a feature name component in URL "${url}".`,
  );
}

export function noVersionLinkDirectiveUrlError(url: string): Error {
  return new Error(
    ` A "@link" directive defines the "url" argument value without a version component in URL "${url}".`,
  );
}

export function invalidVersionLinkDirectiveUrlError({
  url,
  versionString,
}: invalidVersionLinkDirectiveUrlErrorParams): Error {
  return new Error(
    ` A "@link" directive defines the "url" argument value with invalid version string "${versionString}"` +
      ` (not of the form "v1.2") in URL "${url}".`,
  );
}

export function nonIterableLinkDirectiveImportError(kind: Kind): Error {
  return new Error(` A "@link" directive defines the "import" value with non-iterable kind "${kind}"`);
}

export function invalidFieldLinkDirectiveImportObjectError({
  fieldName,
  value,
}: InvalidSubValueFieldLinkDirectiveImportErrorParams): Error {
  return new Error(` A "@link" directive defines invalid sub-value "${value}": field "${fieldName}" must be a string.`);
}

export function noNameFieldLinkDirectiveImportObjectError(value: string): Error {
  return new Error(` A "@link" directive defines invalid sub-value "${value}": required field "name" is missing.`);
}

export function unknownFieldLinkDirectiveImportObjectError({
  fieldName,
  value,
}: InvalidSubValueFieldLinkDirectiveImportErrorParams): Error {
  return new Error(` A "@link" directive defines invalid sub-value "${value}": unknown field "${fieldName}".`);
}

export function invalidLinkDirectiveImportObjectError({
  name,
  rename,
}: InvalidLinkDirectiveImportObjectErrorParams): Error {
  return new Error(
    ` A "@link" directive imports "${name}" and renames to "${rename}": if an import is not a` +
      ` directive, neither value should begin with "@"; otherwise, both values should be referenced with a leading "@".`,
  );
}

export function invalidSubValueLinkDirectiveImportError(index: number): Error {
  return new Error(
    ` A "@link" directive defines invalid sub-value at index ${index}:` +
      ` values should be either strings or input object values of the form { name: "<importedElement>", as: "<alias>" }.`,
  );
}

export function nonEqualCoreFeatureComposeDirectiveError(directiveName: DirectiveName): Error {
  return new Error(` Composed directive "${directiveName}" is not linked by the same core feature in every subgraph.`);
}

export function nonEqualComposeDirectiveMajorVersionError(directiveName: DirectiveName): Error {
  return new Error(` Composed directive "${directiveName}" defines a major version mismatch across subgraphs.`);
}

export function unknownSubgraphNameError(subgraphName: SubgraphName): Error {
  return new Error(`Internal Error: Expected subgraph "${subgraphName}" to be a valid record.`);
}

export function entityCacheWithoutKeyErrorMessage(typeName: TypeName): string {
  return `Object "${typeName}" does not define a "@key" directive.`;
}

export function maxAgeNotPositiveIntegerErrorMessage({
  directiveName,
  value,
}: MaxAgeNotPositiveIntegerErrorParams): string {
  return `The directive "@${directiveName}" argument "maxAge" must be provided a positive integer; received "${value}".`;
}

export function negativeCacheTTLNotNonNegativeIntegerErrorMessage(value: number): string {
  return `The argument "negativeCacheTTL" must be provided zero or a positive integer; received "${value}".`;
}

export function queryCacheOnNonQueryFieldErrorMessage(fieldCoords: string): string {
  return (
    `@openfed__queryCache must only be defined on fields of the root query type; found on "${fieldCoords}".` +
    ` Use @openfed__cachePopulate or @openfed__cacheInvalidate on mutation or subscription fields.`
  );
}

export function queryCacheOnNonEntityReturnTypeErrorMessage(fieldCoords: string, returnType: string): string {
  return (
    `Field "${fieldCoords}" has @openfed__queryCache but returns non-entity type "${returnType}".` +
    ` @openfed__queryCache requires the return type to be an entity with @key.`
  );
}

export function invalidMutationOrSubscriptionFieldCoordsErrorMessage(fieldCoords: string): string {
  return `Field coordinates "${fieldCoords}" are not a Mutation or Subscription root field.`;
}

export function invalidEntityReturnTypeErrorMessage({
  fieldCoords,
  returnTypeName,
}: InvalidEntityReturnTypeErrorParams): string {
  return `Field coordinates "${fieldCoords}" return non-entity type "${returnTypeName}".`;
}

export function invalidMutuallyExclusiveCacheDirectivesError(fieldCoords: string): Error {
  return new Error(
    `Field coordinates "${fieldCoords}" define both mutually exclusive directives "@openfed__cacheInvalidate"` +
      ` and "@openfed__cachePopulate".`,
  );
}

export function isWithoutQueryCacheErrorMessage(argumentName: string, fieldCoords: string): string {
  return `@openfed__is on argument "${argumentName}" of field "${fieldCoords}" has no effect without @openfed__queryCache.`;
}

export function isReferencesUnknownKeyFieldErrorMessage(
  isField: string,
  argumentName: string,
  fieldCoords: string,
  entityType: string,
): string {
  return (
    `@openfed__is(fields: "${isField}") on argument "${argumentName}" of field "${fieldCoords}"` +
    ` references unknown @key field "${isField}" on type "${entityType}".`
  );
}

export function duplicateKeyFieldMappingErrorMessage(fieldCoords: string, keyField: string): string {
  return `Multiple arguments on field "${fieldCoords}" map to @key field "${keyField}".`;
}

export function explicitTypeMismatchErrorMessage(
  argumentName: string,
  fieldCoords: string,
  argumentType: string,
  isField: string,
  entityType: string,
  keyFieldType: string,
): string {
  return `Argument "${argumentName}" on field "${fieldCoords}" has type "${argumentType}" but @openfed__is(fields: "${isField}") targets @key field "${isField}" of type "${keyFieldType}" on entity "${entityType}".`;
}

export function nonKeyFieldSpecErrorMessage(
  argumentName: string,
  fieldCoords: string,
  isField: string,
  entityType: string,
): string {
  return `Argument "${argumentName}" on field "${fieldCoords}" uses @openfed__is(fields: "${isField}"), but "${isField}" is not a @key field on entity "${entityType}". @openfed__is can only target fields that are part of a @key.`;
}

export function listArgumentToScalarKeySpecErrorMessage(
  argumentName: string,
  fieldCoords: string,
  argumentType: string,
  isField: string,
  entityType: string,
  keyFieldType: string,
): string {
  return (
    `Argument "${argumentName}" on field "${fieldCoords}" has type "${argumentType}" but @openfed__is(fields: "${isField}") targets @key field "${isField}" of type "${keyFieldType}" on entity "${entityType}".` +
    ' List arguments can only map to scalar key fields when the field returns a list of entities, or to list key fields when the key field itself is a list type.'
  );
}

export function scalarArgumentToListKeySpecErrorMessage(
  argumentName: string,
  fieldCoords: string,
  argumentType: string,
  isField: string,
  entityType: string,
  keyFieldType: string,
): string {
  return (
    `Argument "${argumentName}" on field "${fieldCoords}" has type "${argumentType}" but @openfed__is(fields: "${isField}") targets @key field "${isField}" of type "${keyFieldType}" on entity "${entityType}".` +
    ' A scalar argument cannot map to a list key field.'
  );
}

export function explicitIncompleteCompositeKeyErrorMessage(
  fieldCoords: string,
  argumentName: string,
  mappedField: string,
  entityType: string,
  compositeKey: string,
  missingField: string,
): string {
  return `Field "${fieldCoords}" has argument "${argumentName}" with @openfed__is mapping to @key field "${mappedField}" on entity "${entityType}", but composite @key "${compositeKey}" is incomplete because no argument maps to required key field "${missingField}".`;
}

export function explicitSingularAdditionalNonKeyArgumentErrorMessage(
  fieldCoords: string,
  argumentName: string,
  keyField: string,
  entityType: string,
  extraArgument: string,
): string {
  return `Field "${fieldCoords}" has argument "${argumentName}" with @openfed__is mapping to @key field "${keyField}" on entity "${entityType}", but also has additional argument "${extraArgument}" which is not mapped to a key field. All arguments must be key arguments — additional arguments may filter the response, making the cache key incomplete.`;
}

export function explicitCompositeAdditionalNonKeyArgumentErrorMessage(
  fieldCoords: string,
  firstArgument: string,
  secondArgument: string,
  compositeKey: string,
  entityType: string,
  extraArgument: string,
): string {
  return `Field "${fieldCoords}" has arguments "${firstArgument}" and "${secondArgument}" with @openfed__is mappings covering composite @key "${compositeKey}" on entity "${entityType}", but also has additional argument "${extraArgument}" which is not mapped to a key field. All arguments must be key arguments — additional arguments may filter the response, making the cache key incomplete.`;
}

export function batchListValuedKeyRequiresNestedListsErrorMessage(
  fieldCoords: string,
  isField: string,
  entityType: string,
  actualType: string,
): string {
  return `Field "${fieldCoords}" returns a list of entities, so cache lookup is a batch lookup and requires one key value per entity. Because @openfed__is(fields: "${isField}") targets list-valued @key field "${isField}" on entity "${entityType}", the argument must provide a list of tag lists (e.g., "[[String!]!]!"), not ${actualType}.`;
}

export function explicitBatchAdditionalNonKeyArgumentErrorMessage(
  fieldCoords: string,
  argumentName: string,
  keyField: string,
  entityType: string,
  extraArgument: string,
): string {
  return `Field "${fieldCoords}" returns a list of entities, so cache lookup is a batch lookup and requires a single key input that determines the returned entities. Argument "${argumentName}" uses @openfed__is to map to @key field "${keyField}" on entity "${entityType}", but additional argument "${extraArgument}" is not mapped to a key field and may filter the response, so the batch key would be incomplete.`;
}

export function explicitScalarArgumentsCannotEstablishBatchMappingErrorMessage(
  fieldCoords: string,
  entityType: string,
): string {
  return `Field "${fieldCoords}" returns a list of entities, so cache lookup is a batch lookup and requires one key value per entity. Scalar arguments with @openfed__is mapping to @key fields on entity "${entityType}" cannot provide a batch of keys, so they cannot establish cache key mappings for this field. Use list arguments for batch cache lookups.`;
}

export function multipleListArgumentsBatchFactoryMessage(fieldCoords: string, entityType: string): string {
  return (
    `Field "${fieldCoords}" has multiple list arguments mapping to @key fields on entity "${entityType}".` +
    ' Batch cache lookups require a single list argument.' +
    ' For composite keys, use a single list of input objects instead.'
  );
}

export function inputObjectCompositeTypeMismatchErrorMessage(
  argumentName: string,
  fieldCoords: string,
  keyFields: string,
  entityType: string,
  inputType: string,
  inputFieldName: string,
  inputFieldType: string,
  entityFieldPath: string,
  entityFieldType: string,
): string {
  return (
    `Argument "${argumentName}" on field "${fieldCoords}" uses @openfed__is(fields: "${keyFields}") mapping to composite @key on entity "${entityType}",` +
    ` but input type "${inputType}" field "${inputFieldName}" has type "${inputFieldType}"` +
    ` which does not match key field "${entityFieldPath}" of type "${entityFieldType}".`
  );
}

export function inputObjectCompositeMissingFieldErrorMessage(
  argumentName: string,
  fieldCoords: string,
  keyFields: string,
  entityType: string,
  inputType: string,
  missingFieldName: string,
): string {
  return (
    `Argument "${argumentName}" on field "${fieldCoords}" uses @openfed__is(fields: "${keyFields}") mapping to composite @key on entity "${entityType}",` +
    ` but input type "${inputType}" is missing required key field "${missingFieldName}".`
  );
}

export function nestedKeyRequiresInputObjectErrorMessage(
  argumentName: string,
  fieldCoords: string,
  keyFields: string,
  entityType: string,
  inputTypeName: string,
  entityKeyPath: string,
): string {
  return (
    `Argument "${argumentName}" on field "${fieldCoords}" maps to nested @key "${keyFields}" on entity "${entityType}",` +
    ` but the input field at key path "${entityKeyPath}" has type "${inputTypeName}",` +
    ` which is not an input object type and therefore cannot provide the nested key selection.`
  );
}

export function nestedInputObjectTypeMismatchErrorMessage(
  argumentName: string,
  fieldCoords: string,
  keyFields: string,
  entityType: string,
  inputType: string,
  inputFieldName: string,
  inputFieldType: string,
  entityFieldPath: string,
  entityFieldType: string,
): string {
  return (
    `Argument "${argumentName}" on field "${fieldCoords}" maps to nested @key "${keyFields}" on entity "${entityType}",` +
    ` but input type "${inputType}" field "${inputFieldName}" has type "${inputFieldType}"` +
    ` which does not match key field "${entityFieldPath}" of type "${entityFieldType}".`
  );
}

export function nestedInputObjectMissingFieldErrorMessage(
  argumentName: string,
  fieldCoords: string,
  keyFields: string,
  entityType: string,
  inputType: string,
  missingFieldName: string,
): string {
  return (
    `Argument "${argumentName}" on field "${fieldCoords}" maps to nested @key "${keyFields}" on entity "${entityType}",` +
    ` but input type "${inputType}" is missing required key field "${missingFieldName}".`
  );
}

export function nonInputArgumentCannotTargetCompositeKeyErrorMessage(
  argumentName: string,
  fieldCoords: string,
  keyFields: string,
  entityType: string,
  argumentType: string,
): string {
  return (
    `Argument "${argumentName}" on field "${fieldCoords}" uses @openfed__is(fields: "${keyFields}") targeting composite @key on entity "${entityType}",` +
    ` but argument type "${argumentType}" does not provide nested fields for each key field.` +
    ' Use separate arguments or an input object that matches the composite key shape.'
  );
}