relay-runtime 2.0.0-rc.2 → 5.0.0

package/lib/fetchQueryInternal.js

@@ -0,0 +1,232 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+'use strict';
+
+var Observable = require("./RelayObservable");
+
+var RelayReplaySubject = require("./RelayReplaySubject");
+
+var getRequestParametersIdentifier = require("./getRequestParametersIdentifier");
+
+var invariant = require("fbjs/lib/invariant");
+
+var requestCachesByEnvironment = new Map();
+/**
+ * Fetches the given query and variables on the provided environment,
+ * and de-dupes identical in-flight requests.
+ *
+ * Observing a request:
+ * ====================
+ * fetchQuery returns an Observable which you can call .subscribe()
+ * on. subscribe() takes an Observer, which you can provide to
+ * observe network events:
+ *
+ * ```
+ * fetchQuery(environment, query, variables).subscribe({
+ *   // Called when network requests starts
+ *   start: (subscription) => {},
+ *
+ *   // Called after a payload is received and written to the local store
+ *   next: (payload) => {},
+ *
+ *   // Called when network requests errors
+ *   error: (error) => {},
+ *
+ *   // Called when network requests fully completes
+ *   complete: () => {},
+ *
+ *   // Called when network request is unsubscribed
+ *   unsubscribe: (subscription) => {},
+ * });
+ * ```
+ *
+ * In-flight request de-duping:
+ * ============================
+ * By default, calling fetchQuery multiple times with the same
+ * environment, query and variables will not initiate a new request if a request
+ * for those same parameters is already in flight.
+ *
+ * A request is marked in-flight from the moment it starts until the moment it
+ * fully completes, regardless of error or successful completion.
+ *
+ * NOTE: If the request completes _synchronously_, calling fetchQuery
+ * a second time with the same arguments in the same tick will _NOT_ de-dupe
+ * the request given that it will no longer be in-flight.
+ *
+ *
+ * Data Retention:
+ * ===============
+ * This function will not retain any query data outside the scope of the
+ * request, which means it is not guaranteed that it won't be garbage
+ * collected after the request completes.
+ * If you need to retain data, you can do so manually with environment.retain().
+ *
+ * Cancelling requests:
+ * ====================
+ * If the subscription returned by subscribe is called while the
+ * request is in-flight, apart from releasing retained data, the request will
+ * also be cancelled.
+ *
+ * ```
+ * const subscription = fetchQuery(...).subscribe(...);
+ *
+ * // This will cancel the request if it is in-flight.
+ * subscription.unsubscribe();
+ * ```
+ * @private
+ */
+
+function fetchQuery(environment, query, options) {
+  return fetchQueryDeduped(environment, query.node.params, query.variables, function () {
+    return environment.execute({
+      operation: query,
+      cacheConfig: options === null || options === void 0 ? void 0 : options.networkCacheConfig
+    });
+  });
+}
+/**
+ * Low-level implementation details of `fetchQuery`.
+ *
+ * `fetchQueryDeduped` can also be used to share a single cache for
+ * requests that aren't using `fetchQuery` directly (e.g. because they don't
+ * have an `OperationDescriptor` when they are called).
+ *
+ * @private
+ */
+
+
+function fetchQueryDeduped(environment, parameters, variables, fetchFn) {
+  return Observable.create(function (sink) {
+    var requestCache = getRequestCache(environment);
+    var cacheKey = getRequestParametersIdentifier(parameters, variables);
+    var cachedRequest = requestCache.get(cacheKey);
+
+    if (!cachedRequest) {
+      fetchFn()["finally"](function () {
+        return requestCache["delete"](cacheKey);
+      }).subscribe({
+        start: function start(subscription) {
+          cachedRequest = {
+            subject: new RelayReplaySubject(),
+            subscription: subscription
+          };
+          requestCache.set(cacheKey, cachedRequest);
+        },
+        next: function next(response) {
+          getCachedRequest(requestCache, cacheKey).subject.next(response);
+        },
+        error: function error(_error) {
+          getCachedRequest(requestCache, cacheKey).subject.error(_error);
+        },
+        complete: function complete() {
+          getCachedRequest(requestCache, cacheKey).subject.complete();
+        }
+      });
+    }
+
+    !(cachedRequest != null) ? process.env.NODE_ENV !== "production" ? invariant(false, '[fetchQueryInternal] fetchQueryDeduped: Expected `start` to be ' + 'called synchronously') : invariant(false) : void 0;
+    var subscription = cachedRequest.subject.subscribe(sink);
+    return function () {
+      subscription.unsubscribe();
+      var cachedRequestInstance = requestCache.get(cacheKey);
+
+      if (cachedRequestInstance) {
+        var requestSubscription = cachedRequestInstance.subscription;
+
+        if (requestSubscription != null && cachedRequestInstance.subject.getObserverCount() === 0) {
+          requestSubscription.unsubscribe();
+          requestCache["delete"](cacheKey);
+        }
+      }
+    };
+  });
+}
+/**
+ * If a request is in flight for the given query, variables and environment,
+ * this function will return a Promise that will resolve when that request has
+ * completed and the data has been saved to the store.
+ * If no request is in flight, null will be returned
+ * @private
+ */
+
+
+function getPromiseForRequestInFlight(environment, query) {
+  var requestCache = getRequestCache(environment);
+  var cacheKey = getRequestParametersIdentifier(query.node.params, query.variables);
+  var cachedRequest = requestCache.get(cacheKey);
+
+  if (!cachedRequest) {
+    return null;
+  }
+
+  return new Promise(function (resolve, reject) {
+    var resolveOnNext = false;
+    fetchQuery(environment, query).subscribe({
+      complete: resolve,
+      error: reject,
+      next: function next(response) {
+        /*
+         * The underlying `RelayReplaySubject` will synchronously replay events
+         * as soon as we subscribe, but since we want the *next* asynchronous
+         * one, we'll ignore them until the replay finishes.
+         */
+        if (resolveOnNext) {
+          resolve(response);
+        }
+      }
+    });
+    resolveOnNext = true;
+  });
+}
+/**
+ * If there is a pending request for the given query, returns an Observable of
+ * *all* its responses. Existing responses are published synchronously and
+ * subsequent responses are published asynchronously. Returns null if there is
+ * no pending request. This is similar to fetchQuery() except that it will not
+ * issue a fetch if there isn't already one pending.
+ */
+
+
+function getObservableForRequestInFlight(environment, query) {
+  var requestCache = getRequestCache(environment);
+  var cacheKey = getRequestParametersIdentifier(query.node.params, query.variables);
+  var cachedRequest = requestCache.get(cacheKey);
+
+  if (!cachedRequest) {
+    return null;
+  }
+
+  return fetchQuery(environment, query);
+}
+
+function getRequestCache(environment) {
+  var cached = requestCachesByEnvironment.get(environment);
+
+  if (cached != null) {
+    return cached;
+  }
+
+  var requestCache = new Map();
+  requestCachesByEnvironment.set(environment, requestCache);
+  return requestCache;
+}
+
+function getCachedRequest(requestCache, cacheKey) {
+  var cached = requestCache.get(cacheKey);
+  !(cached != null) ? process.env.NODE_ENV !== "production" ? invariant(false, '[fetchQueryInternal] getCachedRequest: Expected request to be cached') : invariant(false) : void 0;
+  return cached;
+}
+
+module.exports = {
+  fetchQuery: fetchQuery,
+  getPromiseForRequestInFlight: getPromiseForRequestInFlight,
+  getObservableForRequestInFlight: getObservableForRequestInFlight,
+  fetchQueryDeduped: fetchQueryDeduped
+};

