graphql 0.12.3 → 0.13.2

package/module/type/wrappers.js

@@ -1,80 +0,0 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- */
-
-import { assertType, assertNullableType } from './definition';
-
-/**
- * List Type Wrapper
- *
- * A list is a wrapping type which points to another type.
- * Lists are often created within the context of defining the fields of
- * an object type.
- *
- * Example:
- *
- *     const PersonType = new GraphQLObjectType({
- *       name: 'Person',
- *       fields: () => ({
- *         parents: { type: GraphQLList(PersonType) },
- *         children: { type: GraphQLList(PersonType) },
- *       })
- *     })
- *
- */
-
-// eslint-disable-next-line no-redeclare
-export function GraphQLList(ofType) {
-  if (this instanceof GraphQLList) {
-    this.ofType = assertType(ofType);
-  } else {
-    return new GraphQLList(ofType);
-  }
-}
-
-// Also provide toJSON and inspect aliases for toString.
-var listProto = GraphQLList.prototype;
-listProto.toString = listProto.toJSON = listProto.inspect = function toString() {
-  return '[' + String(this.ofType) + ']';
-};
-
-/**
- * Non-Null Type Wrapper
- *
- * A non-null is a wrapping type which points to another type.
- * Non-null types enforce that their values are never null and can ensure
- * an error is raised if this ever occurs during a request. It is useful for
- * fields which you can make a strong guarantee on non-nullability, for example
- * usually the id field of a database row will never be null.
- *
- * Example:
- *
- *     const RowType = new GraphQLObjectType({
- *       name: 'Row',
- *       fields: () => ({
- *         id: { type: GraphQLNonNull(GraphQLString) },
- *       })
- *     })
- *
- * Note: the enforcement of non-nullability occurs within the executor.
- */
-
-// eslint-disable-next-line no-redeclare
-export function GraphQLNonNull(ofType) {
-  if (this instanceof GraphQLNonNull) {
-    this.ofType = assertNullableType(ofType);
-  } else {
-    return new GraphQLNonNull(ofType);
-  }
-}
-
-// Also provide toJSON and inspect aliases for toString.
-var nonNullProto = GraphQLNonNull.prototype;
-nonNullProto.toString = nonNullProto.toJSON = nonNullProto.inspect = function toString() {
-  return String(this.ofType) + '!';
-};

package/module/type/wrappers.js.flow

@@ -1,91 +0,0 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import { assertType, assertNullableType } from './definition';
-import type { GraphQLType, GraphQLNullableType } from './definition';
-
-/**
- * List Type Wrapper
- *
- * A list is a wrapping type which points to another type.
- * Lists are often created within the context of defining the fields of
- * an object type.
- *
- * Example:
- *
- *     const PersonType = new GraphQLObjectType({
- *       name: 'Person',
- *       fields: () => ({
- *         parents: { type: GraphQLList(PersonType) },
- *         children: { type: GraphQLList(PersonType) },
- *       })
- *     })
- *
- */
-declare class GraphQLList<+T: GraphQLType> {
-  +ofType: T;
-  static <T>(ofType: T): GraphQLList<T>;
-  // Note: constructors cannot be used for covariant types. Drop the "new".
-  constructor(ofType: any): void;
-}
-// eslint-disable-next-line no-redeclare
-export function GraphQLList(ofType) {
-  if (this instanceof GraphQLList) {
-    this.ofType = assertType(ofType);
-  } else {
-    return new GraphQLList(ofType);
-  }
-}
-
-// Also provide toJSON and inspect aliases for toString.
-const listProto: any = GraphQLList.prototype;
-listProto.toString = listProto.toJSON = listProto.inspect = function toString() {
-  return '[' + String(this.ofType) + ']';
-};
-
-/**
- * Non-Null Type Wrapper
- *
- * A non-null is a wrapping type which points to another type.
- * Non-null types enforce that their values are never null and can ensure
- * an error is raised if this ever occurs during a request. It is useful for
- * fields which you can make a strong guarantee on non-nullability, for example
- * usually the id field of a database row will never be null.
- *
- * Example:
- *
- *     const RowType = new GraphQLObjectType({
- *       name: 'Row',
- *       fields: () => ({
- *         id: { type: GraphQLNonNull(GraphQLString) },
- *       })
- *     })
- *
- * Note: the enforcement of non-nullability occurs within the executor.
- */
-declare class GraphQLNonNull<+T: GraphQLNullableType> {
-  +ofType: T;
-  static <T>(ofType: T): GraphQLNonNull<T>;
-  // Note: constructors cannot be used for covariant types. Drop the "new".
-  constructor(ofType: any): void;
-}
-// eslint-disable-next-line no-redeclare
-export function GraphQLNonNull(ofType) {
-  if (this instanceof GraphQLNonNull) {
-    this.ofType = assertNullableType(ofType);
-  } else {
-    return new GraphQLNonNull(ofType);
-  }
-}
-
-// Also provide toJSON and inspect aliases for toString.
-const nonNullProto: any = GraphQLNonNull.prototype;
-nonNullProto.toString = nonNullProto.toJSON = nonNullProto.inspect = function toString() {
-  return String(this.ofType) + '!';
-};

