graphql 0.0.1-test.1

package/utilities/stripIgnoredCharacters.js

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.stripIgnoredCharacters = stripIgnoredCharacters;
+
+var _blockString = require('../language/blockString.js');
+
+var _lexer = require('../language/lexer.js');
+
+var _source = require('../language/source.js');
+
+var _tokenKind = require('../language/tokenKind.js');
+
+/**
+ * Strips characters that are not significant to the validity or execution
+ * of a GraphQL document:
+ *   - UnicodeBOM
+ *   - WhiteSpace
+ *   - LineTerminator
+ *   - Comment
+ *   - Comma
+ *   - BlockString indentation
+ *
+ * Note: It is required to have a delimiter character between neighboring
+ * non-punctuator tokens and this function always uses single space as delimiter.
+ *
+ * It is guaranteed that both input and output documents if parsed would result
+ * in the exact same AST except for nodes location.
+ *
+ * Warning: It is guaranteed that this function will always produce stable results.
+ * However, it's not guaranteed that it will stay the same between different
+ * releases due to bugfixes or changes in the GraphQL specification.
+ *
+ * Query example:
+ *
+ * ```graphql
+ * query SomeQuery($foo: String!, $bar: String) {
+ *   someField(foo: $foo, bar: $bar) {
+ *     a
+ *     b {
+ *       c
+ *       d
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql
+ * query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}
+ * ```
+ *
+ * SDL example:
+ *
+ * ```graphql
+ * """
+ * Type description
+ * """
+ * type Foo {
+ *   """
+ *   Field description
+ *   """
+ *   bar: String
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql
+ * """Type description""" type Foo{"""Field description""" bar:String}
+ * ```
+ */
+function stripIgnoredCharacters(source) {
+  const sourceObj = (0, _source.isSource)(source)
+    ? source
+    : new _source.Source(source);
+  const body = sourceObj.body;
+  const lexer = new _lexer.Lexer(sourceObj);
+  let strippedBody = '';
+  let wasLastAddedTokenNonPunctuator = false;
+
+  while (lexer.advance().kind !== _tokenKind.TokenKind.EOF) {
+    const currentToken = lexer.token;
+    const tokenKind = currentToken.kind;
+    /**
+     * Every two non-punctuator tokens should have space between them.
+     * Also prevent case of non-punctuator token following by spread resulting
+     * in invalid token (e.g. `1...` is invalid Float token).
+     */
+
+    const isNonPunctuator = !(0, _lexer.isPunctuatorTokenKind)(
+      currentToken.kind,
+    );
+
+    if (wasLastAddedTokenNonPunctuator) {
+      if (
+        isNonPunctuator ||
+        currentToken.kind === _tokenKind.TokenKind.SPREAD
+      ) {
+        strippedBody += ' ';
+      }
+    }
+
+    const tokenBody = body.slice(currentToken.start, currentToken.end);
+
+    if (tokenKind === _tokenKind.TokenKind.BLOCK_STRING) {
+      strippedBody += (0, _blockString.printBlockString)(currentToken.value, {
+        minimize: true,
+      });
+    } else {
+      strippedBody += tokenBody;
+    }
+
+    wasLastAddedTokenNonPunctuator = isNonPunctuator;
+  }
+
+  return strippedBody;
+}

package/utilities/stripIgnoredCharacters.mjs

