relay-runtime 12.0.0 → 13.0.0-rc.0

package/lib/multi-actor-environment/MultiActorEnvironment.js

@@ -16,22 +16,22 @@ var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/obje
 
 var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
 
-var ActorSpecificEnvironment = require('./ActorSpecificEnvironment');
-
-var OperationExecutor = require('../store/OperationExecutor');
-
 var RelayDefaultHandlerProvider = require('../handlers/RelayDefaultHandlerProvider');
 
-var RelayModernStore = require('../store/RelayModernStore');
-
 var RelayObservable = require('../network/RelayObservable');
 
-var RelayRecordSource = require('../store/RelayRecordSource');
-
 var defaultGetDataID = require('../store/defaultGetDataID');
 
 var defaultRequiredFieldLogger = require('../store/defaultRequiredFieldLogger');
 
+var OperationExecutor = require('../store/OperationExecutor');
+
+var RelayModernStore = require('../store/RelayModernStore');
+
+var RelayRecordSource = require('../store/RelayRecordSource');
+
+var ActorSpecificEnvironment = require('./ActorSpecificEnvironment');
+
 var MultiActorEnvironment = /*#__PURE__*/function () {
   function MultiActorEnvironment(config) {
     var _config$getDataID, _config$logFn, _config$requiredField, _config$treatMissingF, _config$isServer, _config$defaultRender;
@@ -258,8 +258,7 @@ var MultiActorEnvironment = /*#__PURE__*/function () {
   };
 
   _proto.execute = function execute(actorEnvironment, _ref) {
-    var operation = _ref.operation,
-        updater = _ref.updater;
+    var operation = _ref.operation;
     return this._execute(actorEnvironment, {
       createSource: function createSource() {
         return actorEnvironment.getNetwork().execute(operation.request.node.params, operation.request.variables, operation.request.cacheConfig || {}, null);
@@ -267,16 +266,30 @@ var MultiActorEnvironment = /*#__PURE__*/function () {
       isClientPayload: false,
       operation: operation,
       optimisticConfig: null,
-      updater: updater
+      updater: null
     });
   };
 
-  _proto.executeMutation = function executeMutation(actorEnvironment, _ref2) {
+  _proto.executeSubscription = function executeSubscription(actorEnvironment, _ref2) {
     var operation = _ref2.operation,
-        optimisticResponse = _ref2.optimisticResponse,
-        optimisticUpdater = _ref2.optimisticUpdater,
-        updater = _ref2.updater,
-        uploadables = _ref2.uploadables;
+        updater = _ref2.updater;
+    return this._execute(actorEnvironment, {
+      createSource: function createSource() {
+        return actorEnvironment.getNetwork().execute(operation.request.node.params, operation.request.variables, operation.request.cacheConfig || {}, null);
+      },
+      isClientPayload: false,
+      operation: operation,
+      optimisticConfig: null,
+      updater: updater
+    });
+  };
+
+  _proto.executeMutation = function executeMutation(actorEnvironment, _ref3) {
+    var operation = _ref3.operation,
+        optimisticResponse = _ref3.optimisticResponse,
+        optimisticUpdater = _ref3.optimisticUpdater,
+        updater = _ref3.updater,
+        uploadables = _ref3.uploadables;
     var optimisticConfig;
 
     if (optimisticResponse || optimisticUpdater) {
@@ -322,14 +335,14 @@ var MultiActorEnvironment = /*#__PURE__*/function () {
     return this._isServer;
   };
 
-  _proto._execute = function _execute(actorEnvironment, _ref3) {
+  _proto._execute = function _execute(actorEnvironment, _ref4) {
     var _this4 = this;
 
-    var createSource = _ref3.createSource,
-        isClientPayload = _ref3.isClientPayload,
-        operation = _ref3.operation,
-        optimisticConfig = _ref3.optimisticConfig,
-        updater = _ref3.updater;
+    var createSource = _ref4.createSource,
+        isClientPayload = _ref4.isClientPayload,
+        operation = _ref4.operation,
+        optimisticConfig = _ref4.optimisticConfig,
+        updater = _ref4.updater;
     return RelayObservable.create(function (sink) {
       var executor = OperationExecutor.execute({
         actorIdentifier: actorEnvironment.actorIdentifier,

package/lib/multi-actor-environment/index.js

@@ -10,11 +10,11 @@
  */
 'use strict';
 
-var MultiActorEnvironment = require('./MultiActorEnvironment');
-
 var _require = require('./ActorIdentifier'),
     getActorIdentifier = _require.getActorIdentifier;
 
+var MultiActorEnvironment = require('./MultiActorEnvironment');
+
 module.exports = {
   MultiActorEnvironment: MultiActorEnvironment,
   getActorIdentifier: getActorIdentifier

package/lib/mutations/RelayDeclarativeMutationConfig.js

@@ -201,7 +201,10 @@ function rangeDelete(config, request) {
       return;
     }
 
-    var deleteIDs = [];
+    var deleteIDs = []; // the type of data should come from a type parameter associated with ConcreteRequest,
+    // but ConcreteRequest does not contain a type parameter. Hence, we use a FlowFixMe.
+    // $FlowFixMe[incompatible-use] see above
+
     var deletedIDField = data[rootField];
 
     if (deletedIDField && Array.isArray(deletedIDFieldName)) {

package/lib/mutations/RelayRecordProxy.js

@@ -10,20 +10,21 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require('invariant');
-
 var _require = require('../store/ClientID'),
     generateClientID = _require.generateClientID;
 
 var _require2 = require('../store/RelayStoreUtils'),
     getStableStorageKey = _require2.getStableStorageKey;
 
+var invariant = require('invariant');
 /**
  * @internal
  *
  * A helper class for manipulating a given record from a record source via an
  * imperative/OO-style API.
  */
+
+
 var RelayRecordProxy = /*#__PURE__*/function () {
   function RelayRecordProxy(source, mutator, dataID) {
     this._dataID = dataID;

package/lib/mutations/RelayRecordSourceMutator.js

@@ -12,11 +12,10 @@
 
 var RelayModernRecord = require('../store/RelayModernRecord');
 
-var invariant = require('invariant');
-
 var _require = require('../store/RelayRecordState'),
     EXISTENT = _require.EXISTENT;
 
+var invariant = require('invariant');
 /**
  * @internal
  *
@@ -29,6 +28,8 @@ var _require = require('../store/RelayRecordState'),
  * - Modifications cause a fresh version of a record to be created in `sink`.
  *   These sink records contain only modified fields.
  */
+
+
 var RelayRecordSourceMutator = /*#__PURE__*/function () {
   function RelayRecordSourceMutator(base, sink) {
     this.__sources = [sink, base];

package/lib/mutations/RelayRecordSourceProxy.js

@@ -12,10 +12,6 @@
 
 var RelayModernRecord = require('../store/RelayModernRecord');
 
-var RelayRecordProxy = require('./RelayRecordProxy');
-
-var invariant = require('invariant');
-
 var _require = require('../store/RelayRecordState'),
     EXISTENT = _require.EXISTENT,
     NONEXISTENT = _require.NONEXISTENT;
@@ -24,11 +20,19 @@ var _require2 = require('../store/RelayStoreUtils'),
     ROOT_ID = _require2.ROOT_ID,
     ROOT_TYPE = _require2.ROOT_TYPE;
 
+var _require3 = require('./readUpdatableQuery_EXPERIMENTAL'),
+    _readUpdatableQuery_EXPERIMENTAL = _require3.readUpdatableQuery_EXPERIMENTAL;
+
+var RelayRecordProxy = require('./RelayRecordProxy');
+
+var invariant = require('invariant');
 /**
  * @internal
  *
  * A helper for manipulating a `RecordSource` via an imperative/OO-style API.
  */
+
+
 var RelayRecordSourceProxy = /*#__PURE__*/function () {
   function RelayRecordSourceProxy(mutator, getDataID, handlerProvider) {
     this.__mutator = mutator;
@@ -131,6 +135,10 @@ var RelayRecordSourceProxy = /*#__PURE__*/function () {
     return this._idsMarkedForInvalidation;
   };
 
+  _proto.readUpdatableQuery_EXPERIMENTAL = function readUpdatableQuery_EXPERIMENTAL(query, variables) {
+    return _readUpdatableQuery_EXPERIMENTAL(query, variables, this);
+  };
+
   return RelayRecordSourceProxy;
 }();
 

package/lib/mutations/RelayRecordSourceSelectorProxy.js

@@ -10,12 +10,14 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require('invariant');
-
 var _require = require('../store/RelayStoreUtils'),
-    getStorageKey = _require.getStorageKey,
-    ROOT_TYPE = _require.ROOT_TYPE;
+    ROOT_TYPE = _require.ROOT_TYPE,
+    getStorageKey = _require.getStorageKey;
 
+var _require2 = require('./readUpdatableQuery_EXPERIMENTAL'),
+    _readUpdatableQuery_EXPERIMENTAL = _require2.readUpdatableQuery_EXPERIMENTAL;
+
+var invariant = require('invariant');
 /**
  * @internal
  *
@@ -24,6 +26,8 @@ var _require = require('../store/RelayStoreUtils'),
  * complex arguments and it can be tedious to re-construct the correct sets of
  * arguments to pass to e.g. `getRoot().getLinkedRecord()`.
  */
+
+
 var RelayRecordSourceSelectorProxy = /*#__PURE__*/function () {
   function RelayRecordSourceSelectorProxy(mutator, recordSource, readSelector) {
     this.__mutator = mutator;
@@ -91,6 +95,10 @@ var RelayRecordSourceSelectorProxy = /*#__PURE__*/function () {
     this.__recordSource.invalidateStore();
   };
 
+  _proto.readUpdatableQuery_EXPERIMENTAL = function readUpdatableQuery_EXPERIMENTAL(query, variables) {
+    return _readUpdatableQuery_EXPERIMENTAL(query, variables, this);
+  };
+
   return RelayRecordSourceSelectorProxy;
 }();
 

package/lib/mutations/applyOptimisticMutation.js

@@ -10,18 +10,18 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
-
-var invariant = require('invariant');
-
-var isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
-
 var _require = require('../query/GraphQLTag'),
     getRequest = _require.getRequest;
 
+var isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
+
 var _require2 = require('../store/RelayModernOperationDescriptor'),
     createOperationDescriptor = _require2.createOperationDescriptor;
 
+var RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
+
+var invariant = require('invariant');
+
 /**
  * Higher-level helper function to execute a mutation against a specific
  * environment.

package/lib/mutations/commitMutation.js

@@ -14,25 +14,25 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
-var RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
-
-var invariant = require('invariant');
-
-var isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
-
-var validateMutation = require('./validateMutation');
-
-var warning = require("fbjs/lib/warning");
-
 var _require = require('../query/GraphQLTag'),
     getRequest = _require.getRequest;
 
 var _require2 = require('../store/ClientID'),
     generateUniqueClientID = _require2.generateUniqueClientID;
 
+var isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
+
 var _require3 = require('../store/RelayModernOperationDescriptor'),
     createOperationDescriptor = _require3.createOperationDescriptor;
 
+var RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
+
+var validateMutation = require('./validateMutation');
+
+var invariant = require('invariant');
+
+var warning = require("fbjs/lib/warning");
+
 /**
  * Higher-level helper function to execute a mutation against a specific
  * environment.
@@ -58,10 +58,7 @@ function commitMutation(environment, config) {
       onUnsubscribe = config.onUnsubscribe,
       variables = config.variables,
       uploadables = config.uploadables;
-  var operation = createOperationDescriptor(mutation,
-  /* $FlowFixMe[class-object-subtyping] added when improving typing for this
-   * parameters */
-  variables, cacheConfig, generateUniqueClientID()); // TODO: remove this check after we fix flow.
+  var operation = createOperationDescriptor(mutation, variables, cacheConfig, generateUniqueClientID()); // TODO: remove this check after we fix flow.
 
   if (typeof optimisticResponse === 'function') {
     optimisticResponse = optimisticResponse();
@@ -90,6 +87,8 @@ function commitMutation(environment, config) {
     uploadables: uploadables
   }).subscribe({
     next: function next(payload) {
+      var _config$onNext;
+
       if (Array.isArray(payload)) {
         payload.forEach(function (item) {
           if (item.errors) {
@@ -101,6 +100,8 @@ function commitMutation(environment, config) {
           errors.push.apply(errors, (0, _toConsumableArray2["default"])(payload.errors));
         }
       }
+
+      (_config$onNext = config.onNext) === null || _config$onNext === void 0 ? void 0 : _config$onNext.call(config);
     },
     complete: function complete() {
       var onCompleted = config.onCompleted;

package/lib/mutations/readUpdatableQuery_EXPERIMENTAL.js

@@ -0,0 +1,238 @@
+/**
+ * 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.
+ *
+ * 
+ * @emails oncall+relay
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var _require = require('../query/GraphQLTag'),
+    getRequest = _require.getRequest;
+
+var _require2 = require('../store/RelayStoreUtils'),
+    getArgumentValues = _require2.getArgumentValues;
+
+var nonUpdatableKeys = ['id', '__id', '__typename'];
+
+function readUpdatableQuery_EXPERIMENTAL(query, variables, proxy) {
+  // TODO assert that the concrete request is an updatable query
+  var request = getRequest(query);
+  var updatableProxy = {};
+  updateProxyFromSelections(updatableProxy, proxy.getRoot(), variables, request.fragment.selections, proxy);
+
+  if (process.env.NODE_ENV !== "production") {
+    Object.freeze(updatableProxy);
+  }
+
+  return updatableProxy;
+}
+
+function updateProxyFromSelections(mutableUpdatableProxy, recordProxy, queryVariables, selections, root) {
+  var _selection$alias, _selection$alias2;
+
+  var _iterator = (0, _createForOfIteratorHelper2["default"])(selections),
+      _step;
+
+  try {
+    var _loop = function _loop() {
+      var selection = _step.value;
+
+      switch (selection.kind) {
+        case 'LinkedField':
+          // Linked fields are assignable if they contain fragment spreads or
+          // read-only otherwise.
+          var isAssignable = selection.selections.some(function (item) {
+            return item.kind === 'FragmentSpread';
+          });
+          var set = !isAssignable ? undefined : selection.plural ? createSetterForPluralLinkedField(selection, queryVariables, recordProxy, root) : createSetterForSingularLinkedField(selection, queryVariables, recordProxy, root);
+          var get = selection.plural ? createGetterForPluralLinkedField(selection, queryVariables, recordProxy, root) : createGetterForSingularLinkedField(selection, queryVariables, recordProxy, root);
+          Object.defineProperty(mutableUpdatableProxy, (_selection$alias = selection.alias) !== null && _selection$alias !== void 0 ? _selection$alias : selection.name, {
+            get: get,
+            set: set
+          });
+          break;
+
+        case 'ScalarField':
+          var scalarFieldName = (_selection$alias2 = selection.alias) !== null && _selection$alias2 !== void 0 ? _selection$alias2 : selection.name;
+          Object.defineProperty(mutableUpdatableProxy, scalarFieldName, {
+            get: function get() {
+              var _selection$args;
+
+              var variables = getArgumentValues((_selection$args = selection.args) !== null && _selection$args !== void 0 ? _selection$args : [], queryVariables); // Flow incorrect assumes that the return value for the get method must match
+              // the set parameter.
+
+              return recordProxy.getValue(selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+              variables // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+              );
+            },
+            set: nonUpdatableKeys.includes(selection.name) ? undefined : // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+            function (newValue) {
+              var _selection$args2;
+
+              var variables = getArgumentValues((_selection$args2 = selection.args) !== null && _selection$args2 !== void 0 ? _selection$args2 : [], queryVariables);
+              recordProxy.setValue(newValue, selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+              variables);
+            }
+          });
+          break;
+
+        case 'InlineFragment':
+          if (recordProxy.getType() === selection.type) {
+            updateProxyFromSelections(mutableUpdatableProxy, recordProxy, queryVariables, selection.selections, root);
+          }
+
+          break;
+
+        case 'FragmentSpread':
+          // Explicitly ignore
+          break;
+
+        default:
+          throw new Error('Encountered an unexpected ReaderSelection variant in RelayRecordSourceProxy. This indicates a bug in Relay.');
+      }
+    };
+
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+function createSetterForPluralLinkedField(selection, queryVariables, recordProxy, root) {
+  return function set(newValue) {
+    var _selection$args3;
+
+    var variables = getArgumentValues((_selection$args3 = selection.args) !== null && _selection$args3 !== void 0 ? _selection$args3 : [], queryVariables);
+
+    if (newValue == null) {
+      // $FlowFixMe[unclear-type] No good way to type these variables
+      recordProxy.setValue(null, selection.name, variables);
+    } else {
+      var recordProxies = newValue.map(function (item) {
+        if (item == null) {
+          throw new Error('When assigning an array of items, none of the items should be null or undefined.');
+        }
+
+        var __id = item.__id;
+
+        if (__id == null) {
+          throw new Error('The __id field must be present on each item passed to the setter. This indicates a bug in Relay.');
+        }
+
+        var newValueRecord = root.get(__id);
+
+        if (newValueRecord == null) {
+          throw new Error("Did not find item with data id ".concat(__id, " in the store."));
+        }
+
+        return newValueRecord;
+      });
+      recordProxy.setLinkedRecords(recordProxies, selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+      variables);
+    }
+  };
+}
+
+function createSetterForSingularLinkedField(selection, queryVariables, recordProxy, root) {
+  return function set(newValue) {
+    var _selection$args4;
+
+    var variables = getArgumentValues((_selection$args4 = selection.args) !== null && _selection$args4 !== void 0 ? _selection$args4 : [], queryVariables);
+
+    if (newValue == null) {
+      // $FlowFixMe[unclear-type] No good way to type these variables
+      recordProxy.setValue(null, selection.name, variables);
+    } else {
+      var __id = newValue.__id;
+
+      if (__id == null) {
+        throw new Error('The __id field must be present on the argument. This indicates a bug in Relay.');
+      }
+
+      var newValueRecord = root.get(__id);
+
+      if (newValueRecord == null) {
+        throw new Error("Did not find item with data id ".concat(__id, " in the store."));
+      }
+
+      recordProxy.setLinkedRecord(newValueRecord, selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+      variables);
+    }
+  };
+}
+
+function createGetterForPluralLinkedField(selection, queryVariables, recordProxy, root) {
+  return function () {
+    var _selection$args5;
+
+    var variables = getArgumentValues((_selection$args5 = selection.args) !== null && _selection$args5 !== void 0 ? _selection$args5 : [], queryVariables);
+    var linkedRecords = recordProxy.getLinkedRecords(selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+    variables);
+
+    if (linkedRecords != null) {
+      return linkedRecords.map(function (linkedRecord) {
+        if (linkedRecord != null) {
+          var updatableProxy = {};
+          updateProxyFromSelections(updatableProxy, linkedRecord, queryVariables, selection.selections, root);
+
+          if (process.env.NODE_ENV !== "production") {
+            Object.freeze(updatableProxy);
+          } // Flow incorrect assumes that the return value for the get method must match
+          // the set parameter.
+          // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+
+
+          return updatableProxy;
+        } else {
+          return linkedRecord;
+        } // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+
+      });
+    } else {
+      return linkedRecords;
+    }
+  };
+}
+
+function createGetterForSingularLinkedField(selection, queryVariables, recordProxy, root) {
+  return function () {
+    var _selection$args6;
+
+    var variables = getArgumentValues((_selection$args6 = selection.args) !== null && _selection$args6 !== void 0 ? _selection$args6 : [], queryVariables);
+    var linkedRecord = recordProxy.getLinkedRecord(selection.name, // $FlowFixMe[unclear-type] No good way to type these variables
+    variables);
+
+    if (linkedRecord != null) {
+      var updatableProxy = {};
+      updateProxyFromSelections(updatableProxy, linkedRecord, queryVariables, selection.selections, root);
+
+      if (process.env.NODE_ENV !== "production") {
+        Object.freeze(updatableProxy);
+      } // Flow incorrect assumes that the return value for the get method must match
+      // the set parameter.
+      // $FlowFixMe[unclear-type] Typed by the generated updatable query flow type
+
+
+      return updatableProxy;
+    } else {
+      return linkedRecord;
+    }
+  };
+}
+
+module.exports = {
+  readUpdatableQuery_EXPERIMENTAL: readUpdatableQuery_EXPERIMENTAL
+};

package/lib/mutations/validateMutation.js

@@ -14,16 +14,11 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
-var warning = require("fbjs/lib/warning"); // $FlowFixMe[method-unbinding] added when improving typing for this parameters
-
-
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-
 var _require = require('../util/RelayConcreteNode'),
     ACTOR_CHANGE = _require.ACTOR_CHANGE,
-    CONDITION = _require.CONDITION,
     CLIENT_COMPONENT = _require.CLIENT_COMPONENT,
     CLIENT_EXTENSION = _require.CLIENT_EXTENSION,
+    CONDITION = _require.CONDITION,
     DEFER = _require.DEFER,
     FLIGHT_FIELD = _require.FLIGHT_FIELD,
     FRAGMENT_SPREAD = _require.FRAGMENT_SPREAD,
@@ -36,6 +31,11 @@ var _require = require('../util/RelayConcreteNode'),
     STREAM = _require.STREAM,
     TYPE_DISCRIMINATOR = _require.TYPE_DISCRIMINATOR;
 
+var warning = require("fbjs/lib/warning");
+
+// $FlowFixMe[method-unbinding] added when improving typing for this parameters
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
 var validateMutation = function validateMutation() {};
 
 if (process.env.NODE_ENV !== "production") {

package/lib/network/ConvertToExecuteFunction.js

@@ -11,10 +11,11 @@
 'use strict';
 
 var RelayObservable = require('./RelayObservable');
-
 /**
  * Converts a FetchFunction into an ExecuteFunction for use by RelayNetwork.
  */
+
+
 function convertFetch(fn) {
   return function fetch(request, variables, cacheConfig, uploadables, logRequestInfo) {
     var result = fn(request, variables, cacheConfig, uploadables, logRequestInfo); // Note: We allow FetchFunction to directly return Error to indicate

package/lib/network/RelayNetwork.js

@@ -10,15 +10,16 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require('invariant');
-
 var _require = require('./ConvertToExecuteFunction'),
     convertFetch = _require.convertFetch;
 
+var invariant = require('invariant');
 /**
  * Creates an implementation of the `Network` interface defined in
  * `RelayNetworkTypes` given `fetch` and `subscribe` functions.
  */
+
+
 function create(fetchFn, subscribe) {
   // Convert to functions that returns RelayObservable.
   var observeFetch = convertFetch(fetchFn);

package/lib/network/RelayObservable.js

@@ -332,15 +332,13 @@ var RelayObservable = /*#__PURE__*/function () {
         if (subscriptions.length === 0) {
           sink.complete();
         }
-      } // $FlowFixMe[incompatible-call]
-
+      }
 
       _this7.subscribe({
         start: start,
         next: function next(value) {
           try {
             if (!sink.closed) {
-              // $FlowFixMe[incompatible-call]
               RelayObservable.from(fn(value)).subscribe({
                 start: start,
                 next: sink.next,

package/lib/network/RelayQueryResponseCache.js

@@ -14,10 +14,10 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
-var invariant = require('invariant');
-
 var stableCopy = require('../util/stableCopy');
 
+var invariant = require('invariant');
+
 /**
  * A cache for storing query responses, featuring:
  * - `get` with TTL