relay-runtime 0.0.0-main-6b2ec499 → 0.0.0-main-0796537a

package/store/RelayConcreteVariables.js.flow

@@ -124,7 +124,6 @@ function getLocalVariables(
   const nextVariables = {...currentVariables};
   const nextArgs = args ? getArgumentValues(args, currentVariables) : {};
   argumentDefinitions.forEach(def => {
-    // $FlowFixMe[cannot-write]
     const value = nextArgs[def.name] ?? def.defaultValue;
     nextVariables[def.name] = value;
   });

package/store/RelayModernRecord.js.flow

@@ -16,13 +16,17 @@ import type {DataID} from '../util/RelayRuntimeTypes';
 import type {Record} from './RelayStoreTypes';
 
 const deepFreeze = require('../util/deepFreeze');
-const {isClientID} = require('./ClientID');
+const {generateClientObjectClientID, isClientID} = require('./ClientID');
+const {
+  isSuspenseSentinel,
+} = require('./experimental-live-resolvers/LiveResolverSuspenseSentinel');
 const {
   ACTOR_IDENTIFIER_KEY,
   ID_KEY,
   INVALIDATED_AT_KEY,
   REF_KEY,
   REFS_KEY,
+  RELAY_RESOLVER_VALUE_KEY,
   ROOT_ID,
   TYPENAME_KEY,
 } = require('./RelayStoreUtils');
@@ -441,6 +445,56 @@ function getActorLinkedRecordID(
   return [(link[ACTOR_IDENTIFIER_KEY]: any), (link[REF_KEY]: any)];
 }
 
+function getResolverLinkedRecordID(record: Record, typeName: string): ?DataID {
+  let id = getValue(record, RELAY_RESOLVER_VALUE_KEY);
+  if (id == null || isSuspenseSentinel(id)) {
+    return null;
+  }
+  // TODD: Deprecate client edges that return just id.
+  if (typeof id === 'object') {
+    id = id.id;
+  }
+  invariant(
+    typeof id === 'string',
+    'RelayModernRecord.getResolverLinkedRecordID(): Expected value to be a linked ID, ' +
+      'was `%s`.',
+    JSON.stringify(id),
+  );
+  return generateClientObjectClientID(typeName, id);
+}
+
+function getResolverLinkedRecordIDs(
+  record: Record,
+  typeName: string,
+): ?Array<?DataID> {
+  const resolverValue = getValue(record, RELAY_RESOLVER_VALUE_KEY);
+  if (resolverValue == null || isSuspenseSentinel(resolverValue)) {
+    return null;
+  }
+  invariant(
+    Array.isArray(resolverValue),
+    'RelayModernRecord.getResolverLinkedRecordIDs(): Expected value to be an array of linked IDs, ' +
+      'was `%s`.',
+    JSON.stringify(resolverValue),
+  );
+  return resolverValue.map(id => {
+    if (id == null) {
+      return null;
+    }
+    // TODD: Deprecate client edges that return just id.
+    if (typeof id === 'object') {
+      id = id.id;
+    }
+    invariant(
+      typeof id === 'string',
+      'RelayModernRecord.getResolverLinkedRecordIDs(): Expected item within resolver linked field to be a DataID, ' +
+        'was `%s`.',
+      JSON.stringify(id),
+    );
+    return generateClientObjectClientID(typeName, id);
+  });
+}
+
 module.exports = {
   clone,
   copyFields,
@@ -459,4 +513,6 @@ module.exports = {
   update,
   getActorLinkedRecordID,
   setActorLinkedRecordID,
+  getResolverLinkedRecordID,
+  getResolverLinkedRecordIDs,
 };

package/store/RelayPublishQueue.js.flow

@@ -210,7 +210,6 @@ class RelayPublishQueue implements PublishQueue {
     sourceOperation?: OperationDescriptor,
   ): $ReadOnlyArray<RequestDescriptor> {
     const runWillClearGcHold =
-      // $FlowFixMe[incompatible-type]
       this._appliedOptimisticUpdates === 0 && !!this._gcHold;
     const runIsANoop =
       // this._pendingBackupRebase is true if an applied optimistic

package/store/RelayReferenceMarker.js.flow

@@ -271,17 +271,45 @@ class RelayReferenceMarker {
       return;
     }
     const resolverRecord = this._recordSource.get(dataID);
-    if (resolverRecord != null) {
-      if (field.backingField.isOutputType) {
-        // Mark all @outputType record IDs
-        const outputTypeRecordIDs = getOutputTypeRecordIDs(resolverRecord);
-        if (outputTypeRecordIDs != null) {
-          for (const dataID of outputTypeRecordIDs) {
-            this._references.add(dataID);
+    if (resolverRecord == null) {
+      return;
+    }
+    if (field.backingField.isOutputType) {
+      // Mark all @outputType record IDs
+      const outputTypeRecordIDs = getOutputTypeRecordIDs(resolverRecord);
+      if (outputTypeRecordIDs != null) {
+        for (const dataID of outputTypeRecordIDs) {
+          this._references.add(dataID);
+        }
+      }
+    } else {
+      const {linkedField} = field;
+      const concreteType = linkedField.concreteType;
+      if (concreteType == null) {
+        // TODO: Handle retaining abstract client edges to client types.
+        return;
+      }
+      if (linkedField.plural) {
+        const dataIDs = RelayModernRecord.getResolverLinkedRecordIDs(
+          resolverRecord,
+          concreteType,
+        );
+
+        if (dataIDs != null) {
+          for (const dataID of dataIDs) {
+            if (dataID != null) {
+              this._traverse(linkedField, dataID);
+            }
           }
         }
       } else {
-        // TODO: Find cached resolver value.
+        const dataID = RelayModernRecord.getResolverLinkedRecordID(
+          resolverRecord,
+          concreteType,
+        );
+        if (dataID != null) {
+          this._traverse(linkedField, dataID);
+        }
       }
     }
   }

package/store/RelayResponseNormalizer.js.flow

@@ -310,17 +310,13 @@ class RelayResponseNormalizer {
           const fieldKey = getStorageKey(selection, this._variables);
           const handleKey = getHandleStorageKey(selection, this._variables);
           this._handleFieldPayloads.push({
-            /* $FlowFixMe[class-object-subtyping] added when improving typing
-             * for this parameters */
             args,
             dataID: RelayModernRecord.getDataID(record),
             fieldKey,
             handle: selection.handle,
             handleKey,
             handleArgs: selection.handleArgs
-              ? /* $FlowFixMe[class-object-subtyping] added when improving typing
-                 * for this parameters */
-                getArgumentValues(selection.handleArgs, this._variables)
+              ? getArgumentValues(selection.handleArgs, this._variables)
               : {},
           });
           break;

package/store/RelayStoreTypes.js.flow

@@ -583,6 +583,15 @@ export type LogEvent =
       // Are we reading this result from the fragment resource cache?
       +cached: boolean,
     }
+  | {
+      // Indicates getPendingOperationForFragment identified a pending operation.
+      // Useful for measuring how frequently RelayOperationTracker identifies a
+      // related operation on which to suspend.
+      +name: 'pendingoperation.found',
+      +fragment: ReaderFragment,
+      +fragmentOwner: RequestDescriptor,
+      +pendingOperations: $ReadOnlyArray<RequestDescriptor>,
+    }
   | {
       +name: 'network.info',
       +networkRequestId: number,

package/store/defaultGetDataID.js.flow

@@ -18,10 +18,8 @@ function defaultGetDataID(
   typeName: string,
 ): mixed {
   if (typeName === VIEWER_TYPE) {
-    // $FlowFixMe[prop-missing]
     return fieldValue.id == null ? VIEWER_ID : fieldValue.id;
   }
-  // $FlowFixMe[prop-missing]
   return fieldValue.id;
 }
 

package/util/deepFreeze.js.flow

@@ -20,7 +20,6 @@
 function deepFreeze<T: {...}>(object: T): T {
   Object.freeze(object);
   Object.getOwnPropertyNames(object).forEach(name => {
-    // $FlowFixMe[prop-missing]
     const property = object[name];
     if (
       property &&

package/util/getPendingOperationsForFragment.js.flow

@@ -54,6 +54,16 @@ function getPendingOperationsForFragment(
       : `Relay(${pendingOperationName}:${fragmentName})`;
   // $FlowExpectedError[prop-missing] Expando to annotate Promises.
   promise.displayName = promiseDisplayName;
+
+  // In order to monitor the efficacy of RelayOperationTracker, we log
+  // enough information to track whether we are suspending on the fragment
+  // owner's operation, or some other operation.
+  environment.__log({
+    name: 'pendingoperation.found',
+    fragment: fragmentNode,
+    fragmentOwner,
+    pendingOperations,
+  });
   return {promise, pendingOperations};
 }