graphql 0.0.1-test.1

package/validation/rules/ValuesOfCorrectTypeRule.js

@@ -0,0 +1,183 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.ValuesOfCorrectTypeRule = ValuesOfCorrectTypeRule;
+
+var _didYouMean = require('../../jsutils/didYouMean.js');
+
+var _inspect = require('../../jsutils/inspect.js');
+
+var _keyMap = require('../../jsutils/keyMap.js');
+
+var _suggestionList = require('../../jsutils/suggestionList.js');
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _printer = require('../../language/printer.js');
+
+var _definition = require('../../type/definition.js');
+
+/**
+ * Value literals of correct type
+ *
+ * A GraphQL document is only valid if all value literals are of the type
+ * expected at their position.
+ *
+ * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type
+ */
+function ValuesOfCorrectTypeRule(context) {
+  return {
+    ListValue(node) {
+      // Note: TypeInfo will traverse into a list's item type, so look to the
+      // parent input type to check if it is a list.
+      const type = (0, _definition.getNullableType)(
+        context.getParentInputType(),
+      );
+
+      if (!(0, _definition.isListType)(type)) {
+        isValidValueNode(context, node);
+        return false; // Don't traverse further.
+      }
+    },
+
+    ObjectValue(node) {
+      const type = (0, _definition.getNamedType)(context.getInputType());
+
+      if (!(0, _definition.isInputObjectType)(type)) {
+        isValidValueNode(context, node);
+        return false; // Don't traverse further.
+      } // Ensure every required field exists.
+
+      const fieldNodeMap = (0, _keyMap.keyMap)(
+        node.fields,
+        (field) => field.name.value,
+      );
+
+      for (const fieldDef of Object.values(type.getFields())) {
+        const fieldNode = fieldNodeMap[fieldDef.name];
+
+        if (!fieldNode && (0, _definition.isRequiredInputField)(fieldDef)) {
+          const typeStr = (0, _inspect.inspect)(fieldDef.type);
+          context.reportError(
+            new _GraphQLError.GraphQLError(
+              `Field "${type.name}.${fieldDef.name}" of required type "${typeStr}" was not provided.`,
+              node,
+            ),
+          );
+        }
+      }
+    },
+
+    ObjectField(node) {
+      const parentType = (0, _definition.getNamedType)(
+        context.getParentInputType(),
+      );
+      const fieldType = context.getInputType();
+
+      if (!fieldType && (0, _definition.isInputObjectType)(parentType)) {
+        const suggestions = (0, _suggestionList.suggestionList)(
+          node.name.value,
+          Object.keys(parentType.getFields()),
+        );
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Field "${node.name.value}" is not defined by type "${parentType.name}".` +
+              (0, _didYouMean.didYouMean)(suggestions),
+            node,
+          ),
+        );
+      }
+    },
+
+    NullValue(node) {
+      const type = context.getInputType();
+
+      if ((0, _definition.isNonNullType)(type)) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Expected value of type "${(0, _inspect.inspect)(
+              type,
+            )}", found ${(0, _printer.print)(node)}.`,
+            node,
+          ),
+        );
+      }
+    },
+
+    EnumValue: (node) => isValidValueNode(context, node),
+    IntValue: (node) => isValidValueNode(context, node),
+    FloatValue: (node) => isValidValueNode(context, node),
+    StringValue: (node) => isValidValueNode(context, node),
+    BooleanValue: (node) => isValidValueNode(context, node),
+  };
+}
+/**
+ * Any value literal may be a valid representation of a Scalar, depending on
+ * that scalar type.
+ */
+
+function isValidValueNode(context, node) {
+  // Report any error at the full type expected by the location.
+  const locationType = context.getInputType();
+
+  if (!locationType) {
+    return;
+  }
+
+  const type = (0, _definition.getNamedType)(locationType);
+
+  if (!(0, _definition.isLeafType)(type)) {
+    const typeStr = (0, _inspect.inspect)(locationType);
+    context.reportError(
+      new _GraphQLError.GraphQLError(
+        `Expected value of type "${typeStr}", found ${(0, _printer.print)(
+          node,
+        )}.`,
+        node,
+      ),
+    );
+    return;
+  } // Scalars and Enums determine if a literal value is valid via parseLiteral(),
+  // which may throw or return an invalid value to indicate failure.
+
+  try {
+    const parseResult = type.parseLiteral(
+      node,
+      undefined,
+      /* variables */
+    );
+
+    if (parseResult === undefined) {
+      const typeStr = (0, _inspect.inspect)(locationType);
+      context.reportError(
+        new _GraphQLError.GraphQLError(
+          `Expected value of type "${typeStr}", found ${(0, _printer.print)(
+            node,
+          )}.`,
+          node,
+        ),
+      );
+    }
+  } catch (error) {
+    const typeStr = (0, _inspect.inspect)(locationType);
+
+    if (error instanceof _GraphQLError.GraphQLError) {
+      context.reportError(error);
+    } else {
+      context.reportError(
+        new _GraphQLError.GraphQLError(
+          `Expected value of type "${typeStr}", found ${(0, _printer.print)(
+            node,
+          )}; ` + error.message,
+          node,
+          undefined,
+          undefined,
+          undefined,
+          error,
+        ),
+      );
+    }
+  }
+}

