react-relay 20.1.1 → 21.0.1

package/ReactRelayTypes.d.ts

@@ -0,0 +1,377 @@
+/**
+ * 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 * as React from 'react';
+import {
+  _FragmentRefs,
+  _RefType,
+  CacheConfig,
+  ConcreteRequest,
+  Disposable,
+  DisposeFn,
+  Environment,
+  FetchPolicy,
+  FragmentType,
+  GraphQLResponse,
+  IEnvironment,
+  Observable,
+  Observer,
+  OperationType,
+  PreloadableConcreteRequest,
+  RenderPolicy,
+  Variables,
+  VariablesOf,
+} from 'relay-runtime';
+
+export { FragmentRef } from 'relay-runtime';
+export { VariablesOf } from 'relay-runtime';
+
+// --- Legacy container types ---
+
+export interface RelayProp {
+    environment: Environment;
+    refetch: undefined; // ensures no RelayRefetchProp is used with a fragment container
+    hasMore: undefined; // ensures no RelayPaginationProp is used with a fragment container
+}
+
+export interface RelayRefetchProp {
+    environment: Environment;
+    refetch: (
+        refetchVariables: Variables | ((fragmentVariables: Variables) => Variables),
+        renderVariables?: Variables | null,
+        observerOrCallback?: ObserverOrCallback | null,
+        options?: RefetchOptions,
+    ) => Disposable;
+    hasMore: undefined; // ensures no RelayPaginationProp is used with a refetch container
+}
+export interface RefetchOptions {
+    force?: boolean | undefined;
+    fetchPolicy?: 'store-or-network' | 'network-only' | undefined;
+}
+
+type ObserverOrCallback = Observer<void> | ((error: Error | null | undefined) => void);
+
+export interface RelayPaginationProp {
+    readonly environment: Environment;
+    readonly hasMore: () => boolean;
+    readonly isLoading: () => boolean;
+    readonly loadMore: (
+        pageSize: number,
+        observerOrCallback?: ObserverOrCallback | null,
+        options?: RefetchOptions | null,
+    ) => Disposable | null | undefined;
+    readonly refetchConnection: (
+        totalCount: number,
+        observerOrCallback?: ObserverOrCallback | null,
+        refetchVariables?: Variables | null,
+    ) => Disposable | null | undefined;
+    refetch: undefined; // ensures no RelayRefetchProp is used with a pagination container
+}
+
+export type FragmentOrRegularProp<T> = T extends _RefType<infer U> ? _FragmentRefs<U>
+    : T extends ReadonlyArray<_RefType<infer U>> ? ReadonlyArray<_FragmentRefs<U>>
+    : T;
+
+export type MappedFragmentProps<T> = {
+    [K in keyof T]: FragmentOrRegularProp<T[K]>;
+};
+
+// --- Fragment key types (from helpers) ---
+
+export type KeyType<TData = unknown> = Readonly<{
+    ' $data'?: TData | undefined;
+    ' $fragmentSpreads': FragmentType;
+}>;
+
+export type KeyTypeData<TKey extends KeyType<TData>, TData = unknown> = Required<TKey>[' $data'];
+
+export type ArrayKeyType<TData = unknown> = ReadonlyArray<KeyType<readonly TData[]> | null | undefined>;
+export type ArrayKeyTypeData<TKey extends ArrayKeyType<TData>, TData = unknown> = KeyTypeData<
+    NonNullable<TKey[number]>
+>;
+
+export type GetEntryPointParamsFromEntryPoint<TEntryPoint> = TEntryPoint extends EntryPoint<
+    infer _TEntryPointComponent,
+    infer TEntryPointParams
+> ? TEntryPointParams
+    : never;
+
+export type GetEntryPointComponentFromEntryPoint<TEntryPoint> = TEntryPoint extends EntryPoint<
+    infer TEntryPointComponent,
+    infer _TEntryPointParams
+> ? TEntryPointComponent
+    : never;
+
+// --- EntryPoint types ---
+
+export interface JSResourceReference<TModule> {
+    getModuleId(): string;
+
+    getModuleIfRequired(): TModule | null;
+
+    load(): Promise<TModule>;
+}
+
+export type PreloadFetchPolicy = 'store-or-network' | 'store-and-network' | 'network-only';
+
+export type PreloadOptions = Readonly<{
+    fetchKey?: string | number | undefined;
+    fetchPolicy?: PreloadFetchPolicy | null | undefined;
+    networkCacheConfig?: CacheConfig | null | undefined;
+}>;
+
+export type LoadQueryOptions = Readonly<{
+    fetchPolicy?: FetchPolicy | null | undefined;
+    networkCacheConfig?: CacheConfig | null | undefined;
+    onQueryAstLoadTimeout?: (() => void) | null | undefined;
+}>;
+
+export type EnvironmentProviderOptions<T extends Record<string, unknown> = Record<string, unknown>> = T;
+
+export type PreloadedQuery<
+    TQuery extends OperationType,
+    TEnvironmentProviderOptions = EnvironmentProviderOptions,
+> = Readonly<{
+    kind: 'PreloadedQuery';
+    environment: IEnvironment;
+    environmentProviderOptions?: TEnvironmentProviderOptions | null | undefined;
+    fetchKey: string | number;
+    fetchPolicy: PreloadFetchPolicy;
+    networkCacheConfig?: CacheConfig | null | undefined;
+    id?: string | null | undefined;
+    name: string;
+    source?: Observable<GraphQLResponse> | null | undefined;
+    variables: VariablesOf<TQuery>;
+    dispose: DisposeFn;
+    isDisposed: boolean;
+}>;
+
+export type PreloadQueryStatus = Readonly<{
+    cacheConfig?: CacheConfig | null | undefined;
+    source: 'cache' | 'network';
+    fetchTime?: number | null | undefined;
+}>;
+
+/**
+ * The Interface of the EntryPoints .entrypoint files
+ *
+ * Every .entrypoint file it's an object that must have two required fields:
+ * - getPreloadProps(...)  function that will return the description of preloaded
+ *   queries and preloaded (nested) entry points for the current entry point
+ * - root - JSResource of the module that will render those preloaded queries
+ *
+ * TEntryPointParams - object that contains all necessary information to execute
+ * the preloaders (routeParams, query variables)
+ *
+ * TPreloadedQueries -  queries, defined in the root components
+ *
+ * TNestedEntryPoints - nested entry points, defined in the root components
+ *
+ * TRuntimeProps - the type of additional props that you may pass to the
+ * component (like `onClick` handler, etc) during runtime. Values for them
+ * defined during component runtime
+ *
+ * TExtraProps - a bag of extra props that you may define in `entrypoint` file
+ * and they will be passed to the EntryPointComponent as `extraProps`
+ */
+type InternalEntryPointRepresentation<
+    TEntryPointParams extends Record<string, unknown>,
+    TPreloadedQueries extends Record<string, OperationType>,
+    TNestedEntryPoints extends Record<string, unknown>,
+    TRuntimeProps extends Record<string, unknown>,
+    TExtraProps extends Record<string, unknown> | null,
+> = Readonly<{
+    root: JSResourceReference<
+        EntryPointComponent<TPreloadedQueries, TNestedEntryPoints, TRuntimeProps, TExtraProps>
+    >;
+    getPreloadProps: (
+        entryPointParams: TEntryPointParams,
+    ) => PreloadProps<TEntryPointParams, TPreloadedQueries, TNestedEntryPoints, TExtraProps>;
+}>;
+
+type ThinQueryParamsObject<TPreloadedQueries extends Record<string, OperationType> = Record<string, never>> = {
+    [K in keyof TPreloadedQueries]: ThinQueryParams<TPreloadedQueries[K]>;
+};
+
+type ThinNestedEntryPointParamsObject<
+    TEntryPoints extends Record<string, EntryPoint<any, any> | undefined> = Record<string, never>,
+> = {
+    [K in keyof TEntryPoints]: ThinNestedEntryPointParams<TEntryPoints[K]>;
+};
+
+type PreloadedQueries<TPreloadedQueries> = TPreloadedQueries extends Record<string, OperationType> ? {
+        [T in keyof TPreloadedQueries]: PreloadedQuery<TPreloadedQueries[T]>;
+    }
+    : never;
+
+type PreloadedEntryPoints<TEntryPoints> = TEntryPoints extends Record<
+    string,
+    InternalEntryPointRepresentation<any, any, any, any, any> | undefined
+> ? {
+        [T in keyof TEntryPoints]: PreloadedEntryPoint<
+            GetEntryPointComponentFromEntryPoint<TEntryPoints[T]>
+        >;
+    }
+    : never;
+
+export type PreloadProps<
+    _TPreloadParams extends Record<string, unknown>,
+    TPreloadedQueries extends Record<string, OperationType>,
+    TNestedEntryPoints extends Record<string, EntryPoint<any, any> | undefined>,
+    TExtraProps extends Record<string, unknown> | null,
+> = Readonly<{
+    entryPoints?: ThinNestedEntryPointParamsObject<TNestedEntryPoints> | undefined;
+    extraProps?: TExtraProps | undefined;
+    queries?: ThinQueryParamsObject<TPreloadedQueries> | undefined;
+}>;
+
+export type EntryPointProps<TPreloadedQueries, TNestedEntryPoints, TRuntimeProps, TExtraProps> = Readonly<{
+    entryPoints: PreloadedEntryPoints<TNestedEntryPoints>;
+    extraProps: TExtraProps;
+    props: TRuntimeProps;
+    queries: PreloadedQueries<TPreloadedQueries>;
+}>;
+
+export type EntryPointComponent<
+    TPreloadedQueries extends Record<string, OperationType>,
+    TNestedEntryPoints extends Record<string, EntryPoint<any, any> | undefined>,
+    TRuntimeProps extends Record<string, unknown> = Record<string, unknown>,
+    TExtraProps extends Record<string, unknown> | null = Record<string, unknown>,
+> = React.ComponentType<EntryPointProps<TPreloadedQueries, TNestedEntryPoints, TRuntimeProps, TExtraProps>>;
+
+export type PreloadedEntryPoint<TEntryPointComponent> = TEntryPointComponent extends EntryPointComponent<
+    infer TPreloadedQueries,
+    infer TNestedEntryPoints,
+    infer _TRuntimeProps,
+    infer TExtraProps
+> ? Readonly<{
+        dispose: DisposeFn;
+        entryPoints: PreloadedEntryPoints<TNestedEntryPoints>;
+        extraProps: TExtraProps;
+        getComponent: () => TEntryPointComponent;
+        isDisposed: boolean;
+        queries: PreloadedQueries<TPreloadedQueries>;
+        rootModuleID: string;
+    }>
+    : never;
+
+export type ThinQueryParams<
+    TQuery extends OperationType,
+    TEnvironmentProviderOptions extends EnvironmentProviderOptions = EnvironmentProviderOptions,
+> = Readonly<{
+    parameters: ConcreteRequest | PreloadableConcreteRequest<TQuery>;
+    variables: VariablesOf<TQuery>;
+    options?: PreloadOptions | null | undefined;
+    environmentProviderOptions?: TEnvironmentProviderOptions | null | undefined;
+}>;
+
+export type ThinNestedEntryPointParams<TEntryPoint> = Readonly<{
+    entryPoint: TEntryPoint;
+    entryPointParams: GetEntryPointParamsFromEntryPoint<TEntryPoint>;
+}>;
+
+export type EntryPoint<TEntryPointComponent, TEntryPointParams extends Record<string, unknown> = Record<string, unknown>> = InternalEntryPointRepresentation<
+    TEntryPointParams,
+    TEntryPointComponent extends EntryPointComponent<infer TPreloadedQueries, any, any, any> ? TPreloadedQueries
+        : never,
+    TEntryPointComponent extends EntryPointComponent<any, infer TNestedEntryPoints, any, any> ? TNestedEntryPoints
+        : never,
+    TEntryPointComponent extends EntryPointComponent<any, any, infer TRuntimeProps, any> ? TRuntimeProps : never,
+    TEntryPointComponent extends EntryPointComponent<any, any, any, infer TExtraProps> ? TExtraProps : never
+>;
+
+export interface IEnvironmentProvider<TOptions> {
+    getEnvironment(options: TOptions | null): IEnvironment;
+}
+
+// --- Refetchable fragment types (from useRefetchableFragmentNode) ---
+
+export type RefetchFn<TQuery extends OperationType, TOptions = RefetchableOptions> = RefetchFnExact<TQuery, TOptions>;
+
+export type RefetchFnDynamic<
+    TQuery extends OperationType,
+    _TKey extends KeyType | null | undefined,
+    TOptions = RefetchableOptions,
+> = RefetchInexactDynamicResponse<TQuery, TOptions> & RefetchExactDynamicResponse<TQuery, TOptions>;
+
+export type RefetchInexact<TQuery extends OperationType, TOptions> = (
+    data?: unknown,
+) => RefetchFnInexact<TQuery, TOptions>;
+export type RefetchInexactDynamicResponse<TQuery extends OperationType, TOptions> = ReturnType<
+    RefetchInexact<TQuery, TOptions>
+>;
+
+export type RefetchExact<TQuery extends OperationType, TOptions> = (
+    data?: unknown | null,
+) => RefetchFnExact<TQuery, TOptions>;
+export type RefetchExactDynamicResponse<TQuery extends OperationType, TOptions> = ReturnType<
+    RefetchExact<TQuery, TOptions>
+>;
+
+export type RefetchFnBase<TVars, TOptions> = (vars: TVars, options?: TOptions) => Disposable;
+
+export type RefetchFnExact<TQuery extends OperationType, TOptions = RefetchableOptions> = RefetchFnBase<
+    VariablesOf<TQuery>,
+    TOptions
+>;
+export type RefetchFnInexact<TQuery extends OperationType, TOptions = RefetchableOptions> = RefetchFnBase<
+    Partial<VariablesOf<TQuery>>,
+    TOptions
+>;
+
+export interface ReturnTypeNode<
+    TQuery extends OperationType,
+    TKey extends KeyType | null | undefined,
+    TOptions = RefetchableOptions,
+> {
+    fragmentData: unknown;
+    fragmentRef: unknown;
+    refetch: RefetchFnDynamic<TQuery, TKey, TOptions>;
+    disableStoreUpdates: () => void;
+    enableStoreUpdates: () => void;
+}
+
+export interface RefetchableOptions {
+    fetchPolicy?: FetchPolicy | undefined;
+    onComplete?: ((arg: Error | null) => void) | undefined;
+    UNSTABLE_renderPolicy?: RenderPolicy | undefined;
+}
+
+export interface InternalRefetchableOptions extends RefetchableOptions {
+    __environment?: IEnvironment | undefined;
+}
+
+export type RefetchableAction =
+    | {
+        type: 'reset';
+        environment: IEnvironment;
+        fragmentIdentifier: string;
+    }
+    | {
+        type: 'refetch';
+        refetchVariables: Variables;
+        fetchPolicy?: FetchPolicy | undefined;
+        renderPolicy?: RenderPolicy | undefined;
+        onComplete?: ((args: Error | null) => void) | undefined;
+        environment?: IEnvironment | null | undefined;
+    };
+
+export interface RefetchState {
+    fetchPolicy?: FetchPolicy | undefined;
+    renderPolicy?: RenderPolicy | undefined;
+    mirroredEnvironment: IEnvironment;
+    mirroredFragmentIdentifier: string;
+    onComplete?: ((arg: Error | null) => void) | undefined;
+    refetchEnvironment?: IEnvironment | null | undefined;
+    refetchVariables?: Variables | null | undefined;
+    refetchGeneration: number;
+}
+
+export interface DebugIDandTypename {
+    id: string;
+    typename: string;
+}

