relay-runtime 11.0.1 → 13.0.0-rc.1

package/store/ResolverCache.js.flow

@@ -0,0 +1,249 @@
+/**
+ * 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 strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {ReaderRelayResolver} from '../util/ReaderNode';
+import type {DataID, Variables} from '../util/RelayRuntimeTypes';
+import type {
+  MutableRecordSource,
+  Record,
+  SingularReaderSelector,
+} from './RelayStoreTypes';
+
+const recycleNodesInto = require('../util/recycleNodesInto');
+const {generateClientID} = require('./ClientID');
+const RelayModernRecord = require('./RelayModernRecord');
+const {
+  RELAY_RESOLVER_INPUTS_KEY,
+  RELAY_RESOLVER_INVALIDATION_KEY,
+  RELAY_RESOLVER_READER_SELECTOR_KEY,
+  RELAY_RESOLVER_VALUE_KEY,
+  getStorageKey,
+} = require('./RelayStoreUtils');
+const warning = require('warning');
+
+type ResolverID = string;
+
+type EvaluationResult<T> = {|
+  resolverResult: T,
+  fragmentValue: {...},
+  resolverID: ResolverID,
+  seenRecordIDs: Set<DataID>,
+  readerSelector: SingularReaderSelector,
+|};
+
+export interface ResolverCache {
+  readFromCacheOrEvaluate<T>(
+    record: Record,
+    field: ReaderRelayResolver,
+    variables: Variables,
+    evaluate: () => EvaluationResult<T>,
+    getDataForResolverFragment: (SingularReaderSelector) => mixed,
+  ): [T /* Answer */, ?DataID /* Seen record */];
+  invalidateDataIDs(
+    updatedDataIDs: Set<DataID>, // Mutated in place
+  ): void;
+}
+
+// $FlowFixMe[unclear-type] - will always be empty
+const emptySet: $ReadOnlySet<any> = new Set();
+
+class NoopResolverCache implements ResolverCache {
+  readFromCacheOrEvaluate<T>(
+    record: Record,
+    field: ReaderRelayResolver,
+    variables: Variables,
+    evaluate: () => EvaluationResult<T>,
+    getDataForResolverFragment: SingularReaderSelector => mixed,
+  ): [T /* Answer */, ?DataID /* Seen record */] {
+    return [evaluate().resolverResult, undefined];
+  }
+  invalidateDataIDs(updatedDataIDs: Set<DataID>): void {}
+}
+
+function addDependencyEdge(
+  edges: Map<ResolverID, Set<DataID>> | Map<DataID, Set<ResolverID>>,
+  from: ResolverID | DataID,
+  to: ResolverID | DataID,
+): void {
+  let set = edges.get(from);
+  if (!set) {
+    set = new Set();
+    edges.set(from, set);
+  }
+  set.add(to);
+}
+
+class RecordResolverCache implements ResolverCache {
+  _resolverIDToRecordIDs: Map<ResolverID, Set<DataID>>;
+  _recordIDToResolverIDs: Map<DataID, Set<ResolverID>>;
+
+  _getRecordSource: () => MutableRecordSource;
+
+  constructor(getRecordSource: () => MutableRecordSource) {
+    this._resolverIDToRecordIDs = new Map();
+    this._recordIDToResolverIDs = new Map();
+    this._getRecordSource = getRecordSource;
+  }
+
+  readFromCacheOrEvaluate<T>(
+    record: Record,
+    field: ReaderRelayResolver,
+    variables: Variables,
+    evaluate: () => EvaluationResult<T>,
+    getDataForResolverFragment: SingularReaderSelector => mixed,
+  ): [T /* Answer */, ?DataID /* Seen record */] {
+    const recordSource = this._getRecordSource();
+    const recordID = RelayModernRecord.getDataID(record);
+
+    const storageKey = getStorageKey(field, variables);
+    let linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);
+    let linkedRecord = linkedID == null ? null : recordSource.get(linkedID);
+    if (
+      linkedRecord == null ||
+      this._isInvalid(linkedRecord, getDataForResolverFragment)
+    ) {
+      // Cache miss; evaluate the selector and store the result in a new record:
+      linkedID = linkedID ?? generateClientID(recordID, storageKey);
+      linkedRecord = RelayModernRecord.create(linkedID, '__RELAY_RESOLVER__');
+
+      const evaluationResult = evaluate();
+      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,
+      );
+      recordSource.set(linkedID, linkedRecord);
+
+      // Link the resolver value record to the resolver field of the record being read:
+      const 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:
+      const resolverID = evaluationResult.resolverID;
+      addDependencyEdge(this._resolverIDToRecordIDs, resolverID, linkedID);
+      addDependencyEdge(this._recordIDToResolverIDs, recordID, resolverID);
+      for (const seenRecordID of evaluationResult.seenRecordIDs) {
+        addDependencyEdge(
+          this._recordIDToResolverIDs,
+          seenRecordID,
+          resolverID,
+        );
+      }
+    }
+
+    // $FlowFixMe[incompatible-type] - will always be empty
+    const answer: T = linkedRecord[RELAY_RESOLVER_VALUE_KEY];
+    return [answer, linkedID];
+  }
+
+  invalidateDataIDs(
+    updatedDataIDs: Set<DataID>, // Mutated in place
+  ): void {
+    const recordSource = this._getRecordSource();
+    const visited: Set<string> = new Set();
+    const recordsToVisit = Array.from(updatedDataIDs);
+    while (recordsToVisit.length) {
+      const recordID = recordsToVisit.pop();
+      updatedDataIDs.add(recordID);
+      for (const fragment of this._recordIDToResolverIDs.get(recordID) ??
+        emptySet) {
+        if (!visited.has(fragment)) {
+          for (const anotherRecordID of this._resolverIDToRecordIDs.get(
+            fragment,
+          ) ?? emptySet) {
+            this._markInvalidatedResolverRecord(
+              anotherRecordID,
+              recordSource,
+              updatedDataIDs,
+            );
+            if (!visited.has(anotherRecordID)) {
+              recordsToVisit.push(anotherRecordID);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  _markInvalidatedResolverRecord(
+    dataID: DataID,
+    recordSource: MutableRecordSource, // Written to
+    updatedDataIDs: Set<DataID>, // Mutated in place
+  ) {
+    const record = recordSource.get(dataID);
+    if (!record) {
+      warning(
+        false,
+        'Expected a resolver record with ID %s, but it was missing.',
+        dataID,
+      );
+      return;
+    }
+    const nextRecord = RelayModernRecord.clone(record);
+    RelayModernRecord.setValue(
+      nextRecord,
+      RELAY_RESOLVER_INVALIDATION_KEY,
+      true,
+    );
+    recordSource.set(dataID, nextRecord);
+  }
+
+  _isInvalid(
+    record: Record,
+    getDataForResolverFragment: SingularReaderSelector => mixed,
+  ): boolean {
+    if (!RelayModernRecord.getValue(record, RELAY_RESOLVER_INVALIDATION_KEY)) {
+      return false;
+    }
+    const originalInputs = RelayModernRecord.getValue(
+      record,
+      RELAY_RESOLVER_INPUTS_KEY,
+    );
+    // $FlowFixMe[incompatible-type] - storing values in records is not typed
+    const readerSelector: ?SingularReaderSelector = RelayModernRecord.getValue(
+      record,
+      RELAY_RESOLVER_READER_SELECTOR_KEY,
+    );
+    if (originalInputs == null || readerSelector == null) {
+      warning(
+        false,
+        'Expected previous inputs and reader selector on resolver record with ID %s, but they were missing.',
+        RelayModernRecord.getDataID(record),
+      );
+      return true;
+    }
+    const latestValues = getDataForResolverFragment(readerSelector);
+    const recycled = recycleNodesInto(originalInputs, latestValues);
+    if (recycled !== originalInputs) {
+      return true;
+    }
+    return false;
+  }
+}
+
+module.exports = {
+  NoopResolverCache,
+  RecordResolverCache,
+};

package/store/ResolverFragments.js.flow

@@ -0,0 +1,121 @@
+/**
+ * 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 strict-local
+ * @format
+ */
+
+// flowlint ambiguous-object-type:error
+
+'use strict';
+
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
+import type {FragmentType, SingularReaderSelector} from './RelayStoreTypes';
+
+const {getFragment} = require('../query/GraphQLTag');
+const {getSelector} = require('./RelayModernSelector');
+const invariant = require('invariant');
+
+// When we call the user-supplied resolver function, it will in turn call
+// `readFragment`, but that's a global function -- it needs information
+// about what resolver is being executed, which is supplied by putting the
+// info on this stack before we call the resolver function.
+type ResolverContext = {|
+  getDataForResolverFragment: (SingularReaderSelector, FragmentType) => mixed,
+|};
+const contextStack: Array<ResolverContext> = [];
+
+function withResolverContext<T>(context: ResolverContext, cb: () => T): T {
+  contextStack.push(context);
+  try {
+    return cb();
+  } finally {
+    contextStack.pop();
+  }
+}
+
+// NOTE: these declarations are copied from 'useFragment'; it would be good
+// to figure out how to share the same type signature between the two functions.
+// The declarations ensure that the type of the returned data is:
+//   - non-nullable if the provided ref type is non-nullable
+//   - nullable if the provided ref type is nullable
+//   - array of non-nullable if the privoided ref type is an array of
+//     non-nullable refs
+//   - array of nullable if the privoided ref type is an array of nullable refs
+
+declare function readFragment<
+  TKey: {+$data?: mixed, +$fragmentSpreads: FragmentType, ...},
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentKey: TKey,
+): $Call<<TFragmentData>({+$data?: TFragmentData, ...}) => TFragmentData, TKey>;
+
+declare function readFragment<
+  TKey: ?{+$data?: mixed, +$fragmentSpreads: FragmentType, ...},
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentKey: TKey,
+): $Call<
+  <TFragmentData>(?{+$data?: TFragmentData, ...}) => ?TFragmentData,
+  TKey,
+>;
+
+declare function readFragment<
+  TKey: $ReadOnlyArray<{
+    +$data?: mixed,
+    +$fragmentSpreads: FragmentType,
+    ...
+  }>,
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentKey: TKey,
+): $Call<
+  <TFragmentData>(
+    $ReadOnlyArray<{+$data?: TFragmentData, ...}>,
+  ) => TFragmentData,
+  TKey,
+>;
+
+declare function readFragment<
+  TKey: ?$ReadOnlyArray<{
+    +$data?: mixed,
+    +$fragmentSpreads: FragmentType,
+    ...
+  }>,
+>(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentKey: TKey,
+): $Call<
+  <TFragmentData>(
+    ?$ReadOnlyArray<{+$data?: TFragmentData, ...}>,
+  ) => ?TFragmentData,
+  TKey,
+>;
+
+function readFragment(
+  fragmentInput: GraphQLTaggedNode,
+  fragmentKey: FragmentType,
+): mixed {
+  if (!contextStack.length) {
+    throw new Error(
+      'readFragment should be called only from within a Relay Resolver function.',
+    );
+  }
+  const context = contextStack[contextStack.length - 1];
+  const fragmentNode = getFragment(fragmentInput);
+  const fragmentSelector = getSelector(fragmentNode, fragmentKey);
+  invariant(
+    fragmentSelector != null,
+    `Expected a selector for the fragment of the resolver ${fragmentNode.name}, but got null.`,
+  );
+  invariant(
+    fragmentSelector.kind === 'SingularReaderSelector',
+    `Expected a singular reader selector for the fragment of the resolver ${fragmentNode.name}, but it was plural.`,
+  );
+  return context.getDataForResolverFragment(fragmentSelector, fragmentKey);
+}
+
+module.exports = {readFragment, withResolverContext};

package/store/StoreInspector.js.flow

@@ -56,7 +56,7 @@ if (__DEV__) {
     const keyStyle = {style: 'rgb(136, 19, 145)'};
     const nullStyle = {style: 'color: #777'};
 
-    const reference = (object, config) => {
+    const reference = (object, config: void) => {
       return object == null
         ? ['span', nullStyle, 'undefined']
         : ['object', {object, config}];
@@ -100,7 +100,7 @@ if (__DEV__) {
         }
         return renderRecordHeader(obj);
       },
-      hasBody(obj) {
+      hasBody(obj: $FlowFixMe) {
         return true;
       },
       body(obj) {

package/store/TypeID.js.flow

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @flow strict
+ * @flow strict-local
  * @format
  */
 

package/store/ViewerPattern.js.flow

@@ -12,11 +12,11 @@
 
 'use strict';
 
+import type {DataID} from '../util/RelayRuntimeTypes';
+
 const {generateClientID} = require('./ClientID');
 const {ROOT_ID} = require('./RelayStoreUtils');
 
-import type {DataID} from 'relay-runtime/util/RelayRuntimeTypes';
-
 const VIEWER_ID: DataID = generateClientID(ROOT_ID, 'viewer');
 const VIEWER_TYPE = 'Viewer';
 

package/store/cloneRelayHandleSourceField.js.flow

@@ -12,12 +12,6 @@
 
 'use strict';
 
-const areEqual = require('areEqual');
-const invariant = require('invariant');
-
-const {LINKED_FIELD} = require('../util/RelayConcreteNode');
-const {getHandleStorageKey} = require('./RelayStoreUtils');
-
 import type {
   NormalizationLinkedField,
   NormalizationSelection,
@@ -25,6 +19,11 @@ import type {
 import type {NormalizationLinkedHandle} from '../util/NormalizationNode';
 import type {Variables} from '../util/RelayRuntimeTypes';
 
+const {LINKED_FIELD} = require('../util/RelayConcreteNode');
+const {getHandleStorageKey} = require('./RelayStoreUtils');
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+
 /**
  * @private
  *

package/store/cloneRelayScalarHandleSourceField.js.flow

@@ -12,12 +12,6 @@
 
 'use strict';
 
-const areEqual = require('areEqual');
-const invariant = require('invariant');
-
-const {SCALAR_FIELD} = require('../util/RelayConcreteNode');
-const {getHandleStorageKey} = require('./RelayStoreUtils');
-
 import type {
   NormalizationScalarField,
   NormalizationSelection,
@@ -25,6 +19,11 @@ import type {
 import type {NormalizationScalarHandle} from '../util/NormalizationNode';
 import type {Variables} from '../util/RelayRuntimeTypes';
 
+const {SCALAR_FIELD} = require('../util/RelayConcreteNode');
+const {getHandleStorageKey} = require('./RelayStoreUtils');
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+
 /**
  * @private
  *

package/store/createFragmentSpecResolver.js.flow

@@ -12,10 +12,6 @@
 
 'use strict';
 
-const RelayModernFragmentSpecResolver = require('./RelayModernFragmentSpecResolver');
-
-const warning = require('warning');
-
 import type {
   FragmentMap,
   FragmentSpecResolver,
@@ -23,6 +19,9 @@ import type {
   RelayContext,
 } from './RelayStoreTypes';
 
+const RelayModernFragmentSpecResolver = require('./RelayModernFragmentSpecResolver');
+const warning = require('warning');
+
 function createFragmentSpecResolver(
   context: RelayContext,
   containerName: string,

package/store/createRelayContext.js.flow

@@ -12,11 +12,11 @@
 
 'use strict';
 
-const invariant = require('invariant');
-
 import type {RelayContext} from './RelayStoreTypes.js';
 import typeof {createContext} from 'react';
 
+const invariant = require('invariant');
+
 // Ideally, we'd just import the type of the react module, but this causes Flow
 // problems.
 type React = {
@@ -38,7 +38,7 @@ function createRelayContext(react: React): React$Context<RelayContext | null> {
   }
   invariant(
     react === firstReact,
-    '[createRelayContext]: You passing a different instance of React',
+    '[createRelayContext]: You are passing a different instance of React',
     react.version,
   );
   return relayContext;

package/store/normalizeRelayPayload.js.flow

@@ -12,19 +12,18 @@
 
 'use strict';
 
-const RelayModernRecord = require('./RelayModernRecord');
-const RelayRecordSource = require('./RelayRecordSource');
-const RelayResponseNormalizer = require('./RelayResponseNormalizer');
-
-const {ROOT_TYPE} = require('./RelayStoreUtils');
-
 import type {PayloadData, PayloadError} from '../network/RelayNetworkTypes';
 import type {NormalizationOptions} from './RelayResponseNormalizer';
 import type {
-  RelayResponsePayload,
   NormalizationSelector,
+  RelayResponsePayload,
 } from './RelayStoreTypes';
 
+const RelayModernRecord = require('./RelayModernRecord');
+const RelayRecordSource = require('./RelayRecordSource');
+const RelayResponseNormalizer = require('./RelayResponseNormalizer');
+const {ROOT_TYPE} = require('./RelayStoreUtils');
+
 function normalizeRelayPayload(
   selector: NormalizationSelector,
   payload: PayloadData,

package/store/readInlineData.js.flow

@@ -12,24 +12,23 @@
 
 'use strict';
 
-const invariant = require('invariant');
+import type {GraphQLTaggedNode} from '../query/GraphQLTag';
+import type {FragmentType} from './RelayStoreTypes';
 
 const {getInlineDataFragment} = require('../query/GraphQLTag');
 const {FRAGMENTS_KEY} = require('./RelayStoreUtils');
-
-import type {GraphQLTaggedNode} from '../query/GraphQLTag';
-import type {FragmentReference} from './RelayStoreTypes';
+const invariant = require('invariant');
 
 /**
  * Reads an @inline data fragment that was spread into the parent fragment.
  */
 
 declare function readInlineData<
-  TRef: FragmentReference,
+  TFragmentType: FragmentType,
   TData,
   TKey: {
     +$data?: TData,
-    +$fragmentRefs: TRef,
+    +$fragmentSpreads: TFragmentType,
     ...
   },
 >(
@@ -37,11 +36,11 @@ declare function readInlineData<
   fragmentRef: TKey,
 ): TData;
 declare function readInlineData<
-  TRef: FragmentReference,
+  TFragmentType: FragmentType,
   TData,
   TKey: ?{
     +$data?: TData,
-    +$fragmentRefs: TRef,
+    +$fragmentSpreads: TFragmentType,
     ...
   },
 >(