package/validation/rules/ValuesOfCorrectTypeRule.mjs

@@ -0,0 +1,164 @@
+import { didYouMean } from '../../jsutils/didYouMean.mjs';
+import { inspect } from '../../jsutils/inspect.mjs';
+import { keyMap } from '../../jsutils/keyMap.mjs';
+import { suggestionList } from '../../jsutils/suggestionList.mjs';
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { print } from '../../language/printer.mjs';
+import {
+  getNamedType,
+  getNullableType,
+  isInputObjectType,
+  isLeafType,
+  isListType,
+  isNonNullType,
+  isRequiredInputField,
+} from '../../type/definition.mjs';
+
+/**
+ * Value literals of correct type
+ *
+ * A GraphQL document is only valid if all value literals are of the type
+ * expected at their position.
+ *
+ * See https://spec.graphql.org/draft/#sec-Values-of-Correct-Type
+ */
+export function ValuesOfCorrectTypeRule(context) {
+  return {
+    ListValue(node) {
+      // Note: TypeInfo will traverse into a list's item type, so look to the
+      // parent input type to check if it is a list.
+      const type = getNullableType(context.getParentInputType());
+
+      if (!isListType(type)) {
+        isValidValueNode(context, node);
+        return false; // Don't traverse further.
+      }
+    },
+
+    ObjectValue(node) {
+      const type = getNamedType(context.getInputType());
+
+      if (!isInputObjectType(type)) {
+        isValidValueNode(context, node);
+        return false; // Don't traverse further.
+      } // Ensure every required field exists.
+
+      const fieldNodeMap = keyMap(node.fields, (field) => field.name.value);
+
+      for (const fieldDef of Object.values(type.getFields())) {
+        const fieldNode = fieldNodeMap[fieldDef.name];
+
+        if (!fieldNode && isRequiredInputField(fieldDef)) {
+          const typeStr = inspect(fieldDef.type);
+          context.reportError(
+            new GraphQLError(
+              `Field "${type.name}.${fieldDef.name}" of required type "${typeStr}" was not provided.`,
+              node,
+            ),
+          );
+        }
+      }
+    },
+
+    ObjectField(node) {
+      const parentType = getNamedType(context.getParentInputType());
+      const fieldType = context.getInputType();
+
+      if (!fieldType && isInputObjectType(parentType)) {
+        const suggestions = suggestionList(
+          node.name.value,
+          Object.keys(parentType.getFields()),
+        );
+        context.reportError(
+          new GraphQLError(
+            `Field "${node.name.value}" is not defined by type "${parentType.name}".` +
+              didYouMean(suggestions),
+            node,
+          ),
+        );
+      }
+    },
+
+    NullValue(node) {
+      const type = context.getInputType();
+
+      if (isNonNullType(type)) {
+        context.reportError(
+          new GraphQLError(
+            `Expected value of type "${inspect(type)}", found ${print(node)}.`,
+            node,
+          ),
+        );
+      }
+    },
+
+    EnumValue: (node) => isValidValueNode(context, node),
+    IntValue: (node) => isValidValueNode(context, node),
+    FloatValue: (node) => isValidValueNode(context, node),
+    StringValue: (node) => isValidValueNode(context, node),
+    BooleanValue: (node) => isValidValueNode(context, node),
+  };
+}
+/**
+ * Any value literal may be a valid representation of a Scalar, depending on
+ * that scalar type.
+ */
+
+function isValidValueNode(context, node) {
+  // Report any error at the full type expected by the location.
+  const locationType = context.getInputType();
+
+  if (!locationType) {
+    return;
+  }
+
+  const type = getNamedType(locationType);
+
+  if (!isLeafType(type)) {
+    const typeStr = inspect(locationType);
+    context.reportError(
+      new GraphQLError(
+        `Expected value of type "${typeStr}", found ${print(node)}.`,
+        node,
+      ),
+    );
+    return;
+  } // Scalars and Enums determine if a literal value is valid via parseLiteral(),
+  // which may throw or return an invalid value to indicate failure.
+
+  try {
+    const parseResult = type.parseLiteral(
+      node,
+      undefined,
+      /* variables */
+    );
+
+    if (parseResult === undefined) {
+      const typeStr = inspect(locationType);
+      context.reportError(
+        new GraphQLError(
+          `Expected value of type "${typeStr}", found ${print(node)}.`,
+          node,
+        ),
+      );
+    }
+  } catch (error) {
+    const typeStr = inspect(locationType);
+
+    if (error instanceof GraphQLError) {
+      context.reportError(error);
+    } else {
+      context.reportError(
+        new GraphQLError(
+          `Expected value of type "${typeStr}", found ${print(node)}; ` +
+            error.message,
+          node,
+          undefined,
+          undefined,
+          undefined,
+          error,
+        ),
+      );
+    }
+  }
+}