package/lib/fetchRelayModernQuery.js

@@ -4,18 +4,20 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict-local
+ * 
  * @format
  */
 'use strict';
 
+var invariant = require("fbjs/lib/invariant");
+
 /**
  * A helper function to fetch the results of a query. Note that results for
  * fragment spreads are masked: fields must be explicitly listed in the query in
  * order to be accessible in the result object.
  */
 function fetchRelayModernQuery(environment, taggedNode, variables, cacheConfig) {
-  !environment.unstable_internal ? process.env.NODE_ENV !== "production" ? require("fbjs/lib/invariant")(false, 'fetchRelayModernQuery: Expected a valid Relay environment, got `%s`.', environment) : require("fbjs/lib/invariant")(false) : void 0;
+  !environment.unstable_internal ? process.env.NODE_ENV !== "production" ? invariant(false, 'fetchRelayModernQuery: Expected a valid Relay environment, got `%s`.', environment) : invariant(false) : void 0;
   var _environment$unstable = environment.unstable_internal,
       createOperationDescriptor = _environment$unstable.createOperationDescriptor,
       getRequest = _environment$unstable.getRequest;
@@ -30,7 +32,7 @@ function fetchRelayModernQuery(environment, taggedNode, variables, cacheConfig)
     operation: operation,
     cacheConfig: cacheConfig
   }).map(function () {
-    return environment.lookup(operation.fragment).data;
+    return environment.lookup(operation.fragment, operation).data;
   }).toPromise();
 }
 

