react-relay 14.1.0 → 16.0.0

package/relay-hooks/useMemoOperationDescriptor.js.flow

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * @flow strict-local
  * @format
+ * @oncall relay
  */
 
 'use strict';
@@ -29,8 +29,8 @@ function useMemoOperationDescriptor(
   variables: Variables,
   cacheConfig?: ?CacheConfig,
 ): OperationDescriptor {
-  const [memoVariables] = useMemoVariables(variables);
-  const [memoCacheConfig] = useMemoVariables(cacheConfig || {});
+  const memoVariables = useMemoVariables(variables);
+  const memoCacheConfig = useMemoVariables(cacheConfig || {});
   return useMemo(
     () =>
       createOperationDescriptor(

package/relay-hooks/useMemoVariables.js.flow

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * @flow strict-local
  * @format
+ * @oncall relay
  */
 
 'use strict';
@@ -14,39 +14,23 @@
 import type {Variables} from 'relay-runtime';
 
 const areEqual = require('areEqual');
-const React = require('react');
-
-const {useMemo, useRef, useState} = React;
+const {useState} = require('react');
 
+/**
+ * Memoizes the passed in `variables` object based on `areEqual` equality.
+ * This is useful when a `variables` object is used as a value in a depencency
+ * array as it might often be constructed during render.
+ */
 function useMemoVariables<TVariables: Variables | null>(
   variables: TVariables,
-): [TVariables, number] {
-  // The value of this ref is a counter that should be incremented when
-  // variables change. This allows us to use the counter as a
-  // memoization value to indicate if the computation for useMemo
-  // should be re-executed.
-  const variablesChangedGenerationRef = useRef(0);
-
-  // We mirror the variables to check if they have changed between renders
-  const [mirroredVariables, setMirroredVariables] = useState<Variables | null>(
-    variables,
-  );
-
-  const variablesChanged = !areEqual(variables, mirroredVariables);
-  if (variablesChanged) {
-    variablesChangedGenerationRef.current =
-      (variablesChangedGenerationRef.current ?? 0) + 1;
+): TVariables {
+  const [mirroredVariables, setMirroredVariables] = useState(variables);
+  if (areEqual(variables, mirroredVariables)) {
+    return mirroredVariables;
+  } else {
     setMirroredVariables(variables);
+    return variables;
   }
-
-  // NOTE: We disable react-hooks-deps warning because we explicitly
-  // don't want to memoize on object identity
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  const memoVariables = useMemo(
-    () => variables,
-    [variablesChangedGenerationRef.current],
-  );
-  return [memoVariables, variablesChangedGenerationRef.current ?? 0];
 }
 
 module.exports = useMemoVariables;

package/relay-hooks/useMutation.js.flow

@@ -4,23 +4,24 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * @flow strict-local
  * @format
+ * @oncall relay
  */
 
 'use strict';
 
 import type {
+  CommitMutationConfig,
   DeclarativeMutationConfig,
   Disposable,
-  GraphQLTaggedNode,
   IEnvironment,
-  MutationConfig,
+  Mutation,
   MutationParameters,
   PayloadError,
   SelectorStoreUpdater,
   UploadableMap,
+  Variables,
 } from 'relay-runtime';
 
 const useIsMountedRef = require('./useIsMountedRef');
@@ -50,22 +51,38 @@ export type UseMutationConfig<TMutation: MutationParameters> = {
   variables: TMutation['variables'],
 };
 
-function useMutation<TMutation: MutationParameters>(
-  mutation: GraphQLTaggedNode,
+type UseMutationConfigInternal<TVariables, TData, TRawResponse> = {
+  configs?: Array<DeclarativeMutationConfig>,
+  onError?: ?(error: Error) => void,
+  onCompleted?: ?(response: TData, errors: ?Array<PayloadError>) => void,
+  onNext?: ?() => void,
+  onUnsubscribe?: ?() => void,
+  optimisticResponse?: TRawResponse,
+  optimisticUpdater?: ?SelectorStoreUpdater<TData>,
+  updater?: ?SelectorStoreUpdater<TData>,
+  uploadables?: UploadableMap,
+  variables: TVariables,
+};
+
+function useMutation<TVariables: Variables, TData, TRawResponse = {...}>(
+  mutation: Mutation<TVariables, TData, TRawResponse>,
   commitMutationFn?: (
     environment: IEnvironment,
-    config: MutationConfig<TMutation>,
+    config: CommitMutationConfig<TVariables, TData, TRawResponse>,
   ) => Disposable = defaultCommitMutation,
-): [(UseMutationConfig<TMutation>) => Disposable, boolean] {
+): [
+  (UseMutationConfigInternal<TVariables, TData, TRawResponse>) => Disposable,
+  boolean,
+] {
   const environment = useRelayEnvironment();
   const isMountedRef = useIsMountedRef();
   const environmentRef = useRef(environment);
   const mutationRef = useRef(mutation);
-  const inFlightMutationsRef = useRef(new Set());
+  const inFlightMutationsRef = useRef(new Set<Disposable>());
   const [isMutationInFlight, setMutationInFlight] = useState(false);
 
   const cleanup = useCallback(
-    disposable => {
+    (disposable: Disposable) => {
       if (
         environmentRef.current === environment &&
         mutationRef.current === mutation
@@ -94,18 +111,18 @@ function useMutation<TMutation: MutationParameters>(
   }, [environment, isMountedRef, mutation]);
 
   const commit = useCallback(
-    (config: UseMutationConfig<TMutation>) => {
+    (config: UseMutationConfigInternal<TVariables, TData, TRawResponse>) => {
       if (isMountedRef.current) {
         setMutationInFlight(true);
       }
-      const disposable = commitMutationFn(environment, {
+      const disposable: Disposable = commitMutationFn(environment, {
         ...config,
         mutation,
-        onCompleted: (response, errors) => {
+        onCompleted: (response: TData, errors: ?Array<PayloadError>) => {
           cleanup(disposable);
           config.onCompleted?.(response, errors);
         },
-        onError: error => {
+        onError: (error: Error) => {
           cleanup(disposable);
           config.onError?.(error);
         },

package/relay-hooks/usePaginationFragment.js.flow

@@ -4,21 +4,22 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * @flow strict-local
  * @format
+ * @oncall relay
  */
 
 'use strict';
 
 import type {LoadMoreFn, UseLoadMoreFunctionArgs} from './useLoadMoreFunction';
-import type {RefetchFnDynamic} from './useRefetchableFragmentNode';
+import type {RefetchFn} from './useRefetchableFragment';
+import type {Options} from './useRefetchableFragmentNode';
 import type {
   FragmentType,
   GraphQLResponse,
-  GraphQLTaggedNode,
   Observer,
-  OperationType,
+  RefetchableFragment,
+  Variables,
 } from 'relay-runtime';
 
 const HooksImplementation = require('./HooksImplementation');
@@ -32,43 +33,28 @@ const {
   getPaginationMetadata,
 } = require('relay-runtime');
 
-export type ReturnType<TQuery: OperationType, TKey> = {
-  // NOTE: This $Call ensures that the type of the returned data is either:
-  //   - nullable if the provided ref type is nullable
-  //   - non-nullable if the provided ref type is non-nullable
-  // prettier-ignore
-  data: $Call<
-    & (<TFragmentData>( { +$data?: TFragmentData, ... }) =>  TFragmentData)
-    & (<TFragmentData>(?{ +$data?: TFragmentData, ... }) => ?TFragmentData),
-    TKey,
-  >,
-  loadNext: LoadMoreFn<TQuery>,
-  loadPrevious: LoadMoreFn<TQuery>,
-  hasNext: boolean,
-  hasPrevious: boolean,
-  isLoadingNext: boolean,
-  isLoadingPrevious: boolean,
-  refetch: RefetchFnDynamic<TQuery, TKey>,
-};
-
 // This separate type export is only needed as long as we are injecting
 // a separate hooks implementation in ./HooksImplementation -- it can
 // be removed after we stop doing that.
 export type UsePaginationFragmentType = <
-  TQuery: OperationType,
-  TKey: ?{+$data?: mixed, +$fragmentSpreads: FragmentType, ...},
+  TFragmentType: FragmentType,
+  TVariables: Variables,
+  TData,
+  TKey: ?{+$fragmentSpreads: TFragmentType, ...},
 >(
-  fragmentInput: GraphQLTaggedNode,
+  fragmentInput: RefetchableFragment<TFragmentType, TData, TVariables>,
   parentFragmentRef: TKey,
-) => ReturnType<TQuery, TKey>;
+) => ReturnType<TVariables, TData, TKey>;
 
 function usePaginationFragment_LEGACY<
-  TQuery: OperationType,
-  TKey: ?{+$data?: mixed, +$fragmentSpreads: FragmentType, ...},
+  TFragmentType: FragmentType,
+  TVariables: Variables,
+  TData,
+  TKey: ?{+$fragmentSpreads: TFragmentType, ...},
 >(
-  fragmentInput: GraphQLTaggedNode,
+  fragmentInput: RefetchableFragment<TFragmentType, TData, TVariables>,
   parentFragmentRef: TKey,
-): ReturnType<TQuery, TKey> {
+): ReturnType<TVariables, TData, TKey> {
   const fragmentNode = getFragment(fragmentInput);
   useStaticFragmentNodeWarning(
     fragmentNode,
@@ -76,22 +62,18 @@ function usePaginationFragment_LEGACY<
   );
   const componentDisplayName = 'usePaginationFragment()';
 
-  const {
-    connectionPathInFragmentData,
-    paginationRequest,
-    paginationMetadata,
-    identifierField,
-  } = getPaginationMetadata(fragmentNode, componentDisplayName);
+  const {connectionPathInFragmentData, paginationRequest, paginationMetadata} =
+    getPaginationMetadata(fragmentNode, componentDisplayName);
 
   const {fragmentData, fragmentRef, refetch} = useRefetchableFragmentNode<
-    TQuery,
-    TKey,
+    $FlowFixMe,
+    $FlowFixMe,
   >(fragmentNode, parentFragmentRef, componentDisplayName);
   const fragmentIdentifier = getFragmentIdentifier(fragmentNode, fragmentRef);
 
   // Backward pagination
   const [loadPrevious, hasPrevious, isLoadingPrevious, disposeFetchPrevious] =
-    useLoadMore<TQuery>({
+    useLoadMore<TVariables>({
       componentDisplayName,
       connectionPathInFragmentData,
       direction: 'backward',
@@ -99,14 +81,13 @@ function usePaginationFragment_LEGACY<
       fragmentIdentifier,
       fragmentNode,
       fragmentRef,
-      identifierField,
       paginationMetadata,
       paginationRequest,
     });
 
   // Forward pagination
   const [loadNext, hasNext, isLoadingNext, disposeFetchNext] =
-    useLoadMore<TQuery>({
+    useLoadMore<TVariables>({
       componentDisplayName,
       connectionPathInFragmentData,
       direction: 'forward',
@@ -114,13 +95,12 @@ function usePaginationFragment_LEGACY<
       fragmentIdentifier,
       fragmentNode,
       fragmentRef,
-      identifierField,
       paginationMetadata,
       paginationRequest,
     });
 
-  const refetchPagination: RefetchFnDynamic<TQuery, TKey> = useCallback(
-    (variables, options) => {
+  const refetchPagination: RefetchFn<TVariables, TKey> = useCallback(
+    (variables: TVariables, options: void | Options) => {
       disposeFetchNext();
       disposeFetchPrevious();
       return refetch(variables, {...options, __environment: undefined});
@@ -140,7 +120,7 @@ function usePaginationFragment_LEGACY<
     });
   }
   return {
-    data: fragmentData,
+    data: (fragmentData: $FlowFixMe),
     loadNext,
     loadPrevious,
     hasNext,
@@ -151,7 +131,7 @@ function usePaginationFragment_LEGACY<
   };
 }
 
-function useLoadMore<TQuery: OperationType>(
+function useLoadMore<TVariables: Variables>(
   args: $Diff<
     UseLoadMoreFunctionArgs,
     {
@@ -160,7 +140,7 @@ function useLoadMore<TQuery: OperationType>(
       ...
     },
   >,
-): [LoadMoreFn<TQuery>, boolean, boolean, () => void] {
+): [LoadMoreFn<TVariables>, boolean, boolean, () => void] {
   const [isLoadingMore, setIsLoadingMore] = useState(false);
   const observer = {
     start: () => setIsLoadingMore(true),
@@ -168,7 +148,7 @@ function useLoadMore<TQuery: OperationType>(
     error: () => setIsLoadingMore(false),
   };
   const handleReset = () => setIsLoadingMore(false);
-  const [loadMore, hasMore, disposeFetch] = useLoadMoreFunction({
+  const [loadMore, hasMore, disposeFetch] = useLoadMoreFunction<TVariables>({
     ...args,
     observer,
     onReset: handleReset,
@@ -176,16 +156,37 @@ function useLoadMore<TQuery: OperationType>(
   return [loadMore, hasMore, isLoadingMore, disposeFetch];
 }
 
+export type ReturnType<TVariables, TData, TKey> = {
+  // NOTE: This $Call ensures that the type of the returned data is either:
+  //   - nullable if the provided ref type is nullable
+  //   - non-nullable if the provided ref type is non-nullable
+  // prettier-ignore
+  data: $Call<
+    & (<TFragmentType>( { +$fragmentSpreads: TFragmentType, ... }) =>  TData)
+    & (<TFragmentType>(?{ +$fragmentSpreads: TFragmentType, ... }) => ?TData),
+    TKey,
+  >,
+  loadNext: LoadMoreFn<TVariables>,
+  loadPrevious: LoadMoreFn<TVariables>,
+  hasNext: boolean,
+  hasPrevious: boolean,
+  isLoadingNext: boolean,
+  isLoadingPrevious: boolean,
+  refetch: RefetchFn<TVariables, TKey>,
+};
+
 function usePaginationFragment<
-  TQuery: OperationType,
-  TKey: ?{+$data?: mixed, +$fragmentSpreads: FragmentType, ...},
+  TFragmentType: FragmentType,
+  TVariables: Variables,
+  TData,
+  TKey: ?{+$fragmentSpreads: TFragmentType, ...},
 >(
-  fragmentInput: GraphQLTaggedNode,
+  fragmentInput: RefetchableFragment<TFragmentType, TData, TVariables>,
   parentFragmentRef: TKey,
-): ReturnType<TQuery, TKey> {
+): ReturnType<TVariables, TData, TKey> {
   const impl = HooksImplementation.get();
   if (impl) {
-    return impl.usePaginationFragment<TQuery, TKey>(
+    return impl.usePaginationFragment<TFragmentType, TVariables, TData, TKey>(
       fragmentInput,
       parentFragmentRef,
     );

package/relay-hooks/usePreloadedQuery.js.flow

@@ -4,19 +4,19 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * @flow strict-local
  * @format
+ * @oncall relay
  */
 
 'use strict';
 
-import type {PreloadedQuery} from './EntryPointTypes.flow';
 import type {
-  GraphQLTaggedNode,
-  OperationType,
-  RenderPolicy,
-} from 'relay-runtime';
+  EnvironmentProviderOptions,
+  PreloadedQueryInner,
+  PreloadedQueryInner_DEPRECATED,
+} from './EntryPointTypes.flow';
+import type {Query, RenderPolicy, Variables} from 'relay-runtime';
 
 const {useTrackLoadQueryInRender} = require('./loadQuery');
 const useLazyLoadQueryNode = require('./useLazyLoadQueryNode');
@@ -29,24 +29,44 @@ const {
 } = require('relay-runtime');
 const warning = require('warning');
 
-// This separate type export is only needed as long as we are injecting
-// a separate hooks implementation in ./HooksImplementation -- it can
-// be removed after we stop doing that.
-export type UsePreloadedQueryHookType = <TQuery: OperationType>(
-  gqlQuery: GraphQLTaggedNode,
-  preloadedQuery: PreloadedQuery<TQuery>,
-  options?: {
-    UNSTABLE_renderPolicy?: RenderPolicy,
-  },
-) => TQuery['response'];
+type PreloadedQuery<
+  TVariables: Variables,
+  TData,
+  TRawResponse,
+  TEnvironmentProviderOptions = EnvironmentProviderOptions,
+> =
+  | PreloadedQueryInner_DEPRECATED<
+      {
+        variables: TVariables,
+        response: TData,
+        rawResponse?: TRawResponse,
+      },
+      TEnvironmentProviderOptions,
+    >
+  | PreloadedQueryInner<
+      {
+        variables: TVariables,
+        response: TData,
+        rawResponse?: TRawResponse,
+      },
+      TEnvironmentProviderOptions,
+    >;
 
-function usePreloadedQuery<TQuery: OperationType>(
-  gqlQuery: GraphQLTaggedNode,
-  preloadedQuery: PreloadedQuery<TQuery>,
+function usePreloadedQuery<
+  TVariables: Variables,
+  TData,
+  TRawResponse: ?{...} = void,
+>(
+  gqlQuery: Query<TVariables, TData, TRawResponse>,
+  preloadedQuery: PreloadedQuery<
+    TVariables,
+    TData,
+    $NonMaybeType<TRawResponse>,
+  >,
   options?: {
     UNSTABLE_renderPolicy?: RenderPolicy,
   },
-): TQuery['response'] {
+): TData {
   // We need to use this hook in order to be able to track if
   // loadQuery was called during render
   useTrackLoadQueryInRender();
@@ -136,7 +156,12 @@ function usePreloadedQuery<TQuery: OperationType>(
     };
   }
 
-  const data = useLazyLoadQueryNode(useLazyLoadQueryNodeParams);
+  const data = useLazyLoadQueryNode<{
+    variables: TVariables,
+    response: TData,
+    rawResponse?: $NonMaybeType<TRawResponse>,
+  }>(useLazyLoadQueryNodeParams);
+
   if (__DEV__) {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     useDebugValue({
@@ -151,4 +176,4 @@ function usePreloadedQuery<TQuery: OperationType>(
   return data;
 }
 
-module.exports = (usePreloadedQuery: UsePreloadedQueryHookType);
+module.exports = usePreloadedQuery;

package/relay-hooks/useQueryLoader.js.flow

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * @flow strict-local
  * @format
+ * @oncall relay
  */
 
 'use strict';
@@ -17,9 +17,10 @@ import type {
   PreloadedQuery,
 } from './EntryPointTypes.flow';
 import type {
-  GraphQLTaggedNode,
   IEnvironment,
   OperationType,
+  Query,
+  Variables,
 } from 'relay-runtime';
 
 const {loadQuery, useTrackLoadQueryInRender} = require('./loadQuery');
@@ -38,12 +39,6 @@ export type UseQueryLoaderLoadQueryOptions = $ReadOnly<{
   +__environment?: ?IEnvironment,
 }>;
 
-type UseQueryLoaderHookReturnType<TQuery: OperationType> = [
-  ?PreloadedQuery<TQuery>,
-  LoaderFn<TQuery>,
-  () => void,
-];
-
 // NullQueryReference needs to implement referential equality,
 // so that multiple NullQueryReferences can be in the same set
 // (corresponding to multiple calls to disposeQuery).
@@ -52,20 +47,85 @@ type NullQueryReference = {
 };
 const initialNullQueryReferenceState = {kind: 'NullQueryReference'};
 
-function requestIsLiveQuery<TQuery: OperationType>(
-  preloadableRequest: GraphQLTaggedNode | PreloadableConcreteRequest<TQuery>,
+function requestIsLiveQuery<
+  TVariables: Variables,
+  TData,
+  TRawResponse: ?{...} = void,
+  TQuery: OperationType = {
+    response: TData,
+    variables: TVariables,
+    rawResponse?: $NonMaybeType<TRawResponse>,
+  },
+>(
+  preloadableRequest:
+    | Query<TVariables, TData, TRawResponse>
+    | PreloadableConcreteRequest<TQuery>,
 ): boolean {
   if (preloadableRequest.kind === 'PreloadableConcreteRequest') {
-    return (preloadableRequest: $FlowFixMe).params.metadata.live !== undefined;
+    return preloadableRequest.params.metadata.live !== undefined;
   }
   const request = getRequest(preloadableRequest);
   return request.params.metadata.live !== undefined;
 }
 
-function useQueryLoader<TQuery: OperationType>(
-  preloadableRequest: GraphQLTaggedNode | PreloadableConcreteRequest<TQuery>,
+type UseQueryLoaderHookReturnType<
+  TVariables: Variables,
+  TData,
+  TRawResponse: ?{...} = void,
+> = [
+  ?PreloadedQuery<{
+    response: TData,
+    variables: TVariables,
+    rawResponse?: $NonMaybeType<TRawResponse>,
+  }>,
+  (variables: TVariables, options?: UseQueryLoaderLoadQueryOptions) => void,
+  () => void,
+];
+
+declare function useQueryLoader<
+  TVariables: Variables,
+  TData,
+  TRawResponse: ?{...} = void,
+>(
+  preloadableRequest: Query<TVariables, TData, TRawResponse>,
+): UseQueryLoaderHookReturnType<TVariables, TData>;
+
+declare function useQueryLoader<
+  TVariables: Variables,
+  TData,
+  TRawResponse: ?{...} = void,
+>(
+  preloadableRequest: Query<TVariables, TData, TRawResponse>,
+  initialQueryReference: ?PreloadedQuery<{
+    response: TData,
+    variables: TVariables,
+    rawResponse?: $NonMaybeType<TRawResponse>,
+  }>,
+): UseQueryLoaderHookReturnType<TVariables, TData>;
+
+declare function useQueryLoader<TQuery: OperationType>(
+  preloadableRequest: PreloadableConcreteRequest<TQuery>,
   initialQueryReference?: ?PreloadedQuery<TQuery>,
-): UseQueryLoaderHookReturnType<TQuery> {
+): UseQueryLoaderHookReturnType<TQuery['variables'], TQuery['response']>;
+
+function useQueryLoader<
+  TVariables: Variables,
+  TData,
+  TRawResponse: ?{...} = void,
+>(
+  preloadableRequest: Query<TVariables, TData, TRawResponse>,
+  initialQueryReference?: ?PreloadedQuery<{
+    response: TData,
+    variables: TVariables,
+    rawResponse?: $NonMaybeType<TRawResponse>,
+  }>,
+): UseQueryLoaderHookReturnType<TVariables, TData> {
+  type QueryType = {
+    response: TData,
+    variables: TVariables,
+    rawResponse?: $NonMaybeType<TRawResponse>,
+  };
+
   /**
    * We want to always call `queryReference.dispose()` for every call to
    * `setQueryReference(loadQuery(...))` so that no leaks of data in Relay stores
@@ -94,15 +154,15 @@ function useQueryLoader<TQuery: OperationType>(
 
   const isMountedRef = useIsMountedRef();
   const undisposedQueryReferencesRef = useRef<
-    Set<PreloadedQuery<TQuery> | NullQueryReference>,
+    Set<PreloadedQuery<QueryType> | NullQueryReference>,
   >(new Set([initialQueryReferenceInternal]));
 
   const [queryReference, setQueryReference] = useState<
-    PreloadedQuery<TQuery> | NullQueryReference,
+    PreloadedQuery<QueryType> | NullQueryReference,
   >(() => initialQueryReferenceInternal);
 
   const [previousInitialQueryReference, setPreviousInitialQueryReference] =
-    useState<PreloadedQuery<TQuery> | NullQueryReference>(
+    useState<PreloadedQuery<QueryType> | NullQueryReference>(
       () => initialQueryReferenceInternal,
     );
 
@@ -125,10 +185,7 @@ function useQueryLoader<TQuery: OperationType>(
   }, [isMountedRef]);
 
   const queryLoaderCallback = useCallback(
-    (
-      variables: TQuery['variables'],
-      options?: ?UseQueryLoaderLoadQueryOptions,
-    ) => {
+    (variables: TVariables, options?: ?UseQueryLoaderLoadQueryOptions) => {
       const mergedOptions: ?UseQueryLoaderLoadQueryOptions =
         options != null && options.hasOwnProperty('__environment')
           ? {