package/ReactRelayTypes.js.flow

@@ -22,22 +22,22 @@ import type {
 
 export type GeneratedNodeMap = {[key: string]: GraphQLTaggedNode, ...};
 
-export type ObserverOrCallback = Observer<void> | ((error: ?Error) => mixed);
+export type ObserverOrCallback = Observer<void> | ((error: ?Error) => unknown);
 
 // NOTE: This is an inexact type in order to allow a RelayPaginationProp or
 // RelayRefetchProp to flow into a RelayProp.
-export type RelayProp = {+environment: IEnvironment, ...};
+export type RelayProp = {readonly environment: IEnvironment, ...};
 
 export type RelayPaginationProp = {
-  +environment: IEnvironment,
-  +hasMore: () => boolean,
-  +isLoading: () => boolean,
-  +loadMore: (
+  readonly environment: IEnvironment,
+  readonly hasMore: () => boolean,
+  readonly isLoading: () => boolean,
+  readonly loadMore: (
     pageSize: number,
     observerOrCallback: ?ObserverOrCallback,
     options?: RefetchOptions,
   ) => ?Disposable,
-  +refetchConnection: (
+  readonly refetchConnection: (
     totalCount: number,
     observerOrCallback: ?ObserverOrCallback,
     refetchVariables: ?Variables,
@@ -45,8 +45,8 @@ export type RelayPaginationProp = {
 };
 
 export type RelayRefetchProp = {
-  +environment: IEnvironment,
-  +refetch: (
+  readonly environment: IEnvironment,
+  readonly refetch: (
     refetchVariables: Variables | ((fragmentVariables: Variables) => Variables),
     renderVariables: ?Variables,
     observerOrCallback: ?ObserverOrCallback,
@@ -55,9 +55,9 @@ export type RelayRefetchProp = {
 };
 
 export type RefetchOptions = {
-  +force?: boolean,
-  +fetchPolicy?: 'store-or-network' | 'network-only',
-  +metadata?: {[key: string]: mixed, ...},
+  readonly force?: boolean,
+  readonly fetchPolicy?: 'store-or-network' | 'network-only',
+  readonly metadata?: {[key: string]: unknown, ...},
 };
 
 /**
@@ -93,15 +93,15 @@ export type RefetchOptions = {
  *
  */
 export type $FragmentRef<T> = {
-  +$fragmentSpreads: T['$fragmentType'],
+  readonly $fragmentSpreads: T['$fragmentType'],
   ...
 };
 
 /* $FlowExpectedError[unclear-type]: Intentional so that it won't fail,
  * even if the type we want to exclude doesn't exist in Props */
-type LooseOmitRelayProps<Props, K: $Keys<any>> = Pick<
+type LooseOmitRelayProps<Props, K extends keyof any> = Pick<
   Props,
-  Exclude<$Keys<Props>, K>,
+  Exclude<keyof Props, K>,
 >;
 /**
  * A utility type that takes the Props of a component and the type of
@@ -114,51 +114,55 @@ export type $RelayProps<Props, _RelayPropT = RelayProp> = MapRelayProps<
 >;
 
 type MapRelayProps<Props> = {[K in keyof Props]: MapRelayProp<Props[K]>};
-type MapRelayProp<T> = [+t: T] extends [+t: {+$fragmentType: empty, ...}]
+type MapRelayProp<T> = [readonly t: T] extends [
+  readonly t: {readonly $fragmentType: empty, ...},
+]
   ? T
-  : [+t: T] extends [+t: ?{+$fragmentType: empty, ...}]
+  : [readonly t: T] extends [readonly t: ?{readonly $fragmentType: empty, ...}]
     ? ?T
-    : [+t: T] extends [+t: {+$fragmentType: FragmentType, ...}]
+    : [readonly t: T] extends [
+          readonly t: {readonly $fragmentType: FragmentType, ...},
+        ]
       ? $FragmentRef<T>
-      : [+t: T] extends [+t: ?{+$fragmentType: FragmentType, ...}]
-        ? ?$FragmentRef<$NonMaybeType<T>>
-        : [+t: T] extends [
-              +t: $ReadOnlyArray<
-                infer V extends {+$fragmentType: FragmentType, ...},
+      : [readonly t: T] extends [
+            readonly t: ?{readonly $fragmentType: FragmentType, ...},
+          ]
+        ? ?$FragmentRef<NonNullable<T>>
+        : [readonly t: T] extends [
+              readonly t: ReadonlyArray<
+                infer V extends {readonly $fragmentType: FragmentType, ...},
               >,
             ]
-          ? $ReadOnlyArray<$FragmentRef<V>>
-          : [+t: T] extends [
-                +t: ?$ReadOnlyArray<
-                  infer V extends {+$fragmentType: FragmentType, ...},
+          ? ReadonlyArray<$FragmentRef<V>>
+          : [readonly t: T] extends [
+                readonly t: ?ReadonlyArray<
+                  infer V extends {readonly $fragmentType: FragmentType, ...},
                 >,
               ]
-            ? ?$ReadOnlyArray<$FragmentRef<V>>
-            : [+t: T] extends [
-                  +t: $ReadOnlyArray<?infer V extends {
-                    +$fragmentType: FragmentType,
+            ? ?ReadonlyArray<$FragmentRef<V>>
+            : [readonly t: T] extends [
+                  readonly t: ReadonlyArray<?infer V extends {
+                    readonly $fragmentType: FragmentType,
                     ...
                   }>,
                 ]
-              ? $ReadOnlyArray<?$FragmentRef<$NonMaybeType<V>>>
-              : [+t: T] extends [
-                    +t: ?$ReadOnlyArray<?infer V extends {
-                      +$fragmentType: FragmentType,
+              ? ReadonlyArray<?$FragmentRef<NonNullable<V>>>
+              : [readonly t: T] extends [
+                    readonly t: ?ReadonlyArray<?infer V extends {
+                      readonly $fragmentType: FragmentType,
                       ...
                     }>,
                   ]
-                ? ?$ReadOnlyArray<?$FragmentRef<$NonMaybeType<V>>>
+                ? ?ReadonlyArray<?$FragmentRef<NonNullable<V>>>
                 : T;
 
-export type RelayFragmentContainer<TComponent: component(...empty)> = component(
-  ...$RelayProps<React.ElementConfig<TComponent>, RelayProp>
-);
+export type RelayFragmentContainer<TComponent extends component(...empty)> =
+  component(...$RelayProps<React.ElementConfig<TComponent>, RelayProp>);
 
-export type RelayPaginationContainer<TComponent: component(...empty)> =
+export type RelayPaginationContainer<TComponent extends component(...empty)> =
   component(
     ...$RelayProps<React.ElementConfig<TComponent>, RelayPaginationProp>
   );
 
-export type RelayRefetchContainer<TComponent: component(...empty)> = component(
-  ...$RelayProps<React.ElementConfig<TComponent>, RelayRefetchProp>
-);
+export type RelayRefetchContainer<TComponent extends component(...empty)> =
+  component(...$RelayProps<React.ElementConfig<TComponent>, RelayRefetchProp>);

package/RelayContext.js.flow

@@ -20,21 +20,21 @@ const invariant = require('invariant');
  * Asserts that the input is a matches the `RelayContext` type defined in
  * `RelayEnvironmentTypes` and returns it as that type.
  */
-function assertRelayContext(relay: mixed): RelayContext {
+function assertRelayContext(relay: unknown): RelayContext {
   invariant(
     isRelayContext(relay),
     'RelayContext: Expected `context.relay` to be an object conforming to ' +
       'the `RelayContext` interface, got `%s`.',
     relay,
   );
-  return (relay: any);
+  return relay as any;
 }
 
 /**
  * Determine if the input is a plain object that matches the `RelayContext`
  * type defined in `RelayEnvironmentTypes`.
  */
-function isRelayContext(context: mixed): boolean {
+function isRelayContext(context: unknown): boolean {
   return (
     typeof context === 'object' &&
     context !== null &&

package/__flowtests__/ReactRelayFragmentContainer-flowtest.js.flow

@@ -54,10 +54,10 @@ class BarComponent extends React.Component<{
     const reqLen = this.props.requiredProp.length;
     const optionalProp = this.props.optionalProp;
 
-    /** $FlowExpectedError: `optionalProp` might be null **/
+    /** $FlowExpectedError[incompatible-use] : `optionalProp` might be null **/
     const optionalFoo = this.props.optionalProp.foo;
 
-    /** $FlowExpectedError: there is no prop `missingProp` **/
+    /** $FlowExpectedError[prop-missing] : there is no prop `missingProp` **/
     const missing = this.props.missingProp;
 
     const defLen = this.props.defaultProp.length; // always a valid string, so no error
@@ -78,7 +78,7 @@ const Bar = createFragmentContainer(BarComponent, {
 
 module.exports = {
   checkMissingPropOnFunctionalComponent(): React.Node {
-    /** $FlowExpectedError: Foo missing `requiredProp` **/
+    /** $FlowExpectedError[incompatible-type] : Foo missing `requiredProp` **/
     return <Foo />;
   },
   checkMinimalPropsOnFunctionalComponent(): React.Node {
@@ -86,7 +86,7 @@ module.exports = {
     return <Foo requiredProp="foo" />;
   },
   checkMissingPropOnClassComponent(): React.Node {
-    /** $FlowExpectedError: Bar missing `requiredProp` **/
+    /** $FlowExpectedError[incompatible-type] : Bar missing `requiredProp` **/
     return <Bar />;
   },
   checkMinimalPropsOnClassComponent(): React.Node {
@@ -94,19 +94,19 @@ module.exports = {
     return <Bar requiredProp="foo" />;
   },
   checkWrongPropType(): React.Node {
-    /** $FlowExpectedError: Bar wrong `requiredProp` type, should be string **/
+    /** $FlowExpectedError[incompatible-type] : Bar wrong `requiredProp` type, should be string **/
     return <Bar requiredProp={17} />;
   },
   checkWrongOptionalType(): React.Node {
-    /** $FlowExpectedError: Bar wrong `optionalProp` type, should be `{foo: string}` **/
+    /** $FlowExpectedError[incompatible-type] : Bar wrong `optionalProp` type, should be `{foo: string}` **/
     return <Bar optionalProp="wrongType" requiredProp="foo" />;
   },
   checkNullOptionalType(): React.Node {
-    /** $FlowExpectedError: Bar `optionalProp` must be omitted or truthy, not null **/
+    /** $FlowExpectedError[incompatible-type] : Bar `optionalProp` must be omitted or truthy, not null **/
     return <Bar optionalProp={null} requiredProp="foo" />;
   },
   checkWrongDefaultPropType(): React.Node {
-    /** $FlowExpectedError: Bar wrong `defaultProp` type, should be string **/
+    /** $FlowExpectedError[incompatible-type] : Bar wrong `defaultProp` type, should be string **/
     return <Bar defaultProp={false} requiredProp="foo" />;
   },
   checkAllPossibleProps(): React.Node {
@@ -122,7 +122,7 @@ module.exports = {
   },
   checkMissingPropSpread(): React.Node {
     const props = {defaultProp: 'foo'};
-    /** $FlowExpectedError: Bar missing `requiredProp` with spread **/
+    /** $FlowExpectedError[incompatible-type] : Bar missing `requiredProp` with spread **/
     return <Bar {...props} />;
   },
   checkStaticsAndMethodsProxying(): React.Node {
@@ -131,10 +131,10 @@ module.exports = {
       getString(): string {
         const ok = this._barRef ? this._barRef.getNum() : 'default'; // legit
 
-        /** $FlowExpectedError: Bar does not have `missingMethod` **/
+        /** $FlowExpectedError[prop-missing] : Bar does not have `missingMethod` **/
         const bad = this._barRef ? this._barRef.missingMethod() : 'default';
 
-        /** $FlowExpectedError: Bar `getNum` gives number, but `getString` assumes string  **/
+        /** $FlowExpectedError[incompatible-type] : Bar `getNum` gives number, but `getString` assumes string  **/
         return bad ? 'not good' : ok;
       }
       render(): React.MixedElement {

package/__flowtests__/ReactRelayPaginationContainer-flowtest.js.flow

@@ -39,10 +39,10 @@ class FooComponent extends React.Component<$FlowFixMe> {
     const reqLen = this.props.requiredProp.length;
     const optionalProp = this.props.optionalProp;
 
-    /** $FlowExpectedError: `optionalProp` might be null **/
+    /** $FlowExpectedError[incompatible-use] : `optionalProp` might be null **/
     const optionalFoo = this.props.optionalProp.foo;
 
-    /** $FlowExpectedError: there is no prop `missingProp` **/
+    /** $FlowExpectedError[prop-missing] : there is no prop `missingProp` **/
     const missing = this.props.missingProp;
 
     const defLen = this.props.defaultProp.length; // always a valid string, so no error
@@ -140,7 +140,7 @@ module.exports = {
     return <Foo {...props} />;
   },
   checkStaticsAndMethodsProxying(): React.Node {
-    /* $FlowFixMe(>=0.53.0) This comment suppresses an
+    /* $FlowFixMe[missing-type-arg](>=0.53.0) This comment suppresses an
      * error when upgrading Flow's support for React. Common errors found when
      * upgrading Flow's React support are documented at
      * https://fburl.com/eq7bs81w */
@@ -149,10 +149,10 @@ module.exports = {
       getString(): string {
         const ok = this._fooRef ? this._fooRef.getNum() : 'default'; // legit
 
-        /** $FlowExpectedError: Foo does not have `missingMethod` **/
+        /** $FlowExpectedError[prop-missing] : Foo does not have `missingMethod` **/
         const bad = this._fooRef ? this._fooRef.missingMethod() : 'default';
 
-        /** $FlowExpectedError: Foo `getNum` gives number, but `getString` assumes string  **/
+        /** $FlowExpectedError[incompatible-type] : Foo `getNum` gives number, but `getString` assumes string  **/
         return bad ? 'not good' : ok;
       }
       render(): React.Node {