package/lib/getFragmentIdentifier.js

@@ -0,0 +1,52 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ * @emails oncall+relay
+ */
+'use strict';
+
+var RelayCore = require("./RelayCore");
+
+var getDataIDsFromFragment = RelayCore.getDataIDsFromFragment,
+    getVariablesFromFragment = RelayCore.getVariablesFromFragment;
+
+var _require = require("./RelayModernFragmentOwner"),
+    getFragmentOwner = _require.getFragmentOwner;
+
+var stableCopy = require("./stableCopy");
+
+function getFragmentIdentifier(fragmentNode, fragmentRef) {
+  var _ref3, _ref4, _ref6;
+
+  var fragmentOwner = getFragmentOwner(fragmentNode, // $FlowFixMe - TODO T39154660 Use FragmentPointer type instead of mixed
+  fragmentRef);
+  var fragmentVariables = getVariablesFromFragment( // We get the variables from the fragment owner in the fragment ref, so we
+  // don't pass them here. This API can change once fragment ownership
+  // stops being optional
+  // TODO(T39494051)
+  {}, fragmentNode, fragmentRef, fragmentOwner);
+  var dataIDs = getDataIDsFromFragment(fragmentNode, fragmentRef);
+  var fragmentOwnerID = Array.isArray(fragmentOwner) ? fragmentOwner.map(function (owner) {
+    var _ref, _ref2;
+
+    return (_ref = (_ref2 = owner === null || owner === void 0 ? void 0 : owner.node.params.id) !== null && _ref2 !== void 0 ? _ref2 : owner === null || owner === void 0 ? void 0 : owner.node.params.name) !== null && _ref !== void 0 ? _ref : '';
+  }) : (_ref3 = (_ref4 = fragmentOwner === null || fragmentOwner === void 0 ? void 0 : fragmentOwner.node.params.id) !== null && _ref4 !== void 0 ? _ref4 : fragmentOwner === null || fragmentOwner === void 0 ? void 0 : fragmentOwner.node.params.name) !== null && _ref3 !== void 0 ? _ref3 : '';
+  var fragmentOwnerVariables = Array.isArray(fragmentOwner) ? fragmentOwner.map(function (owner) {
+    var _ref5;
+
+    return (_ref5 = owner === null || owner === void 0 ? void 0 : owner.variables) !== null && _ref5 !== void 0 ? _ref5 : null;
+  }) : (_ref6 = fragmentOwner === null || fragmentOwner === void 0 ? void 0 : fragmentOwner.variables) !== null && _ref6 !== void 0 ? _ref6 : null;
+  return "".concat(fragmentNode.name, "-").concat(JSON.stringify(stableCopy({
+    dataIDs: dataIDs,
+    fragmentVariables: fragmentVariables,
+    fragmentOwnerID: fragmentOwnerID,
+    fragmentOwnerVariables: fragmentOwnerVariables
+  })));
+}
+
+module.exports = getFragmentIdentifier;

package/lib/getFragmentSpecIdentifier.js

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ * @emails oncall+relay
+ */
+'use strict';
+
+var getFragmentIdentifier = require("./getFragmentIdentifier");
+
+var mapObject = require("fbjs/lib/mapObject");
+
+var stableCopy = require("./stableCopy");
+
+function getFragmentSpecIdentifier(fragmentNodes, fragmentRefs) {
+  return JSON.stringify(stableCopy(mapObject(fragmentNodes, function (fragmentNode, key) {
+    var fragmentRef = fragmentRefs[key];
+    return getFragmentIdentifier(fragmentNode, fragmentRef);
+  })));
+}
+
+module.exports = getFragmentSpecIdentifier;

package/lib/getRelayHandleKey.js

@@ -9,18 +9,24 @@
  */
 'use strict';
 
+var invariant = require("fbjs/lib/invariant");
+
+var _require = require("./RelayDefaultHandleKey"),
+    DEFAULT_HANDLE_KEY = _require.DEFAULT_HANDLE_KEY;
 /**
  * @internal
  *
  * Helper to create a unique name for a handle field based on the handle name, handle key and
  * source field.
  */
