@aws-amplify/api-graphql 3.4.12-unstable.7762f1a.0 → 4.0.0

package/lib/types/PubSub.d.ts

@@ -0,0 +1,27 @@
+import { Observer } from 'rxjs';
+export interface SubscriptionObserver<T> {
+    closed: boolean;
+    next(value: T): void;
+    error(errorValue: any): void;
+    complete(): void;
+}
+export declare enum CONTROL_MSG {
+    CONNECTION_CLOSED = "Connection closed",
+    CONNECTION_FAILED = "Connection failed",
+    REALTIME_SUBSCRIPTION_INIT_ERROR = "AppSync Realtime subscription init error",
+    SUBSCRIPTION_ACK = "Subscription ack",
+    TIMEOUT_DISCONNECT = "Timeout disconnect"
+}
+/** @enum {string} */
+export declare enum ConnectionState {
+    Connected = "Connected",
+    ConnectedPendingNetwork = "ConnectedPendingNetwork",
+    ConnectionDisrupted = "ConnectionDisrupted",
+    ConnectionDisruptedPendingNetwork = "ConnectionDisruptedPendingNetwork",
+    Connecting = "Connecting",
+    ConnectedPendingDisconnect = "ConnectedPendingDisconnect",
+    Disconnected = "Disconnected",
+    ConnectedPendingKeepAlive = "ConnectedPendingKeepAlive"
+}
+export declare type PubSubContent = Record<string, unknown>;
+export declare type PubSubContentObserver = Observer<PubSubContent>;

package/lib/types/PubSub.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var CONTROL_MSG;
+(function (CONTROL_MSG) {
+    CONTROL_MSG["CONNECTION_CLOSED"] = "Connection closed";
+    CONTROL_MSG["CONNECTION_FAILED"] = "Connection failed";
+    CONTROL_MSG["REALTIME_SUBSCRIPTION_INIT_ERROR"] = "AppSync Realtime subscription init error";
+    CONTROL_MSG["SUBSCRIPTION_ACK"] = "Subscription ack";
+    CONTROL_MSG["TIMEOUT_DISCONNECT"] = "Timeout disconnect";
+})(CONTROL_MSG = exports.CONTROL_MSG || (exports.CONTROL_MSG = {}));
+/** @enum {string} */
+var ConnectionState;
+(function (ConnectionState) {
+    /*
+     * The connection is alive and healthy
+     */
+    ConnectionState["Connected"] = "Connected";
+    /*
+     * The connection is alive, but the connection is offline
+     */
+    ConnectionState["ConnectedPendingNetwork"] = "ConnectedPendingNetwork";
+    /*
+     * The connection has been disconnected while in use
+     */
+    ConnectionState["ConnectionDisrupted"] = "ConnectionDisrupted";
+    /*
+     * The connection has been disconnected and the network is offline
+     */
+    ConnectionState["ConnectionDisruptedPendingNetwork"] = "ConnectionDisruptedPendingNetwork";
+    /*
+     * The connection is in the process of connecting
+     */
+    ConnectionState["Connecting"] = "Connecting";
+    /*
+     * The connection is not in use and is being disconnected
+     */
+    ConnectionState["ConnectedPendingDisconnect"] = "ConnectedPendingDisconnect";
+    /*
+     * The connection is not in use and has been disconnected
+     */
+    ConnectionState["Disconnected"] = "Disconnected";
+    /*
+     * The connection is alive, but a keep alive message has been missed
+     */
+    ConnectionState["ConnectedPendingKeepAlive"] = "ConnectedPendingKeepAlive";
+})(ConnectionState = exports.ConnectionState || (exports.ConnectionState = {}));

package/lib/types/index.d.ts

@@ -1,11 +1,17 @@
+import { AmplifyClassV6, ResourcesConfig } from '@aws-amplify/core';
 import { Source, DocumentNode, GraphQLError } from 'graphql';
 export { OperationTypeNode } from 'graphql';
