relay-runtime 20.1.1 → 21.0.1

package/network/RelayNetworkTypes.js.flow

@@ -21,12 +21,12 @@ import type RelayObservable, {ObservableFromValue} from './RelayObservable';
  * queries.
  */
 export interface INetwork {
-  +execute: ExecuteFunction;
+  readonly execute: ExecuteFunction;
 }
 
-export type LogRequestInfoFunction = mixed => void;
+export type LogRequestInfoFunction = unknown => void;
 
-export type PayloadData = {+[key: string]: mixed};
+export type PayloadData = {readonly [key: string]: unknown};
 
 export type PayloadError = interface {
   message: string,
@@ -40,26 +40,26 @@ export type PayloadError = interface {
   severity?: 'CRITICAL' | 'ERROR' | 'WARNING',
 };
 
-export type PayloadExtensions = {[key: string]: mixed, ...};
+export type PayloadExtensions = {[key: string]: unknown, ...};
 
 /**
  * The shape of a GraphQL response as dictated by the
  * [spec](https://spec.graphql.org/June2018/#sec-Response-Format).
  */
 export type GraphQLResponseWithData = {
-  +data: PayloadData,
-  +errors?: Array<PayloadError>,
-  +extensions?: PayloadExtensions,
-  +label?: string,
-  +path?: Array<string | number>,
+  readonly data: PayloadData,
+  readonly errors?: Array<PayloadError>,
+  readonly extensions?: PayloadExtensions,
+  readonly label?: string,
+  readonly path?: Array<string | number>,
 };
 
 export type GraphQLResponseWithoutData = {
-  +data?: ?PayloadData,
-  +errors: Array<PayloadError>,
-  +extensions?: PayloadExtensions,
-  +label?: string,
-  +path?: Array<string | number>,
+  readonly data?: ?PayloadData,
+  readonly errors: Array<PayloadError>,
+  readonly extensions?: PayloadExtensions,
+  readonly label?: string,
+  readonly path?: Array<string | number>,
 };
 
 export type GraphQLResponseWithExtensionsOnly = {
@@ -71,8 +71,8 @@ export type GraphQLResponseWithExtensionsOnly = {
   // since `data: null` is a *required* output if there was an error during
   // execution, but the inverse is not described in the sepc: `data: null`
   // does not necessarily indicate that there was an error.
-  +data: null,
-  +extensions: PayloadExtensions,
+  readonly data: null,
+  readonly extensions: PayloadExtensions,
 };
 
 export type GraphQLSingularResponse =
@@ -82,7 +82,7 @@ export type GraphQLSingularResponse =
 
 export type GraphQLResponse =
   | GraphQLSingularResponse
-  | $ReadOnlyArray<GraphQLSingularResponse>;
+  | ReadonlyArray<GraphQLSingularResponse>;
 
 /**
  * A function that pre-process the response at the network layer. This
@@ -134,4 +134,4 @@ export type SubscribeFunction = (
 ) => RelayObservable<GraphQLResponse>;
 
 export type Uploadable = File | Blob;
-export type UploadableMap = {+[key: string]: Uploadable};
+export type UploadableMap = {readonly [key: string]: Uploadable};

package/network/RelayObservable.d.ts

@@ -0,0 +1,197 @@
+/**
+ * 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.
+ */
+
+/**
+ * A Subscription object is returned from .subscribe(), which can be
+ * unsubscribed or checked to see if the resulting subscription has closed.
+ */
+export interface Subscription {
+    unsubscribe(): void;
+    readonly closed: boolean;
+}
+
+/**
+ * An Observer is an object of optional callback functions provided to
+ * .subscribe(). Each callback function is invoked when that event occurs.
+ */
+export interface Observer<T> {
+    readonly start?: ((subscription: Subscription) => void) | undefined;
+    readonly next?: ((value: T) => void) | undefined;
+    readonly error?: ((error: Error) => void) | undefined;
+    readonly complete?: (() => void) | undefined;
+    readonly unsubscribe?: ((subscription: Subscription) => void) | undefined;
+}
+
+/**
+ * A Sink is an object of methods provided by Observable during construction.
+ * The methods are to be called to trigger each event. It also contains a closed
+ * field to see if the resulting subscription has closed.
+ */
+export interface Sink<T> {
+    next(value: T): void;
+    error(error: Error, isUncaughtThrownError?: boolean): void;
+    complete(): void;
+    readonly closed: boolean;
+}
+
+/**
+ * A Source is the required argument when constructing a new Observable. Similar
+ * to a Promise constructor, this is a function which is invoked with a Sink,
+ * and may return either a cleanup function or a Subscription instance (for use
+ * when composing Observables).
+ */
+export type Source<T> = (sink: Sink<T>) => void | Subscription | (() => unknown);
+
+/**
+ * A Subscribable is an interface describing any object which can be subscribed.
+ *
+ * Note: A sink may be passed directly to .subscribe() as its observer,
+ * allowing for easily composing Subscribables.
+ */
+export interface Subscribable<T> {
+    subscribe(observer: Observer<T> | Sink<T>): Subscription;
+}
+
+export type ObservableFromValue<T> = Subscribable<T> | Promise<T> | T;
+
+/**
+ * Limited implementation of ESObservable, providing the limited set of behavior
+ * Relay networking requires.
+ *
+ * Observables retain the benefit of callbacks which can be called
+ * synchronously, avoiding any UI jitter, while providing a compositional API,
+ * which simplifies logic and prevents mishandling of errors compared to
+ * the direct use of callback functions.
+ *
+ * ESObservable: https://github.com/tc39/proposal-observable
+ */
+export class RelayObservable<T> implements Subscribable<T> {
+    // Use RelayObservable.create(source);
+    private constructor(source: never);
+
+    static create<V>(source: Source<V>): RelayObservable<V>;
+
+    /**
+     * When an emitted error event is not handled by an Observer, it is reported
+     * to the host environment (what the ESObservable spec refers to as
+     * "HostReportErrors()").
+     *
+     * The default implementation in development rethrows thrown errors, and
+     * logs emitted error events to the console, while in production does nothing
+     * (swallowing unhandled errors).
+     *
+     * Called during application initialization, this method allows
+     * application-specific handling of unhandled errors. Allowing, for example,
+     * integration with error logging or developer tools.
+     *
+     * A second parameter `isUncaughtThrownError` is true when the unhandled error
+     * was thrown within an Observer handler, and false when the unhandled error
+     * was an unhandled emitted event.
+     *
+     *  - Uncaught thrown errors typically represent avoidable errors thrown from
+     *    application code, which should be handled with a try/catch block, and
+     *    usually have useful stack traces.
+     *
+     *  - Unhandled emitted event errors typically represent unavoidable events in
+     *    application flow such as network failure, and may not have useful
+     *    stack traces.
+     */
+    static onUnhandledError(callback: (error: Error, isUncaughtThrownError: boolean) => void): void;
+
+    /**
+     * Accepts various kinds of data sources, and always returns a RelayObservable
+     * useful for accepting the result of a user-provided FetchFunction.
+     */
+    static from<V>(obj: ObservableFromValue<V>): RelayObservable<V>;
+
+    /**
+     * Similar to promise.catch(), observable.catch() handles error events, and
+     * provides an alternative observable to use in it's place.
+     *
+     * If the catch handler throws a new error, it will appear as an error event
+     * on the resulting Observable.
+     */
+    catch<U>(fn: (error: Error) => RelayObservable<U>): RelayObservable<T | U>;
+
+    /**
+     * Returns a new Observable which first yields values from this Observable,
+     * then yields values from the next Observable. This is useful for chaining
+     * together Observables of finite length.
+     */
+    concat<U>(next: RelayObservable<U>): RelayObservable<T | U>;
+
+    /**
+     * Returns a new Observable which returns the same values as this one, but
+     * modified so that the provided Observer is called to perform a side-effects
+     * for all events emitted by the source.
+     *
+     * Any errors that are thrown in the side-effect Observer are unhandled, and
+     * do not affect the source Observable or its Observer.
+     *
+     * This is useful for when debugging your Observables or performing other
+     * side-effects such as logging or performance monitoring.
+     */
+    do(observer: Observer<T>): RelayObservable<T>;
+
+    /**
+     * Returns a new Observable which returns the same values as this one, but
+     * modified so that the finally callback is performed after completion,
+     * whether normal or due to error or unsubscription.
+     *
+     * This is useful for cleanup such as resource finalization.
+     */
+    finally(fn: () => unknown): RelayObservable<T>;
+
+    /**
+     * Returns a new Observable which is identical to this one, unless this
+     * Observable completes before yielding any values, in which case the new
+     * Observable will yield the values from the alternate Observable.
+     *
+     * If this Observable does yield values, the alternate is never subscribed to.
+     *
+     * This is useful for scenarios where values may come from multiple sources
+     * which should be tried in order, i.e. from a cache before a network.
+     */
+    ifEmpty<U>(alternate: RelayObservable<U>): RelayObservable<T | U>;
+
+    /**
+     * Observable's primary API: returns an unsubscribable Subscription to the
+     * source of this Observable.
+     *
+     * Note: A sink may be passed directly to .subscribe() as its observer,
+     * allowing for easily composing Observables.
+     */
+    subscribe(observer: Observer<T> | Sink<T>): Subscription;
+
+    /**
+     * Returns a new Observerable where each value has been transformed by
+     * the mapping function.
+     */
+    map<U>(fn: (value: T) => U): RelayObservable<U>;
+
+    /**
+     * Returns a new Observable where each value is replaced with a new Observable
+     * by the mapping function, the results of which returned as a single
+     * merged Observable.
+     */
+    mergeMap<U>(fn: (value: T) => ObservableFromValue<U>): RelayObservable<U>;
+
+    /**
+     * Returns a new Observable which first mirrors this Observable, then when it
+     * completes, waits for `pollInterval` milliseconds before re-subscribing to
+     * this Observable again, looping in this manner until unsubscribed.
+     *
+     * The returned Observable never completes.
+     */
+    poll(pollInterval: number): RelayObservable<T>;
+
+    /**
+     * Returns a Promise which resolves when this Observable yields a first value
+     * or when it completes with no value.
+     */
+    toPromise(): Promise<T | undefined>;
+}

package/network/RelayObservable.js.flow

@@ -18,14 +18,14 @@ const isPromise = require('../util/isPromise');
  * unsubscribed or checked to see if the resulting subscription has closed.
  */
 export type Subscription = {
-  +unsubscribe: () => void,
-  +closed: boolean,
+  readonly unsubscribe: () => void,
+  readonly closed: boolean,
 };
 
 type SubscriptionFn = {
-  (): mixed,
-  +unsubscribe?: void,
-  +closed?: void,
+  (): unknown,
+  readonly unsubscribe?: void,
+  readonly closed?: void,
   ...
 };
 
@@ -33,12 +33,12 @@ type SubscriptionFn = {
  * An Observer is an object of optional callback functions provided to
  * .subscribe(). Each callback function is invoked when that event occurs.
  */
-export type Observer<-T> = {
-  +start?: ?(Subscription) => mixed,
-  +next?: ?(T) => mixed,
-  +error?: ?(Error) => mixed,
-  +complete?: ?() => mixed,
-  +unsubscribe?: ?(Subscription) => mixed,
+export type Observer<in T> = {
+  readonly start?: ?(Subscription) => unknown,
+  readonly next?: ?(T) => unknown,
+  readonly error?: ?(Error) => unknown,
+  readonly complete?: ?() => unknown,
+  readonly unsubscribe?: ?(Subscription) => unknown,
 };
 
 /**
@@ -46,11 +46,11 @@ export type Observer<-T> = {
  * The methods are to be called to trigger each event. It also contains a closed
  * field to see if the resulting subscription has closed.
  */
-export type Sink<-T> = {
-  +next: T => void,
-  +error: (Error, isUncaughtThrownError?: boolean) => void,
-  +complete: () => void,
-  +closed: boolean,
+export type Sink<in T> = {
+  readonly next: T => void,
+  readonly error: (Error, isUncaughtThrownError?: boolean) => void,
+  readonly complete: () => void,
+  readonly closed: boolean,
 };
 
 /**
@@ -59,7 +59,7 @@ export type Sink<-T> = {
  * and may return either a cleanup function or a Subscription instance (for use
  * when composing Observables).
  */
-export type Source<+T> = (Sink<T>) => void | Subscription | SubscriptionFn;
+export type Source<out T> = (Sink<T>) => void | Subscription | SubscriptionFn;
 
 /**
  * A Subscribable is an interface describing any object which can be subscribed.
@@ -67,14 +67,14 @@ export type Source<+T> = (Sink<T>) => void | Subscription | SubscriptionFn;
  * Note: A sink may be passed directly to .subscribe() as its observer,
  * allowing for easily composing Subscribables.
  */
-export interface Subscribable<+T> {
+export interface Subscribable<out T> {
   subscribe(observer: Observer<T> | Sink<T>): Subscription;
 }
 
-export type ObservableFromValue<+T> = Subscribable<T> | Promise<T> | T;
+export type ObservableFromValue<out T> = Subscribable<T> | Promise<T> | T;
 
 let hostReportError:
-  | ((Error, isUncaughtThrownError: boolean) => mixed)
+  | ((Error, isUncaughtThrownError: boolean) => unknown)
   | ((_error: Error, _isUncaughtThrownError: boolean) => void) = swallowError;
 
 /**
@@ -88,11 +88,11 @@ let hostReportError:
  *
  * ESObservable: https://github.com/tc39/proposal-observable
  */
-class RelayObservable<+T> implements Subscribable<T> {
-  +_source: Source<T>;
+class RelayObservable<out T> implements Subscribable<T> {
+  readonly _source: Source<T>;
 
   static create<V>(source: Source<V>): RelayObservable<V> {
-    return new RelayObservable((source: any));
+    return new RelayObservable(source as any);
   }
 
   // Use RelayObservable.create()
@@ -103,7 +103,7 @@ class RelayObservable<+T> implements Subscribable<T> {
         throw new Error('Source must be a Function: ' + String(source));
       }
     }
-    (this: any)._source = source;
+    (this as any)._source = source;
   }
 
   /**
@@ -132,7 +132,7 @@ class RelayObservable<+T> implements Subscribable<T> {
    *    stack traces.
    */
   static onUnhandledError(
-    callback: (Error, isUncaughtThrownError: boolean) => mixed,
+    callback: (Error, isUncaughtThrownError: boolean) => unknown,
   ): void {
     hostReportError = callback;
   }
@@ -247,7 +247,7 @@ class RelayObservable<+T> implements Subscribable<T> {
    *
    * This is useful for cleanup such as resource finalization.
    */
-  finally(fn: () => mixed): RelayObservable<T> {
+  finally(fn: () => unknown): RelayObservable<T> {
     return RelayObservable.create(sink => {
       const subscription = this.subscribe(sink);
       return () => {
@@ -351,6 +351,8 @@ class RelayObservable<+T> implements Subscribable<T> {
       }
 
       function complete(this: ObservableContext) {
+        /* $FlowFixMe[incompatible-type] Error exposed after improved typing of
+         * Array.{includes,indexOf,lastIndexOf} */
         subscriptions.splice(subscriptions.indexOf(this._sub), 1);
         if (subscriptions.length === 0) {
           sink.complete();
@@ -445,9 +447,9 @@ class RelayObservable<+T> implements Subscribable<T> {
 }
 
 // Use declarations to teach Flow how to check isObservable.
-declare function isObservable<T>(obj: mixed): obj is Subscribable<T>;
+declare function isObservable<T>(obj: unknown): obj is Subscribable<T>;
 
-function isObservable(obj: mixed) {
+function isObservable(obj: unknown) {
   return (
     typeof obj === 'object' &&
     obj !== null &&
@@ -489,8 +491,8 @@ function subscribe<T>(
   // Subscription objects below, however not all flow environments we expect
   // Relay to be used within will support property getters, and many minifier
   // tools still do not support ES5 syntax. Instead, we can use defineProperty.
-  const withClosed: <O>(obj: O) => {...O, +closed: boolean} = (obj =>
-    Object.defineProperty(obj, 'closed', ({get: () => closed}: any)): any);
+  const withClosed: <O>(obj: O) => {...O, readonly closed: boolean} = (obj =>
+    Object.defineProperty(obj, 'closed', {get: () => closed} as any)) as any;
 
   function doCleanup() {
     if (cleanup) {

package/network/RelayQueryResponseCache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 { Variables } from '../util/RelayRuntimeTypes';
+
+export default class RelayQueryResponseCache {
+    constructor(config: { size: number; ttl: number });
+    clear(): void;
+    get(queryID: string, variables: Variables): GraphQLResponse | null;
+    set(queryID: string, variables: Variables, payload: GraphQLResponse): void;
+}

package/network/RelayQueryResponseCache.js.flow

@@ -77,16 +77,16 @@ class RelayQueryResponseCache {
               ...payload.extensions,
               cacheTimestamp: response.fetchTime,
             },
-          }: GraphQLSingularResponse),
+          }) as GraphQLSingularResponse,
       );
     }
-    return ({
+    return {
       ...response.payload,
       extensions: {
         ...response.payload.extensions,
         cacheTimestamp: response.fetchTime,
       },
-    }: GraphQLSingularResponse);
+    } as GraphQLSingularResponse;
   }
 
   set(queryID: string, variables: Variables, payload: GraphQLResponse): void {

package/network/wrapNetworkWithLogObserver.js.flow

@@ -90,7 +90,7 @@ function wrapNetworkWithLogObserver(
           });
         },
       };
-      const logRequestInfo = (info: mixed) => {
+      const logRequestInfo = (info: unknown) => {
         env.__log({
           name: 'network.info',
           networkRequestId,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "relay-runtime",
   "description": "A core runtime for building GraphQL-driven applications.",
-  "version": "20.1.1",
+  "version": "21.0.1",
   "keywords": [
     "graphql",
     "relay"
@@ -23,5 +23,6 @@
     "": "./"
   },
   "main": "index.js",
+  "types": "index.d.ts",
   "haste_commonjs": true
 }

package/query/GraphQLTag.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 {
+  ReaderFragment,
+  ReaderInlineDataFragment,
+  ReaderPaginationFragment,
+  ReaderRefetchableFragment,
+} from '../util/ReaderNode';
+import { ConcreteRequest } from '../util/RelayConcreteNode';
+
+// The type of a graphql`...` tagged template expression.
+export type GraphQLTaggedNode =
+    | ReaderFragment
+    | ConcreteRequest
+    | ReaderInlineDataFragment
+    | (() => ReaderFragment | ConcreteRequest | ReaderInlineDataFragment);
+
+/**
+ * Runtime function to correspond to the `graphql` tagged template function.
+ * All calls to this function should be transformed by the plugin.
+ */
+export function graphql(strings: unknown): GraphQLTaggedNode;
+
+export function getNode(taggedNode: unknown): unknown;
+
+export function isFragment(node: GraphQLTaggedNode): boolean;
+
+export function isRequest(node: GraphQLTaggedNode): boolean;
+
+export function isInlineDataFragment(node: GraphQLTaggedNode): boolean;
+
+export function getFragment(taggedNode: GraphQLTaggedNode): ReaderFragment;
+
+export function getPaginationFragment(taggedNode: GraphQLTaggedNode): ReaderPaginationFragment | null;
+
+export function getRefetchableFragment(taggedNode: GraphQLTaggedNode): ReaderRefetchableFragment | null;
+
+export function getRequest(taggedNode: GraphQLTaggedNode): ConcreteRequest;
+
+export function getInlineDataFragment(taggedNode: GraphQLTaggedNode): ReaderInlineDataFragment;

package/query/GraphQLTag.js.flow

@@ -46,7 +46,7 @@ export type GraphQLTaggedNode =
  * Runtime function to correspond to the `graphql` tagged template function.
  * All calls to this function should be transformed by the plugin.
  */
-function graphql(strings: $ReadOnlyArray<string>): any {
+function graphql(strings: ReadonlyArray<string>): any {
   invariant(
     false,
     'graphql: Unexpected invocation at runtime. Either the Babel transform ' +
@@ -65,7 +65,7 @@ function getNode(
   | ConcreteUpdatableQuery {
   let node = taggedNode;
   if (typeof node === 'function') {
-    node = (node(): ReaderFragment | ConcreteRequest);
+    node = node() as ReaderFragment | ConcreteRequest;
     warning(
       false,
       'RelayGraphQLTag: node `%s` unexpectedly wrapped in a function.',
@@ -82,6 +82,8 @@ function isFragment(node: GraphQLTaggedNode): boolean {
   const fragment = getNode(node);
   return (
     typeof fragment === 'object' &&
+    /* $FlowFixMe[invalid-compare] Error discovered during Constant Condition
+     * roll out. See https://fburl.com/workplace/5whu3i34. */
     fragment !== null &&
     fragment.kind === RelayConcreteNode.FRAGMENT
   );
@@ -91,6 +93,8 @@ function isRequest(node: GraphQLTaggedNode): boolean {
   const request = getNode(node);
   return (
     typeof request === 'object' &&
+    /* $FlowFixMe[invalid-compare] Error discovered during Constant Condition
+     * roll out. See https://fburl.com/workplace/5whu3i34. */
     request !== null &&
     request.kind === RelayConcreteNode.REQUEST
   );
@@ -100,6 +104,8 @@ function isUpdatableQuery(node: GraphQLTaggedNode): boolean {
   const updatableQuery = getNode(node);
   return (
     typeof updatableQuery === 'object' &&
+    /* $FlowFixMe[invalid-compare] Error discovered during Constant Condition
+     * roll out. See https://fburl.com/workplace/5whu3i34. */
     updatableQuery !== null &&
     updatableQuery.kind === RelayConcreteNode.UPDATABLE_QUERY
   );
@@ -109,6 +115,8 @@ function isInlineDataFragment(node: GraphQLTaggedNode): boolean {
   const fragment = getNode(node);
   return (
     typeof fragment === 'object' &&
+    /* $FlowFixMe[invalid-compare] Error discovered during Constant Condition
+     * roll out. See https://fburl.com/workplace/5whu3i34. */
     fragment !== null &&
     fragment.kind === RelayConcreteNode.INLINE_DATA_FRAGMENT
   );
@@ -121,7 +129,7 @@ function getFragment(taggedNode: GraphQLTaggedNode): ReaderFragment {
     'GraphQLTag: Expected a fragment, got `%s`.',
     JSON.stringify(fragment),
   );
-  return (fragment: any);
+  return fragment as any;
 }
 
 function getPaginationFragment(
@@ -131,6 +139,8 @@ function getPaginationFragment(
   const refetch = fragment.metadata?.refetch;
   const connection = refetch?.connection;
   if (
+    /* $FlowFixMe[invalid-compare] Error discovered during Constant Condition
+     * roll out. See https://fburl.com/workplace/5whu3i34. */
     refetch === null ||
     typeof refetch !== 'object' ||
     connection === null ||
@@ -138,7 +148,7 @@ function getPaginationFragment(
   ) {
     return null;
   }
-  return (fragment: any);
+  return fragment as any;
 }
 
 function getRefetchableFragment(
@@ -146,10 +156,12 @@ function getRefetchableFragment(
 ): ReaderRefetchableFragment | null {
   const fragment = getFragment(taggedNode);
   const refetch = fragment.metadata?.refetch;
+  /* $FlowFixMe[invalid-compare] Error discovered during Constant Condition
+   * roll out. See https://fburl.com/workplace/5whu3i34. */
   if (refetch === null || typeof refetch !== 'object') {
     return null;
   }
-  return (fragment: any);
+  return fragment as any;
 }
 
 function getRequest(taggedNode: GraphQLTaggedNode): ConcreteRequest {
@@ -159,7 +171,7 @@ function getRequest(taggedNode: GraphQLTaggedNode): ConcreteRequest {
     'GraphQLTag: Expected a request, got `%s`.',
     JSON.stringify(request),
   );
-  return (request: any);
+  return request as any;
 }
 
 function getUpdatableQuery(
@@ -171,7 +183,7 @@ function getUpdatableQuery(
     'GraphQLTag: Expected a request, got `%s`.',
     JSON.stringify(updatableQuery),
   );
-  return (updatableQuery: any);
+  return updatableQuery as any;
 }
 
 function getInlineDataFragment(
@@ -183,20 +195,20 @@ function getInlineDataFragment(
     'GraphQLTag: Expected an inline data fragment, got `%s`.',
     JSON.stringify(fragment),
   );
-  return (fragment: any);
+  return fragment as any;
 }
 
 module.exports = {
   getFragment,
+  getInlineDataFragment,
   getNode,
   getPaginationFragment,
   getRefetchableFragment,
   getRequest,
   getUpdatableQuery,
-  getInlineDataFragment,
   graphql,
   isFragment,
+  isInlineDataFragment,
   isRequest,
   isUpdatableQuery,
-  isInlineDataFragment,
 };