@@ -0,0 +1,104 @@
+import { printBlockString } from '../language/blockString.mjs';
+import { isPunctuatorTokenKind, Lexer } from '../language/lexer.mjs';
+import { isSource, Source } from '../language/source.mjs';
+import { TokenKind } from '../language/tokenKind.mjs';
+/**
+ * Strips characters that are not significant to the validity or execution
+ * of a GraphQL document:
+ *   - UnicodeBOM
+ *   - WhiteSpace
+ *   - LineTerminator
+ *   - Comment
+ *   - Comma
+ *   - BlockString indentation
+ *
+ * Note: It is required to have a delimiter character between neighboring
+ * non-punctuator tokens and this function always uses single space as delimiter.
+ *
+ * It is guaranteed that both input and output documents if parsed would result
+ * in the exact same AST except for nodes location.
+ *
+ * Warning: It is guaranteed that this function will always produce stable results.
+ * However, it's not guaranteed that it will stay the same between different
+ * releases due to bugfixes or changes in the GraphQL specification.
+ *
+ * Query example:
+ *
+ * ```graphql
+ * query SomeQuery($foo: String!, $bar: String) {
+ *   someField(foo: $foo, bar: $bar) {
+ *     a
+ *     b {
+ *       c
+ *       d
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql
+ * query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}
+ * ```
+ *
+ * SDL example:
+ *
+ * ```graphql
+ * """
+ * Type description
+ * """
+ * type Foo {
+ *   """
+ *   Field description
+ *   """
+ *   bar: String
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql
+ * """Type description""" type Foo{"""Field description""" bar:String}
+ * ```
+ */
+
+export function stripIgnoredCharacters(source) {
+  const sourceObj = isSource(source) ? source : new Source(source);
+  const body = sourceObj.body;
+  const lexer = new Lexer(sourceObj);
+  let strippedBody = '';
+  let wasLastAddedTokenNonPunctuator = false;
+
+  while (lexer.advance().kind !== TokenKind.EOF) {
+    const currentToken = lexer.token;
+    const tokenKind = currentToken.kind;
+    /**
+     * Every two non-punctuator tokens should have space between them.
+     * Also prevent case of non-punctuator token following by spread resulting
+     * in invalid token (e.g. `1...` is invalid Float token).
+     */
+
+    const isNonPunctuator = !isPunctuatorTokenKind(currentToken.kind);
+
+    if (wasLastAddedTokenNonPunctuator) {
+      if (isNonPunctuator || currentToken.kind === TokenKind.SPREAD) {
+        strippedBody += ' ';
+      }
+    }
+
+    const tokenBody = body.slice(currentToken.start, currentToken.end);
+
+    if (tokenKind === TokenKind.BLOCK_STRING) {
+      strippedBody += printBlockString(currentToken.value, {
+        minimize: true,
+      });
+    } else {
+      strippedBody += tokenBody;
+    }
+
+    wasLastAddedTokenNonPunctuator = isNonPunctuator;
+  }
+
+  return strippedBody;
+}

package/utilities/typeComparators.d.ts

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

package/utilities/typeComparators.js

