relay-runtime 10.1.3 → 11.0.2

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

@@ -0,0 +1,108 @@
+/**
+ * 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
+ */
+'use strict';
+
+var RelayOperationTracker = require('../store/RelayOperationTracker');
+
+function todo() {
+  throw new Error('Not implementd');
+}
+
+var ActorSpecificEnvironment = /*#__PURE__*/function () {
+  // Actor specific properties
+  function ActorSpecificEnvironment(config) {
+    this.actorIdentifier = config.actorIdentifier;
+    this.multiActorEnvironment = config.multiActorEnvironment;
+    this.__log = config.logFn;
+    this.requiredFieldLogger = config.requiredFieldLogger;
+    this._operationTracker = new RelayOperationTracker();
+    this._store = config.store;
+    this._network = config.network;
+  }
+
+  var _proto = ActorSpecificEnvironment.prototype;
+
+  _proto.UNSTABLE_getDefaultRenderPolicy = function UNSTABLE_getDefaultRenderPolicy() {
+    return todo();
+  };
+
+  _proto.applyMutation = function applyMutation(optimisticConfig) {
+    return this.multiActorEnvironment.applyMutation(this.actorIdentifier, optimisticConfig);
+  };
+
+  _proto.applyUpdate = function applyUpdate(optimisticUpdate) {
+    return this.multiActorEnvironment.applyUpdate(this.actorIdentifier, optimisticUpdate);
+  };
+
+  _proto.check = function check(operation) {
+    return this.multiActorEnvironment.check(this.actorIdentifier, operation);
+  };
+
+  _proto.subscribe = function subscribe(snapshot, callback) {
+    return this.multiActorEnvironment.subscribe(this.actorIdentifier, snapshot, callback);
+  };
+
+  _proto.retain = function retain(operation) {
+    return this.multiActorEnvironment.retain(this.actorIdentifier, operation);
+  };
+
+  _proto.commitUpdate = function commitUpdate(updater) {
+    return this.multiActorEnvironment.commitUpdate(this.actorIdentifier, updater);
+  }
+  /**
+   * Commit a payload to the environment using the given operation selector.
+   */
+  ;
+
+  _proto.commitPayload = function commitPayload(operationDescriptor, payload) {
+    return this.multiActorEnvironment.commitPayload(this.actorIdentifier, operationDescriptor, payload);
+  };
+
+  _proto.getNetwork = function getNetwork() {
+    return this._network;
+  };
+
+  _proto.getStore = function getStore() {
+    return this._store;
+  };
+
+  _proto.getOperationTracker = function getOperationTracker() {
+    return this._operationTracker;
+  };
+
+  _proto.lookup = function lookup(selector) {
+    return this.multiActorEnvironment.lookup(this.actorIdentifier, selector);
+  };
+
+  _proto.execute = function execute(config) {
+    return this.multiActorEnvironment.execute(this.actorIdentifier, config);
+  };
+
+  _proto.executeMutation = function executeMutation(options) {
+    return this.multiActorEnvironment.executeMutation(this.actorIdentifier, options);
+  };
+
+  _proto.executeWithSource = function executeWithSource(options) {
+    return this.multiActorEnvironment.executeWithSource(this.actorIdentifier, options);
+  };
+
+  _proto.isRequestActive = function isRequestActive(requestIdentifier) {
+    return this.multiActorEnvironment.isRequestActive(this.actorIdentifier, requestIdentifier);
+  };
+
+  _proto.isServer = function isServer() {
+    return todo();
+  };
+
+  return ActorSpecificEnvironment;
+}();
+
+module.exports = ActorSpecificEnvironment;

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