package/module/utilities/TypeInfo.js.flow

@@ -1,296 +0,0 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import * as Kind from '../language/kinds';
-import {
-  isObjectType,
-  isInterfaceType,
-  isEnumType,
-  isInputObjectType,
-  isListType,
-  isCompositeType,
-  isInputType,
-  isOutputType,
-  getNullableType,
-  getNamedType,
-} from '../type/definition';
-import type {
-  GraphQLType,
-  GraphQLInputType,
-  GraphQLOutputType,
-  GraphQLCompositeType,
-  GraphQLField,
-  GraphQLArgument,
-  GraphQLEnumValue,
-} from '../type/definition';
-import type { GraphQLDirective } from '../type/directives';
-import {
-  SchemaMetaFieldDef,
-  TypeMetaFieldDef,
-  TypeNameMetaFieldDef,
-} from '../type/introspection';
-import type { GraphQLSchema } from '../type/schema';
-import type { ASTNode, FieldNode } from '../language/ast';
-import { typeFromAST } from './typeFromAST';
-import find from '../jsutils/find';
-
-/**
- * TypeInfo is a utility class which, given a GraphQL schema, can keep track
- * of the current field and type definitions at any point in a GraphQL document
- * AST during a recursive descent by calling `enter(node)` and `leave(node)`.
- */
-export class TypeInfo {
-  _schema: GraphQLSchema;
-  _typeStack: Array<?GraphQLOutputType>;
-  _parentTypeStack: Array<?GraphQLCompositeType>;
-  _inputTypeStack: Array<?GraphQLInputType>;
-  _fieldDefStack: Array<?GraphQLField<*, *>>;
-  _directive: ?GraphQLDirective;
-  _argument: ?GraphQLArgument;
-  _enumValue: ?GraphQLEnumValue;
-  _getFieldDef: typeof getFieldDef;
-
-  constructor(
-    schema: GraphQLSchema,
-    // NOTE: this experimental optional second parameter is only needed in order
-    // to support non-spec-compliant codebases. You should never need to use it.
-    // It may disappear in the future.
-    getFieldDefFn?: typeof getFieldDef,
-    // Initial type may be provided in rare cases to facilitate traversals
-    // beginning somewhere other than documents.
-    initialType?: GraphQLType,
-  ): void {
-    this._schema = schema;
-    this._typeStack = [];
-    this._parentTypeStack = [];
-    this._inputTypeStack = [];
-    this._fieldDefStack = [];
-    this._directive = null;
-    this._argument = null;
-    this._enumValue = null;
-    this._getFieldDef = getFieldDefFn || getFieldDef;
-    if (initialType) {
-      if (isInputType(initialType)) {
-        this._inputTypeStack.push(initialType);
-      }
-      if (isCompositeType(initialType)) {
-        this._parentTypeStack.push(initialType);
-      }
-      if (isOutputType(initialType)) {
-        this._typeStack.push(initialType);
-      }
-    }
-  }
-
-  getType(): ?GraphQLOutputType {
-    if (this._typeStack.length > 0) {
-      return this._typeStack[this._typeStack.length - 1];
-    }
-  }
-
-  getParentType(): ?GraphQLCompositeType {
-    if (this._parentTypeStack.length > 0) {
-      return this._parentTypeStack[this._parentTypeStack.length - 1];
-    }
-  }
-
-  getInputType(): ?GraphQLInputType {
-    if (this._inputTypeStack.length > 0) {
-      return this._inputTypeStack[this._inputTypeStack.length - 1];
-    }
-  }
-
-  getParentInputType(): ?GraphQLInputType {
-    if (this._inputTypeStack.length > 1) {
-      return this._inputTypeStack[this._inputTypeStack.length - 2];
-    }
-  }
-
-  getFieldDef(): ?GraphQLField<*, *> {
-    if (this._fieldDefStack.length > 0) {
-      return this._fieldDefStack[this._fieldDefStack.length - 1];
-    }
-  }
-
-  getDirective(): ?GraphQLDirective {
-    return this._directive;
-  }
-
-  getArgument(): ?GraphQLArgument {
-    return this._argument;
-  }
-
-  getEnumValue(): ?GraphQLEnumValue {
-    return this._enumValue;
-  }
-
-  // Flow does not yet handle this case.
-  enter(node: any /* ASTNode */) {
-    const schema = this._schema;
-    // Note: many of the types below are explicitly typed as "mixed" to drop
-    // any assumptions of a valid schema to ensure runtime types are properly
-    // checked before continuing since TypeInfo is used as part of validation
-    // which occurs before guarantees of schema and document validity.
-    switch (node.kind) {
-      case Kind.SELECTION_SET:
-        const namedType: mixed = getNamedType(this.getType());
-        this._parentTypeStack.push(
-          isCompositeType(namedType) ? namedType : undefined,
-        );
-        break;
-      case Kind.FIELD:
-        const parentType = this.getParentType();
-        let fieldDef;
-        let fieldType: mixed;
-        if (parentType) {
-          fieldDef = this._getFieldDef(schema, parentType, node);
-          if (fieldDef) {
-            fieldType = fieldDef.type;
-          }
-        }
-        this._fieldDefStack.push(fieldDef);
-        this._typeStack.push(isOutputType(fieldType) ? fieldType : undefined);
-        break;
-      case Kind.DIRECTIVE:
-        this._directive = schema.getDirective(node.name.value);
-        break;
-      case Kind.OPERATION_DEFINITION:
-        let type: mixed;
-        if (node.operation === 'query') {
-          type = schema.getQueryType();
-        } else if (node.operation === 'mutation') {
-          type = schema.getMutationType();
-        } else if (node.operation === 'subscription') {
-          type = schema.getSubscriptionType();
-        }
-        this._typeStack.push(isObjectType(type) ? type : undefined);
-        break;
-      case Kind.INLINE_FRAGMENT:
-      case Kind.FRAGMENT_DEFINITION:
-        const typeConditionAST = node.typeCondition;
-        const outputType: mixed = typeConditionAST
-          ? typeFromAST(schema, typeConditionAST)
-          : getNamedType(this.getType());
-        this._typeStack.push(isOutputType(outputType) ? outputType : undefined);
-        break;
-      case Kind.VARIABLE_DEFINITION:
-        const inputType: mixed = typeFromAST(schema, node.type);
-        this._inputTypeStack.push(
-          isInputType(inputType) ? inputType : undefined,
-        );
-        break;
-      case Kind.ARGUMENT:
-        let argDef;
-        let argType: mixed;
-        const fieldOrDirective = this.getDirective() || this.getFieldDef();
-        if (fieldOrDirective) {
-          argDef = find(
-            fieldOrDirective.args,
-            arg => arg.name === node.name.value,
-          );
-          if (argDef) {
-            argType = argDef.type;
-          }
-        }
-        this._argument = argDef;
-        this._inputTypeStack.push(isInputType(argType) ? argType : undefined);
-        break;
-      case Kind.LIST:
-        const listType: mixed = getNullableType(this.getInputType());
-        const itemType: mixed = isListType(listType)
-          ? listType.ofType
-          : listType;
-        this._inputTypeStack.push(isInputType(itemType) ? itemType : undefined);
-        break;
-      case Kind.OBJECT_FIELD:
-        const objectType: mixed = getNamedType(this.getInputType());
-        let inputFieldType: mixed;
-        if (isInputObjectType(objectType)) {
-          const inputField = objectType.getFields()[node.name.value];
-          if (inputField) {
-            inputFieldType = inputField.type;
-          }
-        }
-        this._inputTypeStack.push(
-          isInputType(inputFieldType) ? inputFieldType : undefined,
-        );
-        break;
-      case Kind.ENUM:
-        const enumType: mixed = getNamedType(this.getInputType());
-        let enumValue;
-        if (isEnumType(enumType)) {
-          enumValue = enumType.getValue(node.value);
-        }
-        this._enumValue = enumValue;
-        break;
-    }
-  }
-
-  leave(node: ASTNode) {
-    switch (node.kind) {
-      case Kind.SELECTION_SET:
-        this._parentTypeStack.pop();
-        break;
-      case Kind.FIELD:
-        this._fieldDefStack.pop();
-        this._typeStack.pop();
-        break;
-      case Kind.DIRECTIVE:
-        this._directive = null;
-        break;
-      case Kind.OPERATION_DEFINITION:
-      case Kind.INLINE_FRAGMENT:
-      case Kind.FRAGMENT_DEFINITION:
-        this._typeStack.pop();
-        break;
-      case Kind.VARIABLE_DEFINITION:
-        this._inputTypeStack.pop();
-        break;
-      case Kind.ARGUMENT:
-        this._argument = null;
-        this._inputTypeStack.pop();
-        break;
-      case Kind.LIST:
-      case Kind.OBJECT_FIELD:
-        this._inputTypeStack.pop();
-        break;
-      case Kind.ENUM:
-        this._enumValue = null;
-        break;
-    }
-  }
-}
-
-/**
- * Not exactly the same as the executor's definition of getFieldDef, in this
- * statically evaluated environment we do not always have an Object type,
- * and need to handle Interface and Union types.
- */
-function getFieldDef(
-  schema: GraphQLSchema,
-  parentType: GraphQLType,
-  fieldNode: FieldNode,
-): ?GraphQLField<*, *> {
-  const name = fieldNode.name.value;
-  if (
-    name === SchemaMetaFieldDef.name &&
-    schema.getQueryType() === parentType
-  ) {
-    return SchemaMetaFieldDef;
-  }
-  if (name === TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
-    return TypeMetaFieldDef;
-  }
-  if (name === TypeNameMetaFieldDef.name && isCompositeType(parentType)) {
-    return TypeNameMetaFieldDef;
-  }
-  if (isObjectType(parentType) || isInterfaceType(parentType)) {
-    return parentType.getFields()[name];
-  }
-}