@@ -0,0 +1,116 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.doTypesOverlap = doTypesOverlap;
+exports.isEqualType = isEqualType;
+exports.isTypeSubTypeOf = isTypeSubTypeOf;
+
+var _definition = require('../type/definition.js');
+
+/**
+ * Provided two types, return true if the types are equal (invariant).
+ */
+function isEqualType(typeA, typeB) {
+  // Equivalent types are equal.
+  if (typeA === typeB) {
+    return true;
+  } // If either type is non-null, the other must also be non-null.
+
+  if (
+    (0, _definition.isNonNullType)(typeA) &&
+    (0, _definition.isNonNullType)(typeB)
+  ) {
+    return isEqualType(typeA.ofType, typeB.ofType);
+  } // If either type is a list, the other must also be a list.
+
+  if (
+    (0, _definition.isListType)(typeA) &&
+    (0, _definition.isListType)(typeB)
+  ) {
+    return isEqualType(typeA.ofType, typeB.ofType);
+  } // Otherwise the types are not equal.
+
+  return false;
+}
+/**
+ * Provided a type and a super type, return true if the first type is either
+ * equal or a subset of the second super type (covariant).
+ */
+
+function isTypeSubTypeOf(schema, maybeSubType, superType) {
+  // Equivalent type is a valid subtype
+  if (maybeSubType === superType) {
+    return true;
+  } // If superType is non-null, maybeSubType must also be non-null.
+
+  if ((0, _definition.isNonNullType)(superType)) {
+    if ((0, _definition.isNonNullType)(maybeSubType)) {
+      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+    }
+
+    return false;
+  }
+
+  if ((0, _definition.isNonNullType)(maybeSubType)) {
+    // If superType is nullable, maybeSubType may be non-null or nullable.
+    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
+  } // If superType type is a list, maybeSubType type must also be a list.
+
+  if ((0, _definition.isListType)(superType)) {
+    if ((0, _definition.isListType)(maybeSubType)) {
+      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+    }
+
+    return false;
+  }
+
+  if ((0, _definition.isListType)(maybeSubType)) {
+    // If superType is not a list, maybeSubType must also be not a list.
+    return false;
+  } // If superType type is an abstract type, check if it is super type of maybeSubType.
+  // Otherwise, the child type is not a valid subtype of the parent type.
+
+  return (
+    (0, _definition.isAbstractType)(superType) &&
+    ((0, _definition.isInterfaceType)(maybeSubType) ||
+      (0, _definition.isObjectType)(maybeSubType)) &&
+    schema.isSubType(superType, maybeSubType)
+  );
+}
+/**
+ * Provided two composite types, determine if they "overlap". Two composite
+ * types overlap when the Sets of possible concrete types for each intersect.
+ *
+ * This is often used to determine if a fragment of a given type could possibly
+ * be visited in a context of another type.
+ *
+ * This function is commutative.
+ */
+
+function doTypesOverlap(schema, typeA, typeB) {
+  // Equivalent types overlap
+  if (typeA === typeB) {
+    return true;
+  }
+
+  if ((0, _definition.isAbstractType)(typeA)) {
+    if ((0, _definition.isAbstractType)(typeB)) {
+      // If both types are abstract, then determine if there is any intersection
+      // between possible concrete types of each.
+      return schema
+        .getPossibleTypes(typeA)
+        .some((type) => schema.isSubType(typeB, type));
+    } // Determine if the latter type is a possible concrete type of the former.
+
+    return schema.isSubType(typeA, typeB);
+  }
+
+  if ((0, _definition.isAbstractType)(typeB)) {
+    // Determine if the former type is a possible concrete type of the latter.
+    return schema.isSubType(typeB, typeA);
+  } // Otherwise the types do not overlap.
+
+  return false;
+}

package/utilities/typeComparators.mjs