@@ -0,0 +1,156 @@
+/**
+ * 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
+ */
+'use strict';
+
+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 RelayPublishQueue = require('../store/RelayPublishQueue');
+
+var RelayRecordSource = require('../store/RelayRecordSource');
+
+var defaultGetDataID = require('../store/defaultGetDataID');
+
+function todo(what) {
+  throw new Error("Not implementd: ".concat(what));
+}
+
+var MultiActorEnvironment = /*#__PURE__*/function () {
+  function MultiActorEnvironment(config) {
+    var _config$getDataID, _config$treatMissingF;
+
+    this._actorEnvironments = new Map();
+    this._createNetworkForActor = config.createNetworkForActor;
+    this._getDataID = (_config$getDataID = config.getDataID) !== null && _config$getDataID !== void 0 ? _config$getDataID : defaultGetDataID;
+    this._handlerProvider = config.handlerProvider ? config.handlerProvider : RelayDefaultHandlerProvider;
+    this._logFn = config.logFn;
+    this._operationExecutions = new Map();
+    this._requiredFieldLogger = config.requiredFieldLogger;
+    this._treatMissingFieldsAsNull = (_config$treatMissingF = config.treatMissingFieldsAsNull) !== null && _config$treatMissingF !== void 0 ? _config$treatMissingF : false;
+  }
+  /**
+   * This method will create an actor specfic environment. It will create a new instance
+   * and store it in the internal maps. If will return a memozied version
+   * of the environment if we already created one for actor.
+   */
+
+
+  var _proto = MultiActorEnvironment.prototype;
+
+  _proto.forActor = function forActor(actorIdentifier) {
+    var environment = this._actorEnvironments.get(actorIdentifier);
+
+    if (environment == null) {
+      var newEnvironment = new ActorSpecificEnvironment({
+        actorIdentifier: actorIdentifier,
+        multiActorEnvironment: this,
+        logFn: this._logFn,
+        requiredFieldLogger: this._requiredFieldLogger,
+        store: new RelayModernStore(RelayRecordSource.create()),
+        network: this._createNetworkForActor(actorIdentifier)
+      });
+
+      this._actorEnvironments.set(actorIdentifier, newEnvironment);
+
+      return newEnvironment;
+    } else {
+      return environment;
+    }
+  };
+
+  _proto.check = function check(actorIdentifier, operation) {
+    return todo('check');
+  };
+
+  _proto.subscribe = function subscribe(actorIdentifier, snapshot, callback) {
+    return todo('subscribe');
+  };
+
+  _proto.retain = function retain(actorIdentifier, operation) {
+    return todo('retain');
+  };
+
+  _proto.applyUpdate = function applyUpdate(actorIdentifier, optimisticUpdate) {
+    return todo('applyUpdate');
+  };
+
+  _proto.applyMutation = function applyMutation(actorIdentifier, optimisticConfig) {
+    return todo('applyMutation');
+  };
+
+  _proto.commitUpdate = function commitUpdate(actorIdentifier, updater) {
+    return todo('commitUpdate');
+  };
+
+  _proto.commitPayload = function commitPayload(actorIdentifier, operationDescriptor, payload) {
+    return todo('commitPayload');
+  };
+
+  _proto.lookup = function lookup(actorIdentifier, selector) {
+    return todo('lookup');
+  };
+
+  _proto.execute = function execute(actorIdentifier, config) {
+    var _this = this;
+
+    var operation = config.operation,
+        updater = config.updater;
+    return RelayObservable.create(function (sink) {
+      var actorEnvironemnt = _this.forActor(actorIdentifier);
+
+      var source = actorEnvironemnt.getNetwork().execute(operation.request.node.params, operation.request.variables, operation.request.cacheConfig || {}, null);
+      var executor = OperationExecutor.execute({
+        operation: operation,
+        operationExecutions: _this._operationExecutions,
+        operationLoader: null,
+        optimisticConfig: null,
+        publishQueue: new RelayPublishQueue(actorEnvironemnt.getStore(), _this._handlerProvider, _this._getDataID),
+        reactFlightPayloadDeserializer: null,
+        reactFlightServerErrorHandler: null,
+        scheduler: null,
+        sink: sink,
+        source: source,
+        store: actorEnvironemnt.getStore(),
+        updater: updater,
+        operationTracker: actorEnvironemnt.getOperationTracker(),
+        getDataID: _this._getDataID,
+        treatMissingFieldsAsNull: _this._treatMissingFieldsAsNull,
+        shouldProcessClientComponents: false
+      });
+      return function () {
+        return executor.cancel();
+      };
+    });
+  };
+
+  _proto.executeMutation = function executeMutation(actorIdentifier, config) {
+    return todo('executeMutation');
+  };
+
+  _proto.executeWithSource = function executeWithSource(actorIdentifier, config) {
+    return todo('executeWithSource');
+  };
+
+  _proto.isRequestActive = function isRequestActive(actorIdentifier, requestIdentifier) {
+    return todo('isRequestActive');
+  };
+
+  return MultiActorEnvironment;
+}();
+
+module.exports = MultiActorEnvironment;

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

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+'use strict';

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