+
+
 function getRelayHandleKey(handleName, key, fieldName) {
-  if (key && key !== require("./RelayDefaultHandleKey").DEFAULT_HANDLE_KEY) {
+  if (key && key !== DEFAULT_HANDLE_KEY) {
     return "__".concat(key, "_").concat(handleName);
   }
 
-  !(fieldName != null) ? process.env.NODE_ENV !== "production" ? require("fbjs/lib/invariant")(false, 'getRelayHandleKey: Expected either `fieldName` or `key` in `handle` to be provided') : require("fbjs/lib/invariant")(false) : void 0;
+  !(fieldName != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'getRelayHandleKey: Expected either `fieldName` or `key` in `handle` to be provided') : invariant(false) : void 0;
   return "__".concat(fieldName, "_").concat(handleName);
 }
 

package/lib/getRequestParametersIdentifier.js

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ *
+ * 
+ * @format
+ */
+'use strict';
+
+var invariant = require("fbjs/lib/invariant");
+
+var stableCopy = require("./stableCopy");
+
+/**
+ * Returns a stable identifier for the given pair of `RequestParameters` +
+ * variables.
+ */
+function getRequestParametersIdentifier(parameters, variables) {
+  var requestID = parameters.id != null ? parameters.id : parameters.text;
+  !(requestID != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'getRequestParametersIdentifier: Expected request `%s` to have either a ' + 'valid `id` or `text` property', parameters.name) : invariant(false) : void 0;
+  return requestID + JSON.stringify(stableCopy(variables));
+}
+
+module.exports = getRequestParametersIdentifier;

package/lib/hasOverlappingIDs.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict-local
+ * 
  * @format
  */
 'use strict';

package/lib/index.js

@@ -9,6 +9,89 @@
  */
 'use strict';
 
+var RelayConcreteNode = require("./RelayConcreteNode");
+
+var RelayConcreteVariables = require("./RelayConcreteVariables");
+
+var RelayConnectionHandler = require("./RelayConnectionHandler");
+
+var RelayConnectionInterface = require("./RelayConnectionInterface");
+
+var RelayCore = require("./RelayCore");
+
+var RelayDeclarativeMutationConfig = require("./RelayDeclarativeMutationConfig");
+
+var RelayDefaultHandleKey = require("./RelayDefaultHandleKey");
+
+var RelayDefaultHandlerProvider = require("./RelayDefaultHandlerProvider");
+
+var RelayDefaultMissingFieldHandlers = require("./RelayDefaultMissingFieldHandlers");
+
+var RelayError = require("./RelayError");
+
+var RelayFeatureFlags = require("./RelayFeatureFlags");
+
+var RelayInMemoryRecordSource = require("./RelayInMemoryRecordSource");
+
+var RelayModernEnvironment = require("./RelayModernEnvironment");
+
+var RelayModernFragmentOwner = require("./RelayModernFragmentOwner");
+
+var RelayModernGraphQLTag = require("./RelayModernGraphQLTag");
+
+var RelayModernStore = require("./RelayModernStore");
+
+var RelayNetwork = require("./RelayNetwork");
+
+var RelayNetworkLoggerTransaction = require("./RelayNetworkLoggerTransaction");
+
+var RelayObservable = require("./RelayObservable");
+
+var RelayProfiler = require("./RelayProfiler");
+
+var RelayQueryResponseCache = require("./RelayQueryResponseCache");
+
+var RelayStoreUtils = require("./RelayStoreUtils");
+
+var RelayViewerHandler = require("./RelayViewerHandler");
+
+var applyRelayModernOptimisticMutation = require("./applyRelayModernOptimisticMutation");
+
+var commitLocalUpdate = require("./commitLocalUpdate");
+
+var commitRelayModernMutation = require("./commitRelayModernMutation");
+
+var createRelayContext = require("./createRelayContext");
+
+var createRelayNetworkLogger = require("./createRelayNetworkLogger");
+
+var deepFreeze = require("./deepFreeze");
+
+var fetchQueryInternal = require("./fetchQueryInternal");
+
+var fetchRelayModernQuery = require("./fetchRelayModernQuery");
+
+var getFragmentIdentifier = require("./getFragmentIdentifier");
+
+var getFragmentSpecIdentifier = require("./getFragmentSpecIdentifier");
+
+var getRelayHandleKey = require("./getRelayHandleKey");
+
+var getRequestParametersIdentifier = require("./getRequestParametersIdentifier");
+
+var isRelayModernEnvironment = require("./isRelayModernEnvironment");
+
+var isScalarAndEqual = require("./isScalarAndEqual");
+
+var recycleNodesInto = require("./recycleNodesInto");
+
+var requestRelaySubscription = require("./requestRelaySubscription");
+
+var stableCopy = require("./stableCopy");
+
+var _require = require("./ClientID"),
+    generateClientID = _require.generateClientID;
+
 // 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 (process.env.NODE_ENV !== "production") {
@@ -23,65 +106,84 @@ if (process.env.NODE_ENV !== "production") {
 
 module.exports = {
   // Core API
-  Environment: require("./RelayModernEnvironment"),
-  Network: require("./RelayNetwork"),
-  Observable: require("./RelayObservable"),
-  QueryResponseCache: require("./RelayQueryResponseCache"),
-  RecordSource: require("./RelayInMemoryRecordSource"),
-  Store: require("./RelayModernStore"),
-  areEqualSelectors: require("./RelayCore").areEqualSelectors,
-  createFragmentSpecResolver: require("./RelayCore").createFragmentSpecResolver,
-  createOperationDescriptor: require("./RelayCore").createOperationDescriptor,
-  getDataIDsFromObject: require("./RelayCore").getDataIDsFromObject,
-  getFragment: require("./RelayModernGraphQLTag").getFragment,
-  getPaginationFragment: require("./RelayModernGraphQLTag").getPaginationFragment,
-  getRefetchableFragment: require("./RelayModernGraphQLTag").getRefetchableFragment,
-  getRequest: require("./RelayModernGraphQLTag").getRequest,
-  getSelector: require("./RelayCore").getSelector,
-  getSelectorList: require("./RelayCore").getSelectorList,
-  getSelectorsFromObject: require("./RelayCore").getSelectorsFromObject,
-  getStorageKey: require("./RelayStoreUtils").getStorageKey,
-  getVariablesFromObject: require("./RelayCore").getVariablesFromObject,
-  graphql: require("./RelayModernGraphQLTag").graphql,
+  Environment: RelayModernEnvironment,
+  Network: RelayNetwork,
+  Observable: RelayObservable,
+  QueryResponseCache: RelayQueryResponseCache,
+  RecordSource: RelayInMemoryRecordSource,
+  Store: RelayModernStore,
+  areEqualSelectors: RelayCore.areEqualSelectors,
+  createFragmentSpecResolver: RelayCore.createFragmentSpecResolver,
+  createOperationDescriptor: RelayCore.createOperationDescriptor,
+  getDataIDsFromFragment: RelayCore.getDataIDsFromFragment,
+  getDataIDsFromObject: RelayCore.getDataIDsFromObject,
+  getFragment: RelayModernGraphQLTag.getFragment,
+  getFragmentOwner: RelayModernFragmentOwner.getFragmentOwner,
+  getFragmentOwners: RelayModernFragmentOwner.getFragmentOwners,
+  getPaginationFragment: RelayModernGraphQLTag.getPaginationFragment,
+  getModuleComponentKey: RelayStoreUtils.getModuleComponentKey,
+  getModuleOperationKey: RelayStoreUtils.getModuleOperationKey,
+  getRefetchableFragment: RelayModernGraphQLTag.getRefetchableFragment,
+  getRequest: RelayModernGraphQLTag.getRequest,
+  getSingularSelector: RelayCore.getSingularSelector,
+  getPluralSelector: RelayCore.getPluralSelector,
+  getSelector: RelayCore.getSelector,
+  getSelectorsFromObject: RelayCore.getSelectorsFromObject,
+  getStorageKey: RelayStoreUtils.getStorageKey,
+  getVariablesFromSingularFragment: RelayCore.getVariablesFromSingularFragment,
+  getVariablesFromPluralFragment: RelayCore.getVariablesFromPluralFragment,
+  getVariablesFromFragment: RelayCore.getVariablesFromFragment,
+  getVariablesFromObject: RelayCore.getVariablesFromObject,
+  graphql: RelayModernGraphQLTag.graphql,
   // Declarative mutation API
-  MutationTypes: require("./RelayDeclarativeMutationConfig").MutationTypes,
-  RangeOperations: require("./RelayDeclarativeMutationConfig").RangeOperations,
+  MutationTypes: RelayDeclarativeMutationConfig.MutationTypes,
+  RangeOperations: RelayDeclarativeMutationConfig.RangeOperations,
   // Extensions
-  DefaultHandlerProvider: require("./RelayDefaultHandlerProvider"),
-  ConnectionHandler: require("./RelayConnectionHandler"),
-  ViewerHandler: require("./RelayViewerHandler"),
+  DefaultHandlerProvider: RelayDefaultHandlerProvider,
+  DefaultMissingFieldHandlers: RelayDefaultMissingFieldHandlers,
+  ConnectionHandler: RelayConnectionHandler,
+  ViewerHandler: RelayViewerHandler,
   // Helpers (can be implemented via the above API)
-  applyOptimisticMutation: require("./applyRelayModernOptimisticMutation"),
-  commitLocalUpdate: require("./commitLocalUpdate"),
-  commitMutation: require("./commitRelayModernMutation"),
-  fetchQuery: require("./fetchRelayModernQuery"),
-  isRelayModernEnvironment: require("./isRelayModernEnvironment"),
-  requestSubscription: require("./requestRelaySubscription"),
+  applyOptimisticMutation: applyRelayModernOptimisticMutation,
+  commitLocalUpdate: commitLocalUpdate,
+  commitMutation: commitRelayModernMutation,
+  fetchQuery: fetchRelayModernQuery,
+  isRelayModernEnvironment: isRelayModernEnvironment,
+  requestSubscription: requestRelaySubscription,
   // Configuration interface for legacy or special uses
-  ConnectionInterface: require("./RelayConnectionInterface"),
+  ConnectionInterface: RelayConnectionInterface,
   // Utilities
-  RelayProfiler: require("./RelayProfiler"),
+  RelayProfiler: RelayProfiler,
   // INTERNAL-ONLY: These exports might be removed at any point.
-  RelayConcreteNode: require("./RelayConcreteNode"),
-  RelayError: require("./RelayError"),
-  RelayNetworkLoggerTransaction: require("./RelayNetworkLoggerTransaction"),
-  DEFAULT_HANDLE_KEY: require("./RelayDefaultHandleKey").DEFAULT_HANDLE_KEY,
-  FRAGMENTS_KEY: require("./RelayStoreUtils").FRAGMENTS_KEY,
-  FRAGMENT_OWNER_KEY: require("./RelayStoreUtils").FRAGMENT_OWNER_KEY,
-  ID_KEY: require("./RelayStoreUtils").ID_KEY,
-  REF_KEY: require("./RelayStoreUtils").REF_KEY,
-  REFS_KEY: require("./RelayStoreUtils").REFS_KEY,
-  ROOT_ID: require("./RelayStoreUtils").ROOT_ID,
-  ROOT_TYPE: require("./RelayStoreUtils").ROOT_TYPE,
-  createRelayNetworkLogger: require("./createRelayNetworkLogger"),
-  deepFreeze: require("./deepFreeze"),
-  generateClientID: require("./generateRelayClientID"),
-  getRelayHandleKey: require("./getRelayHandleKey"),
-  isScalarAndEqual: require("./isScalarAndEqual"),
-  recycleNodesInto: require("./recycleNodesInto"),
-  simpleClone: require("./simpleClone"),
-  stableCopy: require("./stableCopy"),
+  RelayConcreteNode: RelayConcreteNode,
+  RelayError: RelayError,
+  RelayFeatureFlags: RelayFeatureFlags,
+  RelayNetworkLoggerTransaction: RelayNetworkLoggerTransaction,
+  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,
+  createRelayNetworkLogger: createRelayNetworkLogger,
+  deepFreeze: deepFreeze,
+  generateClientID: generateClientID,
+  getRelayHandleKey: getRelayHandleKey,
+  isScalarAndEqual: isScalarAndEqual,
+  recycleNodesInto: recycleNodesInto,
+  stableCopy: stableCopy,
+  getFragmentIdentifier: getFragmentIdentifier,
+  getFragmentSpecIdentifier: getFragmentSpecIdentifier,
+  getRequestParametersIdentifier: getRequestParametersIdentifier,
   __internal: {
-    getModernOperationVariables: require("./RelayConcreteVariables").getOperationVariables
+    createRelayContext: createRelayContext,
+    getModernOperationVariables: RelayConcreteVariables.getOperationVariables,
+    fetchQuery: fetchQueryInternal.fetchQuery,
+    fetchQueryDeduped: fetchQueryInternal.fetchQueryDeduped,
+    getPromiseForRequestInFlight: fetchQueryInternal.getPromiseForRequestInFlight,
+    getObservableForRequestInFlight: fetchQueryInternal.getObservableForRequestInFlight
   }
 };

package/lib/isPromise.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  * @format
  */
 'use strict';

package/lib/isScalarAndEqual.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- *  strict
+ * 
  * @format
  */
 'use strict';