@@ -0,0 +1,106 @@
+import {
+  isAbstractType,
+  isInterfaceType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+} from '../type/definition.mjs';
+
+/**
+ * Provided two types, return true if the types are equal (invariant).
+ */
+export function isEqualType(typeA, typeB) {
+  // Equivalent types are equal.
+  if (typeA === typeB) {
+    return true;
+  } // If either type is non-null, the other must also be non-null.
+
+  if (isNonNullType(typeA) && isNonNullType(typeB)) {
+    return isEqualType(typeA.ofType, typeB.ofType);
+  } // If either type is a list, the other must also be a list.
+
+  if (isListType(typeA) && isListType(typeB)) {
+    return isEqualType(typeA.ofType, typeB.ofType);
+  } // Otherwise the types are not equal.
+
+  return false;
+}
+/**
+ * Provided a type and a super type, return true if the first type is either
+ * equal or a subset of the second super type (covariant).
+ */
+
+export function isTypeSubTypeOf(schema, maybeSubType, superType) {
+  // Equivalent type is a valid subtype
+  if (maybeSubType === superType) {
+    return true;
+  } // If superType is non-null, maybeSubType must also be non-null.
+
+  if (isNonNullType(superType)) {
+    if (isNonNullType(maybeSubType)) {
+      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+    }
+
+    return false;
+  }
+
+  if (isNonNullType(maybeSubType)) {
+    // If superType is nullable, maybeSubType may be non-null or nullable.
+    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
+  } // If superType type is a list, maybeSubType type must also be a list.
+
+  if (isListType(superType)) {
+    if (isListType(maybeSubType)) {
+      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+    }
+
+    return false;
+  }
+
+  if (isListType(maybeSubType)) {
+    // If superType is not a list, maybeSubType must also be not a list.
+    return false;
+  } // If superType type is an abstract type, check if it is super type of maybeSubType.
+  // Otherwise, the child type is not a valid subtype of the parent type.
+
+  return (
+    isAbstractType(superType) &&
+    (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&
+    schema.isSubType(superType, maybeSubType)
+  );
+}
+/**
+ * Provided two composite types, determine if they "overlap". Two composite
+ * types overlap when the Sets of possible concrete types for each intersect.
+ *
+ * This is often used to determine if a fragment of a given type could possibly
+ * be visited in a context of another type.
+ *
+ * This function is commutative.
+ */
+
+export function doTypesOverlap(schema, typeA, typeB) {
+  // Equivalent types overlap
+  if (typeA === typeB) {
+    return true;
+  }
+
+  if (isAbstractType(typeA)) {
+    if (isAbstractType(typeB)) {
+      // If both types are abstract, then determine if there is any intersection
+      // between possible concrete types of each.
+      return schema
+        .getPossibleTypes(typeA)
+        .some((type) => schema.isSubType(typeB, type));
+    } // Determine if the latter type is a possible concrete type of the former.
+
+    return schema.isSubType(typeA, typeB);
+  }
+
+  if (isAbstractType(typeB)) {
+    // Determine if the former type is a possible concrete type of the latter.
+    return schema.isSubType(typeB, typeA);
+  } // Otherwise the types do not overlap.
+
+  return false;
+}

package/utilities/typeFromAST.d.ts

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

package/utilities/typeFromAST.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.typeFromAST = typeFromAST;
+
+var _kinds = require('../language/kinds.js');
+
+var _definition = require('../type/definition.js');
+
+function typeFromAST(schema, typeNode) {
+  switch (typeNode.kind) {
+    case _kinds.Kind.LIST_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new _definition.GraphQLList(innerType);
+    }
+
+    case _kinds.Kind.NON_NULL_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new _definition.GraphQLNonNull(innerType);
+    }
+
+    case _kinds.Kind.NAMED_TYPE:
+      return schema.getType(typeNode.name.value);
+  }
+}

package/utilities/typeFromAST.mjs

@@ -0,0 +1,18 @@
+import { Kind } from '../language/kinds.mjs';
+import { GraphQLList, GraphQLNonNull } from '../type/definition.mjs';
+export function typeFromAST(schema, typeNode) {
+  switch (typeNode.kind) {
+    case Kind.LIST_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new GraphQLList(innerType);
+    }
+
+    case Kind.NON_NULL_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new GraphQLNonNull(innerType);
+    }
+
+    case Kind.NAMED_TYPE:
+      return schema.getType(typeNode.name.value);
+  }
+}

package/utilities/typedQueryDocumentNode.d.ts

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

package/utilities/typedQueryDocumentNode.js

@@ -0,0 +1,5 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});

package/utilities/typedQueryDocumentNode.mjs

@@ -0,0 +1 @@
+export {};

package/utilities/valueFromAST.d.ts

@@ -0,0 +1,29 @@
+import type { Maybe } from '../jsutils/Maybe';
+import type { ObjMap } from '../jsutils/ObjMap';
+import type { ValueNode } from '../language/ast';
+import type { GraphQLInputType } from '../type/definition';
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * GraphQL Value literals.
+ *
+ * Returns `undefined` when the value could not be validly coerced according to
+ * the provided type.
+ *
+ * | GraphQL Value        | JSON Value    |
+ * | -------------------- | ------------- |
+ * | Input Object         | Object        |
+ * | List                 | Array         |
+ * | Boolean              | Boolean       |
+ * | String               | String        |
+ * | Int / Float          | Number        |
+ * | Enum Value           | Unknown       |
+ * | NullValue            | null          |
+ *
+ */
+export declare function valueFromAST(
+  valueNode: Maybe<ValueNode>,
+  type: GraphQLInputType,
+  variables?: Maybe<ObjMap<unknown>>,
+): unknown;