relay-compiler 12.0.0 → 13.0.0

package/transforms/ConnectionTransform.js.flow

@@ -1,859 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow strict-local
- * @format
- */
-
-// flowlint ambiguous-object-type:error
-
-'use strict';
-
-const IRTransformer = require('../core/IRTransformer');
-const RelayParser = require('../core/RelayParser');
-const SchemaUtils = require('../core/SchemaUtils');
-
-const getLiteralArgumentValues = require('../core/getLiteralArgumentValues');
-
-const {createCompilerError, createUserError} = require('../core/CompilerError');
-const {parse} = require('graphql');
-const {ConnectionInterface, RelayFeatureFlags} = require('relay-runtime');
-
-import type CompilerContext from '../core/CompilerContext';
-import type {
-  Argument,
-  Directive,
-  Fragment,
-  Handle,
-  InlineFragment,
-  LinkedField,
-  Root,
-  Selection,
-  Variable,
-  Location,
-  Defer,
-} from '../core/IR';
-import type {Schema, CompositeTypeID} from '../core/Schema';
-import type {ConnectionMetadata} from 'relay-runtime';
-
-type Options = {
-  documentName: string,
-  // The current path
-  path: Array<?string>,
-  // Metadata recorded for @connection fields
-  connectionMetadata: Array<ConnectionMetadata>,
-  ...
-};
-
-type ConnectionArguments = {|
-  handler: ?string,
-  key: string,
-  dynamicKey: Variable | null,
-  filters: ?$ReadOnlyArray<string>,
-  stream: ?{|
-    if: ?Argument,
-    initialCount: ?Argument,
-    useCustomizedBatch: ?Argument,
-    label: string,
-  |},
-|};
-
-const AFTER = 'after';
-const BEFORE = 'before';
-const FIRST = 'first';
-const KEY = 'key';
-const LAST = 'last';
-
-const CONNECTION = 'connection';
-const STREAM_CONNECTION = 'stream_connection';
-const HANDLER = 'handler';
-
-/**
- * @public
- *
- * Transforms fields with the `@connection` directive:
- * - Verifies that the field type is connection-like.
- * - Adds a `handle` property to the field, either the user-provided `handle`
- *   argument or the default value "connection".
- * - Inserts a sub-fragment on the field to ensure that standard connection
- *   fields are fetched (e.g. cursors, node ids, page info).
- */
-function connectionTransform(context: CompilerContext): CompilerContext {
-  return IRTransformer.transform(
-    context,
-    {
-      Fragment: visitFragmentOrRoot,
-      LinkedField: visitLinkedField,
-      Root: visitFragmentOrRoot,
-    },
-    node => ({
-      documentName: node.name,
-      path: [],
-      connectionMetadata: [],
-    }),
-  );
-}
-
-const SCHEMA_EXTENSION = `
-  directive @connection(
-    key: String!
-    filters: [String]
-    handler: String
-    dynamicKey_UNSTABLE: String
-  ) on FIELD
-
-  directive @stream_connection(
-    key: String!
-    filters: [String]
-    handler: String
-    initial_count: Int!
-    if: Boolean = true
-    use_customized_batch: Boolean = false
-    dynamicKey_UNSTABLE: String
-  ) on FIELD
-`;
-
-/**
- * @internal
- */
-function visitFragmentOrRoot<N: Fragment | Root>(
-  node: N,
-  options: Options,
-): ?N {
-  // $FlowFixMe[incompatible-use]
-  const transformedNode = this.traverse(node, options);
-  const connectionMetadata = options.connectionMetadata;
-  if (connectionMetadata.length) {
-    return {
-      ...transformedNode,
-      metadata: {
-        ...transformedNode.metadata,
-        connection: connectionMetadata,
-      },
-    };
-  }
-  return transformedNode;
-}
-
-/**
- * @internal
- */
-function visitLinkedField(field: LinkedField, options: Options): LinkedField {
-  // $FlowFixMe[incompatible-use]
-  const context: CompilerContext = this.getContext();
-  const schema = context.getSchema();
-
-  const nullableType = schema.getNullableType(field.type);
-
-  const isPlural = schema.isList(nullableType);
-  const path = options.path.concat(isPlural ? null : field.alias || field.name);
-  // $FlowFixMe[incompatible-use]
-  let transformedField: LinkedField = this.traverse(field, {
-    ...options,
-    path,
-  });
-  const connectionDirective = field.directives.find(
-    directive =>
-      directive.name === CONNECTION || directive.name === STREAM_CONNECTION,
-  );
-  if (!connectionDirective) {
-    return transformedField;
-  }
-  if (!schema.isObject(nullableType) && !schema.isInterface(nullableType)) {
-    throw new createUserError(
-      `@${connectionDirective.name} used on invalid field '${field.name}'. ` +
-        'Expected the return type to be a non-plural interface or object, ' +
-        `got '${schema.getTypeString(field.type)}'.`,
-      [transformedField.loc],
-    );
-  }
-
-  validateConnectionSelection(transformedField);
-  validateConnectionType(
-    schema,
-    transformedField,
-    schema.assertCompositeType(nullableType),
-    connectionDirective,
-  );
-
-  const connectionArguments = buildConnectionArguments(
-    transformedField,
-    connectionDirective,
-  );
-
-  const connectionMetadata = buildConnectionMetadata(
-    transformedField,
-    path,
-    connectionArguments.stream != null,
-  );
-  options.connectionMetadata.push(connectionMetadata);
-
-  const handle: Handle = {
-    name: connectionArguments.handler ?? CONNECTION,
-    key: connectionArguments.key,
-    dynamicKey: connectionArguments.dynamicKey,
-    filters: connectionArguments.filters,
-  };
-
-  const {direction} = connectionMetadata;
-  if (direction != null) {
-    const selections = transformConnectionSelections(
-      // $FlowFixMe[incompatible-use]
-      this.getContext(),
-      transformedField,
-      schema.assertCompositeType(nullableType),
-      direction,
-      connectionArguments,
-      connectionDirective.loc,
-      options.documentName,
-    );
-    transformedField = {
-      ...transformedField,
-      selections,
-    };
-  }
-  return {
-    ...transformedField,
-    directives: transformedField.directives.filter(
-      directive => directive !== connectionDirective,
-    ),
-    connection: true,
-    handles: transformedField.handles
-      ? [...transformedField.handles, handle]
-      : [handle],
-  };
-}
-
-function buildConnectionArguments(
-  field: LinkedField,
-  connectionDirective: Directive,
-): ConnectionArguments {
-  const {
-    handler,
-    key,
-    label,
-    filters: literalFilters,
-  } = getLiteralArgumentValues(connectionDirective.args);
-  if (handler != null && typeof handler !== 'string') {
-    const handleArg = connectionDirective.args.find(
-      arg => arg.name === 'handler',
-    );
-    throw createUserError(
-      `Expected the ${HANDLER} argument to @${connectionDirective.name} to ` +
-        `be a string literal for field ${field.name}.`,
-      [handleArg?.value?.loc ?? connectionDirective.loc],
-    );
-  }
-  if (typeof key !== 'string') {
-    const keyArg = connectionDirective.args.find(arg => arg.name === 'key');
-    throw createUserError(
-      `Expected the ${KEY} argument to @${connectionDirective.name} to be a ` +
-        `string literal for field ${field.name}.`,
-      [keyArg?.value?.loc ?? connectionDirective.loc],
-    );
-  }
-  const postfix = field.alias || field.name;
-  if (!key.endsWith('_' + postfix)) {
-    const keyArg = connectionDirective.args.find(arg => arg.name === 'key');
-    throw createUserError(
-      `Expected the ${KEY} argument to @${connectionDirective.name} to be of ` +
-        `form <SomeName>_${postfix}, got '${key}'. ` +
-        'For a detailed explanation, check out ' +
-        'https://relay.dev/docs/en/pagination-container#connection',
-      [keyArg?.value?.loc ?? connectionDirective.loc],
-    );
-  }
-  if (
-    literalFilters != null &&
-    (!Array.isArray(literalFilters) ||
-      literalFilters.some(filter => typeof filter !== 'string'))
-  ) {
-    const filtersArg = connectionDirective.args.find(
-      arg => arg.name === 'filters',
-    );
-    throw createUserError(
-      `Expected the 'filters' argument to @${connectionDirective.name} to be ` +
-        'a string literal.',
-      [filtersArg?.value?.loc ?? connectionDirective.loc],
-    );
-  }
-
-  let filters = literalFilters;
-  if (filters == null) {
-    const generatedFilters = field.args
-      .filter(
-        arg =>
-          !ConnectionInterface.isConnectionCall({
-            name: arg.name,
-            value: null,
-          }),
-      )
-      .map(arg => arg.name);
-    filters = generatedFilters.length !== 0 ? generatedFilters : null;
-  }
-
-  let stream = null;
-  if (connectionDirective.name === STREAM_CONNECTION) {
-    const initialCountArg = connectionDirective.args.find(
-      arg => arg.name === 'initial_count',
-    );
-    const useCustomizedBatchArg = connectionDirective.args.find(
-      arg => arg.name === 'use_customized_batch',
-    );
-    const ifArg = connectionDirective.args.find(arg => arg.name === 'if');
-    stream = {
-      if: ifArg,
-      initialCount: initialCountArg,
-      useCustomizedBatch: useCustomizedBatchArg,
-      label: key,
-    };
-  }
-
-  const dynamicKeyArg = connectionDirective.args.find(
-    arg => arg.name === 'dynamicKey_UNSTABLE',
-  );
-  let dynamicKey: Variable | null = null;
-  if (dynamicKeyArg != null) {
-    if (
-      RelayFeatureFlags.ENABLE_VARIABLE_CONNECTION_KEY &&
-      dynamicKeyArg.value.kind === 'Variable'
-    ) {
-      dynamicKey = dynamicKeyArg.value;
-    } else {
-      throw createUserError(
-        `Unsupported 'dynamicKey_UNSTABLE' argument to @${connectionDirective.name}. This argument is only valid when the feature flag is enabled and ` +
-          'the variable must be a variable',
-        [connectionDirective.loc],
-      );
-    }
-  }
-
-  return {
-    handler,
-    key,
-    dynamicKey,
-    filters: (filters: $FlowFixMe),
-    stream,
-  };
-}
-
-function buildConnectionMetadata(
-  field: LinkedField,
-  path: Array<?string>,
-  stream: boolean,
-): ConnectionMetadata {
-  const pathHasPlural = path.includes(null);
-  const firstArg = findArg(field, FIRST);
-  const lastArg = findArg(field, LAST);
-  let direction = null;
-  let countArg = null;
-  let cursorArg = null;
-  if (firstArg && !lastArg) {
-    direction = 'forward';
-    countArg = firstArg;
-    cursorArg = findArg(field, AFTER);
-  } else if (lastArg && !firstArg) {
-    direction = 'backward';
-    countArg = lastArg;
-    cursorArg = findArg(field, BEFORE);
-  } else if (lastArg && firstArg) {
-    direction = 'bidirectional';
-    // TODO(T26511885) Maybe add connection metadata to this case
-  }
-  const countVariable =
-    countArg && countArg.value.kind === 'Variable'
-      ? countArg.value.variableName
-      : null;
-  const cursorVariable =
-    cursorArg && cursorArg.value.kind === 'Variable'
-      ? cursorArg.value.variableName
-      : null;
-  if (stream) {
-    return {
-      count: countVariable,
-      cursor: cursorVariable,
-      direction,
-      path: pathHasPlural ? null : (path: $FlowFixMe),
-      stream: true,
-    };
-  }
-  return {
-    count: countVariable,
-    cursor: cursorVariable,
-    direction,
-    path: pathHasPlural ? null : (path: $FlowFixMe),
-  };
-}
-
-/**
- * @internal
- *
- * Transforms the selections on a connection field, generating fields necessary
- * for pagination (edges.cursor, pageInfo, etc) and adding/merging them with
- * existing selections.
- */
-function transformConnectionSelections(
-  context: CompilerContext,
-  field: LinkedField,
-  nullableType: CompositeTypeID,
-  direction: 'forward' | 'backward' | 'bidirectional',
-  connectionArguments: ConnectionArguments,
-  directiveLocation: Location,
-  documentName: string,
-): $ReadOnlyArray<Selection> {
-  const schema = context.getSchema();
-  const derivedFieldLocation = {kind: 'Derived', source: field.loc};
-  const derivedDirectiveLocation = {
-    kind: 'Derived',
-    source: directiveLocation,
-  };
-  const {
-    CURSOR,
-    EDGES,
-    END_CURSOR,
-    HAS_NEXT_PAGE,
-    HAS_PREV_PAGE,
-    NODE,
-    PAGE_INFO,
-    START_CURSOR,
-  } = ConnectionInterface.get();
-
-  // Find existing edges/pageInfo selections
-  let edgesSelection: ?LinkedField;
-  let pageInfoSelection: ?LinkedField;
-  field.selections.forEach(selection => {
-    if (selection.kind === 'LinkedField') {
-      if (selection.name === EDGES) {
-        if (edgesSelection != null) {
-          throw createCompilerError(
-            `ConnectionTransform: Unexpected duplicate field '${EDGES}'.`,
-            [edgesSelection.loc, selection.loc],
-          );
-        }
-        edgesSelection = selection;
-        return;
-      } else if (selection.name === PAGE_INFO) {
-        if (pageInfoSelection != null) {
-          throw createCompilerError(
-            `ConnectionTransform: Unexpected duplicate field '${PAGE_INFO}'.`,
-            [pageInfoSelection.loc, selection.loc],
-          );
-        }
-        pageInfoSelection = selection;
-        return;
-      }
-    }
-  });
-  // If streaming is enabled, construct directives to apply to the edges/
-  // pageInfo fields
-  let streamDirective;
-  const stream = connectionArguments.stream;
-  if (stream != null) {
-    streamDirective = {
-      args: [
-        stream.if,
-        stream.initialCount,
-        stream.useCustomizedBatch,
-        {
-          kind: 'Argument',
-          loc: derivedDirectiveLocation,
-          name: 'label',
-          type: SchemaUtils.getNullableStringInput(schema),
-          value: {
-            kind: 'Literal',
-            loc: derivedDirectiveLocation,
-            value: stream.label,
-          },
-        },
-      ].filter(Boolean),
-      kind: 'Directive',
-      loc: derivedDirectiveLocation,
-      name: 'stream',
-    };
-  }
-  // For backwards compatibility with earlier versions of this transform,
-  // edges/pageInfo have to be generated as non-aliased fields (since product
-  // code may be accessing the non-aliased response keys). But for streaming
-  // mode we need to generate @stream/@defer directives on these fields *and*
-  // we prefer to avoid generating extra selections (we want one payload per
-  // item, not two as could happen with separate @stream directives on the
-  // aliased and non-aliased edges fields). So we keep things simple by
-  // disallowing aliases on edges/pageInfo in streaming mode.
-  if (edgesSelection && edgesSelection.alias !== edgesSelection.name) {
-    if (stream) {
-      throw createUserError(
-        `@stream_connection does not support aliasing the '${EDGES}' field.`,
-        [edgesSelection.loc],
-      );
-    }
-    edgesSelection = null;
-  }
-  if (pageInfoSelection && pageInfoSelection.alias !== pageInfoSelection.name) {
-    if (stream) {
-      throw createUserError(
-        `@stream_connection does not support aliasing the '${PAGE_INFO}' field.`,
-        [pageInfoSelection.loc],
-      );
-    }
-    pageInfoSelection = null;
-  }
-
-  // Separately create transformed versions of edges/pageInfo so that we can
-  // later replace the originals at the same point within the selection array
-  let transformedEdgesSelection: ?LinkedField = edgesSelection;
-  let transformedPageInfoSelection: ?(
-    | Defer
-    | InlineFragment
-    | LinkedField
-  ) = pageInfoSelection;
-  const edgesType = schema.getFieldConfig(
-    schema.expectField(nullableType, EDGES),
-  ).type;
-
-  const pageInfoType = schema.getFieldConfig(
-    schema.expectField(nullableType, PAGE_INFO),
-  ).type;
-
-  if (transformedEdgesSelection == null) {
-    transformedEdgesSelection = {
-      alias: EDGES,
-      args: [],
-      connection: false,
-      directives: [],
-      handles: null,
-      kind: 'LinkedField',
-      loc: derivedFieldLocation,
-      metadata: null,
-      name: EDGES,
-      selections: [],
-      type: schema.assertLinkedFieldType(edgesType),
-    };
-  }
-  if (transformedPageInfoSelection == null) {
-    transformedPageInfoSelection = {
-      alias: PAGE_INFO,
-      args: [],
-      connection: false,
-      directives: [],
-      handles: null,
-      kind: 'LinkedField',
-      loc: derivedFieldLocation,
-      metadata: null,
-      name: PAGE_INFO,
-      selections: [],
-      type: schema.assertLinkedFieldType(pageInfoType),
-    };
-  }
-
-  // Generate (additional) fields on pageInfo and add to the transformed
-  // pageInfo field
-  const pageInfoRawType = schema.getRawType(pageInfoType);
-  let pageInfoText;
-  if (direction === 'forward') {
-    pageInfoText = `fragment PageInfo on ${schema.getTypeString(
-      pageInfoRawType,
-    )} {
-      ${END_CURSOR}
-      ${HAS_NEXT_PAGE}
-    }`;
-  } else if (direction === 'backward') {
-    pageInfoText = `fragment PageInfo on ${schema.getTypeString(
-      pageInfoRawType,
-    )}  {
-      ${HAS_PREV_PAGE}
-      ${START_CURSOR}
-    }`;
-  } else {
-    pageInfoText = `fragment PageInfo on ${schema.getTypeString(
-      pageInfoRawType,
-    )}  {
-      ${END_CURSOR}
-      ${HAS_NEXT_PAGE}
-      ${HAS_PREV_PAGE}
-      ${START_CURSOR}
-    }`;
-  }
-  const pageInfoAst = parse(pageInfoText);
-  const pageInfoFragment = RelayParser.transform(schema, [
-    pageInfoAst.definitions[0],
-  ])[0];
-  if (transformedPageInfoSelection.kind !== 'LinkedField') {
-    throw createCompilerError(
-      'ConnectionTransform: Expected generated pageInfo selection to be ' +
-        'a LinkedField',
-      [field.loc],
-    );
-  }
-  transformedPageInfoSelection = {
-    ...transformedPageInfoSelection,
-    selections: [
-      ...transformedPageInfoSelection.selections,
-      {
-        directives: [],
-        kind: 'InlineFragment',
-        loc: derivedFieldLocation,
-        metadata: null,
-        selections: pageInfoFragment.selections,
-        typeCondition: pageInfoFragment.type,
-      },
-    ],
-  };
-  // When streaming the pageInfo field has to be deferred
-  if (stream != null) {
-    transformedPageInfoSelection = {
-      if: stream.if?.value ?? null,
-      label: `${documentName}$defer$${stream.label}$${PAGE_INFO}`,
-      kind: 'Defer',
-      loc: derivedFieldLocation,
-      selections: [transformedPageInfoSelection],
-    };
-  }
-
-  // Generate additional fields on edges and append to the transformed edges
-  // selection
-  const edgeText = `
-    fragment Edges on ${schema.getTypeString(schema.getRawType(edgesType))} {
-      ${CURSOR}
-      ${NODE} {
-        __typename # rely on GenerateRequisiteFieldTransform to add "id"
-      }
-    }
-  `;
-  const edgeAst = parse(edgeText);
-  const edgeFragment = RelayParser.transform(schema, [
-    edgeAst.definitions[0],
-  ])[0];
-  // When streaming the edges field needs @stream
-  transformedEdgesSelection = {
-    ...transformedEdgesSelection,
-    directives:
-      streamDirective != null
-        ? [...transformedEdgesSelection.directives, streamDirective]
-        : transformedEdgesSelection.directives,
-    selections: [
-      ...transformedEdgesSelection.selections,
-      {
-        directives: [],
-        kind: 'InlineFragment',
-        loc: derivedFieldLocation,
-        metadata: null,
-        selections: edgeFragment.selections,
-        typeCondition: edgeFragment.type,
-      },
-    ],
-  };
-  // Copy the original selections, replacing edges/pageInfo (if present)
-  // with the generated locations. This is to maintain the original field
-  // ordering.
-  const selections = field.selections.map(selection => {
-    if (
-      transformedEdgesSelection != null &&
-      edgesSelection != null &&
-      selection === edgesSelection
-    ) {
-      return transformedEdgesSelection;
-    } else if (
-      transformedPageInfoSelection != null &&
-      pageInfoSelection != null &&
-      selection === pageInfoSelection
-    ) {
-      return transformedPageInfoSelection;
-    } else {
-      return selection;
-    }
-  });
-  // If edges/pageInfo were missing, append the generated versions instead.
-  if (edgesSelection == null && transformedEdgesSelection != null) {
-    selections.push(transformedEdgesSelection);
-  }
-  if (pageInfoSelection == null && transformedPageInfoSelection != null) {
-    selections.push(transformedPageInfoSelection);
-  }
-  return selections;
-}
-
-function findArg(field: LinkedField, argName: string): ?Argument {
-  return field.args && field.args.find(arg => arg.name === argName);
-}
-
-/**
- * @internal
- *
- * Validates that the selection is a valid connection:
- * - Specifies a first or last argument to prevent accidental, unconstrained
- *   data access.
- * - Has an `edges` selection, otherwise there is nothing to paginate.
- *
- * TODO: This implementation requires the edges field to be a direct selection
- * and not contained within an inline fragment or fragment spread. It's
- * technically possible to remove this restriction if this pattern becomes
- * common/necessary.
- */
-function validateConnectionSelection(field: LinkedField): void {
-  const {EDGES} = ConnectionInterface.get();
-
-  if (!findArg(field, FIRST) && !findArg(field, LAST)) {
-    throw createUserError(
-      `Expected field '${field.name}' to have a '${FIRST}' or '${LAST}' ` +
-        'argument.',
-      [field.loc],
-    );
-  }
-  if (
-    !field.selections.some(
-      selection => selection.kind === 'LinkedField' && selection.name === EDGES,
-    )
-  ) {
-    throw createUserError(
-      `Expected field '${field.name}' to have an '${EDGES}' selection.`,
-      [field.loc],
-    );
-  }
-}
-
-/**
- * @internal
- *
- * Validates that the type satisfies the Connection specification:
- * - The type has an edges field, and edges have scalar `cursor` and object
- *   `node` fields.
- * - The type has a page info field which is an object with the correct
- *   subfields.
- */
-function validateConnectionType(
-  schema: Schema,
-  field: LinkedField,
-  nullableType: CompositeTypeID,
-  connectionDirective: Directive,
-): void {
-  const directiveName = connectionDirective.name;
-  const {
-    CURSOR,
-    EDGES,
-    END_CURSOR,
-    HAS_NEXT_PAGE,
-    HAS_PREV_PAGE,
-    NODE,
-    PAGE_INFO,
-    START_CURSOR,
-  } = ConnectionInterface.get();
-
-  const typeName = schema.getTypeString(nullableType);
-  if (!schema.hasField(nullableType, EDGES)) {
-    throw createUserError(
-      `@${directiveName} used on invalid field '${field.name}'. Expected the ` +
-        `field type '${typeName}' to have an '${EDGES}' field`,
-      [field.loc],
-    );
-  }
-
-  const edges = schema.getFieldConfig(schema.expectField(nullableType, EDGES));
-
-  const edgesType = schema.getNullableType(edges.type);
-  if (!schema.isList(edgesType)) {
-    throw createUserError(
-      `@${directiveName} used on invalid field '${field.name}'. Expected the ` +
-        `field type '${typeName}' to have an '${EDGES}' field that returns ` +
-        'a list of objects.',
-      [field.loc],
-    );
-  }
-  let edgeType = schema.getNullableType(schema.getListItemType(edgesType));
-  if (!schema.isObject(edgeType) && !schema.isInterface(edgeType)) {
-    throw createUserError(
-      `@${directiveName} used on invalid field '${field.name}'. Expected the ` +
-        `field type '${typeName}' to have an '${EDGES}' field that returns ` +
-        'a list of objects.',
-      [field.loc],
-    );
-  }
-  edgeType = schema.assertCompositeType(edgeType);
-
-  if (!schema.hasField(edgeType, NODE)) {
-    throw createUserError(
-      `@${directiveName} used on invalid field '${field.name}'. Expected the ` +
-        `field type '${typeName}' to have an '${EDGES} { ${NODE} }' field ` +
-        'that returns an object, interface, or union.',
-      [field.loc],
-    );
-  }
-  const node = schema.getFieldConfig(schema.expectField(edgeType, NODE));
-
-  const nodeType = schema.getNullableType(node.type);
-  if (!(schema.isAbstractType(nodeType) || schema.isObject(nodeType))) {
-    throw createUserError(
-      `@${directiveName} used on invalid field '${field.name}'. Expected the ` +
-        `field type '${typeName}' to have an '${EDGES} { ${NODE} }' field ` +
-        'that returns an object, interface, or union.',
-      [field.loc],
-    );
-  }
-
-  if (!schema.hasField(edgeType, CURSOR)) {
-    throw createUserError(
-      `@${directiveName} used on invalid field '${field.name}'. Expected the ` +
-        `field type '${typeName}' to have an '${EDGES} { ${CURSOR} }' field ` +
-        'that returns a scalar value.',
-      [field.loc],
-    );
-  }
-  const cursor = schema.getFieldConfig(schema.expectField(edgeType, CURSOR));
-
-  if (!schema.isScalar(schema.getNullableType(cursor.type))) {
-    throw createUserError(
-      `@${directiveName} used on invalid field '${field.name}'. Expected the ` +
-        `field type '${typeName}' to have an '${EDGES} { ${CURSOR} }' field ` +
-        'that returns a scalar value.',
-      [field.loc],
-    );
-  }
-
-  if (!schema.hasField(nullableType, PAGE_INFO)) {
-    throw createUserError(
-      `@${directiveName} used on invalid field '${field.name}'. Expected the ` +
-        `field type '${typeName}' to have a '${PAGE_INFO}' field that returns ` +
-        'an object.',
-      [field.loc],
-    );
-  }
-
-  const pageInfo = schema.getFieldConfig(
-    schema.expectField(nullableType, PAGE_INFO),
-  );
-
-  const pageInfoType = schema.getNullableType(pageInfo.type);
-  if (!schema.isObject(pageInfoType)) {
-    throw createUserError(
-      `@${directiveName} used on invalid field '${field.name}'. Expected the ` +
-        `field type '${typeName}' to have a '${PAGE_INFO}' field that ` +
-        'returns an object.',
-      [field.loc],
-    );
-  }
-
-  [END_CURSOR, HAS_NEXT_PAGE, HAS_PREV_PAGE, START_CURSOR].forEach(
-    fieldName => {
-      const pageInfoField = schema.getFieldConfig(
-        schema.expectField(schema.assertObjectType(pageInfoType), fieldName),
-      );
-      if (!schema.isScalar(schema.getNullableType(pageInfoField.type))) {
-        throw createUserError(
-          `@${directiveName} used on invalid field '${field.name}'. Expected ` +
-            `the field type '${typeName}' to have a '${PAGE_INFO} { ${fieldName} }' ` +
-            'field returns a scalar.',
-          [field.loc],
-        );
-      }
-    },
-  );
-}
-
-module.exports = {
-  buildConnectionMetadata,
-  CONNECTION,
-  SCHEMA_EXTENSION,
-  transform: connectionTransform,
-};