@@ -0,0 +1,17 @@
+/**
+ * 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
+ */
+'use strict';
+
+var MultiActorEnvironment = require('./MultiActorEnvironment');
+
+module.exports = {
+  MultiActorEnvironment: MultiActorEnvironment
+};

package/lib/mutations/RelayRecordProxy.js

@@ -10,7 +10,7 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var _require = require('../store/ClientID'),
     generateClientID = _require.generateClientID;

package/lib/mutations/RelayRecordSourceMutator.js

@@ -12,7 +12,7 @@
 
 var RelayModernRecord = require('../store/RelayModernRecord');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var _require = require('../store/RelayRecordState'),
     EXISTENT = _require.EXISTENT;

package/lib/mutations/RelayRecordSourceProxy.js

@@ -14,7 +14,7 @@ var RelayModernRecord = require('../store/RelayModernRecord');
 
 var RelayRecordProxy = require('./RelayRecordProxy');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var _require = require('../store/RelayRecordState'),
     EXISTENT = _require.EXISTENT,

package/lib/mutations/RelayRecordSourceSelectorProxy.js

@@ -10,7 +10,7 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var _require = require('../store/RelayStoreUtils'),
     getStorageKey = _require.getStorageKey,

package/lib/mutations/applyOptimisticMutation.js

@@ -12,7 +12,7 @@
 
 var RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
 

package/lib/mutations/commitMutation.js

@@ -16,7 +16,7 @@ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers
 
 var RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var isRelayModernEnvironment = require('../store/isRelayModernEnvironment');
 

package/lib/mutations/validateMutation.js