package/validation/rules/VariablesAreInputTypesRule.d.ts

@@ -0,0 +1,13 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { ValidationContext } from '../ValidationContext';
+/**
+ * Variables are input types
+ *
+ * A GraphQL operation is only valid if all the variables it defines are of
+ * input types (scalar, enum, or input object).
+ *
+ * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types
+ */
+export declare function VariablesAreInputTypesRule(
+  context: ValidationContext,
+): ASTVisitor;

package/validation/rules/VariablesAreInputTypesRule.js

@@ -0,0 +1,44 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.VariablesAreInputTypesRule = VariablesAreInputTypesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _printer = require('../../language/printer.js');
+
+var _definition = require('../../type/definition.js');
+
+var _typeFromAST = require('../../utilities/typeFromAST.js');
+
+/**
+ * Variables are input types
+ *
+ * A GraphQL operation is only valid if all the variables it defines are of
+ * input types (scalar, enum, or input object).
+ *
+ * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types
+ */
+function VariablesAreInputTypesRule(context) {
+  return {
+    VariableDefinition(node) {
+      const type = (0, _typeFromAST.typeFromAST)(
+        context.getSchema(),
+        node.type,
+      );
+
+      if (type !== undefined && !(0, _definition.isInputType)(type)) {
+        const variableName = node.variable.name.value;
+        const typeName = (0, _printer.print)(node.type);
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Variable "$${variableName}" cannot be non-input type "${typeName}".`,
+            node.type,
+          ),
+        );
+      }
+    },
+  };
+}

package/validation/rules/VariablesAreInputTypesRule.mjs

@@ -0,0 +1,31 @@
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { print } from '../../language/printer.mjs';
+import { isInputType } from '../../type/definition.mjs';
+import { typeFromAST } from '../../utilities/typeFromAST.mjs';
+
+/**
+ * Variables are input types
+ *
+ * A GraphQL operation is only valid if all the variables it defines are of
+ * input types (scalar, enum, or input object).
+ *
+ * See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types
+ */
+export function VariablesAreInputTypesRule(context) {
+  return {
+    VariableDefinition(node) {
+      const type = typeFromAST(context.getSchema(), node.type);
+
+      if (type !== undefined && !isInputType(type)) {
+        const variableName = node.variable.name.value;
+        const typeName = print(node.type);
+        context.reportError(
+          new GraphQLError(
+            `Variable "$${variableName}" cannot be non-input type "${typeName}".`,
+            node.type,
+          ),
+        );
+      }
+    },
+  };
+}

package/validation/rules/VariablesInAllowedPositionRule.d.ts

@@ -0,0 +1,12 @@
+import type { ASTVisitor } from '../../language/visitor';
+import type { ValidationContext } from '../ValidationContext';
+/**
+ * Variables in allowed position
+ *
+ * Variable usages must be compatible with the arguments they are passed to.
+ *
+ * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed
+ */
+export declare function VariablesInAllowedPositionRule(
+  context: ValidationContext,
+): ASTVisitor;

package/validation/rules/VariablesInAllowedPositionRule.js

@@ -0,0 +1,114 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.VariablesInAllowedPositionRule = VariablesInAllowedPositionRule;
+
+var _inspect = require('../../jsutils/inspect.js');
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _kinds = require('../../language/kinds.js');
+
+var _definition = require('../../type/definition.js');
+
+var _typeComparators = require('../../utilities/typeComparators.js');
+
+var _typeFromAST = require('../../utilities/typeFromAST.js');
+
+/**
+ * Variables in allowed position
+ *
+ * Variable usages must be compatible with the arguments they are passed to.
+ *
+ * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed
+ */
+function VariablesInAllowedPositionRule(context) {
+  let varDefMap = Object.create(null);
+  return {
+    OperationDefinition: {
+      enter() {
+        varDefMap = Object.create(null);
+      },
+
+      leave(operation) {
+        const usages = context.getRecursiveVariableUsages(operation);
+
+        for (const { node, type, defaultValue } of usages) {
+          const varName = node.name.value;
+          const varDef = varDefMap[varName];
+
+          if (varDef && type) {
+            // A var type is allowed if it is the same or more strict (e.g. is
+            // a subtype of) than the expected type. It can be more strict if
+            // the variable type is non-null when the expected type is nullable.
+            // If both are list types, the variable item type can be more strict
+            // than the expected item type (contravariant).
+            const schema = context.getSchema();
+            const varType = (0, _typeFromAST.typeFromAST)(schema, varDef.type);
+
+            if (
+              varType &&
+              !allowedVariableUsage(
+                schema,
+                varType,
+                varDef.defaultValue,
+                type,
+                defaultValue,
+              )
+            ) {
+              const varTypeStr = (0, _inspect.inspect)(varType);
+              const typeStr = (0, _inspect.inspect)(type);
+              context.reportError(
+                new _GraphQLError.GraphQLError(
+                  `Variable "$${varName}" of type "${varTypeStr}" used in position expecting type "${typeStr}".`,
+                  [varDef, node],
+                ),
+              );
+            }
+          }
+        }
+      },
+    },
+
+    VariableDefinition(node) {
+      varDefMap[node.variable.name.value] = node;
+    },
+  };
+}
+/**
+ * Returns true if the variable is allowed in the location it was found,
+ * which includes considering if default values exist for either the variable
+ * or the location at which it is located.
+ */
+
+function allowedVariableUsage(
+  schema,
+  varType,
+  varDefaultValue,
+  locationType,
+  locationDefaultValue,
+) {
+  if (
+    (0, _definition.isNonNullType)(locationType) &&
+    !(0, _definition.isNonNullType)(varType)
+  ) {
+    const hasNonNullVariableDefaultValue =
+      varDefaultValue != null && varDefaultValue.kind !== _kinds.Kind.NULL;
+    const hasLocationDefaultValue = locationDefaultValue !== undefined;
+
+    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {
+      return false;
+    }
+
+    const nullableLocationType = locationType.ofType;
+    return (0, _typeComparators.isTypeSubTypeOf)(
+      schema,
+      varType,
+      nullableLocationType,
+    );
+  }
+
+  return (0, _typeComparators.isTypeSubTypeOf)(schema, varType, locationType);
+}

package/validation/rules/VariablesInAllowedPositionRule.mjs

@@ -0,0 +1,95 @@
+import { inspect } from '../../jsutils/inspect.mjs';
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { Kind } from '../../language/kinds.mjs';
+import { isNonNullType } from '../../type/definition.mjs';
+import { isTypeSubTypeOf } from '../../utilities/typeComparators.mjs';
+import { typeFromAST } from '../../utilities/typeFromAST.mjs';
+
+/**
+ * Variables in allowed position
+ *
+ * Variable usages must be compatible with the arguments they are passed to.
+ *
+ * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed
+ */
+export function VariablesInAllowedPositionRule(context) {
+  let varDefMap = Object.create(null);
+  return {
+    OperationDefinition: {
+      enter() {
+        varDefMap = Object.create(null);
+      },
+
+      leave(operation) {
+        const usages = context.getRecursiveVariableUsages(operation);
+
+        for (const { node, type, defaultValue } of usages) {
+          const varName = node.name.value;
+          const varDef = varDefMap[varName];
+
+          if (varDef && type) {
+            // A var type is allowed if it is the same or more strict (e.g. is
+            // a subtype of) than the expected type. It can be more strict if
+            // the variable type is non-null when the expected type is nullable.
+            // If both are list types, the variable item type can be more strict
+            // than the expected item type (contravariant).
+            const schema = context.getSchema();
+            const varType = typeFromAST(schema, varDef.type);
+
+            if (
+              varType &&
+              !allowedVariableUsage(
+                schema,
+                varType,
+                varDef.defaultValue,
+                type,
+                defaultValue,
+              )
+            ) {
+              const varTypeStr = inspect(varType);
+              const typeStr = inspect(type);
+              context.reportError(
+                new GraphQLError(
+                  `Variable "$${varName}" of type "${varTypeStr}" used in position expecting type "${typeStr}".`,
+                  [varDef, node],
+                ),
+              );
+            }
+          }
+        }
+      },
+    },
+
+    VariableDefinition(node) {
+      varDefMap[node.variable.name.value] = node;
+    },
+  };
+}
+/**
+ * Returns true if the variable is allowed in the location it was found,
+ * which includes considering if default values exist for either the variable
+ * or the location at which it is located.
+ */
+
+function allowedVariableUsage(
+  schema,
+  varType,
+  varDefaultValue,
+  locationType,
+  locationDefaultValue,
+) {
+  if (isNonNullType(locationType) && !isNonNullType(varType)) {
+    const hasNonNullVariableDefaultValue =
+      varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;
+    const hasLocationDefaultValue = locationDefaultValue !== undefined;
+
+    if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {
+      return false;
+    }
+
+    const nullableLocationType = locationType.ofType;
+    return isTypeSubTypeOf(schema, varType, nullableLocationType);
+  }
+
+  return isTypeSubTypeOf(schema, varType, locationType);
+}

package/validation/rules/custom/NoDeprecatedCustomRule.d.ts

@@ -0,0 +1,15 @@
+import type { ASTVisitor } from '../../../language/visitor';
+import type { ValidationContext } from '../../ValidationContext';
+/**
+ * No deprecated
+ *
+ * A GraphQL document is only valid if all selected fields and all used enum values have not been
+ * deprecated.
+ *
+ * Note: This rule is optional and is not part of the Validation section of the GraphQL
+ * Specification. The main purpose of this rule is detection of deprecated usages and not
+ * necessarily to forbid their use when querying a service.
+ */
+export declare function NoDeprecatedCustomRule(
+  context: ValidationContext,
+): ASTVisitor;