relay-runtime 11.0.0-rc.0 → 12.0.0

package/lib/store/RelayPublishQueue.js

@@ -10,7 +10,7 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var ErrorUtils = require("fbjs/lib/ErrorUtils");
+var _global$ErrorUtils$ap, _global, _global$ErrorUtils;
 
 var RelayReader = require('./RelayReader');
 
@@ -22,10 +22,13 @@ var RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');
 
 var RelayRecordSourceSelectorProxy = require('../mutations/RelayRecordSourceSelectorProxy');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var warning = require("fbjs/lib/warning");
 
+var applyWithGuard = (_global$ErrorUtils$ap = (_global = global) === null || _global === void 0 ? void 0 : (_global$ErrorUtils = _global.ErrorUtils) === null || _global$ErrorUtils === void 0 ? void 0 : _global$ErrorUtils.applyWithGuard) !== null && _global$ErrorUtils$ap !== void 0 ? _global$ErrorUtils$ap : function (callback, context, args, onError, name) {
+  return callback.apply(context, args);
+};
 /**
  * Coordinates the concurrent modification of a `Store` due to optimistic and
  * non-revertable client updates and server payloads:
@@ -37,6 +40,7 @@ var warning = require("fbjs/lib/warning");
  *   - Executes handlers for "handle" fields.
  *   - Reverts and reapplies pending optimistic updates.
  */