@@ -18,6 +18,22 @@ var warning = require("fbjs/lib/warning");
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 
+var _require = require('../util/RelayConcreteNode'),
+    CONDITION = _require.CONDITION,
+    CLIENT_COMPONENT = _require.CLIENT_COMPONENT,
+    CLIENT_EXTENSION = _require.CLIENT_EXTENSION,
+    DEFER = _require.DEFER,
+    FLIGHT_FIELD = _require.FLIGHT_FIELD,
+    FRAGMENT_SPREAD = _require.FRAGMENT_SPREAD,
+    INLINE_FRAGMENT = _require.INLINE_FRAGMENT,
+    LINKED_FIELD = _require.LINKED_FIELD,
+    LINKED_HANDLE = _require.LINKED_HANDLE,
+    MODULE_IMPORT = _require.MODULE_IMPORT,
+    SCALAR_FIELD = _require.SCALAR_FIELD,
+    SCALAR_HANDLE = _require.SCALAR_HANDLE,
+    STREAM = _require.STREAM,
+    TYPE_DISCRIMINATOR = _require.TYPE_DISCRIMINATOR;
+
 var validateMutation = function validateMutation() {};
 
 if (process.env.NODE_ENV !== "production") {
@@ -60,16 +76,21 @@ if (process.env.NODE_ENV !== "production") {
 
   var validateSelection = function validateSelection(optimisticResponse, selection, context) {
     switch (selection.kind) {
-      case 'Condition':
+      case CONDITION:
         validateSelections(optimisticResponse, selection.selections, context);
         return;
 
-      case 'ScalarField':
-      case 'LinkedField':
-      case 'FlightField':
+      case CLIENT_COMPONENT:
+      case FRAGMENT_SPREAD:
+        validateSelections(optimisticResponse, selection.fragment.selections, context);
+        return;
+
+      case SCALAR_FIELD:
+      case LINKED_FIELD:
+      case FLIGHT_FIELD:
         return validateField(optimisticResponse, selection, context);
 
-      case 'InlineFragment':
+      case INLINE_FRAGMENT:
         var type = selection.type;
         var isConcreteType = selection.abstractKey == null;
         selection.selections.forEach(function (subselection) {
@@ -81,20 +102,20 @@ if (process.env.NODE_ENV !== "production") {
         });
         return;
 
-      case 'ClientExtension':
+      case CLIENT_EXTENSION:
         selection.selections.forEach(function (subselection) {
           validateSelection(optimisticResponse, subselection, context);
         });
         return;
 
-      case 'ModuleImport':
+      case MODULE_IMPORT:
         return validateModuleImport(context);
 
-      case 'LinkedHandle':
-      case 'ScalarHandle':
-      case 'Defer':
-      case 'Stream':
-      case 'TypeDiscriminator':
+      case LINKED_HANDLE:
+      case SCALAR_HANDLE:
+      case DEFER:
+      case STREAM:
+      case TYPE_DISCRIMINATOR:
         {
           // TODO(T35864292) - Add missing validations for these types
           return;
@@ -116,14 +137,14 @@ if (process.env.NODE_ENV !== "production") {
     context.visitedPaths.add(path);
 
     switch (field.kind) {
-      case 'ScalarField':
+      case SCALAR_FIELD:
         if (hasOwnProperty.call(optimisticResponse, fieldName) === false) {
           addFieldToDiff(path, context.missingDiff, true);
         }
 
         return;
 
-      case 'LinkedField':
+      case LINKED_FIELD:
         var selections = field.selections;
 
         if (optimisticResponse[fieldName] === null || hasOwnProperty.call(optimisticResponse, fieldName) && optimisticResponse[fieldName] === undefined) {
@@ -156,7 +177,7 @@ if (process.env.NODE_ENV !== "production") {
           }
         }
 
-      case 'FlightField':
+      case FLIGHT_FIELD:
         if (optimisticResponse[fieldName] === null || hasOwnProperty.call(optimisticResponse, fieldName) && optimisticResponse[fieldName] === undefined) {
           return;
         }

package/lib/network/RelayNetwork.js

@@ -10,7 +10,7 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var _require = require('./ConvertToExecuteFunction'),
     convertFetch = _require.convertFetch;

package/lib/network/RelayQueryResponseCache.js

@@ -14,7 +14,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var stableCopy = require('../util/stableCopy');
 
@@ -53,7 +53,8 @@ var RelayQueryResponseCache = /*#__PURE__*/function () {
 
     var response = this._responses.get(cacheKey);
 
-    return response != null ? (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, response.payload), {}, {
+    return response != null ? // $FlowFixMe[speculation-ambiguous]
+    (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, response.payload), {}, {
       extensions: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, response.payload.extensions), {}, {
         cacheTimestamp: response.fetchTime
       })

package/lib/query/GraphQLTag.js

@@ -12,7 +12,7 @@
 
 var RelayConcreteNode = require('../util/RelayConcreteNode');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var warning = require("fbjs/lib/warning");
 

package/lib/query/fetchQuery.js

@@ -4,12 +4,25 @@
  * 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 _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var RelayObservable = require('../network/RelayObservable');
+
+var fetchQueryInternal = require('./fetchQueryInternal');
+
+var invariant = require('invariant');
+
+var reportMissingRequiredFields = require('../util/reportMissingRequiredFields');
+
 var _require = require('../store/RelayModernOperationDescriptor'),
     createOperationDescriptor = _require.createOperationDescriptor;
 
@@ -17,23 +30,126 @@ var _require2 = require('./GraphQLTag'),
     getRequest = _require2.getRequest;
 
 /**
- * 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.
+ * 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 optionally takes an Observer, which you can provide to
+ * observe network events:
+ *
+ * ```
+ * fetchQuery(environment, query, variables).subscribe({
+ *   // Called when network requests starts
+ *   start: (subsctiption) => {},
+ *
+ *   // 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) => {},
+ * });
+ * ```
+ *
+ * Request Promise:
+ * ================
+ * The obervable can be converted to a Promise with .toPromise(), which will
+ * resolve to a snapshot of the query data when the first response is received
+ * from the server.
+ *
+ * ```
+ * fetchQuery(environment, query, variables).toPromise().then((data) => {
+ *   // ...
+ * });
+ * ```
+ *
+ * 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 query data, meaning that it is not guaranteed
+ * that the fetched data will remain in the Relay store after the request has
+ * completed.
+ * If you need to retain the query data outside of the network request,
+ * you need to use `environment.retain()`.
+ *
+ *
+ * Cancelling requests:
+ * ====================
+ * If the disposable returned by subscribe is called while the
+ * request is in-flight, the request will be cancelled.
+ *
+ * ```
+ * const disposable = fetchQuery(...).subscribe(...);
+ *
+ * // This will cancel the request if it is in-flight.
+ * disposable.dispose();
+ * ```
+ * NOTE: When using .toPromise(), the request cannot be cancelled.
  */
-function fetchQuery(environment, taggedNode, variables, cacheConfig) {
-  var query = getRequest(taggedNode);
+function fetchQuery(environment, query, variables, options) {
+  var _options$fetchPolicy;
+
+  var queryNode = getRequest(query);
+  !(queryNode.params.operationKind === 'query') ? process.env.NODE_ENV !== "production" ? invariant(false, 'fetchQuery: Expected query operation') : invariant(false) : void 0;
+  var networkCacheConfig = (0, _objectSpread2["default"])({
+    force: true
+  }, options === null || options === void 0 ? void 0 : options.networkCacheConfig);
+  var operation = createOperationDescriptor(queryNode, variables, networkCacheConfig);
+  var fetchPolicy = (_options$fetchPolicy = options === null || options === void 0 ? void 0 : options.fetchPolicy) !== null && _options$fetchPolicy !== void 0 ? _options$fetchPolicy : 'network-only';
 
-  if (query.params.operationKind !== 'query') {
-    throw new Error('fetchQuery: Expected query operation');
+  function readData(snapshot) {
+    if (snapshot.missingRequiredFields != null) {
+      reportMissingRequiredFields(environment, snapshot.missingRequiredFields);
+    }
+
+    return snapshot.data;
   }
 
-  var operation = createOperationDescriptor(query, variables, cacheConfig);
-  return environment.execute({
-    operation: operation
-  }).map(function () {
-    return environment.lookup(operation.fragment).data;
-  }).toPromise();
+  switch (fetchPolicy) {
+    case 'network-only':
+      {
+        return getNetworkObservable(environment, operation).map(readData);
+      }
+
+    case 'store-or-network':
+      {
+        if (environment.check(operation).status === 'available') {
+          return RelayObservable.from(environment.lookup(operation.fragment)).map(readData);
+        }
+
+        return getNetworkObservable(environment, operation).map(readData);
+      }
+
+    default:
+      fetchPolicy;
+      throw new Error('fetchQuery: Invalid fetchPolicy ' + fetchPolicy);
+  }
+}
+
+function getNetworkObservable(environment, operation) {
+  return fetchQueryInternal.fetchQuery(environment, operation).map(function () {
+    return environment.lookup(operation.fragment);
+  });
 }
 
 module.exports = fetchQuery;