relay-runtime 20.1.1 → 21.0.1

package/query/fetchQuery.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+
+import { RelayObservable } from '../network/RelayObservable';
+import { Environment } from '../store/RelayStoreTypes';
+import {CacheConfig, FetchQueryFetchPolicy, OperationType} from '../util/RelayRuntimeTypes';
+import { GraphQLTaggedNode } from './GraphQLTag';
+
+export function fetchQuery<T extends OperationType>(
+    environment: Environment,
+    taggedNode: GraphQLTaggedNode,
+    variables: T['variables'],
+    cacheConfig?: {
+        networkCacheConfig?: CacheConfig | null | undefined;
+        fetchPolicy?: FetchQueryFetchPolicy | null | undefined;
+    } | null,
+): RelayObservable<T['response']>;

package/query/fetchQuery.js.flow

@@ -112,11 +112,11 @@ const invariant = require('invariant');
  * ```
  * NOTE: When using .toPromise(), the request cannot be cancelled.
  */
-function fetchQuery<TVariables: Variables, TData, TRawResponse>(
+function fetchQuery<TVariables extends Variables, TData, TRawResponse>(
   environment: IEnvironment,
   query: Query<TVariables, TData, TRawResponse>,
   variables: NoInfer<TVariables>,
-  options?: $ReadOnly<{
+  options?: Readonly<{
     fetchPolicy?: FetchQueryFetchPolicy,
     networkCacheConfig?: CacheConfig,
   }>,
@@ -139,7 +139,7 @@ function fetchQuery<TVariables: Variables, TData, TRawResponse>(
 
   function readData(snapshot: Snapshot): TData {
     handlePotentialSnapshotErrors(environment, snapshot.fieldErrors);
-    /* $FlowFixMe[incompatible-return] we assume readData returns the right
+    /* $FlowFixMe[incompatible-type] we assume readData returns the right
      * data just having written it from network or checked availability. */
     return snapshot.data;
   }
@@ -151,22 +151,35 @@ function fetchQuery<TVariables: Variables, TData, TRawResponse>(
       );
     }
     case 'store-or-network': {
-      if (environment.check(operation).status === 'available') {
-        return RelayObservable.from<Snapshot>(
+      const queryAvailability = environment.check(operation);
+      const shouldFetch = queryAvailability.status !== 'available';
+      let observable;
+      if (!shouldFetch) {
+        observable = RelayObservable.from<Snapshot>(
           environment.lookup(operation.fragment),
         ).map(readData);
+      } else {
+        observable = getNetworkObservable<$FlowFixMe>(
+          environment,
+          operation,
+        ).map(readData);
       }
-      return getNetworkObservable<$FlowFixMe>(environment, operation).map(
-        readData,
-      );
+      environment.__log({
+        name: 'fetchquery.fetch',
+        operation,
+        fetchPolicy,
+        queryAvailability,
+        shouldFetch,
+      });
+      return observable;
     }
     default:
-      (fetchPolicy: empty);
+      fetchPolicy as empty;
       throw new Error('fetchQuery: Invalid fetchPolicy ' + fetchPolicy);
   }
 }
 
-function getNetworkObservable<TQuery: OperationType>(
+function getNetworkObservable<TQuery extends OperationType>(
   environment: IEnvironment,
   operation: OperationDescriptor,
 ): RelayObservable<TQuery['response']> {

package/query/fetchQueryInternal.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+
+import { GraphQLResponse } from '../network/RelayNetworkTypes';
+import { RelayObservable as Observable } from '../network/RelayObservable';
+import {Environment, OperationDescriptor, RequestDescriptor} from '../store/RelayStoreTypes';
+import { RequestIdentifier } from '../util/getRequestIdentifier';
+
+export function fetchQuery(environment: Environment, operation: OperationDescriptor): Observable<GraphQLResponse>;
+
+export function fetchQueryDeduped(
+    environment: Environment,
+    identifier: RequestIdentifier,
+    fetchFn: () => Observable<GraphQLResponse>,
+): Observable<GraphQLResponse>;
+
+export function getPromiseForActiveRequest(environment: Environment, request: RequestDescriptor): Promise<void> | null;
+
+export function getObservableForActiveRequest(
+    environment: Environment,
+    request: RequestDescriptor,
+): Observable<void> | null;

package/query/fetchQueryInternal.js.flow

@@ -25,10 +25,10 @@ const RelayReplaySubject = require('../util/RelayReplaySubject');
 const invariant = require('invariant');
 
 type RequestCacheEntry = {
-  +identifier: RequestIdentifier,
-  +subject: RelayReplaySubject<GraphQLResponse>,
-  +subjectForInFlightStatus: RelayReplaySubject<GraphQLResponse>,
-  +subscription: Subscription,
+  readonly identifier: RequestIdentifier,
+  readonly subject: RelayReplaySubject<GraphQLResponse>,
+  readonly subjectForInFlightStatus: RelayReplaySubject<GraphQLResponse>,
+  readonly subscription: Subscription,
   promise: ?Promise<void>,
 };
 

package/query/fetchQuery_DEPRECATED.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+
+import { Environment } from '../store/RelayStoreTypes';
+import {CacheConfig, OperationType} from '../util/RelayRuntimeTypes';
+import { GraphQLTaggedNode } from './GraphQLTag';
+
+export function fetchQuery_DEPRECATED<T extends OperationType>(
+    environment: Environment,
+    taggedNode: GraphQLTaggedNode,
+    variables: T['variables'],
+    cacheConfig?: CacheConfig | null,
+): Promise<T['response']>;

package/query/fetchQuery_DEPRECATED.js.flow

@@ -26,7 +26,7 @@ const {getRequest} = require('./GraphQLTag');
  * order to be accessible in the result object.
  */
 
-function fetchQuery_DEPRECATED<T: OperationType>(
+function fetchQuery_DEPRECATED<T extends OperationType>(
   environment: IEnvironment,
   taggedNode: GraphQLTaggedNode,
   variables: T['variables'],

package/store/ClientID.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ */
+
+import { DataID } from '../util/RelayRuntimeTypes';
+
+export function generateClientID(id: DataID, storageKey: string, index?: number): DataID;
+
+export function isClientID(id: DataID): boolean;
+
+export function generateUniqueClientID(): DataID;

package/store/DataChecker.js.flow

@@ -46,8 +46,8 @@ const {TYPE_SCHEMA_TYPE, generateTypeID} = require('./TypeID');
 const invariant = require('invariant');
 
 export type Availability = {
-  +status: 'available' | 'missing',
-  +mostRecentlyInvalidatedAt: ?number,
+  readonly status: 'available' | 'missing',
+  readonly mostRecentlyInvalidatedAt: ?number,
 };
 
 const {getModuleOperationKey, getStorageKey, getArgumentValues} =
@@ -68,7 +68,7 @@ function check(
   getTargetForActor: (actorIdentifier: ActorIdentifier) => MutableRecordSource,
   defaultActorIdentifier: ActorIdentifier,
   selector: NormalizationSelector,
-  handlers: $ReadOnlyArray<MissingFieldHandler>,
+  handlers: ReadonlyArray<MissingFieldHandler>,
   operationLoader: ?OperationLoader,
   getDataID: GetDataID,
   shouldProcessClientComponents: ?boolean,
@@ -108,7 +108,7 @@ function check(
  * @private
  */
 class DataChecker {
-  _handlers: $ReadOnlyArray<MissingFieldHandler>;
+  _handlers: ReadonlyArray<MissingFieldHandler>;
   _mostRecentlyInvalidatedAt: number | null;
   _mutator: RelayRecordSourceMutator;
   _operationLoader: OperationLoader | null;
@@ -118,12 +118,14 @@ class DataChecker {
   _useExecTimeResolvers: boolean;
   _variables: Variables;
   _shouldProcessClientComponents: ?boolean;
-  +_getSourceForActor: (actorIdentifier: ActorIdentifier) => RecordSource;
-  +_getTargetForActor: (
+  readonly _getSourceForActor: (
+    actorIdentifier: ActorIdentifier,
+  ) => RecordSource;
+  readonly _getTargetForActor: (
     actorIdentifier: ActorIdentifier,
   ) => MutableRecordSource;
-  +_getDataID: GetDataID;
-  +_mutatorRecordSourceProxyCache: Map<
+  readonly _getDataID: GetDataID;
+  readonly _mutatorRecordSourceProxyCache: Map<
     ActorIdentifier,
     [RelayRecordSourceMutator, RelayRecordSourceProxy],
   >;
@@ -136,7 +138,7 @@ class DataChecker {
     ) => MutableRecordSource,
     defaultActorIdentifier: ActorIdentifier,
     variables: Variables,
-    handlers: $ReadOnlyArray<MissingFieldHandler>,
+    handlers: ReadonlyArray<MissingFieldHandler>,
     operationLoader: ?OperationLoader,
     getDataID: GetDataID,
     shouldProcessClientComponents: ?boolean,
@@ -193,16 +195,16 @@ class DataChecker {
 
     return this._recordWasMissing === true
       ? {
-          status: 'missing',
           mostRecentlyInvalidatedAt: this._mostRecentlyInvalidatedAt,
+          status: 'missing',
         }
       : {
-          status: 'available',
           mostRecentlyInvalidatedAt: this._mostRecentlyInvalidatedAt,
+          status: 'available',
         };
   }
 
-  _getVariableValue(name: string): mixed {
+  _getVariableValue(name: string): unknown {
     invariant(
       this._variables.hasOwnProperty(name),
       'RelayAsyncLoader(): Undefined variable `%s`.',
@@ -218,7 +220,7 @@ class DataChecker {
   _handleMissingScalarField(
     field: NormalizationScalarField,
     dataID: DataID,
-  ): mixed {
+  ): unknown {
     if (field.name === 'id' && field.alias == null && isClientID(dataID)) {
       return undefined;
     }
@@ -239,6 +241,15 @@ class DataChecker {
         }
       }
     }
+    if (this._log != null) {
+      this._log({
+        name: 'store.datachecker.missing',
+        kind: 'scalar',
+        dataID,
+        fieldName: field.name,
+        storageKey: getStorageKey(field, this._variables),
+      });
+    }
     this._handleMissing();
   }
 
@@ -266,6 +277,15 @@ class DataChecker {
         }
       }
     }
+    if (this._log != null) {
+      this._log({
+        name: 'store.datachecker.missing',
+        kind: 'linked',
+        dataID,
+        fieldName: field.name,
+        storageKey: getStorageKey(field, this._variables),
+      });
+    }
     this._handleMissing();
   }
 
@@ -299,12 +319,28 @@ class DataChecker {
         }
       }
     }
+    if (this._log != null) {
+      this._log({
+        name: 'store.datachecker.missing',
+        kind: 'pluralLinked',
+        dataID,
+        fieldName: field.name,
+        storageKey: getStorageKey(field, this._variables),
+      });
+    }
     this._handleMissing();
   }
 
   _traverse(node: NormalizationNode, dataID: DataID): void {
     const status = this._mutator.getStatus(dataID);
     if (status === UNKNOWN) {
+      if (this._log != null) {
+        this._log({
+          name: 'store.datachecker.missing',
+          kind: 'unknown_record',
+          dataID,
+        });
+      }
       this._handleMissing();
     }
 
@@ -323,7 +359,7 @@ class DataChecker {
   }
 
   _traverseSelections(
-    selections: $ReadOnlyArray<NormalizationSelection>,
+    selections: ReadonlyArray<NormalizationSelection>,
     dataID: DataID,
   ): void {
     selections.forEach(selection => {
@@ -470,7 +506,7 @@ class DataChecker {
           }
           break;
         default:
-          (selection: empty);
+          selection as empty;
           invariant(
             false,
             'RelayAsyncLoader(): Unexpected ast kind `%s`.',