relay-runtime 11.0.2 → 13.0.0-rc.2

package/store/RelayModernRecord.js.flow

@@ -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.
@@ -12,23 +12,24 @@
 
 'use strict';
 
-const areEqual = require('areEqual');
-const deepFreeze = require('../util/deepFreeze');
-const invariant = require('invariant');
-const warning = require('warning');
+import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
+import type {DataID} from '../util/RelayRuntimeTypes';
+import type {Record} from './RelayStoreTypes';
 
+const deepFreeze = require('../util/deepFreeze');
 const {isClientID} = require('./ClientID');
 const {
+  ACTOR_IDENTIFIER_KEY,
   ID_KEY,
+  INVALIDATED_AT_KEY,
   REF_KEY,
   REFS_KEY,
-  TYPENAME_KEY,
-  INVALIDATED_AT_KEY,
   ROOT_ID,
+  TYPENAME_KEY,
 } = require('./RelayStoreUtils');
-
-import type {DataID} from '../util/RelayRuntimeTypes';
-import type {Record} from './RelayStoreTypes';
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+const warning = require('warning');
 
 /**
  * @public
@@ -172,10 +173,14 @@ function getLinkedRecordID(record: Record, storageKey: string): ?DataID {
   invariant(
     typeof link === 'object' && link && typeof link[REF_KEY] === 'string',
     'RelayModernRecord.getLinkedRecordID(): Expected `%s.%s` to be a linked ID, ' +
-      'was `%s`.',
+      'was `%s`.%s',
     record[ID_KEY],
     storageKey,
     JSON.stringify(link),
+    typeof link === 'object' && link[REFS_KEY] !== undefined
+      ? ' It appears to be a plural linked record: did you mean to call ' +
+          'getLinkedRecords() instead of getLinkedRecord()?'
+      : '',
   );
   return link[REF_KEY];
 }
@@ -197,10 +202,14 @@ function getLinkedRecordIDs(
   invariant(
     typeof links === 'object' && Array.isArray(links[REFS_KEY]),
     'RelayModernRecord.getLinkedRecordIDs(): Expected `%s.%s` to contain an array ' +
-      'of linked IDs, got `%s`.',
+      'of linked IDs, got `%s`.%s',
     record[ID_KEY],
     storageKey,
     JSON.stringify(links),
+    typeof links === 'object' && links[REF_KEY] !== undefined
+      ? ' It appears to be a singular linked record: did you mean to call ' +
+          'getLinkedRecord() instead of getLinkedRecords()?'
+      : '',
   );
   // assume items of the array are ids
   return (links[REFS_KEY]: any);
@@ -384,6 +393,51 @@ function setLinkedRecordIDs(
   record[storageKey] = links;
 }
 
+/**
+ * @public
+ *
+ * Set the value of a field to a reference to another record in the actor specific store.
+ */
+function setActorLinkedRecordID(
+  record: Record,
+  storageKey: string,
+  actorIdentifier: ActorIdentifier,
+  linkedID: DataID,
+): void {
+  // See perf note above for why we aren't using computed property access.
+  const link = {};
+  link[REF_KEY] = linkedID;
+  link[ACTOR_IDENTIFIER_KEY] = actorIdentifier;
+  record[storageKey] = link;
+}
+
+/**
+ * @public
+ *
+ * Get link to a record and the actor identifier for the store.
+ */
+function getActorLinkedRecordID(
+  record: Record,
+  storageKey: string,
+): ?[ActorIdentifier, DataID] {
+  const link = record[storageKey];
+  if (link == null) {
+    return link;
+  }
+  invariant(
+    typeof link === 'object' &&
+      typeof link[REF_KEY] === 'string' &&
+      link[ACTOR_IDENTIFIER_KEY] != null,
+    'RelayModernRecord.getActorLinkedRecordID(): Expected `%s.%s` to be an actor specific linked ID, ' +
+      'was `%s`.',
+    record[ID_KEY],
+    storageKey,
+    JSON.stringify(link),
+  );
+
+  return [(link[ACTOR_IDENTIFIER_KEY]: any), (link[REF_KEY]: any)];
+}
+
 module.exports = {
   clone,
   copyFields,
@@ -400,4 +454,6 @@ module.exports = {
   setLinkedRecordID,
   setLinkedRecordIDs,
   update,
+  getActorLinkedRecordID,
+  setActorLinkedRecordID,
 };

package/store/RelayModernSelector.js.flow

@@ -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.
@@ -12,22 +12,11 @@
 
 'use strict';
 
-const areEqual = require('areEqual');
-const invariant = require('invariant');
-const warning = require('warning');
-
-const {getFragmentVariables} = require('./RelayConcreteVariables');
-const {
-  FRAGMENT_OWNER_KEY,
-  FRAGMENTS_KEY,
-  ID_KEY,
-  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
-} = require('./RelayStoreUtils');
-
 import type {NormalizationSelectableNode} from '../util/NormalizationNode';
 import type {ReaderFragment} from '../util/ReaderNode';
 import type {DataID, Variables} from '../util/RelayRuntimeTypes';
 import type {
+  ClientEdgeTraversalPath,
   NormalizationSelector,
   PluralReaderSelector,
   ReaderSelector,
@@ -35,6 +24,18 @@ import type {
   SingularReaderSelector,
 } from './RelayStoreTypes';
 
+const {getFragmentVariables} = require('./RelayConcreteVariables');
+const {
+  CLIENT_EDGE_TRAVERSAL_PATH,
+  FRAGMENT_OWNER_KEY,
+  FRAGMENTS_KEY,
+  ID_KEY,
+  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,
+} = require('./RelayStoreUtils');
+const areEqual = require('areEqual');
+const invariant = require('invariant');
+const warning = require('warning');
+
 /**
  * @public
  *
@@ -80,6 +81,7 @@ function getSingularSelector(
   const mixedOwner = item[FRAGMENT_OWNER_KEY];
   const isWithinUnmatchedTypeRefinement =
     item[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] === true;
+  const mixedClientEdgeTraversalPath = item[CLIENT_EDGE_TRAVERSAL_PATH];
   if (
     typeof dataID === 'string' &&
     typeof fragments === 'object' &&
@@ -87,22 +89,28 @@ function getSingularSelector(
     typeof fragments[fragment.name] === 'object' &&
     fragments[fragment.name] !== null &&
     typeof mixedOwner === 'object' &&
-    mixedOwner !== null
+    mixedOwner !== null &&
+    (mixedClientEdgeTraversalPath == null ||
+      Array.isArray(mixedClientEdgeTraversalPath))
   ) {
     const owner: RequestDescriptor = (mixedOwner: $FlowFixMe);
-    const argumentVariables = fragments[fragment.name];
+    const clientEdgeTraversalPath: ?ClientEdgeTraversalPath =
+      (mixedClientEdgeTraversalPath: $FlowFixMe);
 
+    const argumentVariables = fragments[fragment.name];
     const fragmentVariables = getFragmentVariables(
       fragment,
       owner.variables,
       argumentVariables,
     );
+
     return createReaderSelector(
       fragment,
       dataID,
       fragmentVariables,
       owner,
       isWithinUnmatchedTypeRefinement,
+      clientEdgeTraversalPath,
     );
   }
 
@@ -419,11 +427,13 @@ function createReaderSelector(
   variables: Variables,
   request: RequestDescriptor,
   isWithinUnmatchedTypeRefinement: boolean = false,
+  clientEdgeTraversalPath: ?ClientEdgeTraversalPath,
 ): SingularReaderSelector {
   return {
     kind: 'SingularReaderSelector',
     dataID,
     isWithinUnmatchedTypeRefinement,
+    clientEdgeTraversalPath: clientEdgeTraversalPath ?? null,
     node: fragment,
     variables,
     owner: request,

package/store/RelayModernStore.js.flow

@@ -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.
@@ -12,29 +12,13 @@
 
 'use strict';
 
-const DataChecker = require('./DataChecker');
-const RelayFeatureFlags = require('../util/RelayFeatureFlags');
-const RelayModernRecord = require('./RelayModernRecord');
-const RelayOptimisticRecordSource = require('./RelayOptimisticRecordSource');
-const RelayReader = require('./RelayReader');
-const RelayReferenceMarker = require('./RelayReferenceMarker');
-const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
-const RelayStoreSubscriptions = require('./RelayStoreSubscriptions');
-const RelayStoreSubscriptionsUsingMapByID = require('./RelayStoreSubscriptionsUsingMapByID');
-const RelayStoreUtils = require('./RelayStoreUtils');
-
-const deepFreeze = require('../util/deepFreeze');
-const defaultGetDataID = require('./defaultGetDataID');
-const invariant = require('invariant');
-const resolveImmediate = require('../util/resolveImmediate');
-
-const {ROOT_ID, ROOT_TYPE} = require('./RelayStoreUtils');
-
+import type {ActorIdentifier} from '../multi-actor-environment/ActorIdentifier';
 import type {DataID, Disposable} from '../util/RelayRuntimeTypes';
 import type {Availability} from './DataChecker';
 import type {GetDataID} from './RelayResponseNormalizer';
 import type {
   CheckOptions,
+  DataIDSet,
   LogFunction,
   MutableRecordSource,
   OperationAvailability,
@@ -47,8 +31,28 @@ import type {
   Snapshot,
   Store,
   StoreSubscriptions,
-  DataIDSet,
 } from './RelayStoreTypes';
+import type {ResolverCache} from './ResolverCache';
+
+const {
+  INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
+  assertInternalActorIndentifier,
+} = require('../multi-actor-environment/ActorIdentifier');
+const deepFreeze = require('../util/deepFreeze');
+const RelayFeatureFlags = require('../util/RelayFeatureFlags');
+const resolveImmediate = require('../util/resolveImmediate');
+const DataChecker = require('./DataChecker');
+const defaultGetDataID = require('./defaultGetDataID');
+const RelayModernRecord = require('./RelayModernRecord');
+const RelayOptimisticRecordSource = require('./RelayOptimisticRecordSource');
+const RelayReader = require('./RelayReader');
+const RelayReferenceMarker = require('./RelayReferenceMarker');
+const RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');
+const RelayStoreSubscriptions = require('./RelayStoreSubscriptions');
+const RelayStoreUtils = require('./RelayStoreUtils');
+const {ROOT_ID, ROOT_TYPE} = require('./RelayStoreUtils');
+const {RecordResolverCache} = require('./ResolverCache');
+const invariant = require('invariant');
 
 export opaque type InvalidationState = {|
   dataIDs: $ReadOnlyArray<DataID>,
@@ -89,6 +93,7 @@ class RelayModernStore implements Store {
   _operationLoader: ?OperationLoader;
   _optimisticSource: ?MutableRecordSource;
   _recordSource: MutableRecordSource;
+  _resolverCache: ResolverCache;
   _releaseBuffer: Array<string>;
   _roots: Map<
     string,
@@ -144,10 +149,13 @@ class RelayModernStore implements Store {
     this._releaseBuffer = [];
     this._roots = new Map();
     this._shouldScheduleGC = false;
-    this._storeSubscriptions =
-      RelayFeatureFlags.ENABLE_STORE_SUBSCRIPTIONS_REFACTOR === true
-        ? new RelayStoreSubscriptionsUsingMapByID(options?.log)
-        : new RelayStoreSubscriptions(options?.log);
+    this._resolverCache = new RecordResolverCache(() =>
+      this._getMutableRecordSource(),
+    );
+    this._storeSubscriptions = new RelayStoreSubscriptions(
+      options?.log,
+      this._resolverCache,
+    );
     this._updatedRecordIDs = new Set();
     this._shouldProcessClientComponents =
       options?.shouldProcessClientComponents;
@@ -159,12 +167,16 @@ class RelayModernStore implements Store {
     return this._optimisticSource ?? this._recordSource;
   }
 
+  _getMutableRecordSource(): MutableRecordSource {
+    return this._optimisticSource ?? this._recordSource;
+  }
+
   check(
     operation: OperationDescriptor,
     options?: CheckOptions,
   ): OperationAvailability {
     const selector = operation.root;
-    const source = this._optimisticSource ?? this._recordSource;
+    const source = this._getMutableRecordSource();
     const globalInvalidationEpoch = this._globalInvalidationEpoch;
 
     const rootEntry = this._roots.get(operation.request.identifier);
@@ -173,7 +185,7 @@ class RelayModernStore implements Store {
     // Check if store has been globally invalidated
     if (globalInvalidationEpoch != null) {
       // If so, check if the operation we're checking was last written
-      // before or after invalidation occured.
+      // before or after invalidation occurred.
       if (
         operationLastWrittenAt == null ||
         operationLastWrittenAt <= globalInvalidationEpoch
@@ -186,11 +198,24 @@ class RelayModernStore implements Store {
       }
     }
 
-    const target = options?.target ?? source;
     const handlers = options?.handlers ?? [];
+    const getSourceForActor =
+      options?.getSourceForActor ??
+      (actorIdentifier => {
+        assertInternalActorIndentifier(actorIdentifier);
+        return source;
+      });
+    const getTargetForActor =
+      options?.getTargetForActor ??
+      (actorIdentifier => {
+        assertInternalActorIndentifier(actorIdentifier);
+        return source;
+      });
+
     const operationAvailability = DataChecker.check(
-      source,
-      target,
+      getSourceForActor,
+      getTargetForActor,
+      options?.defaultActorIdentifier ?? INTERNAL_ACTOR_IDENTIFIER_DO_NOT_USE,
       selector,
       handlers,
       this._operationLoader,
@@ -274,7 +299,7 @@ class RelayModernStore implements Store {
 
   lookup(selector: SingularReaderSelector): Snapshot {
     const source = this.getSource();
-    const snapshot = RelayReader.read(source, selector);
+    const snapshot = RelayReader.read(source, selector, this._resolverCache);
     if (__DEV__) {
       deepFreeze(snapshot);
     }
@@ -302,6 +327,13 @@ class RelayModernStore implements Store {
       this._globalInvalidationEpoch = this._currentWriteEpoch;
     }
 
+    if (RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {
+      // When a record is updated, we need to also handle records that depend on it,
+      // specifically Relay Resolver result records containing results based on the
+      // updated records. This both adds to updatedRecordIDs and invalidates any
+      // cached data as needed.
+      this._resolverCache.invalidateDataIDs(this._updatedRecordIDs);
+    }
     const source = this.getSource();
     const updatedOwners = [];
     this._storeSubscriptions.updateSubscriptions(
@@ -364,7 +396,7 @@ class RelayModernStore implements Store {
   }
 
   publish(source: RecordSource, idsMarkedForInvalidation?: DataIDSet): void {
-    const target = this._optimisticSource ?? this._recordSource;
+    const target = this._getMutableRecordSource();
     updateTargetFromSource(
       target,
       source,
@@ -417,6 +449,10 @@ class RelayModernStore implements Store {
     return 'RelayModernStore()';
   }
 
+  getEpoch(): number {
+    return this._currentWriteEpoch;
+  }
+
   // Internal API
   __getUpdatedRecordIDs(): DataIDSet {
     return this._updatedRecordIDs;
@@ -677,7 +713,6 @@ function updateTargetFromSource(
         currentWriteEpoch,
       );
       invalidatedRecordIDs.add(dataID);
-      // $FlowFixMe[incompatible-call]
       target.set(dataID, nextRecord);
     });
   }

package/store/RelayOperationTracker.js.flow

@@ -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.
@@ -12,22 +12,26 @@
 
 'use strict';
 
-const invariant = require('invariant');
-
 import type {RequestDescriptor} from './RelayStoreTypes';
 
+const invariant = require('invariant');
+
 class RelayOperationTracker {
-  _ownersToPendingOperationsIdentifier: Map<string, Set<string>>;
-  _pendingOperationsToOwnersIdentifier: Map<string, Set<string>>;
-  _ownersIdentifierToPromise: Map<
+  _ownersToPendingOperations: Map<string, Map<string, RequestDescriptor>>;
+  _pendingOperationsToOwners: Map<string, Set<string>>;
+  _ownersToPendingPromise: Map<
     string,
-    {|promise: Promise<void>, resolve: () => void|},
+    {|
+      promise: Promise<void>,
+      resolve: () => void,
+      pendingOperations: $ReadOnlyArray<RequestDescriptor>,
+    |},
   >;
 
   constructor() {
-    this._ownersToPendingOperationsIdentifier = new Map();
-    this._pendingOperationsToOwnersIdentifier = new Map();
-    this._ownersIdentifierToPromise = new Map();
+    this._ownersToPendingOperations = new Map();
+    this._pendingOperationsToOwners = new Map();
+    this._ownersToPendingPromise = new Map();
   }
 
   /**
@@ -45,22 +49,24 @@ class RelayOperationTracker {
     const newlyAffectedOwnersIdentifier = new Set();
     for (const owner of affectedOwners) {
       const ownerIdentifier = owner.identifier;
-      const pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(
-        ownerIdentifier,
-      );
+      const pendingOperationsAffectingOwner =
+        this._ownersToPendingOperations.get(ownerIdentifier);
       if (pendingOperationsAffectingOwner != null) {
         // In this case the `ownerIdentifier` already affected by some operations
         // We just need to detect, is it the same operation that we already
         // have in the list, or it's a new operation
         if (!pendingOperationsAffectingOwner.has(pendingOperationIdentifier)) {
-          pendingOperationsAffectingOwner.add(pendingOperationIdentifier);
+          pendingOperationsAffectingOwner.set(
+            pendingOperationIdentifier,
+            pendingOperation,
+          );
           newlyAffectedOwnersIdentifier.add(ownerIdentifier);
         }
       } else {
         // This is a new `ownerIdentifier` that is affected by the operation
-        this._ownersToPendingOperationsIdentifier.set(
+        this._ownersToPendingOperations.set(
           ownerIdentifier,
-          new Set([pendingOperationIdentifier]),
+          new Map([[pendingOperationIdentifier, pendingOperation]]),
         );
         newlyAffectedOwnersIdentifier.add(ownerIdentifier);
       }
@@ -72,19 +78,18 @@ class RelayOperationTracker {
     }
 
     // But, if some owners were affected we need to add them to
-    // the `_pendingOperationsToOwnersIdentifier` set
-    const ownersAffectedByOperationIdentifier =
-      this._pendingOperationsToOwnersIdentifier.get(
-        pendingOperationIdentifier,
-      ) || new Set();
+    // the `_pendingOperationsToOwners` set
+    const ownersAffectedByPendingOperation =
+      this._pendingOperationsToOwners.get(pendingOperationIdentifier) ||
+      new Set();
 
     for (const ownerIdentifier of newlyAffectedOwnersIdentifier) {
       this._resolveOwnerResolvers(ownerIdentifier);
-      ownersAffectedByOperationIdentifier.add(ownerIdentifier);
+      ownersAffectedByPendingOperation.add(ownerIdentifier);
     }
-    this._pendingOperationsToOwnersIdentifier.set(
+    this._pendingOperationsToOwners.set(
       pendingOperationIdentifier,
-      ownersAffectedByOperationIdentifier,
+      ownersAffectedByPendingOperation,
     );
   }
 
@@ -94,7 +99,7 @@ class RelayOperationTracker {
    */
   complete(pendingOperation: RequestDescriptor): void {
     const pendingOperationIdentifier = pendingOperation.identifier;
-    const affectedOwnersIdentifier = this._pendingOperationsToOwnersIdentifier.get(
+    const affectedOwnersIdentifier = this._pendingOperationsToOwners.get(
       pendingOperationIdentifier,
     );
     if (affectedOwnersIdentifier == null) {
@@ -107,9 +112,8 @@ class RelayOperationTracker {
     // and some other operations
     const updatedOwnersIdentifier = new Set();
     for (const ownerIdentifier of affectedOwnersIdentifier) {
-      const pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(
-        ownerIdentifier,
-      );
+      const pendingOperationsAffectingOwner =
+        this._ownersToPendingOperations.get(ownerIdentifier);
       if (!pendingOperationsAffectingOwner) {
         continue;
       }
@@ -124,7 +128,7 @@ class RelayOperationTracker {
     // Complete subscriptions for all owners, affected by `pendingOperationIdentifier`
     for (const ownerIdentifier of completedOwnersIdentifier) {
       this._resolveOwnerResolvers(ownerIdentifier);
-      this._ownersToPendingOperationsIdentifier.delete(ownerIdentifier);
+      this._ownersToPendingOperations.delete(ownerIdentifier);
     }
 
     // Update all ownerIdentifier that were updated by `pendingOperationIdentifier` but still
@@ -134,31 +138,38 @@ class RelayOperationTracker {
     }
 
     // Finally, remove pending operation identifier
-    this._pendingOperationsToOwnersIdentifier.delete(
-      pendingOperationIdentifier,
-    );
+    this._pendingOperationsToOwners.delete(pendingOperationIdentifier);
   }
 
   _resolveOwnerResolvers(ownerIdentifier: string): void {
-    const promiseEntry = this._ownersIdentifierToPromise.get(ownerIdentifier);
+    const promiseEntry = this._ownersToPendingPromise.get(ownerIdentifier);
     if (promiseEntry != null) {
       promiseEntry.resolve();
     }
-    this._ownersIdentifierToPromise.delete(ownerIdentifier);
+    this._ownersToPendingPromise.delete(ownerIdentifier);
   }
 
-  getPromiseForPendingOperationsAffectingOwner(
-    owner: RequestDescriptor,
-  ): Promise<void> | null {
+  getPendingOperationsAffectingOwner(owner: RequestDescriptor): {|
+    promise: Promise<void>,
+    pendingOperations: $ReadOnlyArray<RequestDescriptor>,
+  |} | null {
     const ownerIdentifier = owner.identifier;
-    if (!this._ownersToPendingOperationsIdentifier.has(ownerIdentifier)) {
+    const pendingOperationsForOwner =
+      this._ownersToPendingOperations.get(ownerIdentifier);
+    if (
+      pendingOperationsForOwner == null ||
+      pendingOperationsForOwner.size === 0
+    ) {
       return null;
     }
-    const cachedPromiseEntry = this._ownersIdentifierToPromise.get(
-      ownerIdentifier,
-    );
+
+    const cachedPromiseEntry =
+      this._ownersToPendingPromise.get(ownerIdentifier);
     if (cachedPromiseEntry != null) {
-      return cachedPromiseEntry.promise;
+      return {
+        promise: cachedPromiseEntry.promise,
+        pendingOperations: cachedPromiseEntry.pendingOperations,
+      };
     }
     let resolve;
     const promise = new Promise(r => {
@@ -169,8 +180,13 @@ class RelayOperationTracker {
       'RelayOperationTracker: Expected resolver to be defined. If you' +
         'are seeing this, it is likely a bug in Relay.',
     );
-    this._ownersIdentifierToPromise.set(ownerIdentifier, {promise, resolve});
-    return promise;
+    const pendingOperations = Array.from(pendingOperationsForOwner.values());
+    this._ownersToPendingPromise.set(ownerIdentifier, {
+      promise,
+      resolve,
+      pendingOperations,
+    });
+    return {promise, pendingOperations};
   }
 }
 

package/store/RelayOptimisticRecordSource.js.flow

@@ -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.
@@ -12,8 +12,6 @@
 
 'use strict';
 
-const RelayRecordSource = require('./RelayRecordSource');
-
 import type {DataID} from '../util/RelayRuntimeTypes';
 import type {RecordState} from './RelayRecordState';
 import type {
@@ -22,6 +20,8 @@ import type {
   RecordSource,
 } from './RelayStoreTypes';
 
+const RelayRecordSource = require('./RelayRecordSource');
+
 const UNPUBLISH_RECORD_SENTINEL = Object.freeze({
   __UNPUBLISH_RECORD_SENTINEL: true,
 });