relay-runtime 8.0.0 → 10.0.1

package/handlers/connection/MutationHandlers.js.flow

@@ -0,0 +1,88 @@
+/**
+ * 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
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const ConnectionHandler = require('./ConnectionHandler');
+
+const invariant = require('invariant');
+const warning = require('warning');
+
+import type {
+  RecordProxy,
+  HandleFieldPayload,
+  RecordSourceProxy,
+  Handler,
+} from '../../store/RelayStoreTypes';
+
+const DeleteRecordHandler = {
+  update: (store: RecordSourceProxy, payload: HandleFieldPayload) => {
+    const record = store.get(payload.dataID);
+    if (record != null) {
+      const id = record.getValue(payload.fieldKey);
+      if (typeof id === 'string') {
+        store.delete(id);
+      }
+    }
+  },
+};
+
+const AppendEdgeHandler: Handler = {
+  update: edgeUpdater(ConnectionHandler.insertEdgeAfter),
+};
+
+const PrependEdgeHandler: Handler = {
+  update: edgeUpdater(ConnectionHandler.insertEdgeBefore),
+};
+
+function edgeUpdater(
+  insertFn: (RecordProxy, RecordProxy, ?string) => void,
+): (RecordSourceProxy, HandleFieldPayload) => void {
+  return (store: RecordSourceProxy, payload: HandleFieldPayload) => {
+    const record = store.get(payload.dataID);
+    if (record == null) {
+      return;
+    }
+    const {connections} = payload.handleArgs;
+    invariant(
+      connections != null,
+      'MutationHandlers: Expected connection IDs to be specified.',
+    );
+    const serverEdge = record.getLinkedRecord(payload.fieldKey, payload.args);
+    for (const connectionID of connections) {
+      const connection = store.get(connectionID);
+      if (connection == null) {
+        warning(
+          false,
+          `[Relay][Mutation] The connection with id '${connectionID}' doesn't exist.`,
+        );
+        continue;
+      }
+      const clientEdge = ConnectionHandler.buildConnectionEdge(
+        store,
+        connection,
+        serverEdge,
+      );
+      invariant(
+        clientEdge != null,
+        'MutationHandlers: Failed to build the edge.',
+      );
+      insertFn(connection, clientEdge);
+    }
+  };
+}
+
+module.exports = {
+  AppendEdgeHandler,
+  DeleteRecordHandler,
+  PrependEdgeHandler,
+};

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v8.0.0
+ * Relay v10.0.1
  *
  * Copyright (c) Facebook, Inc. and its affiliates.
  *

package/index.js.flow

@@ -0,0 +1,320 @@
+/**
+ * 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 ConnectionHandler = require('./handlers/connection/ConnectionHandler');
+const ConnectionInterface = require('./handlers/connection/ConnectionInterface');
+const GraphQLTag = require('./query/GraphQLTag');
+const MutationHandlers = require('./handlers/connection/MutationHandlers');
+const PreloadableQueryRegistry = require('./query/PreloadableQueryRegistry');
+const RelayConcreteNode = require('./util/RelayConcreteNode');
+const RelayConcreteVariables = require('./store/RelayConcreteVariables');
+const RelayDeclarativeMutationConfig = require('./mutations/RelayDeclarativeMutationConfig');
+const RelayDefaultHandleKey = require('./util/RelayDefaultHandleKey');
+const RelayDefaultHandlerProvider = require('./handlers/RelayDefaultHandlerProvider');
+const RelayError = require('./util/RelayError');
+const RelayFeatureFlags = require('./util/RelayFeatureFlags');
+const RelayModernEnvironment = require('./store/RelayModernEnvironment');
+const RelayModernOperationDescriptor = require('./store/RelayModernOperationDescriptor');
+const RelayModernRecord = require('./store/RelayModernRecord');
+const RelayModernSelector = require('./store/RelayModernSelector');
+const RelayModernStore = require('./store/RelayModernStore');
+const RelayNetwork = require('./network/RelayNetwork');
+const RelayObservable = require('./network/RelayObservable');
+const RelayOperationTracker = require('./store/RelayOperationTracker');
+const RelayProfiler = require('./util/RelayProfiler');
+const RelayQueryResponseCache = require('./network/RelayQueryResponseCache');
+const RelayRecordSource = require('./store/RelayRecordSource');
+const RelayReplaySubject = require('./util/RelayReplaySubject');
+const RelayStoreUtils = require('./store/RelayStoreUtils');
+const ViewerPattern = require('./store/ViewerPattern');
+
+const applyOptimisticMutation = require('./mutations/applyOptimisticMutation');
+const commitLocalUpdate = require('./mutations/commitLocalUpdate');
+const commitMutation = require('./mutations/commitMutation');
+const createFragmentSpecResolver = require('./store/createFragmentSpecResolver');
+const createPayloadFor3DField = require('./util/createPayloadFor3DField');
+const createRelayContext = require('./store/createRelayContext');
+const deepFreeze = require('./util/deepFreeze');
+const fetchQuery = require('./query/fetchQuery');
+const fetchQueryInternal = require('./query/fetchQueryInternal');
+const getFragmentIdentifier = require('./util/getFragmentIdentifier');
+const getRelayHandleKey = require('./util/getRelayHandleKey');
+const getRequestIdentifier = require('./util/getRequestIdentifier');
+const isPromise = require('./util/isPromise');
+const isRelayModernEnvironment = require('./store/isRelayModernEnvironment');
+const isScalarAndEqual = require('./util/isScalarAndEqual');
+const readInlineData = require('./store/readInlineData');
+const recycleNodesInto = require('./util/recycleNodesInto');
+const requestSubscription = require('./subscription/requestSubscription');
+const stableCopy = require('./util/stableCopy');
+
+const {
+  generateClientID,
+  generateUniqueClientID,
+  isClientID,
+} = require('./store/ClientID');
+
+export type {ConnectionMetadata} from './handlers/connection/ConnectionHandler';
+export type {
+  EdgeRecord,
+  PageInfo,
+} from './handlers/connection/ConnectionInterface';
+export type {
+  DeclarativeMutationConfig,
+  MutationType,
+  RangeBehaviors,
+  RangeOperation,
+} from './mutations/RelayDeclarativeMutationConfig';
+export type {OptimisticMutationConfig} from './mutations/applyOptimisticMutation';
+export type {
+  DEPRECATED_MutationConfig,
+  MutationConfig,
+  MutationParameters,
+} from './mutations/commitMutation';
+export type {
+  ExecuteFunction,
+  FetchFunction,
+  GraphQLResponse,
+  GraphQLResponseWithData,
+  GraphQLResponseWithoutData,
+  GraphQLSingularResponse,
+  INetwork,
+  LogRequestInfoFunction,
+  PayloadData,
+  PayloadError,
+  SubscribeFunction,
+  Uploadable,
+  UploadableMap,
+} from './network/RelayNetworkTypes';
+export type {
+  ObservableFromValue,
+  Observer,
+  Subscribable,
+  Subscription,
+} from './network/RelayObservable';
+export type {GraphQLTaggedNode} from './query/GraphQLTag';
+export type {EnvironmentConfig} from './store/RelayModernEnvironment';
+export type {TaskScheduler} from './store/RelayModernQueryExecutor';
+export type {RecordState} from './store/RelayRecordState';
+export type {
+  FragmentMap,
+  FragmentPointer,
+  FragmentReference,
+  FragmentSpecResolver,
+  HandleFieldPayload,
+  IEnvironment,
+  InvalidationState,
+  LogEvent,
+  LogFunction,
+  MissingFieldHandler,
+  ModuleImportPointer,
+  NormalizationSelector,
+  OperationAvailability,
+  OperationDescriptor,
+  OperationLoader,
+  OperationTracker,
+  OptimisticResponseConfig,
+  OptimisticUpdate,
+  OptimisticUpdateFunction,
+  PluralReaderSelector,
+  Props,
+  PublishQueue,
+  ReaderSelector,
+  ReadOnlyRecordProxy,
+  RecordProxy,
+  RecordSourceProxy,
+  RecordSourceSelectorProxy,
+  RelayContext,
+  RequestDescriptor,
+  SelectorData,
+  SelectorStoreUpdater,
+  SingularReaderSelector,
+  Snapshot,
+  StoreUpdater,
+} from './store/RelayStoreTypes';
+export type {GraphQLSubscriptionConfig} from './subscription/requestSubscription';
+export type {JSResourceReference} from './util/JSResourceTypes.flow';
+export type {
+  NormalizationArgument,
+  NormalizationDefer,
+  NormalizationField,
+  NormalizationLinkedField,
+  NormalizationLinkedHandle,
+  NormalizationLocalArgumentDefinition,
+  NormalizationModuleImport,
+  NormalizationScalarField,
+  NormalizationSelection,
+  NormalizationSplitOperation,
+  NormalizationStream,
+  NormalizationTypeDiscriminator,
+} from './util/NormalizationNode';
+export type {NormalizationOperation} from './util/NormalizationNode';
+export type {
+  ReaderArgument,
+  ReaderArgumentDefinition,
+  ReaderField,
+  ReaderFragment,
+  ReaderInlineDataFragment,
+  ReaderInlineDataFragmentSpread,
+  ReaderLinkedField,
+  ReaderModuleImport,
+  ReaderPaginationMetadata,
+  ReaderRefetchableFragment,
+  ReaderRefetchMetadata,
+  ReaderScalarField,
+  ReaderSelection,
+} from './util/ReaderNode';
+export type {
+  ConcreteRequest,
+  GeneratedNode,
+  RequestParameters,
+} from './util/RelayConcreteNode';
+export type {
+  CacheConfig,
+  DataID,
+  Disposable,
+  FetchPolicy,
+  FetchQueryFetchPolicy,
+  OperationType,
+  RenderPolicy,
+  Variables,
+  VariablesOf,
+} from './util/RelayRuntimeTypes';
+export type {Local3DPayload} from './util/createPayloadFor3DField';
+
+// As early as possible, check for the existence of the JavaScript globals which
+// Relay Runtime relies upon, and produce a clear message if they do not exist.
+if (__DEV__) {
+  const mapStr = typeof Map !== 'function' ? 'Map' : null;
+  const setStr = typeof Set !== 'function' ? 'Set' : null;
+  const promiseStr = typeof Promise !== 'function' ? 'Promise' : null;
+  const objStr = typeof Object.assign !== 'function' ? 'Object.assign' : null;
+  if (mapStr || setStr || promiseStr || objStr) {
+    throw new Error(
+      `relay-runtime requires ${[mapStr, setStr, promiseStr, objStr]
+        .filter(Boolean)
+        .join(', and ')} to exist. ` +
+        'Use a polyfill to provide these for older browsers.',
+    );
+  }
+}
+
+/**
+ * The public interface to Relay Runtime.
+ */
+module.exports = {
+  // Core API
+  Environment: RelayModernEnvironment,
+  Network: RelayNetwork,
+  Observable: RelayObservable,
+  QueryResponseCache: RelayQueryResponseCache,
+  RecordSource: RelayRecordSource,
+  Record: RelayModernRecord,
+  ReplaySubject: RelayReplaySubject,
+  Store: RelayModernStore,
+
+  areEqualSelectors: RelayModernSelector.areEqualSelectors,
+  createFragmentSpecResolver: createFragmentSpecResolver,
+  createNormalizationSelector: RelayModernSelector.createNormalizationSelector,
+  createOperationDescriptor:
+    RelayModernOperationDescriptor.createOperationDescriptor,
+  createReaderSelector: RelayModernSelector.createReaderSelector,
+  createRequestDescriptor:
+    RelayModernOperationDescriptor.createRequestDescriptor,
+  getDataIDsFromFragment: RelayModernSelector.getDataIDsFromFragment,
+  getDataIDsFromObject: RelayModernSelector.getDataIDsFromObject,
+  getFragment: GraphQLTag.getFragment,
+  getInlineDataFragment: GraphQLTag.getInlineDataFragment,
+  getModuleComponentKey: RelayStoreUtils.getModuleComponentKey,
+  getModuleOperationKey: RelayStoreUtils.getModuleOperationKey,
+  getPaginationFragment: GraphQLTag.getPaginationFragment,
+  getPluralSelector: RelayModernSelector.getPluralSelector,
+  getRefetchableFragment: GraphQLTag.getRefetchableFragment,
+  getRequest: GraphQLTag.getRequest,
+  getRequestIdentifier: getRequestIdentifier,
+  getSelector: RelayModernSelector.getSelector,
+  getSelectorsFromObject: RelayModernSelector.getSelectorsFromObject,
+  getSingularSelector: RelayModernSelector.getSingularSelector,
+  getStorageKey: RelayStoreUtils.getStorageKey,
+  getVariablesFromFragment: RelayModernSelector.getVariablesFromFragment,
+  getVariablesFromObject: RelayModernSelector.getVariablesFromObject,
+  getVariablesFromPluralFragment:
+    RelayModernSelector.getVariablesFromPluralFragment,
+  getVariablesFromSingularFragment:
+    RelayModernSelector.getVariablesFromSingularFragment,
+  graphql: GraphQLTag.graphql,
+  readInlineData,
+
+  // Declarative mutation API
+  MutationTypes: RelayDeclarativeMutationConfig.MutationTypes,
+  RangeOperations: RelayDeclarativeMutationConfig.RangeOperations,
+
+  // Extensions
+  DefaultHandlerProvider: RelayDefaultHandlerProvider,
+  ConnectionHandler,
+  MutationHandlers,
+  VIEWER_ID: ViewerPattern.VIEWER_ID,
+  VIEWER_TYPE: ViewerPattern.VIEWER_TYPE,
+
+  // Helpers (can be implemented via the above API)
+  applyOptimisticMutation,
+  commitLocalUpdate,
+  commitMutation,
+  fetchQuery,
+  isRelayModernEnvironment,
+  requestSubscription,
+
+  // Configuration interface for legacy or special uses
+  ConnectionInterface,
+
+  // Utilities
+  PreloadableQueryRegistry,
+  RelayProfiler: RelayProfiler,
+  createPayloadFor3DField: createPayloadFor3DField,
+
+  // INTERNAL-ONLY: These exports might be removed at any point.
+  RelayConcreteNode: RelayConcreteNode,
+  RelayError: RelayError,
+  RelayFeatureFlags: RelayFeatureFlags,
+  DEFAULT_HANDLE_KEY: RelayDefaultHandleKey.DEFAULT_HANDLE_KEY,
+  FRAGMENTS_KEY: RelayStoreUtils.FRAGMENTS_KEY,
+  FRAGMENT_OWNER_KEY: RelayStoreUtils.FRAGMENT_OWNER_KEY,
+  ID_KEY: RelayStoreUtils.ID_KEY,
+  REF_KEY: RelayStoreUtils.REF_KEY,
+  REFS_KEY: RelayStoreUtils.REFS_KEY,
+  ROOT_ID: RelayStoreUtils.ROOT_ID,
+  ROOT_TYPE: RelayStoreUtils.ROOT_TYPE,
+  TYPENAME_KEY: RelayStoreUtils.TYPENAME_KEY,
+
+  deepFreeze: deepFreeze,
+  generateClientID: generateClientID,
+  generateUniqueClientID: generateUniqueClientID,
+  getRelayHandleKey: getRelayHandleKey,
+  isClientID: isClientID,
+  isPromise: isPromise,
+  isScalarAndEqual: isScalarAndEqual,
+  recycleNodesInto: recycleNodesInto,
+  stableCopy: stableCopy,
+  getFragmentIdentifier: getFragmentIdentifier,
+  __internal: {
+    OperationTracker: RelayOperationTracker,
+    createRelayContext: createRelayContext,
+    getOperationVariables: RelayConcreteVariables.getOperationVariables,
+    fetchQuery: fetchQueryInternal.fetchQuery,
+    fetchQueryDeduped: fetchQueryInternal.fetchQueryDeduped,
+    getPromiseForActiveRequest: fetchQueryInternal.getPromiseForActiveRequest,
+    getObservableForActiveRequest:
+      fetchQueryInternal.getObservableForActiveRequest,
+  },
+};

