@aws-amplify/api-graphql 3.4.11 → 4.0.1-console-preview.047a1dd.0

package/lib-esm/types/PubSub.d.ts

@@ -0,0 +1,27 @@
+import { ZenObservable } from 'zen-observable-ts';
+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> | string;
+export declare type PubSubContentObserver = ZenObservable.SubscriptionObserver<PubSubContent>;

package/lib-esm/types/PubSub.js

@@ -0,0 +1,44 @@
+export 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 || (CONTROL_MSG = {}));
+/** @enum {string} */
+export 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 || (ConnectionState = {}));

package/lib-esm/types/index.d.ts

@@ -1,11 +1,15 @@
 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 { DocumentType } from '@aws-amplify/api-rest';
+export declare type GraphQLAuthMode = 'AWS_IAM' | 'COGNITO_USERPOOLS' | 'API_KEY';
+/**
+ * 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?: string;
     authToken?: string;
     /**
      * @deprecated This property should not be used
@@ -19,6 +23,68 @@ export interface GraphQLResult<T = object> {
         [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';
+};
+/**
+ * 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 +97,117 @@ 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<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;
+/**
+ * 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;
+};

package/lib-esm/types/index.js

@@ -1,5 +1,3 @@
-import { GRAPHQL_AUTH_MODE } from '@aws-amplify/auth';
-export { GRAPHQL_AUTH_MODE };
 export var GraphQLAuthError;
 (function (GraphQLAuthError) {
     GraphQLAuthError["NO_API_KEY"] = "No api-key configured";
@@ -8,4 +6,3 @@ export var GraphQLAuthError;
     GraphQLAuthError["NO_FEDERATED_JWT"] = "No federated jwt";
     GraphQLAuthError["NO_AUTH_TOKEN"] = "No auth token specified";
 })(GraphQLAuthError || (GraphQLAuthError = {}));
-//# sourceMappingURL=index.js.map

package/lib-esm/utils/ConnectionStateMonitor.d.ts

@@ -0,0 +1,41 @@
+import Observable from 'zen-observable-ts';
+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-esm/utils/ConnectionStateMonitor.js

@@ -0,0 +1,141 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { __assign } from "tslib";
+import Observable from 'zen-observable-ts';
+import { ConnectionState } from '../types/PubSub';
+import { ReachabilityMonitor } from './ReachabilityMonitor';
+export var 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' },
+};
+var ConnectionStateMonitor = /** @class */ (function () {
+    function ConnectionStateMonitor() {
+        var _this = this;
+        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().subscribe(function (_a) {
+            var online = _a.online;
+            var _b;
+            _this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
+            (_b = _this._initialNetworkStateSubscription) === null || _b === void 0 ? void 0 : _b.unsubscribe();
+        });
+        this._linkedConnectionStateObservable =
+            new Observable(function (connectionStateObserver) {
+                connectionStateObserver.next(_this._linkedConnectionState);
+                _this._linkedConnectionStateObserver = connectionStateObserver;
+            });
+    }
+    /**
+     * Turn network state monitoring on if it isn't on already
+     */
+    ConnectionStateMonitor.prototype.enableNetworkMonitoring = function () {
+        var _this = this;
+        var _a;
+        // If no initial network state was discovered, stop trying
+        (_a = this._initialNetworkStateSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        // Maintain the network state based on the reachability monitor
+        if (this._networkMonitoringSubscription === undefined) {
+            this._networkMonitoringSubscription = ReachabilityMonitor().subscribe(function (_a) {
+                var online = _a.online;
+                _this.record(online ? CONNECTION_CHANGE.ONLINE : CONNECTION_CHANGE.OFFLINE);
+            });
+        }
+    };
+    /**
+     * Turn network state monitoring off if it isn't off already
+     */
+    ConnectionStateMonitor.prototype.disableNetworkMonitoring = function () {
+        var _a;
+        (_a = this._networkMonitoringSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this._networkMonitoringSubscription = undefined;
+    };
+    Object.defineProperty(ConnectionStateMonitor.prototype, "connectionStateObservable", {
+        /**
+         * Get the observable that allows us to monitor the connection state
+         *
+         * @returns {Observable<ConnectionState>} - The observable that emits ConnectionState updates
+         */
+        get: function () {
+            var _this = this;
+            var 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
+                .map(function (value) {
+                return _this.connectionStatesTranslator(value);
+            })
+                .filter(function (current) {
+                var toInclude = current !== previous;
+                previous = current;
+                return toInclude;
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /*
+     * Updates local connection state and emits the full state to the observer.
+     */
+    ConnectionStateMonitor.prototype.record = function (statusUpdates) {
+        // Maintain the network monitor
+        if (statusUpdates.intendedConnectionState === 'connected') {
+            this.enableNetworkMonitoring();
+        }
+        else if (statusUpdates.intendedConnectionState === 'disconnected') {
+            this.disableNetworkMonitoring();
+        }
+        // Maintain the socket state
+        var newSocketStatus = __assign(__assign({}, this._linkedConnectionState), statusUpdates);
+        this._linkedConnectionState = __assign({}, newSocketStatus);
+        this._linkedConnectionStateObserver.next(this._linkedConnectionState);
+    };
+    /*
+     * Translate the ConnectionState structure into a specific ConnectionState string literal union
+     */
+    ConnectionStateMonitor.prototype.connectionStatesTranslator = function (_a) {
+        var connectionState = _a.connectionState, networkState = _a.networkState, intendedConnectionState = _a.intendedConnectionState, keepAliveState = _a.keepAliveState;
+        if (connectionState === 'connected' && networkState === 'disconnected')
+            return ConnectionState.ConnectedPendingNetwork;
+        if (connectionState === 'connected' &&
+            intendedConnectionState === 'disconnected')
+            return ConnectionState.ConnectedPendingDisconnect;
+        if (connectionState === 'disconnected' &&
+            intendedConnectionState === 'connected' &&
+            networkState === 'disconnected')
+            return ConnectionState.ConnectionDisruptedPendingNetwork;
+        if (connectionState === 'disconnected' &&
+            intendedConnectionState === 'connected')
+            return ConnectionState.ConnectionDisrupted;
+        if (connectionState === 'connected' && keepAliveState === 'unhealthy')
+            return ConnectionState.ConnectedPendingKeepAlive;
+        // All remaining states directly correspond to the connection state
+        if (connectionState === 'connecting')
+            return ConnectionState.Connecting;
+        if (connectionState === 'disconnected')
+            return ConnectionState.Disconnected;
+        return ConnectionState.Connected;
+    };
+    return ConnectionStateMonitor;
+}());
+export { ConnectionStateMonitor };

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

@@ -0,0 +1,3 @@
+export declare const ReachabilityMonitor: () => import("zen-observable-ts").default<{
+    online: boolean;
+}>;

package/lib-esm/utils/ReachabilityMonitor/index.js

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Reachability } from '@aws-amplify/core/internals/utils';
+export var ReachabilityMonitor = function () { return new Reachability().networkMonitor(); };

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

@@ -0,0 +1,3 @@
+export declare const ReachabilityMonitor: () => import("zen-observable-ts").default<{
+    online: boolean;
+}>;

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

@@ -0,0 +1,7 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Reachability } from '@aws-amplify/core/internals/utils';
+import { default as NetInfo } from '@react-native-community/netinfo';
+export var ReachabilityMonitor = function () {
+    return new Reachability().networkMonitor(NetInfo);
+};

package/lib-esm/utils/ReconnectionMonitor.d.ts

@@ -0,0 +1,29 @@
+import { Observer } from 'zen-observable-ts';
+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-esm/utils/ReconnectionMonitor.js

@@ -0,0 +1,70 @@
+import { RECONNECT_DELAY, RECONNECT_INTERVAL } from '../Providers/constants';
+export var ReconnectEvent;
+(function (ReconnectEvent) {
+    ReconnectEvent["START_RECONNECT"] = "START_RECONNECT";
+    ReconnectEvent["HALT_RECONNECT"] = "HALT_RECONNECT";
+})(ReconnectEvent || (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.
+ */
+var ReconnectionMonitor = /** @class */ (function () {
+    function ReconnectionMonitor() {
+        this.reconnectObservers = [];
+    }
+    /**
+     * Add reconnect observer to the list of observers to alert on reconnect
+     */
+    ReconnectionMonitor.prototype.addObserver = function (reconnectObserver) {
+        this.reconnectObservers.push(reconnectObserver);
+    };
+    /**
+     * Given a reconnect event, start the appropriate behavior
+     */
+    ReconnectionMonitor.prototype.record = function (event) {
+        var _this = this;
+        if (event === ReconnectEvent.START_RECONNECT) {
+            // If the reconnection hasn't been started
+            if (this.reconnectSetTimeoutId === undefined &&
+                this.reconnectIntervalId === undefined) {
+                this.reconnectSetTimeoutId = setTimeout(function () {
+                    // Reconnect now
+                    _this._triggerReconnect();
+                    // Retry reconnect every periodically until it works
+                    _this.reconnectIntervalId = setInterval(function () {
+                        _this._triggerReconnect();
+                    }, RECONNECT_INTERVAL);
+                }, 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
+     */
+    ReconnectionMonitor.prototype.close = function () {
+        this.reconnectObservers.forEach(function (reconnectObserver) {
+            var _a;
+            (_a = reconnectObserver.complete) === null || _a === void 0 ? void 0 : _a.call(reconnectObserver);
+        });
+    };
+    ReconnectionMonitor.prototype._triggerReconnect = function () {
+        this.reconnectObservers.forEach(function (reconnectObserver) {
+            var _a;
+            (_a = reconnectObserver.next) === null || _a === void 0 ? void 0 : _a.call(reconnectObserver);
+        });
+    };
+    return ReconnectionMonitor;
+}());
+export { ReconnectionMonitor };

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

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

package/lib-esm/utils/errors/APIError.js

@@ -0,0 +1,20 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { __extends } from "tslib";
+import { AmplifyError } from '@aws-amplify/core/internals/utils';
+/**
+ * @internal
+ */
+var APIError = /** @class */ (function (_super) {
+    __extends(APIError, _super);
+    function APIError(params) {
+        var _this = _super.call(this, params) || this;
+        // 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);
+        return _this;
+    }
+    return APIError;
+}(AmplifyError));
+export { APIError };

package/lib-esm/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-esm/utils/errors/assertValidationError.js

@@ -0,0 +1,13 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { APIError } from './APIError';
+import { validationErrorMap } from './validation';
+/**
+ * @internal
+ */
+export function assertValidationError(assertion, name) {
+    var _a = validationErrorMap[name], message = _a.message, recoverySuggestion = _a.recoverySuggestion;
+    if (!assertion) {
+        throw new APIError({ name: name, message: message, recoverySuggestion: recoverySuggestion });
+    }
+}

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

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

package/lib-esm/utils/errors/index.js

@@ -0,0 +1,5 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { APIError } from './APIError';
+export { assertValidationError } from './assertValidationError';
+export { APIValidationErrorCode, validationErrorMap } from './validation';

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

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