package/module/utilities/assertValidName.js.flow

@@ -1,56 +0,0 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import { GraphQLError } from '../error/GraphQLError';
-import type { ASTNode } from '../language/ast';
-import invariant from '../jsutils/invariant';
-
-const NAME_RX = /^[_a-zA-Z][_a-zA-Z0-9]*$/;
-
-/**
- * Upholds the spec rules about naming.
- */
-export function assertValidName(name: string): string {
-  const error = isValidNameError(name);
-  if (error) {
-    throw error;
-  }
-  return name;
-}
-
-/**
- * Returns an Error if a name is invalid.
- */
-export function isValidNameError(
-  name: string,
-  node?: ASTNode | void,
-): GraphQLError | void {
-  invariant(typeof name === 'string', 'Expected string');
-  if (
-    name.length > 1 &&
-    name[0] === '_' &&
-    name[1] === '_' &&
-    // Note: this special case is not part of the spec and exists only to
-    // support legacy server configurations. Do not rely on this special case
-    // as it may be removed at any time.
-    name !== '__configs__'
-  ) {
-    return new GraphQLError(
-      `Name "${name}" must not begin with "__", which is reserved by ` +
-        'GraphQL introspection.',
-      node,
-    );
-  }
-  if (!NAME_RX.test(name)) {
-    return new GraphQLError(
-      `Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/ but "${name}" does not.`,
-      node,
-    );
-  }
-}

