relay-runtime 8.0.0 → 10.0.1

package/lib/store/normalizeRelayPayload.js

@@ -12,7 +12,11 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 var RelayModernRecord = require('./RelayModernRecord');
 
@@ -27,7 +31,7 @@ function normalizeRelayPayload(selector, payload, errors, options) {
   var source = RelayRecordSource.create();
   source.set(selector.dataID, RelayModernRecord.create(selector.dataID, ROOT_TYPE));
   var relayPayload = RelayResponseNormalizer.normalize(source, selector, payload, options);
-  return (0, _objectSpread2["default"])({}, relayPayload, {
+  return _objectSpread({}, relayPayload, {
     errors: errors
   });
 }

package/lib/store/readInlineData.js

@@ -27,7 +27,7 @@ function readInlineData(fragment, fragmentRef) {
     return fragmentRef;
   }
 
-  !(typeof fragmentRef === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'readInlineData(): Expected an object, got `%s`.', typeof fragmentRef) : invariant(false) : void 0; // $FlowFixMe
+  !(typeof fragmentRef === 'object') ? process.env.NODE_ENV !== "production" ? invariant(false, 'readInlineData(): Expected an object, got `%s`.', typeof fragmentRef) : invariant(false) : void 0; // $FlowFixMe[incompatible-use]
 
   var inlineData = (_fragmentRef$FRAGMENT = fragmentRef[FRAGMENTS_KEY]) === null || _fragmentRef$FRAGMENT === void 0 ? void 0 : _fragmentRef$FRAGMENT[inlineDataFragment.name];
   !(inlineData != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'readInlineData(): Expected fragment `%s` to be spread in the parent ' + 'fragment.', inlineDataFragment.name) : invariant(false) : void 0;

package/lib/subscription/requestSubscription.js

@@ -31,7 +31,8 @@ function requestSubscription(environment, config) {
       onCompleted = config.onCompleted,
       onError = config.onError,
       onNext = config.onNext,
-      variables = config.variables;
+      variables = config.variables,
+      cacheConfig = config.cacheConfig;
   var operation = createOperationDescriptor(subscription, variables);
   process.env.NODE_ENV !== "production" ? warning(!(config.updater && configs), 'requestSubscription: Expected only one of `updater` and `configs` to be provided') : void 0;
 
@@ -42,9 +43,10 @@ function requestSubscription(environment, config) {
 
   var sub = environment.execute({
     operation: operation,
-    updater: updater
+    updater: updater,
+    cacheConfig: cacheConfig
   }).map(function () {
-    var data = environment.lookup(operation.fragment).data; // $FlowFixMe
+    var data = environment.lookup(operation.fragment).data; // $FlowFixMe[incompatible-cast]
 
     return data;
   }).subscribe({

package/lib/util/RelayConcreteNode.js

@@ -11,15 +11,17 @@
 'use strict';
 
 /**
- * Represents a common GraphQL request with `text` (or persisted `id`) can be
- * used to execute it, an `operation` containing information to normalize the
- * results, and a `fragment` derived from that operation to read the response
- * data (masking data from child fragments).
+ * Represents a common GraphQL request that can be executed, an `operation`
+ * containing information to normalize the results, and a `fragment` derived
+ * from that operation to read the response data (masking data from child
+ * fragments).
  */
 
 /**
- * Contains the `text` (or persisted `id`) required for executing a common
- * GraphQL request.
+ * Contains the parameters required for executing a GraphQL request.
+ * The operation can either be provided as a persisted `id` or `text`. If given
+ * in `text` format, a `cacheID` as a hash of the text should be set to be used
+ * for local caching.
  */
 var RelayConcreteNode = {
   CONDITION: 'Condition',
@@ -45,6 +47,7 @@ var RelayConcreteNode = {
   SCALAR_HANDLE: 'ScalarHandle',
   SPLIT_OPERATION: 'SplitOperation',
   STREAM: 'Stream',
+  TYPE_DISCRIMINATOR: 'TypeDiscriminator',
   VARIABLE: 'Variable'
 };
 module.exports = RelayConcreteNode;

package/lib/util/RelayError.js

@@ -13,19 +13,49 @@
  * @private
  */
 
-function createError(type, name, message) {
-  var error = new Error(message);
-  error.name = name;
-  error.type = type;
-  error.framesToPop = 2;
+function createError(type, name, messageFormat) {
+  for (var _len = arguments.length, messageParams = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+    messageParams[_key - 3] = arguments[_key];
+  }
+
+  var index = 0;
+  var message = messageFormat.replace(/%s/g, function () {
+    return String(messageParams[index++]);
+  });
+  var err = new Error(message);
+  var error = Object.assign(err, {
+    name: name,
+    messageFormat: messageFormat,
+    messageParams: messageParams,
+    type: type,
+    taalOpcodes: [2, 2] // skip frame (code=2) twice
+
+  }); // In V8, Error objects keep the closure scope chain alive until the
+  // err.stack property is accessed.
+
+  if (error.stack === undefined) {
+    // IE sets the stack only if error is thrown
+    try {
+      throw error;
+    } catch (_unused) {}
+  }
+
   return error;
 }
 
 module.exports = {
-  create: function create(name, message) {
-    return createError('mustfix', name, message);
+  create: function create(name, messageFormat) {
+    for (var _len2 = arguments.length, messageParams = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+      messageParams[_key2 - 2] = arguments[_key2];
+    }
+
+    return createError.apply(void 0, ['error', name, messageFormat].concat(messageParams));
   },
-  createWarning: function createWarning(name, message) {
-    return createError('warn', name, message);
+  createWarning: function createWarning(name, messageFormat) {
+    for (var _len3 = arguments.length, messageParams = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+      messageParams[_key3 - 2] = arguments[_key3];
+    }
+
+    return createError.apply(void 0, ['warn', name, messageFormat].concat(messageParams));
   }
 };

package/lib/util/RelayFeatureFlags.js

@@ -13,11 +13,8 @@
 var RelayFeatureFlags = {
   // T45504512: new connection model
   ENABLE_VARIABLE_CONNECTION_KEY: false,
-  ENABLE_CONNECTION_RESOLVERS: false,
   ENABLE_PARTIAL_RENDERING_DEFAULT: false,
-  ENABLE_RELAY_CONTAINERS_SUSPENSE: true,
-  ENABLE_MISSING_VIEWER_FIELD_HANDLER: true,
-  ENABLE_UNIQUE_MUTATION_ROOT: true,
-  USE_RECORD_SOURCE_MAP_IMPL: false
+  ENABLE_RELAY_CONTAINERS_SUSPENSE: false,
+  ENABLE_PRECISE_TYPE_REFINEMENT: false
 };
 module.exports = RelayFeatureFlags;

package/lib/util/RelayReplaySubject.js

@@ -24,9 +24,7 @@ var invariant = require("fbjs/lib/invariant");
  * Records events provided and synchronously plays them back to new subscribers,
  * as well as forwarding new asynchronous events.
  */
-var RelayReplaySubject =
-/*#__PURE__*/
-function () {
+var RelayReplaySubject = /*#__PURE__*/function () {
   function RelayReplaySubject() {
     var _this = this;
 
@@ -130,6 +128,8 @@ function () {
   _proto.unsubscribe = function unsubscribe() {
     if (this._subscription) {
       this._subscription.unsubscribe();
+
+      this._subscription = null;
     }
   };
 

package/lib/util/createPayloadFor3DField.js

@@ -13,14 +13,19 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 var _require = require('../store/RelayStoreUtils'),
     getModuleComponentKey = _require.getModuleComponentKey,
     getModuleOperationKey = _require.getModuleOperationKey;
 
 function createPayloadFor3DField(name, operation, component, response) {
-  var data = (0, _objectSpread2["default"])({}, response);
+  var data = _objectSpread({}, response);
+
   data[getModuleComponentKey(name)] = component;
   data[getModuleOperationKey(name)] = operation;
   return data;

package/lib/util/getRequestIdentifier.js

@@ -19,8 +19,8 @@ var stableCopy = require('./stableCopy');
  * variables.
  */
 function getRequestIdentifier(parameters, variables) {
-  var requestID = parameters.id != null ? parameters.id : parameters.text;
-  !(requestID != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'getRequestIdentifier: Expected request `%s` to have either a ' + 'valid `id` or `text` property', parameters.name) : invariant(false) : void 0;
+  var requestID = parameters.cacheID != null ? parameters.cacheID : parameters.id;
+  !(requestID != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'getRequestIdentifier: Expected request `%s` to have either a ' + 'valid `id` or `cacheID` property', parameters.name) : invariant(false) : void 0;
   return requestID + JSON.stringify(stableCopy(variables));
 }
 

package/lib/util/recycleNodesInto.js

@@ -53,15 +53,11 @@ function recycleNodesInto(prevData, nextData) {
       if (nextValue !== nextObject[key]) {
         if (process.env.NODE_ENV !== "production") {
           if (!Object.isFrozen(nextObject)) {
-            /* $FlowFixMe(>=0.98.0 site=www,mobile,react_native_fb,oss) This
-             * comment suppresses an error found when Flow v0.98 was deployed.
-             * To see the error delete this comment and run Flow. */
+            // $FlowFixMe[cannot-write]
             nextObject[key] = nextValue;
           }
         } else {
-          /* $FlowFixMe(>=0.98.0 site=www,mobile,react_native_fb,oss) This comment
-           * suppresses an error found when Flow v0.98 was deployed. To see
-           * the error delete this comment and run Flow. */
+          // $FlowFixMe[cannot-write]
           nextObject[key] = nextValue;
         }
       }

package/mutations/RelayDeclarativeMutationConfig.js.flow

@@ -0,0 +1,380 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+const ConnectionHandler = require('../handlers/connection/ConnectionHandler');
+
+const warning = require('warning');
+
+import type {
+  RecordSourceSelectorProxy,
+  SelectorData,
+  SelectorStoreUpdater,
+} from '../store/RelayStoreTypes';
+import type {ConcreteRequest} from '../util/RelayConcreteNode';
+import type {Variables} from '../util/RelayRuntimeTypes';
+
+const MutationTypes = Object.freeze({
+  RANGE_ADD: 'RANGE_ADD',
+  RANGE_DELETE: 'RANGE_DELETE',
+  NODE_DELETE: 'NODE_DELETE',
+});
+export type MutationType = $Values<typeof MutationTypes>;
+
+const RangeOperations = Object.freeze({
+  APPEND: 'append',
+  PREPEND: 'prepend',
+});
+export type RangeOperation = $Values<typeof RangeOperations>;
+
+type RangeBehaviorsFunction = (connectionArgs: {
+  [name: string]: $FlowFixMe,
+  ...,
+}) => RangeOperation;
+type RangeBehaviorsObject = {[key: string]: RangeOperation, ...};
+export type RangeBehaviors = RangeBehaviorsFunction | RangeBehaviorsObject;
+
+type RangeAddConfig = {|
+  type: 'RANGE_ADD',
+  parentName?: string,
+  parentID?: string,
+  connectionInfo?: Array<{|
+    key: string,
+    filters?: Variables,
+    rangeBehavior: string,
+  |}>,
+  connectionName?: string,
+  edgeName: string,
+  rangeBehaviors?: RangeBehaviors,
+|};
+
+type RangeDeleteConfig = {|
+  type: 'RANGE_DELETE',
+  parentName?: string,
+  parentID?: string,
+  connectionKeys?: Array<{|
+    key: string,
+    filters?: Variables,
+  |}>,
+  connectionName?: string,
+  deletedIDFieldName: string | Array<string>,
+  pathToConnection: Array<string>,
+|};
+
+type NodeDeleteConfig = {|
+  type: 'NODE_DELETE',
+  parentName?: string,
+  parentID?: string,
+  connectionName?: string,
+  deletedIDFieldName: string,
+|};
+
+export type DeclarativeMutationConfig =
+  | RangeAddConfig
+  | RangeDeleteConfig
+  | NodeDeleteConfig;
+
+function convert(
+  configs: Array<DeclarativeMutationConfig>,
+  request: ConcreteRequest,
+  optimisticUpdater?: ?SelectorStoreUpdater,
+  updater?: ?SelectorStoreUpdater,
+): {
+  optimisticUpdater: SelectorStoreUpdater,
+  updater: SelectorStoreUpdater,
+  ...
+} {
+  const configOptimisticUpdates = optimisticUpdater ? [optimisticUpdater] : [];
+  const configUpdates = updater ? [updater] : [];
+  configs.forEach(config => {
+    switch (config.type) {
+      case 'NODE_DELETE':
+        const nodeDeleteResult = nodeDelete(config, request);
+        if (nodeDeleteResult) {
+          configOptimisticUpdates.push(nodeDeleteResult);
+          configUpdates.push(nodeDeleteResult);
+        }
+        break;
+      case 'RANGE_ADD':
+        const rangeAddResult = rangeAdd(config, request);
+        if (rangeAddResult) {
+          configOptimisticUpdates.push(rangeAddResult);
+          configUpdates.push(rangeAddResult);
+        }
+        break;
+      case 'RANGE_DELETE':
+        const rangeDeleteResult = rangeDelete(config, request);
+        if (rangeDeleteResult) {
+          configOptimisticUpdates.push(rangeDeleteResult);
+          configUpdates.push(rangeDeleteResult);
+        }
+        break;
+    }
+  });
+  return {
+    optimisticUpdater: (
+      store: RecordSourceSelectorProxy,
+      data: ?SelectorData,
+    ) => {
+      configOptimisticUpdates.forEach(eachOptimisticUpdater => {
+        eachOptimisticUpdater(store, data);
+      });
+    },
+    updater: (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+      configUpdates.forEach(eachUpdater => {
+        eachUpdater(store, data);
+      });
+    },
+  };
+}
+
+function nodeDelete(
+  config: NodeDeleteConfig,
+  request: ConcreteRequest,
+): ?SelectorStoreUpdater {
+  const {deletedIDFieldName} = config;
+  const rootField = getRootField(request);
+  if (!rootField) {
+    return null;
+  }
+  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+    const payload = store.getRootField(rootField);
+    if (!payload) {
+      return;
+    }
+    const deleteID = payload.getValue(deletedIDFieldName);
+    const deleteIDs = Array.isArray(deleteID) ? deleteID : [deleteID];
+    deleteIDs.forEach(id => {
+      if (id && typeof id === 'string') {
+        store.delete(id);
+      }
+    });
+  };
+}
+
+function rangeAdd(
+  config: RangeAddConfig,
+  request: ConcreteRequest,
+): ?SelectorStoreUpdater {
+  const {parentID, connectionInfo, edgeName} = config;
+  if (!parentID) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: For mutation config RANGE_ADD ' +
+        'to work you must include a parentID',
+    );
+    return null;
+  }
+  const rootField = getRootField(request);
+  if (!connectionInfo || !rootField) {
+    return null;
+  }
+  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+    const parent = store.get(parentID);
+    if (!parent) {
+      return;
+    }
+    const payload = store.getRootField(rootField);
+    if (!payload) {
+      return;
+    }
+    const serverEdge = payload.getLinkedRecord(edgeName);
+    for (const info of connectionInfo) {
+      if (!serverEdge) {
+        continue;
+      }
+      const connection = ConnectionHandler.getConnection(
+        parent,
+        info.key,
+        info.filters,
+      );
+      if (!connection) {
+        continue;
+      }
+      const clientEdge = ConnectionHandler.buildConnectionEdge(
+        store,
+        connection,
+        serverEdge,
+      );
+      if (!clientEdge) {
+        continue;
+      }
+      switch (info.rangeBehavior) {
+        case 'append':
+          ConnectionHandler.insertEdgeAfter(connection, clientEdge);
+          break;
+        case 'prepend':
+          ConnectionHandler.insertEdgeBefore(connection, clientEdge);
+          break;
+        default:
+          warning(
+            false,
+            'RelayDeclarativeMutationConfig: RANGE_ADD range behavior `%s` ' +
+              'will not work as expected in RelayModern, supported range ' +
+              "behaviors are 'append', 'prepend'.",
+            info.rangeBehavior,
+          );
+          break;
+      }
+    }
+  };
+}
+
+function rangeDelete(
+  config: RangeDeleteConfig,
+  request: ConcreteRequest,
+): ?SelectorStoreUpdater {
+  const {
+    parentID,
+    connectionKeys,
+    pathToConnection,
+    deletedIDFieldName,
+  } = config;
+  if (!parentID) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: For mutation config RANGE_DELETE ' +
+        'to work you must include a parentID',
+    );
+    return null;
+  }
+  const rootField = getRootField(request);
+  if (!rootField) {
+    return null;
+  }
+  return (store: RecordSourceSelectorProxy, data: ?SelectorData) => {
+    if (!data) {
+      return;
+    }
+    const deleteIDs = [];
+    let deletedIDField = data[rootField];
+    if (deletedIDField && Array.isArray(deletedIDFieldName)) {
+      for (const eachField of deletedIDFieldName) {
+        if (deletedIDField && typeof deletedIDField === 'object') {
+          deletedIDField = deletedIDField[eachField];
+        }
+      }
+      if (Array.isArray(deletedIDField)) {
+        deletedIDField.forEach(idObject => {
+          if (
+            idObject &&
+            idObject.id &&
+            typeof idObject === 'object' &&
+            typeof idObject.id === 'string'
+          ) {
+            deleteIDs.push(idObject.id);
+          }
+        });
+      } else if (
+        deletedIDField &&
+        deletedIDField.id &&
+        typeof deletedIDField.id === 'string'
+      ) {
+        deleteIDs.push(deletedIDField.id);
+      }
+    } else if (
+      deletedIDField &&
+      typeof deletedIDFieldName === 'string' &&
+      typeof deletedIDField === 'object'
+    ) {
+      deletedIDField = deletedIDField[deletedIDFieldName];
+      if (typeof deletedIDField === 'string') {
+        deleteIDs.push(deletedIDField);
+      } else if (Array.isArray(deletedIDField)) {
+        deletedIDField.forEach(id => {
+          if (typeof id === 'string') {
+            deleteIDs.push(id);
+          }
+        });
+      }
+    }
+    deleteNode(parentID, connectionKeys, pathToConnection, store, deleteIDs);
+  };
+}
+
+function deleteNode(
+  parentID: string,
+  connectionKeys: ?Array<{|
+    key: string,
+    filters?: Variables,
+  |}>,
+  pathToConnection: Array<string>,
+  store: RecordSourceSelectorProxy,
+  deleteIDs: Array<string>,
+): void {
+  warning(
+    connectionKeys != null,
+    'RelayDeclarativeMutationConfig: RANGE_DELETE must provide a ' +
+      'connectionKeys',
+  );
+  const parent = store.get(parentID);
+  if (!parent) {
+    return;
+  }
+  if (pathToConnection.length < 2) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: RANGE_DELETE ' +
+        'pathToConnection must include at least parent and connection',
+    );
+    return;
+  }
+  let recordProxy = parent;
+  for (let i = 1; i < pathToConnection.length - 1; i++) {
+    if (recordProxy) {
+      recordProxy = recordProxy.getLinkedRecord(pathToConnection[i]);
+    }
+  }
+  // Should never enter loop except edge cases
+  if (!connectionKeys || !recordProxy) {
+    warning(
+      false,
+      'RelayDeclarativeMutationConfig: RANGE_DELETE ' +
+        'pathToConnection is incorrect. Unable to find connection with ' +
+        'parentID: %s and path: %s',
+      parentID,
+      pathToConnection.toString(),
+    );
+    return;
+  }
+  for (const key of connectionKeys) {
+    const connection = ConnectionHandler.getConnection(
+      recordProxy,
+      key.key,
+      key.filters,
+    );
+    if (connection) {
+      deleteIDs.forEach(deleteID => {
+        ConnectionHandler.deleteNode(connection, deleteID);
+      });
+    }
+  }
+}
+
+function getRootField(request: ConcreteRequest): ?string {
+  if (
+    request.fragment.selections &&
+    request.fragment.selections.length > 0 &&
+    request.fragment.selections[0].kind === 'LinkedField'
+  ) {
+    return request.fragment.selections[0].name;
+  }
+  return null;
+}
+
+module.exports = {
+  MutationTypes,
+  RangeOperations,
+
+  convert,
+};