package/lib/handlers/RelayDefaultHandlerProvider.js

@@ -10,14 +10,25 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var RelayConnectionHandler = require('./connection/RelayConnectionHandler');
+var ConnectionHandler = require('./connection/ConnectionHandler');
+
+var MutationHandlers = require('./connection/MutationHandlers');
 
 var invariant = require("fbjs/lib/invariant");
 
 function RelayDefaultHandlerProvider(handle) {
   switch (handle) {
     case 'connection':
-      return RelayConnectionHandler;
+      return ConnectionHandler;
+
+    case 'deleteRecord':
+      return MutationHandlers.DeleteRecordHandler;
+
+    case 'appendEdge':
+      return MutationHandlers.AppendEdgeHandler;
+
+    case 'prependEdge':
+      return MutationHandlers.PrependEdgeHandler;
   }
 
   !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayDefaultHandlerProvider: No handler provided for `%s`.', handle) : invariant(false) : void 0;

package/lib/handlers/connection/{RelayConnectionHandler.js → ConnectionHandler.js}

@@ -10,7 +10,7 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var RelayConnectionInterface = require('./RelayConnectionInterface');
+var ConnectionInterface = require('./ConnectionInterface');
 
 var getRelayHandleKey = require('../../util/getRelayHandleKey');
 
@@ -33,22 +33,20 @@ var NEXT_EDGE_INDEX = '__connection_next_edge_index';
  */
 
 function update(store, payload) {
-  var _clientConnectionFiel;
-
   var record = store.get(payload.dataID);
 
   if (!record) {
     return;
   }
 
-  var _RelayConnectionInter = RelayConnectionInterface.get(),
-      EDGES = _RelayConnectionInter.EDGES,
-      END_CURSOR = _RelayConnectionInter.END_CURSOR,
-      HAS_NEXT_PAGE = _RelayConnectionInter.HAS_NEXT_PAGE,
-      HAS_PREV_PAGE = _RelayConnectionInter.HAS_PREV_PAGE,
-      PAGE_INFO = _RelayConnectionInter.PAGE_INFO,
-      PAGE_INFO_TYPE = _RelayConnectionInter.PAGE_INFO_TYPE,
-      START_CURSOR = _RelayConnectionInter.START_CURSOR;
+  var _ConnectionInterface$ = ConnectionInterface.get(),
+      EDGES = _ConnectionInterface$.EDGES,
+      END_CURSOR = _ConnectionInterface$.END_CURSOR,
+      HAS_NEXT_PAGE = _ConnectionInterface$.HAS_NEXT_PAGE,
+      HAS_PREV_PAGE = _ConnectionInterface$.HAS_PREV_PAGE,
+      PAGE_INFO = _ConnectionInterface$.PAGE_INFO,
+      PAGE_INFO_TYPE = _ConnectionInterface$.PAGE_INFO_TYPE,
+      START_CURSOR = _ConnectionInterface$.START_CURSOR;
 
   var serverConnection = record.getLinkedRecord(payload.fieldKey);
   var serverPageInfo = serverConnection && serverConnection.getLinkedRecord(PAGE_INFO);
@@ -64,7 +62,7 @@ function update(store, payload) {
 
   var clientConnectionID = generateClientID(record.getDataID(), payload.handleKey);
   var clientConnectionField = record.getLinkedRecord(payload.handleKey);
-  var clientConnection = (_clientConnectionFiel = clientConnectionField) !== null && _clientConnectionFiel !== void 0 ? _clientConnectionFiel : store.get(clientConnectionID);
+  var clientConnection = clientConnectionField !== null && clientConnectionField !== void 0 ? clientConnectionField : store.get(clientConnectionID);
   var clientPageInfo = clientConnection && clientConnection.getLinkedRecord(PAGE_INFO);
 
   if (!clientConnection) {
@@ -139,7 +137,7 @@ function update(store, payload) {
           mergeEdges(prevEdges, nextEdges, nodeIDs);
           mergeEdges(_serverEdges, nextEdges, nodeIDs);
         } else {
-          process.env.NODE_ENV !== "production" ? warning(false, 'RelayConnectionHandler: Unexpected after cursor `%s`, edges must ' + 'be fetched from the end of the list (`%s`).', args.after, clientPageInfo && clientPageInfo.getValue(END_CURSOR)) : void 0;
+          process.env.NODE_ENV !== "production" ? warning(false, 'Relay: Unexpected after cursor `%s`, edges must ' + 'be fetched from the end of the list (`%s`).', args.after, clientPageInfo && clientPageInfo.getValue(END_CURSOR)) : void 0;
           return;
         }
       } else if (args.before != null) {
@@ -150,7 +148,7 @@ function update(store, payload) {
           mergeEdges(_serverEdges, nextEdges, _nodeIDs);
           mergeEdges(prevEdges, nextEdges, _nodeIDs);
         } else {
-          process.env.NODE_ENV !== "production" ? warning(false, 'RelayConnectionHandler: Unexpected before cursor `%s`, edges must ' + 'be fetched from the beginning of the list (`%s`).', args.before, clientPageInfo && clientPageInfo.getValue(START_CURSOR)) : void 0;
+          process.env.NODE_ENV !== "production" ? warning(false, 'Relay: Unexpected before cursor `%s`, edges must ' + 'be fetched from the beginning of the list (`%s`).', args.before, clientPageInfo && clientPageInfo.getValue(START_CURSOR)) : void 0;
           return;
         }
       } else {
@@ -221,7 +219,7 @@ function update(store, payload) {
  * ```
  * store => {
  *   const user = store.get('<id>');
- *   const friends = RelayConnectionHandler.getConnection(user, 'FriendsFragment_friends');
+ *   const friends = ConnectionHandler.getConnection(user, 'FriendsFragment_friends');
  *   // Access fields on the connection:
  *   const edges = friends.getLinkedRecords('edges');
  * }
@@ -265,18 +263,18 @@ function getConnection(record, key, filters) {
  * ```
  * store => {
  *   const user = store.get('<id>');
- *   const friends = RelayConnectionHandler.getConnection(user, 'FriendsFragment_friends');
+ *   const friends = ConnectionHandler.getConnection(user, 'FriendsFragment_friends');
  *   const edge = store.create('<edge-id>', 'FriendsEdge');
- *   RelayConnectionHandler.insertEdgeAfter(friends, edge);
+ *   ConnectionHandler.insertEdgeAfter(friends, edge);
  * }
  * ```
  */
 
 
 function insertEdgeAfter(record, newEdge, cursor) {
-  var _RelayConnectionInter2 = RelayConnectionInterface.get(),
-      CURSOR = _RelayConnectionInter2.CURSOR,
-      EDGES = _RelayConnectionInter2.EDGES;
+  var _ConnectionInterface$2 = ConnectionInterface.get(),
+      CURSOR = _ConnectionInterface$2.CURSOR,
+      EDGES = _ConnectionInterface$2.EDGES;
 
   var edges = record.getLinkedRecords(EDGES);
 
@@ -324,8 +322,8 @@ function insertEdgeAfter(record, newEdge, cursor) {
 
 
 function createEdge(store, record, node, edgeType) {
-  var _RelayConnectionInter3 = RelayConnectionInterface.get(),
-      NODE = _RelayConnectionInter3.NODE; // An index-based client ID could easily conflict (unless it was
+  var _ConnectionInterface$3 = ConnectionInterface.get(),
+      NODE = _ConnectionInterface$3.NODE; // An index-based client ID could easily conflict (unless it was
   // auto-incrementing, but there is nowhere to the store the id)
   // Instead, construct a client ID based on the connection ID and node ID,
   // which will only conflict if the same node is added to the same connection
@@ -371,18 +369,18 @@ function createEdge(store, record, node, edgeType) {
  * ```
  * store => {
  *   const user = store.get('<id>');
- *   const friends = RelayConnectionHandler.getConnection(user, 'FriendsFragment_friends');
+ *   const friends = ConnectionHandler.getConnection(user, 'FriendsFragment_friends');
  *   const edge = store.create('<edge-id>', 'FriendsEdge');
- *   RelayConnectionHandler.insertEdgeBefore(friends, edge);
+ *   ConnectionHandler.insertEdgeBefore(friends, edge);
  * }
  * ```
  */
 
 
 function insertEdgeBefore(record, newEdge, cursor) {
-  var _RelayConnectionInter4 = RelayConnectionInterface.get(),
-      CURSOR = _RelayConnectionInter4.CURSOR,
-      EDGES = _RelayConnectionInter4.EDGES;
+  var _ConnectionInterface$4 = ConnectionInterface.get(),
+      CURSOR = _ConnectionInterface$4.CURSOR,
+      EDGES = _ConnectionInterface$4.EDGES;
 
   var edges = record.getLinkedRecords(EDGES);
 
@@ -429,9 +427,9 @@ function insertEdgeBefore(record, newEdge, cursor) {
 
 
 function deleteNode(record, nodeID) {
-  var _RelayConnectionInter5 = RelayConnectionInterface.get(),
-      EDGES = _RelayConnectionInter5.EDGES,
-      NODE = _RelayConnectionInter5.NODE;
+  var _ConnectionInterface$5 = ConnectionInterface.get(),
+      EDGES = _ConnectionInterface$5.EDGES,
+      NODE = _ConnectionInterface$5.NODE;
 
   var edges = record.getLinkedRecords(EDGES);
 
@@ -478,11 +476,11 @@ function buildConnectionEdge(store, connection, edge) {
     return edge;
   }
 
-  var _RelayConnectionInter6 = RelayConnectionInterface.get(),
-      EDGES = _RelayConnectionInter6.EDGES;
+  var _ConnectionInterface$6 = ConnectionInterface.get(),
+      EDGES = _ConnectionInterface$6.EDGES;
 
   var edgeIndex = connection.getValue(NEXT_EDGE_INDEX);
-  !(typeof edgeIndex === 'number') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayConnectionHandler: Expected %s to be a number, got `%s`.', NEXT_EDGE_INDEX, edgeIndex) : invariant(false) : void 0;
+  !(typeof edgeIndex === 'number') ? process.env.NODE_ENV !== "production" ? invariant(false, 'ConnectionHandler: Expected %s to be a number, got `%s`.', NEXT_EDGE_INDEX, edgeIndex) : invariant(false) : void 0;
   var edgeID = generateClientID(connection.getDataID(), EDGES, edgeIndex);
   var connectionEdge = store.create(edgeID, edge.getType());
   connectionEdge.copyFieldsFrom(edge);
@@ -498,8 +496,8 @@ function buildConnectionEdge(store, connection, edge) {
 
 
 function mergeEdges(sourceEdges, targetEdges, nodeIDs) {
-  var _RelayConnectionInter7 = RelayConnectionInterface.get(),
-      NODE = _RelayConnectionInter7.NODE;
+  var _ConnectionInterface$7 = ConnectionInterface.get(),
+      NODE = _ConnectionInterface$7.NODE;
 
   for (var ii = 0; ii < sourceEdges.length; ii++) {
     var edge = sourceEdges[ii];

package/lib/handlers/connection/{RelayConnectionInterface.js → ConnectionInterface.js}

@@ -36,7 +36,7 @@ var config = {
  * Defines logic relevant to the informal "Connection" GraphQL interface.
  */
 
-var RelayConnectionInterface = {
+var ConnectionInterface = {
   inject: function inject(newConfig) {
     config = newConfig;
   },
@@ -53,4 +53,4 @@ var RelayConnectionInterface = {
     return CONNECTION_CALLS.hasOwnProperty(call.name);
   }
 };
-module.exports = RelayConnectionInterface;
+module.exports = ConnectionInterface;