+
 var RelayPublishQueue = /*#__PURE__*/function () {
   // True if the next `run()` should apply the backup and rerun all optimistic
   // updates performing a rebase.
@@ -145,11 +149,25 @@ var RelayPublishQueue = /*#__PURE__*/function () {
   ;
 
   _proto.run = function run(sourceOperation) {
+    var runWillClearGcHold = this._appliedOptimisticUpdates === 0 && !!this._gcHold;
+    var runIsANoop = // this._pendingBackupRebase is true if an applied optimistic
+    // update has potentially been reverted or if this._pendingData is not empty.
+    !this._pendingBackupRebase && this._pendingOptimisticUpdates.size === 0 && !runWillClearGcHold;
+
     if (process.env.NODE_ENV !== "production") {
+      process.env.NODE_ENV !== "production" ? warning(!runIsANoop, 'RelayPublishQueue.run was called, but the call would have been a noop.') : void 0;
       process.env.NODE_ENV !== "production" ? warning(this._isRunning !== true, 'A store update was detected within another store update. Please ' + "make sure new store updates aren't being executed within an " + 'updater function for a different update.') : void 0;
       this._isRunning = true;
     }
 
+    if (runIsANoop) {
+      if (process.env.NODE_ENV !== "production") {
+        this._isRunning = false;
+      }
+
+      return [];
+    }
+
     if (this._pendingBackupRebase) {
       if (this._hasStoreSnapshot) {
         this._store.restore();
@@ -259,7 +277,7 @@ var RelayPublishQueue = /*#__PURE__*/function () {
         var sink = RelayRecordSource.create();
         var mutator = new RelayRecordSourceMutator(_this2._store.getSource(), sink);
         var recordSourceProxy = new RelayRecordSourceProxy(mutator, _this2._getDataID);
-        ErrorUtils.applyWithGuard(updater, null, [recordSourceProxy], null, 'RelayPublishQueue:commitData');
+        applyWithGuard(updater, null, [recordSourceProxy], null, 'RelayPublishQueue:commitData');
         invalidatedStore = invalidatedStore || recordSourceProxy.isStoreMarkedForInvalidation();
         var idsMarkedForInvalidation = recordSourceProxy.getIDsMarkedForInvalidation();
 
@@ -288,23 +306,27 @@ var RelayPublishQueue = /*#__PURE__*/function () {
     var processUpdate = function processUpdate(optimisticUpdate) {
       if (optimisticUpdate.storeUpdater) {
         var storeUpdater = optimisticUpdate.storeUpdater;
-        ErrorUtils.applyWithGuard(storeUpdater, null, [recordSourceProxy], null, 'RelayPublishQueue:applyUpdates');
+        applyWithGuard(storeUpdater, null, [recordSourceProxy], null, 'RelayPublishQueue:applyUpdates');
       } else {
         var operation = optimisticUpdate.operation,
             payload = optimisticUpdate.payload,
             updater = optimisticUpdate.updater;
         var source = payload.source,
             fieldPayloads = payload.fieldPayloads;
-        var recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(mutator, recordSourceProxy, operation.fragment);
-        var selectorData;
 
         if (source) {
           recordSourceProxy.publishSource(source, fieldPayloads);
-          selectorData = lookupSelector(source, operation.fragment);
         }
 
         if (updater) {
-          ErrorUtils.applyWithGuard(updater, null, [recordSourceSelectorProxy, selectorData], null, 'RelayPublishQueue:applyUpdates');
+          var selectorData;
+
+          if (source) {
+            selectorData = lookupSelector(source, operation.fragment);
+          }
+
+          var recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(mutator, recordSourceProxy, operation.fragment);
+          applyWithGuard(updater, null, [recordSourceSelectorProxy, selectorData], null, 'RelayPublishQueue:applyUpdates');
         }
       }
     }; // rerun all updaters in case we are running a rebase

package/lib/store/RelayReader.js

@@ -10,13 +10,20 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var ClientID = require('./ClientID');
+
 var RelayFeatureFlags = require('../util/RelayFeatureFlags');
 
 var RelayModernRecord = require('./RelayModernRecord');
 
-var invariant = require("fbjs/lib/invariant");
+var invariant = require('invariant');
 
 var _require = require('../util/RelayConcreteNode'),
+    ACTOR_CHANGE = _require.ACTOR_CHANGE,
     CLIENT_EXTENSION = _require.CLIENT_EXTENSION,
     CONDITION = _require.CONDITION,
     DEFER = _require.DEFER,
@@ -27,6 +34,7 @@ var _require = require('../util/RelayConcreteNode'),
     LINKED_FIELD = _require.LINKED_FIELD,
     MODULE_IMPORT = _require.MODULE_IMPORT,
     REQUIRED_FIELD = _require.REQUIRED_FIELD,
+    RELAY_RESOLVER = _require.RELAY_RESOLVER,
     SCALAR_FIELD = _require.SCALAR_FIELD,
     STREAM = _require.STREAM;
 
@@ -45,11 +53,17 @@ var _require3 = require('./RelayStoreUtils'),
     getStorageKey = _require3.getStorageKey,
     getModuleComponentKey = _require3.getModuleComponentKey;
 
-var _require4 = require('./TypeID'),
-    generateTypeID = _require4.generateTypeID;
+var _require4 = require('./ResolverCache'),
+    NoopResolverCache = _require4.NoopResolverCache;
+
+var _require5 = require('./ResolverFragments'),
+    withResolverContext = _require5.withResolverContext;
 
-function read(recordSource, selector) {
-  var reader = new RelayReader(recordSource, selector);
+var _require6 = require('./TypeID'),
+    generateTypeID = _require6.generateTypeID;
+
+function read(recordSource, selector, resolverCache) {
+  var reader = new RelayReader(recordSource, selector, resolverCache !== null && resolverCache !== void 0 ? resolverCache : new NoopResolverCache());
   return reader.read();
 }
 /**
@@ -58,7 +72,7 @@ function read(recordSource, selector) {
 
 
 var RelayReader = /*#__PURE__*/function () {
-  function RelayReader(recordSource, selector) {
+  function RelayReader(recordSource, selector, resolverCache) {
     this._isMissingData = false;
     this._isWithinUnmatchedTypeRefinement = false;
     this._missingRequiredFields = null;
@@ -67,6 +81,7 @@ var RelayReader = /*#__PURE__*/function () {
     this._seenRecords = new Set();
     this._selector = selector;
     this._variables = selector.variables;
+    this._resolverCache = resolverCache;
   }
 
   var _proto = RelayReader.prototype;
@@ -95,7 +110,15 @@ var RelayReader = /*#__PURE__*/function () {
     if (isDataExpectedToBePresent && abstractKey == null && record != null) {
       var recordType = RelayModernRecord.getType(record);
 
-      if (recordType !== node.type && dataID !== ROOT_ID) {
+      if (recordType !== node.type && // The root record type is a special `__Root` type and may not match the
+      // type on the ast, so ignore type mismatches at the root.
+      // We currently detect whether we're at the root by checking against ROOT_ID,
+      // but this does not work for mutations/subscriptions which generate unique
+      // root ids. This is acceptable in practice as we don't read data for mutations/
+      // subscriptions in a situation where we would use isMissingData to decide whether
+      // to suspend or not.
+      // TODO T96653810: Correctly detect reading from root of mutation/subscription
+      dataID !== ROOT_ID) {
         isDataExpectedToBePresent = false;
       }
     } // If this is an abstract fragment (and the precise refinement GK is enabled)
@@ -104,7 +127,7 @@ var RelayReader = /*#__PURE__*/function () {
     // the interface, that itself constitutes "expected" data being missing.
 
 
-    if (isDataExpectedToBePresent && abstractKey != null && record != null && RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+    if (isDataExpectedToBePresent && abstractKey != null && record != null) {
       var _recordType = RelayModernRecord.getType(record);
 
       var typeID = generateTypeID(_recordType);
@@ -156,7 +179,8 @@ var RelayReader = /*#__PURE__*/function () {
   };
 
   _proto._getVariableValue = function _getVariableValue(name) {
-    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReader(): Undefined variable `%s`.', name) : invariant(false) : void 0;
+    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReader(): Undefined variable `%s`.', name) : invariant(false) : void 0; // $FlowFixMe[cannot-write]
+
     return this._variables[name];
   };
 
@@ -245,7 +269,7 @@ var RelayReader = /*#__PURE__*/function () {
           break;
 
         case CONDITION:
-          var conditionValue = this._getVariableValue(selection.condition);
+          var conditionValue = Boolean(this._getVariableValue(selection.condition));
 
           if (conditionValue === selection.passingValue) {
             var hasExpectedData = this._traverseSelections(selection.selections, record, data);
@@ -272,7 +296,7 @@ var RelayReader = /*#__PURE__*/function () {
                   return false;
                 }
               }
-            } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
+            } else {
               // Similar to the logic in read(): data is only expected to be present
               // if the record is known to conform to the interface. If we don't know
               // whether the type conforms or not, that constitutes missing data.
@@ -300,15 +324,22 @@ var RelayReader = /*#__PURE__*/function () {
                 // Don't know if the type implements the interface or not
                 this._isMissingData = true;
               }
-            } else {
-              // legacy behavior for abstract refinements: always read even
-              // if the type doesn't conform and don't reset isMissingData
-              this._traverseSelections(selection.selections, record, data);
             }
 
             break;
           }
 
+        case RELAY_RESOLVER:
+          {
+            if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+              throw new Error('Relay Resolver fields are not yet supported.');
+            }
+
+            this._readResolverField(selection, record, data);
+
+            break;
+          }
+
         case FRAGMENT_SPREAD:
           this._createFragmentPointer(selection, record, data);
 
@@ -320,7 +351,7 @@ var RelayReader = /*#__PURE__*/function () {
           break;
 
         case INLINE_DATA_FRAGMENT_SPREAD:
-          this._createInlineDataFragmentPointer(selection, record, data);
+          this._createInlineDataOrResolverFragmentPointer(selection, record, data);
 
           break;
 
@@ -360,6 +391,11 @@ var RelayReader = /*#__PURE__*/function () {
 
           break;
 
+        case ACTOR_CHANGE:
+          this._readActorChange(selection, record, data);
+
+          break;
+
         default:
           selection;
           !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReader(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;
@@ -381,12 +417,95 @@ var RelayReader = /*#__PURE__*/function () {
           return this._readLink(selection.field, record, data);
         }
 
+      case RELAY_RESOLVER:
+        if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+          throw new Error('Relay Resolver fields are not yet supported.');
+        }
+
+        this._readResolverField(selection.field, record, data);
+
+        break;
+
       default:
         selection.field.kind;
         !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReader(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;
     }
   };
 
+  _proto._readResolverField = function _readResolverField(field, record, data) {
+    var _this = this;
+
+    var resolverModule = field.resolverModule,
+        fragment = field.fragment;
+    var storageKey = getStorageKey(field, this._variables);
+    var resolverID = ClientID.generateClientID(RelayModernRecord.getDataID(record), storageKey); // Found when reading the resolver fragment, which can happen either when
+    // evaluating the resolver and it calls readFragment, or when checking if the
+    // inputs have changed since a previous evaluation:
+
+    var fragmentValue;
+    var fragmentReaderSelector;
+    var fragmentSeenRecordIDs = new Set();
+
+    var getDataForResolverFragment = function getDataForResolverFragment(singularReaderSelector) {
+      if (fragmentValue != null) {
+        // It was already read when checking for input staleness; no need to read it again.
+        // Note that the variables like fragmentSeenRecordIDs in the outer closure will have
+        // already been set and will still be used in this case.
+        return fragmentValue;
+      }
+
+      fragmentReaderSelector = singularReaderSelector;
+      var existingSeenRecords = _this._seenRecords;
+
+      try {
+        var _resolverFragmentData;
+
+        _this._seenRecords = fragmentSeenRecordIDs;
+        var resolverFragmentData = {};
+
+        _this._createInlineDataOrResolverFragmentPointer(singularReaderSelector.node, record, resolverFragmentData);
+
+        fragmentValue = (_resolverFragmentData = resolverFragmentData[FRAGMENTS_KEY]) === null || _resolverFragmentData === void 0 ? void 0 : _resolverFragmentData[fragment.name];
+        !(typeof fragmentValue === 'object' && fragmentValue !== null) ? process.env.NODE_ENV !== "production" ? invariant(false, "Expected reader data to contain a __fragments property with a property for the fragment named ".concat(fragment.name, ", but it is missing.")) : invariant(false) : void 0;
+        return fragmentValue;
+      } finally {
+        _this._seenRecords = existingSeenRecords;
+      }
+    };
+
+    var resolverContext = {
+      getDataForResolverFragment: getDataForResolverFragment
+    };
+
+    var _this$_resolverCache$ = this._resolverCache.readFromCacheOrEvaluate(record, field, this._variables, function () {
+      var key = {
+        __id: RelayModernRecord.getDataID(record),
+        __fragmentOwner: _this._owner,
+        __fragments: (0, _defineProperty2["default"])({}, fragment.name, {})
+      };
+      return withResolverContext(resolverContext, function () {
+        // $FlowFixMe[prop-missing] - resolver module's type signature is a lie
+        var resolverResult = resolverModule(key);
+        return {
+          resolverResult: resolverResult,
+          fragmentValue: fragmentValue,
+          resolverID: resolverID,
+          seenRecordIDs: fragmentSeenRecordIDs,
+          readerSelector: fragmentReaderSelector
+        };
+      });
+    }, getDataForResolverFragment),
+        result = _this$_resolverCache$[0],
+        seenRecord = _this$_resolverCache$[1];
+
+    if (seenRecord != null) {
+      this._seenRecords.add(seenRecord);
+    }
+
+    data[storageKey] = result;
+    return result;
+  };
+
   _proto._readFlightField = function _readFlightField(field, record, data) {
     var _field$alias;
 
@@ -464,13 +583,45 @@ var RelayReader = /*#__PURE__*/function () {
     return value;
   };
 
-  _proto._readPluralLink = function _readPluralLink(field, record, data) {
-    var _this = this;
-
+  _proto._readActorChange = function _readActorChange(field, record, data) {
     var _field$alias4;
 
     var applicationName = (_field$alias4 = field.alias) !== null && _field$alias4 !== void 0 ? _field$alias4 : field.name;
     var storageKey = getStorageKey(field, this._variables);
+    var externalRef = RelayModernRecord.getActorLinkedRecordID(record, storageKey);
+
+    if (externalRef == null) {
+      data[applicationName] = externalRef;
+
+      if (externalRef === undefined) {
+        this._isMissingData = true;
+      }
+
+      return data[applicationName];
+    }
+
+    var actorIdentifier = externalRef[0],
+        dataID = externalRef[1];
+    var fragmentRef = {};
+
+    this._createFragmentPointer(field.fragmentSpread, {
+      __id: dataID
+    }, fragmentRef);
+
+    data[applicationName] = {
+      __fragmentRef: fragmentRef,
+      __viewer: actorIdentifier
+    };
+    return data[applicationName];
+  };
+
+  _proto._readPluralLink = function _readPluralLink(field, record, data) {
+    var _this2 = this;
+
+    var _field$alias5;
+
+    var applicationName = (_field$alias5 = field.alias) !== null && _field$alias5 !== void 0 ? _field$alias5 : field.name;
+    var storageKey = getStorageKey(field, this._variables);
     var linkedIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);
 
     if (linkedIDs == null) {
@@ -489,7 +640,7 @@ var RelayReader = /*#__PURE__*/function () {
     linkedIDs.forEach(function (linkedID, nextIndex) {
       if (linkedID == null) {
         if (linkedID === undefined) {
-          _this._isMissingData = true;
+          _this2._isMissingData = true;
         } // $FlowFixMe[cannot-write]
 
 
@@ -501,7 +652,7 @@ var RelayReader = /*#__PURE__*/function () {
       !(prevItem == null || typeof prevItem === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'RelayReader(): Expected data for field `%s` on record `%s` ' + 'to be an object, got `%s`.', applicationName, RelayModernRecord.getDataID(record), prevItem) : invariant(false) : void 0; // $FlowFixMe[cannot-write]
       // $FlowFixMe[incompatible-variance]
 
-      linkedArray[nextIndex] = _this._traverse(field, linkedID, prevItem);
+      linkedArray[nextIndex] = _this2._traverse(field, linkedID, prevItem);
     });
     data[applicationName] = linkedArray;
     return linkedArray;
@@ -534,7 +685,7 @@ var RelayReader = /*#__PURE__*/function () {
     this._createFragmentPointer({
       kind: 'FragmentSpread',
       name: moduleImport.fragmentName,
-      args: null
+      args: moduleImport.args
     }, record, data);
 
     data[FRAGMENT_PROP_NAME_KEY] = moduleImport.fragmentPropName;
@@ -557,13 +708,10 @@ var RelayReader = /*#__PURE__*/function () {
 
     fragmentPointers[fragmentSpread.name] = fragmentSpread.args ? getArgumentValues(fragmentSpread.args, this._variables) : {};
     data[FRAGMENT_OWNER_KEY] = this._owner;
-
-    if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {
-      data[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] = this._isWithinUnmatchedTypeRefinement;
-    }
+    data[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] = this._isWithinUnmatchedTypeRefinement;
   };
 
-  _proto._createInlineDataFragmentPointer = function _createInlineDataFragmentPointer(inlineDataFragmentSpread, record, data) {
+  _proto._createInlineDataOrResolverFragmentPointer = function _createInlineDataOrResolverFragmentPointer(fragmentSpreadOrFragment, record, data) {
     var fragmentPointers = data[FRAGMENTS_KEY];
 
     if (fragmentPointers == null) {
@@ -578,10 +726,10 @@ var RelayReader = /*#__PURE__*/function () {
 
     var inlineData = {};
 
-    this._traverseSelections(inlineDataFragmentSpread.selections, record, inlineData); // $FlowFixMe[cannot-write] - writing into read-only field
+    this._traverseSelections(fragmentSpreadOrFragment.selections, record, inlineData); // $FlowFixMe[cannot-write] - writing into read-only field
 
 
-    fragmentPointers[inlineDataFragmentSpread.name] = inlineData;
+    fragmentPointers[fragmentSpreadOrFragment.name] = inlineData;
   };
 
   return RelayReader;

package/lib/store/RelayRecordSource.js

@@ -10,15 +10,99 @@
 // flowlint ambiguous-object-type:error
 'use strict';
 
-var RelayRecordSourceMapImpl = require('./RelayRecordSourceMapImpl');
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var RelayRecordState = require('./RelayRecordState');
+
+var EXISTENT = RelayRecordState.EXISTENT,
+    NONEXISTENT = RelayRecordState.NONEXISTENT,
+    UNKNOWN = RelayRecordState.UNKNOWN;
+/**
+ * An implementation of the `MutableRecordSource` interface (defined in
+ * `RelayStoreTypes`) that holds all records in memory (JS Map).
+ */
 
 var RelayRecordSource = /*#__PURE__*/function () {
   function RelayRecordSource(records) {
-    return RelayRecordSource.create(records);
+    var _this = this;
+
+    this._records = new Map();
+
+    if (records != null) {
+      Object.keys(records).forEach(function (key) {
+        _this._records.set(key, records[key]);
+      });
+    }
   }
 
   RelayRecordSource.create = function create(records) {
-    return new RelayRecordSourceMapImpl(records);
+    return new RelayRecordSource(records);
+  };
+
+  var _proto = RelayRecordSource.prototype;
+
+  _proto.clear = function clear() {
+    this._records = new Map();
+  };
+
+  _proto["delete"] = function _delete(dataID) {
+    this._records.set(dataID, null);
+  };
+
+  _proto.get = function get(dataID) {
+    return this._records.get(dataID);
+  };
+
+  _proto.getRecordIDs = function getRecordIDs() {
+    return Array.from(this._records.keys());
+  };
+
+  _proto.getStatus = function getStatus(dataID) {
+    if (!this._records.has(dataID)) {
+      return UNKNOWN;
+    }
+
+    return this._records.get(dataID) == null ? NONEXISTENT : EXISTENT;
+  };
+
+  _proto.has = function has(dataID) {
+    return this._records.has(dataID);
+  };
+
+  _proto.remove = function remove(dataID) {
+    this._records["delete"](dataID);
+  };
+
+  _proto.set = function set(dataID, record) {
+    this._records.set(dataID, record);
+  };
+
+  _proto.size = function size() {
+    return this._records.size;
+  };
+
+  _proto.toJSON = function toJSON() {
+    var obj = {};
+
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(this._records),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _step.value,
+            key = _step$value[0],
+            value = _step$value[1];
+        obj[key] = value;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return obj;
   };
 
   return RelayRecordSource;