package/module/utilities/astFromValue.js.flow

@@ -1,159 +0,0 @@
-/**
- * Copyright (c) 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import { forEach, isCollection } from 'iterall';
-
-import isNullish from '../jsutils/isNullish';
-import isInvalid from '../jsutils/isInvalid';
-import type {
-  ValueNode,
-  IntValueNode,
-  FloatValueNode,
-  StringValueNode,
-  BooleanValueNode,
-  NullValueNode,
-  EnumValueNode,
-  ListValueNode,
-  ObjectValueNode,
-} from '../language/ast';
-import * as Kind from '../language/kinds';
-import type { GraphQLInputType } from '../type/definition';
-import {
-  isScalarType,
-  isEnumType,
-  isInputObjectType,
-  isListType,
-  isNonNullType,
-} from '../type/definition';
-import { GraphQLID } from '../type/scalars';
-
-/**
- * Produces a GraphQL Value AST given a JavaScript value.
- *
- * A GraphQL type must be provided, which will be used to interpret different
- * JavaScript values.
- *
- * | JSON Value    | GraphQL Value        |
- * | ------------- | -------------------- |
- * | Object        | Input Object         |
- * | Array         | List                 |
- * | Boolean       | Boolean              |
- * | String        | String / Enum Value  |
- * | Number        | Int / Float          |
- * | Mixed         | Enum Value           |
- * | null          | NullValue            |
- *
- */
-export function astFromValue(value: mixed, type: GraphQLInputType): ?ValueNode {
-  // Ensure flow knows that we treat function params as const.
-  const _value = value;
-
-  if (isNonNullType(type)) {
-    const astValue = astFromValue(_value, type.ofType);
-    if (astValue && astValue.kind === Kind.NULL) {
-      return null;
-    }
-    return astValue;
-  }
-
-  // only explicit null, not undefined, NaN
-  if (_value === null) {
-    return ({ kind: Kind.NULL }: NullValueNode);
-  }
-
-  // undefined, NaN
-  if (isInvalid(_value)) {
-    return null;
-  }
-
-  // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
-  // the value is not an array, convert the value using the list's item type.
-  if (isListType(type)) {
-    const itemType = type.ofType;
-    if (isCollection(_value)) {
-      const valuesNodes = [];
-      forEach((_value: any), item => {
-        const itemNode = astFromValue(item, itemType);
-        if (itemNode) {
-          valuesNodes.push(itemNode);
-        }
-      });
-      return ({ kind: Kind.LIST, values: valuesNodes }: ListValueNode);
-    }
-    return astFromValue(_value, itemType);
-  }
-
-  // Populate the fields of the input object by creating ASTs from each value
-  // in the JavaScript object according to the fields in the input type.
-  if (isInputObjectType(type)) {
-    if (_value === null || typeof _value !== 'object') {
-      return null;
-    }
-    const fields = type.getFields();
-    const fieldNodes = [];
-    Object.keys(fields).forEach(fieldName => {
-      const fieldType = fields[fieldName].type;
-      const fieldValue = astFromValue(_value[fieldName], fieldType);
-      if (fieldValue) {
-        fieldNodes.push({
-          kind: Kind.OBJECT_FIELD,
-          name: { kind: Kind.NAME, value: fieldName },
-          value: fieldValue,
-        });
-      }
-    });
-    return ({ kind: Kind.OBJECT, fields: fieldNodes }: ObjectValueNode);
-  }
-
-  if (isScalarType(type) || isEnumType(type)) {
-    // Since value is an internally represented value, it must be serialized
-    // to an externally represented value before converting into an AST.
-    const serialized = type.serialize(_value);
-    if (isNullish(serialized)) {
-      return null;
-    }
-
-    // Others serialize based on their corresponding JavaScript scalar types.
-    if (typeof serialized === 'boolean') {
-      return ({ kind: Kind.BOOLEAN, value: serialized }: BooleanValueNode);
-    }
-
-    // JavaScript numbers can be Int or Float values.
-    if (typeof serialized === 'number') {
-      const stringNum = String(serialized);
-      return /^[0-9]+$/.test(stringNum)
-        ? ({ kind: Kind.INT, value: stringNum }: IntValueNode)
-        : ({ kind: Kind.FLOAT, value: stringNum }: FloatValueNode);
-    }
-
-    if (typeof serialized === 'string') {
-      // Enum types use Enum literals.
-      if (isEnumType(type)) {
-        return ({ kind: Kind.ENUM, value: serialized }: EnumValueNode);
-      }
-
-      // ID types can use Int literals.
-      if (type === GraphQLID && /^[0-9]+$/.test(serialized)) {
-        return ({ kind: Kind.INT, value: serialized }: IntValueNode);
-      }
-
-      // Use JSON stringify, which uses the same string encoding as GraphQL,
-      // then remove the quotes.
-      return ({
-        kind: Kind.STRING,
-        value: JSON.stringify(serialized).slice(1, -1),
-      }: StringValueNode);
-    }
-
-    throw new TypeError('Cannot convert value to AST: ' + String(serialized));
-  }
-
-  /* istanbul ignore next */
-  throw new Error(`Unknown type: ${(type: empty)}.`);
-}