-import { GRAPHQL_AUTH_MODE } from '@aws-amplify/auth';
-export { GRAPHQL_AUTH_MODE };
+import { Observable } from 'rxjs';
+import { GraphQLAuthMode, DocumentType } from '@aws-amplify/core/internals/utils';
+import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
+export { CONTROL_MSG, ConnectionState } from './PubSub';
+/**
+ * Loose/Unknown options for raw GraphQLAPICategory `graphql()`.
+ */
 export interface GraphQLOptions {
     query: string | DocumentNode;
-    variables?: object;
-    authMode?: keyof typeof GRAPHQL_AUTH_MODE;
+    variables?: Record<string, DocumentType>;
+    authMode?: GraphQLAuthMode;
     authToken?: string;
     /**
      * @deprecated This property should not be used
@@ -13,12 +19,134 @@ export interface GraphQLOptions {
     userAgentSuffix?: string;
 }
 export interface GraphQLResult<T = object> {
-    data?: T;
+    data: T;
     errors?: GraphQLError[];
     extensions?: {
         [key: string]: any;
     };
 }
+declare const queryType: unique symbol;
+export declare type GraphQLQuery<T> = T & {
+    readonly [queryType]: 'query';
+};
+export declare type GraphQLSubscription<T> = T & {
+    readonly [queryType]: 'subscription';
+};
+/**
+ * Accepts a code generated model type and returns a supertype that
+ * can accept return values from the relevant graphql operations.
+ *
+ * For example:
+ *
+ * ```typescript
+ * import { GraphQLReturnType } from 'aws-amplify/api';
+ * import { MyModel } from './API';
+ * import { getMyModel } from './graphql/queries';
+ *
+ * const [item, setItem] = useState<GraphQLReturnType<MyModel>>();
+ * setItem(await client.graphql({ query: getMyModel }).data.getMyModel!)
+ * ```
+ *
+ * Trying to assign the result of a `getMyModel` operation directly to a
+ * `MyModel` variables won't necessarily work, because normally-required related
+ * models might not be part of the selection set.
+ *
+ * This util simply makes related model properties optional recursively.
+ */
+export declare type GraphQLReturnType<T> = T extends {} ? {
+    [K in keyof T]?: GraphQLReturnType<T[K]>;
+} : T;
+/**
+ * Describes a paged list result from AppSync, which can either
+ * live at the top query or property (e.g., related model) level.
+ */
+declare type PagedList<T, TYPENAME> = {
+    __typename: TYPENAME;
+    nextToken?: string | null | undefined;
+    items: Array<T>;
+};
+/**
+ * Recursively looks through a result type and removes nulls and
+ * and undefined from `PagedList` types.
+ *
+ * Although a graphql response might contain empty values in an
+ * array, this will only be the case when we also have errors,
+ * which will then be *thrown*.
+ */
+declare type WithListsFixed<T> = T extends PagedList<infer IT, infer NAME> ? PagedList<Exclude<IT, null | undefined>, NAME> : T extends {} ? {
+    [K in keyof T]: WithListsFixed<T[K]>;
+} : T;
+/**
+ * Returns an updated response type to always return a value.
+ */
+declare type NeverEmpty<T> = {
+    [K in keyof T]-?: Exclude<WithListsFixed<T[K]>, undefined | null>;
+};
+/**
+ * Replaces all list result types in a query result with types to exclude
+ * nulls and undefined from list member unions.
+ *
+ * If empty members are present, there will also be errors present,
+ * and the response will instead be *thrown*.
+ */
+declare type FixedQueryResult<T> = Exclude<T[keyof T], null | undefined> extends PagedList<any, any> ? {
+    [K in keyof T]-?: WithListsFixed<Exclude<T[K], null | undefined>>;
+} : T;
+/**
+ * The return value from a `graphql({query})` call when `query` is a subscription.
+ *
+ * ```ts
+ * //               |-- You are here
+ * //               v
+ * const subResult: GraphqlSubscriptionResult<T> = client.graphql({
+ * 	query: onCreateWidget
+ * });
+ *
+ * const sub = subResult.subscribe({
+ * 	//
+ * 	//            |-- You are here
+ * 	//            v
+ * 	next(message: GraphqlSubscriptionMessage<OnCreateWidgetSubscription>) {
+ * 		handle(message.value);  // <-- type OnCreateWidgetSubscription
+ * 	}
+ * })
+ * ```
+ */
+export declare type GraphqlSubscriptionResult<T> = Observable<GraphqlSubscriptionMessage<T>>;
+/**
+ * The shape of messages passed to `next()` from a graphql subscription. E.g.,
+ *
+ * ```ts
+ * const sub = client.graphql({
+ * 	query: onCreateWidget,
+ * }).subscribe({
+ * 	//
+ * 	//            |-- You are here
+ * 	//            v
+ * 	next(message: GraphqlSubscriptionMessage<OnCreateWidgetSubscription>) {
+ * 		handle(message.value);  // <-- type OnCreateWidgetSubscription
+ * 	}
+ * })
+ * ```
+ */
+export declare type GraphqlSubscriptionMessage<T> = {
+    data: T;
+};
+export interface AWSAppSyncRealTimeProviderOptions {
+    appSyncGraphqlEndpoint?: string;
+    authenticationType?: GraphQLAuthMode;
+    query?: string;
+    variables?: Record<string, unknown>;
+    apiKey?: string;
+    region?: string;
+    graphql_headers?: () => {} | (() => Promise<{}>);
+    additionalHeaders?: {
+        [key: string]: string;
+    };
+}
+export declare type AWSAppSyncRealTimeProvider = {
+    subscribe(options?: AWSAppSyncRealTimeProviderOptions): Observable<Record<string, unknown>>;
+};
 export declare enum GraphQLAuthError {
     NO_API_KEY = "No api-key configured",
     NO_CURRENT_USER = "No current user",
@@ -31,3 +159,151 @@ export declare enum GraphQLAuthError {
  * @see: https://graphql.org/graphql-js/language/#parse
  */
 export declare type GraphQLOperation = Source | string;
+/**
+ * API V6 `graphql({options})` type that can leverage branded graphql `query`
+ * objects and fallback types.
+ */
+export interface GraphQLOptionsV6<FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string> {
+    query: TYPED_GQL_STRING | DocumentNode;
+    variables?: GraphQLVariablesV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+    authMode?: GraphQLAuthMode;
+    authToken?: string;
+    /**
+     * @deprecated This property should not be used
+     */
+    userAgentSuffix?: string;
+}
+/**
+ * Result type for `graphql()` operations that don't include any specific
+ * type information. The result could be either a `Promise` or `Subscription`.
+ *
+ * Invoking code should either cast the result or use `?` and `!` operators to
+ * navigate the result objects.
+ */
+export declare type UnknownGraphQLResponse = Promise<GraphQLResult<any>> | GraphqlSubscriptionResult<any>;
+/**
+ * The expected type for `variables` in a V6 `graphql()` operation with
+ * respect to the given `FALLBACK_TYPES` and `TYPED_GQL_STRING`.
+ */
+export declare type GraphQLVariablesV6<FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string> = TYPED_GQL_STRING extends GeneratedQuery<infer IN, any> ? IN : TYPED_GQL_STRING extends GeneratedMutation<infer IN, any> ? IN : TYPED_GQL_STRING extends GeneratedSubscription<infer IN, any> ? IN : FALLBACK_TYPES extends GraphQLOperationType<infer IN, any> ? IN : any;
+/**
+ * The expected return type with respect to the given `FALLBACK_TYPE`
+ * and `TYPED_GQL_STRING`.
+ */
+export declare type GraphQLResponseV6<FALLBACK_TYPE = unknown, TYPED_GQL_STRING extends string = string> = TYPED_GQL_STRING extends GeneratedQuery<infer IN, infer QUERY_OUT> ? Promise<GraphQLResult<FixedQueryResult<QUERY_OUT>>> : TYPED_GQL_STRING extends GeneratedMutation<infer IN, infer MUTATION_OUT> ? Promise<GraphQLResult<NeverEmpty<MUTATION_OUT>>> : TYPED_GQL_STRING extends GeneratedSubscription<infer IN, infer SUB_OUT> ? GraphqlSubscriptionResult<NeverEmpty<SUB_OUT>> : FALLBACK_TYPE extends GraphQLQuery<infer T> ? Promise<GraphQLResult<FALLBACK_TYPE>> : FALLBACK_TYPE extends GraphQLSubscription<infer T> ? GraphqlSubscriptionResult<FALLBACK_TYPE> : FALLBACK_TYPE extends GraphQLOperationType<infer IN, infer CUSTOM_OUT> ? CUSTOM_OUT : UnknownGraphQLResponse;
+/**
+ * The shape customers can use to provide `T` to `graphql<T>()` to specify both
+ * `IN` and `OUT` types (the type of `variables` and the return type, respectively).
+ *
+ * I.E.,
+ *
+ * ```ts
+ * type MyVariablesType = { ... };
+ * type MyResultType = { ... };
+ * type MyOperationType = { variables: MyVariablesType, result: MyResultType };
+ *
+ * const result: MyResultType = graphql<MyOperationType>("graphql string", {
+ * 	variables: {
+ * 		// MyVariablesType
+ * 	}
+ * })
+ * ```
+ */
+export declare type GraphQLOperationType<IN extends {}, OUT extends {}> = {
+    variables: IN;
+    result: OUT;
+};
+/**
+ * Nominal type for branding generated graphql query operation strings with
+ * input and output types.
+ *
+ * E.g.,
+ *
+ * ```ts
+ * export const getWidget = `...` as GeneratedQuery<
+ * 	GetWidgetQueryVariables,
+ * 	GetWidgetQuery
+ * >;
+ * ```
+ *
+ * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
+ * assign types to the `variables` and result objects.
+ */
+export declare type GeneratedQuery<InputType, OutputType> = string & {
+    __generatedQueryInput: InputType;
+    __generatedQueryOutput: OutputType;
+};
+/**
+ * Nominal type for branding generated graphql mutation operation strings with
+ * input and output types.
+ *
+ * E.g.,
+ *
+ * ```ts
+ * export const createWidget = `...` as GeneratedQuery<
+ * 	CreateWidgetMutationVariables,
+ * 	CreateWidgetMutation
+ * >;
+ * ```
+ *
+ * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
+ * assign types to the `variables` and result objects.
+ */
+export declare type GeneratedMutation<InputType, OutputType> = string & {
+    __generatedMutationInput: InputType;
+    __generatedMutationOutput: OutputType;
+};
+/**
+ * Nominal type for branding generated graphql mutation operation strings with
+ * input and output types.
+ *
+ * E.g.,
+ *
+ * ```ts
+ * export const createWidget = `...` as GeneratedMutation<
+ * 	CreateWidgetMutationVariables,
+ * 	CreateWidgetMutation
+ * >;
+ * ```
+ *
+ * This allows `graphql()` to extract `InputType` and `OutputType` to correctly
+ * assign types to the `variables` and result objects.
+ */
+export declare type GeneratedSubscription<InputType, OutputType> = string & {
+    __generatedSubscriptionInput: InputType;
+    __generatedSubscriptionOutput: OutputType;
+};
+declare type FilteredKeys<T> = {
+    [P in keyof T]: T[P] extends never ? never : P;
+}[keyof T];
+declare type ExcludeNeverFields<O> = {
+    [K in FilteredKeys<O>]: O[K];
+};
+export declare const __amplify: unique symbol;
+export declare type V6Client<T extends Record<any, any> = never> = ExcludeNeverFields<{
+    [__amplify]: AmplifyClassV6;
+    graphql: GraphQLMethod;
+    cancel: (promise: Promise<any>, message?: string) => boolean;
+    isCancelError: (error: any) => boolean;
+}>;
+export declare type V6ClientSSR<T extends Record<any, any> = never> = ExcludeNeverFields<{
+    [__amplify]: AmplifyClassV6;
+    graphql: GraphQLMethodSSR;
+    cancel: (promise: Promise<any>, message?: string) => boolean;
+    isCancelError: (error: any) => boolean;
+}>;
+export declare type GraphQLMethod = <FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string>(options: GraphQLOptionsV6<FALLBACK_TYPES, TYPED_GQL_STRING>, additionalHeaders?: {
+    [key: string]: string;
+} | undefined) => GraphQLResponseV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+export declare type GraphQLMethodSSR = <FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string>(contextSpec: AmplifyServer.ContextSpec, options: GraphQLOptionsV6<FALLBACK_TYPES, TYPED_GQL_STRING>, additionalHeaders?: {
+    [key: string]: string;
+} | undefined) => GraphQLResponseV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+/**
+ * @private
+ *
+ * The knobs available for configuring `server/generateClient` internally.
+ */
+export declare type ServerClientGenerationParams = {
+    amplify: null | ((fn: (amplify: any) => Promise<any>) => Promise<AmplifyClassV6>);
+    config: ResourcesConfig;
+};

package/lib/types/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var auth_1 = require("@aws-amplify/auth");
-exports.GRAPHQL_AUTH_MODE = auth_1.GRAPHQL_AUTH_MODE;
+var PubSub_1 = require("./PubSub");
+exports.CONTROL_MSG = PubSub_1.CONTROL_MSG;
+exports.ConnectionState = PubSub_1.ConnectionState;
 var GraphQLAuthError;
 (function (GraphQLAuthError) {
     GraphQLAuthError["NO_API_KEY"] = "No api-key configured";
@@ -10,4 +11,4 @@ var GraphQLAuthError;
     GraphQLAuthError["NO_FEDERATED_JWT"] = "No federated jwt";
     GraphQLAuthError["NO_AUTH_TOKEN"] = "No auth token specified";
 })(GraphQLAuthError = exports.GraphQLAuthError || (exports.GraphQLAuthError = {}));
-//# sourceMappingURL=index.js.map
+exports.__amplify = Symbol('amplify');

package/lib/utils/ConnectionStateMonitor.d.ts

@@ -0,0 +1,41 @@
+import { Observable } from 'rxjs';
+import { ConnectionState } from '../types/PubSub';
+declare type LinkedConnectionState = 'connected' | 'disconnected';
+declare type LinkedHealthState = 'healthy' | 'unhealthy';
+declare type LinkedConnectionStates = {
+    networkState: LinkedConnectionState;
+    connectionState: LinkedConnectionState | 'connecting';
+    intendedConnectionState: LinkedConnectionState;
+    keepAliveState: LinkedHealthState;
+};
+export declare const CONNECTION_CHANGE: {
+    [key in 'KEEP_ALIVE_MISSED' | 'KEEP_ALIVE' | 'CONNECTION_ESTABLISHED' | 'CONNECTION_FAILED' | 'CLOSING_CONNECTION' | 'OPENING_CONNECTION' | 'CLOSED' | 'ONLINE' | 'OFFLINE']: Partial<LinkedConnectionStates>;
+};
+export declare class ConnectionStateMonitor {
+    /**
+     * @private
+     */
+    private _linkedConnectionState;
+    private _linkedConnectionStateObservable;
+    private _linkedConnectionStateObserver;
+    private _networkMonitoringSubscription?;
+    private _initialNetworkStateSubscription?;
+    constructor();
+    /**
+     * Turn network state monitoring on if it isn't on already
+     */
+    private enableNetworkMonitoring;
+    /**
+     * Turn network state monitoring off if it isn't off already
+     */
+    private disableNetworkMonitoring;
+    /**
+     * Get the observable that allows us to monitor the connection state
+     *
+     * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
+     */
+    get connectionStateObservable(): Observable<ConnectionState>;
+    record(statusUpdates: Partial<LinkedConnectionStates>): void;
+    private connectionStatesTranslator;
+}
+export {};

package/lib/utils/ConnectionStateMonitor.js

@@ -0,0 +1,131 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+const rxjs_1 = require("rxjs");
+const PubSub_1 = require("../types/PubSub");
+const ReachabilityMonitor_1 = require("./ReachabilityMonitor");
+exports.CONNECTION_CHANGE = {
+    KEEP_ALIVE_MISSED: { keepAliveState: 'unhealthy' },
+    KEEP_ALIVE: { keepAliveState: 'healthy' },
+    CONNECTION_ESTABLISHED: { connectionState: 'connected' },
+    CONNECTION_FAILED: {
+        intendedConnectionState: 'disconnected',
+        connectionState: 'disconnected',
+    },
+    CLOSING_CONNECTION: { intendedConnectionState: 'disconnected' },
+    OPENING_CONNECTION: {
+        intendedConnectionState: 'connected',
+        connectionState: 'connecting',
+    },
+    CLOSED: { connectionState: 'disconnected' },
+    ONLINE: { networkState: 'connected' },
+    OFFLINE: { networkState: 'disconnected' },
+};
+class ConnectionStateMonitor {
+    constructor() {
+        this._networkMonitoringSubscription = undefined;
+        this._linkedConnectionState = {
+            networkState: 'connected',
+            connectionState: 'disconnected',
+            intendedConnectionState: 'disconnected',
+            keepAliveState: 'healthy',
+        };
+        // Attempt to update the state with the current actual network state
+        this._initialNetworkStateSubscription = ReachabilityMonitor_1.ReachabilityMonitor().subscribe(({ online }) => {
+            this.record(online ? exports.CONNECTION_CHANGE.ONLINE : exports.CONNECTION_CHANGE.OFFLINE);
+            this._initialNetworkStateSubscription?.unsubscribe();
+        });
+        this._linkedConnectionStateObservable =
+            new rxjs_1.Observable(connectionStateObserver => {
+                connectionStateObserver.next(this._linkedConnectionState);
+                this._linkedConnectionStateObserver = connectionStateObserver;
+            });
+    }
+    /**
+     * Turn network state monitoring on if it isn't on already
+     */
+    enableNetworkMonitoring() {
+        // If no initial network state was discovered, stop trying
+        this._initialNetworkStateSubscription?.unsubscribe();
+        // Maintain the network state based on the reachability monitor
+        if (this._networkMonitoringSubscription === undefined) {
+            this._networkMonitoringSubscription = ReachabilityMonitor_1.ReachabilityMonitor().subscribe(({ online }) => {
+                this.record(online ? exports.CONNECTION_CHANGE.ONLINE : exports.CONNECTION_CHANGE.OFFLINE);
+            });
+        }
+    }
+    /**
+     * Turn network state monitoring off if it isn't off already
+     */
+    disableNetworkMonitoring() {
+        this._networkMonitoringSubscription?.unsubscribe();
+        this._networkMonitoringSubscription = undefined;
+    }
+    /**
+     * Get the observable that allows us to monitor the connection state
+     *
+     * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
+     */
+    get connectionStateObservable() {
+        let previous;
+        // The linked state aggregates state changes to any of the network, connection,
+        // intendedConnection and keepAliveHealth. Some states will change these independent
+        // states without changing the overall connection state.
+        // After translating from linked states to ConnectionState, then remove any duplicates
+        return this._linkedConnectionStateObservable
+            .pipe(rxjs_1.map(value => {
+            return this.connectionStatesTranslator(value);
+        }))
+            .pipe(rxjs_1.filter(current => {
+            const toInclude = current !== previous;
+            previous = current;
+            return toInclude;
+        }));
+    }
+    /*
+     * Updates local connection state and emits the full state to the observer.
+     */
+    record(statusUpdates) {
+        // Maintain the network monitor
+        if (statusUpdates.intendedConnectionState === 'connected') {
+            this.enableNetworkMonitoring();
+        }
+        else if (statusUpdates.intendedConnectionState === 'disconnected') {
+            this.disableNetworkMonitoring();
+        }
+        // Maintain the socket state
+        const newSocketStatus = {
+            ...this._linkedConnectionState,
+            ...statusUpdates,
+        };
+        this._linkedConnectionState = { ...newSocketStatus };
+        this._linkedConnectionStateObserver?.next(this._linkedConnectionState);
+    }
+    /*
+     * Translate the ConnectionState structure into a specific ConnectionState string literal union
+     */
+    connectionStatesTranslator({ connectionState, networkState, intendedConnectionState, keepAliveState, }) {
+        if (connectionState === 'connected' && networkState === 'disconnected')
+            return PubSub_1.ConnectionState.ConnectedPendingNetwork;
+        if (connectionState === 'connected' &&
+            intendedConnectionState === 'disconnected')
+            return PubSub_1.ConnectionState.ConnectedPendingDisconnect;
+        if (connectionState === 'disconnected' &&
+            intendedConnectionState === 'connected' &&
+            networkState === 'disconnected')
+            return PubSub_1.ConnectionState.ConnectionDisruptedPendingNetwork;
+        if (connectionState === 'disconnected' &&
+            intendedConnectionState === 'connected')
+            return PubSub_1.ConnectionState.ConnectionDisrupted;
+        if (connectionState === 'connected' && keepAliveState === 'unhealthy')
+            return PubSub_1.ConnectionState.ConnectedPendingKeepAlive;
+        // All remaining states directly correspond to the connection state
+        if (connectionState === 'connecting')
+            return PubSub_1.ConnectionState.Connecting;
+        if (connectionState === 'disconnected')
+            return PubSub_1.ConnectionState.Disconnected;
+        return PubSub_1.ConnectionState.Connected;
+    }
+}
+exports.ConnectionStateMonitor = ConnectionStateMonitor;

package/lib/utils/ReachabilityMonitor/index.d.ts

@@ -0,0 +1 @@
+export declare const ReachabilityMonitor: () => any;

package/lib/utils/ReachabilityMonitor/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const utils_1 = require("@aws-amplify/core/internals/utils");
+exports.ReachabilityMonitor = () => new utils_1.Reachability().networkMonitor();

package/lib/utils/ReachabilityMonitor/index.native.d.ts

@@ -0,0 +1 @@
+export declare const ReachabilityMonitor: () => any;

package/lib/utils/ReachabilityMonitor/index.native.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+const utils_1 = require("@aws-amplify/core/internals/utils");
+const netinfo_1 = tslib_1.__importDefault(require("@react-native-community/netinfo"));
+exports.ReachabilityMonitor = () => new utils_1.Reachability().networkMonitor(netinfo_1.default);

package/lib/utils/ReconnectionMonitor.d.ts

@@ -0,0 +1,29 @@
+import { Observer } from 'rxjs';
+export declare enum ReconnectEvent {
+    START_RECONNECT = "START_RECONNECT",
+    HALT_RECONNECT = "HALT_RECONNECT"
+}
+/**
+ * Captures the reconnect event logic used to determine when to reconnect to PubSub providers.
+ *   Reconnnect attempts are delayed by 5 seconds to let the interface settle.
+ *   Attempting to reconnect only once creates unrecoverable states when the network state isn't
+ *   supported by the browser, so this keeps retrying every minute until halted.
+ */
+export declare class ReconnectionMonitor {
+    private reconnectObservers;
+    private reconnectIntervalId?;
+    private reconnectSetTimeoutId?;
+    /**
+     * Add reconnect observer to the list of observers to alert on reconnect
+     */
+    addObserver(reconnectObserver: Observer<void>): void;
+    /**
+     * Given a reconnect event, start the appropriate behavior
+     */
+    record(event: ReconnectEvent): void;
+    /**
+     * Complete all reconnect observers
+     */
+    close(): void;
+    private _triggerReconnect;
+}