relay-runtime 0.0.0-main-605e3666 → 0.0.0-main-0f21ad98

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v0.0.0-main-605e3666
+ * Relay v0.0.0-main-0f21ad98
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/lib/store/experimental-external-state-resolvers/ExternalStateResolverCache.js

@@ -0,0 +1,320 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ * @format
+ */
+// flowlint ambiguous-object-type:error
+'use strict';
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var recycleNodesInto = require('../../util/recycleNodesInto');
+
+var _require = require('../ClientID'),
+    generateClientID = _require.generateClientID;
+
+var RelayModernRecord = require('../RelayModernRecord');
+
+var RelayRecordSource = require('../RelayRecordSource');
+
+var _require2 = require('../RelayStoreUtils'),
+    RELAY_RESOLVER_ERROR_KEY = _require2.RELAY_RESOLVER_ERROR_KEY,
+    RELAY_RESOLVER_INPUTS_KEY = _require2.RELAY_RESOLVER_INPUTS_KEY,
+    RELAY_RESOLVER_INVALIDATION_KEY = _require2.RELAY_RESOLVER_INVALIDATION_KEY,
+    RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY = _require2.RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY,
+    RELAY_RESOLVER_READER_SELECTOR_KEY = _require2.RELAY_RESOLVER_READER_SELECTOR_KEY,
+    RELAY_RESOLVER_VALUE_KEY = _require2.RELAY_RESOLVER_VALUE_KEY,
+    getStorageKey = _require2.getStorageKey;
+
+var ExternalStateResolverStore = require('./ExternalStateResolverStore');
+
+var warning = require("fbjs/lib/warning"); // When this experiment gets promoted to stable, these keys will move into
+// `RelayStoreUtils`.
+
+
+var RELAY_RESOLVER_EXTERNAL_STATE_SUBSCRIPTION_KEY = '__resolverExternalStateSubscription';
+var RELAY_EXTERNAL_STATE_VALUE = '__resolverExternalStateValue';
+var RELAY_EXTERNAL_STATE_DIRTY = '__resolverExternalStateDirty';
+/**
+ * An experimental fork of store/ResolverCache.js intended to let us experiment
+ * with External State Resolvers.
+ */
+
+// $FlowFixMe[unclear-type] - will always be empty
+var emptySet = new Set();
+
+function addDependencyEdge(edges, from, to) {
+  var set = edges.get(from);
+
+  if (!set) {
+    set = new Set();
+    edges.set(from, set);
+  }
+
+  set.add(to);
+}
+
+var ExternalStateResolverCache = /*#__PURE__*/function () {
+  function ExternalStateResolverCache(getRecordSource, store) {
+    this._resolverIDToRecordIDs = new Map();
+    this._recordIDToResolverIDs = new Map();
+    this._getRecordSource = getRecordSource;
+    this._store = store;
+  }
+
+  var _proto = ExternalStateResolverCache.prototype;
+
+  _proto.readFromCacheOrEvaluate = function readFromCacheOrEvaluate(record, field, variables, evaluate, getDataForResolverFragment) {
+    var recordSource = this._getRecordSource();
+
+    var recordID = RelayModernRecord.getDataID(record);
+    var storageKey = getStorageKey(field, variables);
+    var linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);
+    var linkedRecord = linkedID == null ? null : recordSource.get(linkedID);
+
+    if (linkedRecord == null || this._isInvalid(linkedRecord, getDataForResolverFragment)) {
+      var _linkedID;
+
+      // Cache miss; evaluate the selector and store the result in a new record:
+      linkedID = (_linkedID = linkedID) !== null && _linkedID !== void 0 ? _linkedID : generateClientID(recordID, storageKey);
+      linkedRecord = RelayModernRecord.create(linkedID, '__RELAY_RESOLVER__');
+      var evaluationResult = evaluate(); // In the future we we know from the Reader AST node if we are trying to
+      // read a Relay Resolver field or not. For the purpose of this hack, we
+      // will just check if it quacks like a duck.
+
+      var externalState = isExternalStateValue(evaluationResult.resolverResult);
+
+      if (externalState != null) {
+        this._setExternalStateValue(linkedRecord, linkedID, externalState);
+      } else {
+        RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_VALUE_KEY, evaluationResult.resolverResult);
+      }
+
+      RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_INPUTS_KEY, evaluationResult.fragmentValue);
+      RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_READER_SELECTOR_KEY, evaluationResult.readerSelector);
+      RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY, evaluationResult.missingRequiredFields);
+      RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_ERROR_KEY, evaluationResult.errors);
+      recordSource.set(linkedID, linkedRecord); // Link the resolver value record to the resolver field of the record being read:
+
+      var nextRecord = RelayModernRecord.clone(record);
+      RelayModernRecord.setLinkedRecordID(nextRecord, storageKey, linkedID);
+      recordSource.set(RelayModernRecord.getDataID(nextRecord), nextRecord); // Put records observed by the resolver into the dependency graph:
+
+      var resolverID = evaluationResult.resolverID;
+      addDependencyEdge(this._resolverIDToRecordIDs, resolverID, linkedID);
+      addDependencyEdge(this._recordIDToResolverIDs, recordID, resolverID);
+
+      var _iterator = (0, _createForOfIteratorHelper2["default"])(evaluationResult.seenRecordIDs),
+          _step;
+
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var seenRecordID = _step.value;
+          addDependencyEdge(this._recordIDToResolverIDs, seenRecordID, resolverID);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    } else {
+      // If this is an External State Resolver, we might have a cache hit (the
+      // fragment data hasn't changed since we last evaluated the resolver),
+      // but it might still be "dirty" (the external state changed and we need
+      // to call `.read()` again).
+      //
+      // This is currently a bit implicit for now since we rely on the fact that
+      // only External State Resolvers can have `RELAY_EXTERNAL_STATE_DIRTY`
+      // set. However, in the future, we will have a distinct Reader AST node
+      // for External State Resolvers, so we won't have to be so implicit.
+      if (RelayModernRecord.getValue(linkedRecord, RELAY_EXTERNAL_STATE_DIRTY)) {
+        var _linkedID2;
+
+        linkedID = (_linkedID2 = linkedID) !== null && _linkedID2 !== void 0 ? _linkedID2 : generateClientID(recordID, storageKey);
+        linkedRecord = RelayModernRecord.clone(linkedRecord); // $FlowFixMe[incompatible-type] - casting mixed
+
+        var _externalState = RelayModernRecord.getValue(linkedRecord, RELAY_EXTERNAL_STATE_VALUE); // Set the new value for this and future reads.
+
+
+        RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_VALUE_KEY, _externalState.read()); // Mark the resolver as clean again.
+
+        RelayModernRecord.setValue(linkedRecord, RELAY_EXTERNAL_STATE_DIRTY, false);
+        recordSource.set(linkedID, linkedRecord);
+      }
+    } // $FlowFixMe[incompatible-type] - will always be empty
+
+
+    var answer = linkedRecord[RELAY_RESOLVER_VALUE_KEY];
+    var missingRequiredFields = // $FlowFixMe[incompatible-type] - casting mixed
+    linkedRecord[RELAY_RESOLVER_MISSING_REQUIRED_FIELDS_KEY]; // $FlowFixMe[incompatible-type] - casting mixed
+
+    var errors = linkedRecord[RELAY_RESOLVER_ERROR_KEY];
+    return [answer, linkedID, errors, missingRequiredFields];
+  } // Register a new External State object in the store, subscribing to future
+  // updates.
+  ;
+
+  _proto._setExternalStateValue = function _setExternalStateValue(linkedRecord, linkedID, externalState) {
+    // If there's an existing subscription, unsubscribe.
+    // $FlowFixMe[incompatible-type] - casting mixed
+    var previousUnsubscribe = RelayModernRecord.getValue(linkedRecord, RELAY_RESOLVER_EXTERNAL_STATE_SUBSCRIPTION_KEY);
+
+    if (previousUnsubscribe != null) {
+      previousUnsubscribe();
+    } // Subscribe to future values
+
+
+    var handler = this._makeExternalStateHandler(linkedID, externalState);
+
+    var unsubscribe = externalState.subscribe(handler); // Store the external state value for future re-reads.
+
+    RelayModernRecord.setValue(linkedRecord, RELAY_EXTERNAL_STATE_VALUE, externalState); // Store the current value, for this read, and future cached reads.
+
+    RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_VALUE_KEY, externalState.read()); // Mark the field as clean.
+
+    RelayModernRecord.setValue(linkedRecord, RELAY_EXTERNAL_STATE_DIRTY, false); // Store our our unsubscribe function for future cleanup.
+
+    RelayModernRecord.setValue(linkedRecord, RELAY_RESOLVER_EXTERNAL_STATE_SUBSCRIPTION_KEY, unsubscribe);
+  } // Create a callback to handle notifications from the external source that the
+  // value may have changed.
+  ;
+
+  _proto._makeExternalStateHandler = function _makeExternalStateHandler(linkedID, externalState) {
+    var _this = this;
+
+    return function () {
+      var currentSource = _this._getRecordSource();
+
+      var currentRecord = currentSource.get(linkedID);
+
+      if (!currentRecord) {
+        process.env.NODE_ENV !== "production" ? warning(false, 'Expected a resolver record with ID %s, but it was missing.', linkedID) : void 0;
+        return;
+      }
+
+      var nextSource = RelayRecordSource.create();
+      var nextRecord = RelayModernRecord.clone(currentRecord); // Mark the field as dirty. The next time it's read, we will call
+      // `ExternalState.read()`.
+
+      RelayModernRecord.setValue(nextRecord, RELAY_EXTERNAL_STATE_DIRTY, true);
+      nextSource.set(linkedID, nextRecord);
+
+      _this._store.publish(nextSource); // In the future, this notify might be defferred if we are within a
+      // transaction.
+
+
+      _this._store.notify();
+    };
+  };
+
+  _proto.invalidateDataIDs = function invalidateDataIDs(updatedDataIDs) {
+    var recordSource = this._getRecordSource();
+
+    var visited = new Set();
+    var recordsToVisit = Array.from(updatedDataIDs);
+
+    while (recordsToVisit.length) {
+      var recordID = recordsToVisit.pop();
+      updatedDataIDs.add(recordID);
+
+      var _iterator2 = (0, _createForOfIteratorHelper2["default"])((_this$_recordIDToReso = this._recordIDToResolverIDs.get(recordID)) !== null && _this$_recordIDToReso !== void 0 ? _this$_recordIDToReso : emptySet),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _this$_recordIDToReso;
+
+          var fragment = _step2.value;
+
+          if (!visited.has(fragment)) {
+            var _iterator3 = (0, _createForOfIteratorHelper2["default"])((_this$_resolverIDToRe = this._resolverIDToRecordIDs.get(fragment)) !== null && _this$_resolverIDToRe !== void 0 ? _this$_resolverIDToRe : emptySet),
+                _step3;
+
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var _this$_resolverIDToRe;
+
+                var anotherRecordID = _step3.value;
+
+                this._markInvalidatedResolverRecord(anotherRecordID, recordSource);
+
+                if (!visited.has(anotherRecordID)) {
+                  recordsToVisit.push(anotherRecordID);
+                }
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  };
+
+  _proto._markInvalidatedResolverRecord = function _markInvalidatedResolverRecord(dataID, recordSource) // Written to
+  {
+    var record = recordSource.get(dataID);
+
+    if (!record) {
+      process.env.NODE_ENV !== "production" ? warning(false, 'Expected a resolver record with ID %s, but it was missing.', dataID) : void 0;
+      return;
+    }
+
+    var nextRecord = RelayModernRecord.clone(record);
+    RelayModernRecord.setValue(nextRecord, RELAY_RESOLVER_INVALIDATION_KEY, true);
+    recordSource.set(dataID, nextRecord);
+  };
+
+  _proto._isInvalid = function _isInvalid(record, getDataForResolverFragment) {
+    if (!RelayModernRecord.getValue(record, RELAY_RESOLVER_INVALIDATION_KEY)) {
+      return false;
+    }
+
+    var originalInputs = RelayModernRecord.getValue(record, RELAY_RESOLVER_INPUTS_KEY); // $FlowFixMe[incompatible-type] - storing values in records is not typed
+
+    var readerSelector = RelayModernRecord.getValue(record, RELAY_RESOLVER_READER_SELECTOR_KEY);
+
+    if (originalInputs == null || readerSelector == null) {
+      process.env.NODE_ENV !== "production" ? warning(false, 'Expected previous inputs and reader selector on resolver record with ID %s, but they were missing.', RelayModernRecord.getDataID(record)) : void 0;
+      return true;
+    }
+
+    var latestValues = getDataForResolverFragment(readerSelector);
+    var recycled = recycleNodesInto(originalInputs, latestValues);
+
+    if (recycled !== originalInputs) {
+      return true;
+    }
+
+    return false;
+  };
+
+  return ExternalStateResolverCache;
+}(); // In the real implementaiton, we will probably have a special Reader AST node to tell us when
+// a value is external state
+// $FlowFixMe
+
+
+function isExternalStateValue(v) {
+  if (v != null && typeof v.read === 'function' && typeof v.subscribe === 'function') {
+    return v;
+  } else {
+    return null;
+  }
+}
+
+module.exports = {
+  ExternalStateResolverCache: ExternalStateResolverCache
+};