@aws-amplify/api-graphql 3.4.12-api-v6-models.b3abc9b.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,16 +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 'zen-observable-ts';
-import { AWSAppSyncRealTimeProvider } from '@aws-amplify/pubsub';
+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
@@ -18,7 +19,7 @@ export interface GraphQLOptions {
     userAgentSuffix?: string;
 }
 export interface GraphQLResult<T = object> {
-    data?: T;
+    data: T;
     errors?: GraphQLError[];
     extensions?: {
         [key: string]: any;
@@ -31,6 +32,66 @@ export declare type GraphQLQuery<T> = T & {
 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.
  *
@@ -69,10 +130,22 @@ export declare type GraphqlSubscriptionResult<T> = Observable<GraphqlSubscriptio
  * ```
  */
 export declare type GraphqlSubscriptionMessage<T> = {
-    provider: AWSAppSyncRealTimeProvider;
-    value: {
-        data?: 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",
@@ -93,7 +166,7 @@ export declare type GraphQLOperation = Source | string;
 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?: keyof typeof GRAPHQL_AUTH_MODE;
+    authMode?: GraphQLAuthMode;
     authToken?: string;
     /**
      * @deprecated This property should not be used
@@ -117,7 +190,7 @@ export declare type GraphQLVariablesV6<FALLBACK_TYPES = unknown, TYPED_GQL_STRIN
  * 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<QUERY_OUT>> : TYPED_GQL_STRING extends GeneratedMutation<infer IN, infer MUTATION_OUT> ? Promise<GraphQLResult<MUTATION_OUT>> : TYPED_GQL_STRING extends GeneratedSubscription<infer IN, infer SUB_OUT> ? GraphqlSubscriptionResult<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;
+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).
@@ -200,3 +273,37 @@ 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;
+}

package/lib/utils/ReconnectionMonitor.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../Providers/constants");
+var ReconnectEvent;
+(function (ReconnectEvent) {
+    ReconnectEvent["START_RECONNECT"] = "START_RECONNECT";
+    ReconnectEvent["HALT_RECONNECT"] = "HALT_RECONNECT";
+})(ReconnectEvent = exports.ReconnectEvent || (exports.ReconnectEvent = {}));
+/**
+ * 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.
+ */
+class ReconnectionMonitor {
+    constructor() {
+        this.reconnectObservers = [];
+    }
+    /**
+     * Add reconnect observer to the list of observers to alert on reconnect
+     */
+    addObserver(reconnectObserver) {
+        this.reconnectObservers.push(reconnectObserver);
+    }
+    /**
+     * Given a reconnect event, start the appropriate behavior
+     */
+    record(event) {
+        if (event === ReconnectEvent.START_RECONNECT) {
+            // If the reconnection hasn't been started
+            if (this.reconnectSetTimeoutId === undefined &&
+                this.reconnectIntervalId === undefined) {
+                this.reconnectSetTimeoutId = setTimeout(() => {
+                    // Reconnect now
+                    this._triggerReconnect();
+                    // Retry reconnect every periodically until it works
+                    this.reconnectIntervalId = setInterval(() => {
+                        this._triggerReconnect();
+                    }, constants_1.RECONNECT_INTERVAL);
+                }, constants_1.RECONNECT_DELAY);
+            }
+        }
+        if (event === ReconnectEvent.HALT_RECONNECT) {
+            if (this.reconnectIntervalId) {
+                clearInterval(this.reconnectIntervalId);
+                this.reconnectIntervalId = undefined;
+            }
+            if (this.reconnectSetTimeoutId) {
+                clearTimeout(this.reconnectSetTimeoutId);
+                this.reconnectSetTimeoutId = undefined;
+            }
+        }
+    }
+    /**
+     * Complete all reconnect observers
+     */
+    close() {
+        this.reconnectObservers.forEach(reconnectObserver => {
+            reconnectObserver.complete?.();
+        });
+    }
+    _triggerReconnect() {
+        this.reconnectObservers.forEach(reconnectObserver => {
+            reconnectObserver.next?.();
+        });
+    }
+}
+exports.ReconnectionMonitor = ReconnectionMonitor;

package/lib/utils/errors/APIError.d.ts

@@ -0,0 +1,7 @@
+import { AmplifyError, AmplifyErrorParams } from '@aws-amplify/core/internals/utils';
+/**
+ * @internal
+ */
+export declare class APIError extends AmplifyError {
+    constructor(params: AmplifyErrorParams);
+}

package/lib/utils/errors/APIError.js

@@ -0,0 +1,18 @@
+"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 utils_1 = require("@aws-amplify/core/internals/utils");
+/**
+ * @internal
+ */
+class APIError extends utils_1.AmplifyError {
+    constructor(params) {
+        super(params);
+        // Hack for making the custom error class work when transpiled to es5
+        // TODO: Delete the following 2 lines after we change the build target to >= es2015
+        this.constructor = APIError;
+        Object.setPrototypeOf(this, APIError.prototype);
+    }
+}
+exports.APIError = APIError;

package/lib/utils/errors/assertValidationError.d.ts

@@ -0,0 +1,5 @@
+import { APIValidationErrorCode } from './validation';
+/**
+ * @internal
+ */
+export declare function assertValidationError(assertion: boolean, name: APIValidationErrorCode): asserts assertion;

package/lib/utils/errors/assertValidationError.js

@@ -0,0 +1,16 @@
+"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 APIError_1 = require("./APIError");
+const validation_1 = require("./validation");
+/**
+ * @internal
+ */
+function assertValidationError(assertion, name) {
+    const { message, recoverySuggestion } = validation_1.validationErrorMap[name];
+    if (!assertion) {
+        throw new APIError_1.APIError({ name, message, recoverySuggestion });
+    }
+}
+exports.assertValidationError = assertValidationError;

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

@@ -0,0 +1,3 @@
+export { APIError } from './APIError';
+export { assertValidationError } from './assertValidationError';
+export { APIValidationErrorCode, validationErrorMap } from './validation';

package/lib/utils/errors/index.js

@@ -0,0 +1,11 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var APIError_1 = require("./APIError");
+exports.APIError = APIError_1.APIError;
+var assertValidationError_1 = require("./assertValidationError");
+exports.assertValidationError = assertValidationError_1.assertValidationError;
+var validation_1 = require("./validation");
+exports.APIValidationErrorCode = validation_1.APIValidationErrorCode;
+exports.validationErrorMap = validation_1.validationErrorMap;

package/lib/utils/errors/validation.d.ts

@@ -0,0 +1,7 @@
+import { AmplifyErrorMap } from '@aws-amplify/core/internals/utils';
+export declare enum APIValidationErrorCode {
+    NoAuthSession = "NoAuthSession",
+    NoRegion = "NoRegion",
+    NoCustomEndpoint = "NoCustomEndpoint"
+}
+export declare const validationErrorMap: AmplifyErrorMap<APIValidationErrorCode>;