relay-runtime 12.0.0 → 13.0.0

package/lib/store/RelayConcreteVariables.js

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Facebook, Inc. and its affiliates.
+ * 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.
@@ -14,11 +14,10 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 
-var invariant = require('invariant');
-
 var _require = require('./RelayStoreUtils'),
     getArgumentValues = _require.getArgumentValues;
 
+var invariant = require('invariant');
 /**
  * Determines the variables that are in scope for a fragment given the variables
  * in scope at the root query as well as any arguments applied at the fragment
@@ -26,13 +25,14 @@ var _require = require('./RelayStoreUtils'),
  *
  * Note that this is analagous to determining function arguments given a function call.
  */
+
+
 function getFragmentVariables(fragment, rootVariables, argumentVariables) {
   var variables;
   fragment.argumentDefinitions.forEach(function (definition) {
     if (argumentVariables.hasOwnProperty(definition.name)) {
       return;
-    } // $FlowFixMe[cannot-spread-interface]
-
+    }
 
     variables = variables || (0, _objectSpread2["default"])({}, argumentVariables);
 
@@ -52,12 +52,9 @@ function getFragmentVariables(fragment, rootVariables, argumentVariables) {
            * RelayStoreUtils.getStableVariableValue() that variable keys are all
            * present.
            */
-          // $FlowFixMe[incompatible-use]
           variables[definition.name] = undefined;
           break;
-        } // $FlowFixMe[incompatible-use]
-        // $FlowFixMe[cannot-write]
-
+        }
 
         variables[definition.name] = rootVariables[definition.name];
         break;
@@ -80,7 +77,7 @@ function getFragmentVariables(fragment, rootVariables, argumentVariables) {
 function getOperationVariables(operation, variables) {
   var operationVariables = {};
   operation.argumentDefinitions.forEach(function (def) {
-    var value = def.defaultValue; // $FlowFixMe[cannot-write]
+    var value = def.defaultValue;
 
     if (variables[def.name] != null) {
       value = variables[def.name];

package/lib/store/RelayExperimentalGraphResponseHandler.js

@@ -0,0 +1,153 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleGraphModeResponse = handleGraphModeResponse;
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * 
+ * @format
+ */
+var RelayModernRecord = require('./RelayModernRecord');
+
+var invariant = require('invariant');
+/**
+ * Given a stream of GraphMode chunks, populate a MutableRecordSource.
+ */
+
+
+function handleGraphModeResponse(recordSource, response) {
+  var handler = new GraphModeHandler(recordSource);
+  return handler.populateRecordSource(response);
+}
+
+var GraphModeHandler = /*#__PURE__*/function () {
+  function GraphModeHandler(recordSource) {
+    this._recordSource = recordSource;
+    this._streamIdToCacheKey = new Map();
+  }
+
+  var _proto = GraphModeHandler.prototype;
+
+  _proto.populateRecordSource = function populateRecordSource(response) {
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(response),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var chunk = _step.value;
+
+        switch (chunk.$kind) {
+          case 'Record':
+            this._handleRecordChunk(chunk);
+
+            break;
+
+          case 'Extend':
+            {
+              var cacheKey = this._lookupCacheKey(chunk.$streamID);
+
+              var record = this._recordSource.get(cacheKey);
+
+              !(record != null) ? process.env.NODE_ENV !== "production" ? invariant(false, "Expected to have a record for cache key ".concat(cacheKey)) : invariant(false) : void 0;
+
+              this._populateRecord(record, chunk);
+
+              break;
+            }
+
+          case 'Complete':
+            this._streamIdToCacheKey.clear();
+
+            break;
+
+          default:
+            chunk.$kind;
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return this._recordSource;
+  };
+
+  _proto._handleRecordChunk = function _handleRecordChunk(chunk) {
+    var cacheKey = chunk.__id;
+
+    var record = this._recordSource.get(cacheKey);
+
+    if (record == null) {
+      record = RelayModernRecord.create(cacheKey, chunk.__typename);
+
+      this._recordSource.set(cacheKey, record);
+    }
+
+    this._streamIdToCacheKey.set(chunk.$streamID, cacheKey);
+
+    this._populateRecord(record, chunk);
+  };
+
+  _proto._populateRecord = function _populateRecord(parentRecord, chunk) {
+    var _this = this;
+
+    for (var _i = 0, _Object$entries = Object.entries(chunk); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _Object$entries[_i],
+          key = _Object$entries$_i[0],
+          value = _Object$entries$_i[1];
+
+      switch (key) {
+        case '$streamID':
+        case '$kind':
+        case '__typename':
+          break;
+
+        default:
+          if (typeof value !== 'object' || value == null || Array.isArray(value)) {
+            RelayModernRecord.setValue(parentRecord, key, value);
+          } else {
+            if (value.hasOwnProperty('__id')) {
+              // Singular
+              var streamID = value.__id;
+
+              var id = this._lookupCacheKey(streamID);
+
+              RelayModernRecord.setLinkedRecordID(parentRecord, key, id);
+            } else if (value.hasOwnProperty('__ids')) {
+              // Plural
+              var streamIDs = value.__ids;
+              var ids = streamIDs.map(function (sID) {
+                return sID == null ? null : _this._lookupCacheKey(sID);
+              });
+              RelayModernRecord.setLinkedRecordIDs(parentRecord, key, ids);
+            } else {
+              !false ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected object to have either __id or __ids.') : invariant(false) : void 0;
+            }
+          }
+
+      }
+    }
+  };
+
+  _proto._lookupCacheKey = function _lookupCacheKey(streamID) {
+    var cacheKey = this._streamIdToCacheKey.get(streamID);
+
+    !(cacheKey != null) ? process.env.NODE_ENV !== "production" ? invariant(false, "Expected to have a cacheKey for $streamID ".concat(streamID)) : invariant(false) : void 0;
+    return cacheKey;
+  };
+
+  return GraphModeHandler;
+}();

package/lib/store/RelayExperimentalGraphResponseTransform.js

@@ -0,0 +1,391 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeResponse = normalizeResponse;
+
+var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * 
+ * @format
+ */
+var _require = require('../util/RelayConcreteNode'),
+    CLIENT_EXTENSION = _require.CLIENT_EXTENSION,
+    CONDITION = _require.CONDITION,
+    DEFER = _require.DEFER,
+    FRAGMENT_SPREAD = _require.FRAGMENT_SPREAD,
+    INLINE_FRAGMENT = _require.INLINE_FRAGMENT,
+    LINKED_FIELD = _require.LINKED_FIELD,
+    SCALAR_FIELD = _require.SCALAR_FIELD;
+
+var _require2 = require('./RelayConcreteVariables'),
+    getLocalVariables = _require2.getLocalVariables;
+
+var _require3 = require('./RelayModernSelector'),
+    createNormalizationSelector = _require3.createNormalizationSelector;
+
+var _require4 = require('./RelayStoreUtils'),
+    ROOT_TYPE = _require4.ROOT_TYPE,
+    TYPENAME_KEY = _require4.TYPENAME_KEY,
+    getStorageKey = _require4.getStorageKey;
+
+var invariant = require('invariant');
+
+var _require5 = require('relay-runtime'),
+    generateClientID = _require5.generateClientID;
+/**
+ * This module is an experiment to explore a proposal normalized response format for GraphQL.
+ * See the Quip document: Canonical Normalized Response Format (“GraphMode”) Proposal
+ */
+
+/**
+ * # TODO
+ *
+ * - [ ] Compute storage keys using method outlined in the proposal
+ * - [ ] Plural fields
+ * - [ ] Write a utility to populate the store using a GraphMode response.
+ */
+
+
+/**
+ * Converts a JSON response (and Normalization AST) into a stream of GraphMode chunks
+ *
+ * The stream is modeled as a Generator in order to highlight the streaming
+ * nature of the response. Once a chunk is generated, it can be immediately flushed
+ * to the client.
+ *
+ * The response is traversed depth-first, meaning children are emitted before
+ * the parent. This allows parent objects to reference children using their
+ * `$streamID`.
+ *
+ * After each object is traversed, a chunk is emitted. The first time an object
+ * -- identified by its strong ID -- is encountered we emit a `Record`, and its
+ * `$streamID` is recorded. If that same object is encountered again later in
+ * the response, an `Extend` chunk is emitted, which includes any previously
+ * unsent fields. If no unsent fields are present in the second appearance of
+ * the new object, no chunk is emitted.
+ *
+ * ## State
+ *
+ * As we traverse we must maintain some state:
+ *
+ * - The next streamID
+ * - A mapping of cache keys to streamIDs
+ * - The set of fields which we've sent for each streamID. This allows us to
+ *   avoid sending fields twice.
+ */
+function normalizeResponse(response, selector, options) {
+  var node = selector.node,
+      variables = selector.variables,
+      dataID = selector.dataID;
+  var normalizer = new GraphModeNormalizer(variables, options);
+  return normalizer.normalizeResponse(node, dataID, response);
+}
+
+var GraphModeNormalizer = /*#__PURE__*/function () {
+  function GraphModeNormalizer(variables, options) {
+    this._actorIdentifier = options.actorIdentifier;
+    this._path = options.path ? (0, _toConsumableArray2["default"])(options.path) : [];
+    this._getDataID = options.getDataID;
+    this._cacheKeyToStreamID = new Map();
+    this._sentFields = new Map();
+    this._nextStreamID = 0;
+    this._variables = variables;
+  }
+
+  var _proto = GraphModeNormalizer.prototype;
+
+  _proto._getStreamID = function _getStreamID() {
+    return this._nextStreamID++;
+  };
+
+  _proto._getSentFields = function _getSentFields(cacheKey) {
+    var maybeSent = this._sentFields.get(cacheKey);
+
+    if (maybeSent != null) {
+      return maybeSent;
+    }
+
+    var sent = new Set();
+
+    this._sentFields.set(cacheKey, sent);
+
+    return sent;
+  };
+
+  _proto._getObjectType = function _getObjectType(data) {
+    var typeName = data[TYPENAME_KEY];
+    !(typeName != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected a typename for record `%s`.', JSON.stringify(data, null, 2)) : invariant(false) : void 0;
+    return typeName;
+  } // TODO: The GraphMode proposal outlines different approachs to derive keys. We
+  // can expriment with different approaches here.
+  ;
+
+  _proto._getStorageKey = function _getStorageKey(selection) {
+    return getStorageKey(selection, this._variables);
+  };
+
+  _proto._getVariableValue = function _getVariableValue(name) {
+    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'Unexpected undefined variable `%s`.', name) : invariant(false) : void 0;
+    return this._variables[name];
+  };
+
+  _proto.normalizeResponse = function* normalizeResponse(node, dataID, data) {
+    var rootFields = {};
+    yield* this._traverseSelections(node, data, rootFields, dataID, new Set());
+
+    var $streamID = this._getStreamID();
+
+    yield (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, rootFields), {}, {
+      $kind: 'Record',
+      $streamID: $streamID,
+      __id: dataID,
+      __typename: ROOT_TYPE
+    });
+    yield {
+      $kind: 'Complete'
+    };
+  };
+
+  _proto._flushFields = function* _flushFields(cacheKey, typename, fields) {
+    var maybeStreamID = this._cacheKeyToStreamID.get(cacheKey);
+
+    var $streamID = maybeStreamID !== null && maybeStreamID !== void 0 ? maybeStreamID : this._getStreamID();
+
+    if (maybeStreamID == null) {
+      this._cacheKeyToStreamID.set(cacheKey, $streamID); // TODO: We could mutate `fields` rather than constructing a new
+      // chunk object, but it's hard to convince Flow that we've
+      // constructed a valid Chunk, and perf is not important for this
+      // experimental transform
+
+
+      yield (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, fields), {}, {
+        $kind: 'Record',
+        __typename: typename,
+        __id: cacheKey,
+        $streamID: $streamID
+      });
+    } else if (Object.keys(fields).length > 0) {
+      yield (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, fields), {}, {
+        $kind: 'Extend',
+        $streamID: $streamID
+      });
+    }
+
+    return $streamID;
+  };
+
+  _proto._traverseSelections = function* _traverseSelections(node, data, parentFields, parentID, sentFields) {
+    var selections = node.selections;
+
+    var _iterator = (0, _createForOfIteratorHelper2["default"])(selections),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var selection = _step.value;
+
+        switch (selection.kind) {
+          case LINKED_FIELD:
+            {
+              var _selection$alias;
+
+              var responseKey = (_selection$alias = selection.alias) !== null && _selection$alias !== void 0 ? _selection$alias : selection.name;
+              var fieldData = data[responseKey];
+
+              var storageKey = this._getStorageKey(selection);
+
+              this._path.push(responseKey);
+
+              var fieldValue = yield* this._traverseLinkedField(selection.plural, fieldData, storageKey, selection, parentID);
+
+              this._path.pop(); // TODO: We could also opt to confirm that this matches the previously
+              // seen value.
+
+
+              if (sentFields.has(storageKey)) {
+                break;
+              }
+
+              parentFields[storageKey] = fieldValue;
+              sentFields.add(storageKey);
+              break;
+            }
+
+          case SCALAR_FIELD:
+            {
+              var _selection$alias2;
+
+              var _responseKey = (_selection$alias2 = selection.alias) !== null && _selection$alias2 !== void 0 ? _selection$alias2 : selection.name;
+
+              var _storageKey = this._getStorageKey(selection); // TODO: We could also opt to confirm that this matches the previously
+              // seen value.
+
+
+              if (sentFields.has(_storageKey)) {
+                break;
+              }
+
+              var _fieldData = data[_responseKey];
+              parentFields[_storageKey] = _fieldData;
+              sentFields.add(_storageKey);
+              break;
+            }
+
+          case INLINE_FRAGMENT:
+            {
+              var objType = this._getObjectType(data);
+
+              var abstractKey = selection.abstractKey;
+
+              if (abstractKey == null) {
+                if (objType !== selection.type) {
+                  break;
+                }
+              } else if (!data.hasOwnProperty(abstractKey)) {
+                break;
+              }
+
+              yield* this._traverseSelections(selection, data, parentFields, parentID, sentFields);
+              break;
+            }
+
+          case FRAGMENT_SPREAD:
+            {
+              var prevVariables = this._variables;
+              this._variables = getLocalVariables(this._variables, selection.fragment.argumentDefinitions, selection.args);
+              yield* this._traverseSelections(selection.fragment, data, parentFields, parentID, sentFields);
+              this._variables = prevVariables;
+              break;
+            }
+
+          case CONDITION:
+            var conditionValue = Boolean(this._getVariableValue(selection.condition));
+
+            if (conditionValue === selection.passingValue) {
+              yield* this._traverseSelections(selection, data, parentFields, parentID, sentFields);
+            }
+
+            break;
+
+          case DEFER:
+            var isDeferred = selection["if"] === null || this._getVariableValue(selection["if"]);
+
+            if (isDeferred === false) {
+              // If defer is disabled there will be no additional response chunk:
+              // normalize the data already present.
+              yield* this._traverseSelections(selection, data, parentFields, parentID, sentFields);
+            } else {
+              // Otherwise data *for this selection* should not be present: enqueue
+              // metadata to process the subsequent response chunk.
+              this._incrementalPlaceholders.push({
+                kind: 'defer',
+                data: data,
+                label: selection.label,
+                path: (0, _toConsumableArray2["default"])(this._path),
+                selector: createNormalizationSelector(selection, parentID, this._variables),
+                typeName: this._getObjectType(data),
+                actorIdentifier: this._actorIdentifier
+              });
+            }
+
+            break;
+
+          case CLIENT_EXTENSION:
+            // Since we are only expecting to handle server responses, we can skip
+            // over client extensions.
+            break;
+
+          default:
+            throw new Error("Unexpected selection type: ".concat(selection.kind));
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  };
+
+  _proto._traverseLinkedField = function* _traverseLinkedField(plural, fieldData, storageKey, selection, parentID, index) {
+    var _selection$concreteTy;
+
+    if (fieldData == null) {
+      return null;
+    }
+
+    if (plural) {
+      !Array.isArray(fieldData) ? process.env.NODE_ENV !== "production" ? invariant(false, "Expected fieldData to be an array. Got ".concat(JSON.stringify(fieldData))) : invariant(false) : void 0;
+      var fieldValue = [];
+
+      var _iterator2 = (0, _createForOfIteratorHelper2["default"])(fieldData.entries()),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _step2$value = _step2.value,
+              i = _step2$value[0],
+              itemData = _step2$value[1];
+
+          this._path.push(String(i));
+
+          var itemValue = yield* this._traverseLinkedField(false, itemData, storageKey, selection, parentID, i);
+
+          this._path.pop();
+
+          fieldValue.push(itemValue);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+
+      var ids = fieldValue.map(function (value) {
+        if (value == null) {
+          return null;
+        }
+
+        !(typeof value.__id === 'number') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected objects in a plural linked field to have an __id.') : invariant(false) : void 0;
+        return value.__id;
+      });
+      return {
+        __ids: ids
+      };
+    }
+
+    !(typeof fieldData === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected data for field `%s` to be an object.', storageKey) : invariant(false) : void 0;
+    var objType = (_selection$concreteTy = selection.concreteType) !== null && _selection$concreteTy !== void 0 ? _selection$concreteTy : this._getObjectType(fieldData);
+    var nextID = this._getDataID(fieldData, objType) || // Note: In RelayResponseNormalizer we try to access a cached
+    // version of the key before generating a new one. I'm not clear if
+    // that's a performance optimization (which would not be important
+    // here) or important for stable ids.
+    // TODO: The proposal does not yet specify how we handle objects
+    // without strong ids.
+    generateClientID(parentID, storageKey, index);
+    !(typeof nextID === 'string') ? process.env.NODE_ENV !== "production" ? invariant(false, 'Expected id on field `%s` to be a string.', storageKey) : invariant(false) : void 0;
+    var fields = {}; // Yield any decendent record chunks, and mutatively populate direct fields.
+
+    yield* this._traverseSelections(selection, fieldData, fields, nextID, this._getSentFields(nextID));
+    var $streamID = yield* this._flushFields(nextID, objType, fields);
+    return {
+      __id: $streamID
+    };
+  };
+
+  return GraphModeNormalizer;
+}();