@aws-amplify/core 5.8.2 → 6.0.1-console-preview.f63250a.0

package/lib-esm/clients/middleware/retry/defaultRetryDecider.js

@@ -43,20 +43,21 @@ import { isClockSkewError } from './isClockSkewError';
  */
 export var getRetryDecider = function (errorParser) {
     return function (response, error) { return __awaiter(void 0, void 0, void 0, function () {
-        var errorCode, _a, statusCode;
-        var _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
+        var parsedError, _a, errorCode, statusCode;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
                 case 0:
-                    if (!(error !== null && error !== void 0)) return [3 /*break*/, 1];
-                    _a = error;
+                    if (!((_b = error) !== null && _b !== void 0)) return [3 /*break*/, 1];
+                    _a = _b;
                     return [3 /*break*/, 3];
                 case 1: return [4 /*yield*/, errorParser(response)];
                 case 2:
-                    _a = (_c.sent());
-                    _c.label = 3;
+                    _a = (_d.sent());
+                    _d.label = 3;
                 case 3:
-                    errorCode = ((_b = _a) !== null && _b !== void 0 ? _b : {}).name;
+                    parsedError = (_c = _a) !== null && _c !== void 0 ? _c : undefined;
+                    errorCode = parsedError === null || parsedError === void 0 ? void 0 : parsedError['code'];
                     statusCode = response === null || response === void 0 ? void 0 : response.statusCode;
                     return [2 /*return*/, (isConnectionError(error) ||
                             isThrottlingError(statusCode, errorCode) ||
@@ -88,10 +89,13 @@ var TIMEOUT_ERROR_CODES = [
     'RequestTimeoutException',
 ];
 var isThrottlingError = function (statusCode, errorCode) {
-    return statusCode === 429 || THROTTLING_ERROR_CODES.includes(errorCode);
+    return statusCode === 429 ||
+        (!!errorCode && THROTTLING_ERROR_CODES.includes(errorCode));
+};
+var isConnectionError = function (error) {
+    return (error === null || error === void 0 ? void 0 : error['name']) === 'Network error';
 };
-var isConnectionError = function (error) { return (error === null || error === void 0 ? void 0 : error.name) === 'Network error'; };
 var isServerSideError = function (statusCode, errorCode) {
-    return [500, 502, 503, 504].includes(statusCode) ||
-        TIMEOUT_ERROR_CODES.includes(errorCode);
+    return (!!statusCode && [500, 502, 503, 504].includes(statusCode)) ||
+        (!!errorCode && TIMEOUT_ERROR_CODES.includes(errorCode));
 };

package/lib-esm/clients/middleware/retry/isClockSkewError.js

@@ -19,5 +19,5 @@ var CLOCK_SKEW_ERROR_CODES = [
  * @internal
  */
 export var isClockSkewError = function (errorCode) {
-    return CLOCK_SKEW_ERROR_CODES.includes(errorCode);
+    return !!errorCode && CLOCK_SKEW_ERROR_CODES.includes(errorCode);
 };

package/lib-esm/clients/middleware/retry/middleware.d.ts

@@ -30,4 +30,4 @@ export interface RetryOptions<TResponse = Response> {
 /**
  * Retry middleware
  */
-export declare const retryMiddleware: <TInput = Request, TOutput = Response>({ maxAttempts, retryDecider, computeDelay, abortSignal, }: RetryOptions<TOutput>) => (next: MiddlewareHandler<TInput, TOutput>, context: MiddlewareContext) => (request: TInput) => Promise<TOutput>;
+export declare const retryMiddleware: <TInput = Request, TOutput = Response>({ maxAttempts, retryDecider, computeDelay, abortSignal, }: RetryOptions<TOutput>) => (next: MiddlewareHandler<TInput, TOutput>, context: MiddlewareContext) => (request: TInput) => Promise<NonNullable<TOutput>>;

package/lib-esm/clients/middleware/retry/middleware.js

@@ -58,11 +58,11 @@ export var retryMiddleware = function (_a) {
     }
     return function (next, context) {
         return function retryMiddleware(request) {
-            var _a;
+            var _a, _b, _c;
             return __awaiter(this, void 0, void 0, function () {
                 var error, attemptsCount, response, handleTerminalErrorOrResponse, e_1, delay;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
                         case 0:
                             attemptsCount = (_a = context.attemptsCount) !== null && _a !== void 0 ? _a : 0;
                             handleTerminalErrorOrResponse = function () {
@@ -75,38 +75,38 @@ export var retryMiddleware = function (_a) {
                                     throw error;
                                 }
                             };
-                            _b.label = 1;
+                            _d.label = 1;
                         case 1:
                             if (!(!(abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) && attemptsCount < maxAttempts)) return [3 /*break*/, 11];
-                            _b.label = 2;
+                            _d.label = 2;
                         case 2:
-                            _b.trys.push([2, 4, , 5]);
+                            _d.trys.push([2, 4, , 5]);
                             return [4 /*yield*/, next(request)];
                         case 3:
-                            response = _b.sent();
+                            response = _d.sent();
                             error = undefined;
                             return [3 /*break*/, 5];
                         case 4:
-                            e_1 = _b.sent();
+                            e_1 = _d.sent();
                             error = e_1;
                             response = undefined;
                             return [3 /*break*/, 5];
                         case 5:
                             // context.attemptsCount may be updated after calling next handler which may retry the request by itself.
                             attemptsCount =
-                                context.attemptsCount > attemptsCount
-                                    ? context.attemptsCount
+                                ((_b = context.attemptsCount) !== null && _b !== void 0 ? _b : 0) > attemptsCount
+                                    ? (_c = context.attemptsCount) !== null && _c !== void 0 ? _c : 0
                                     : attemptsCount + 1;
                             context.attemptsCount = attemptsCount;
                             return [4 /*yield*/, retryDecider(response, error)];
                         case 6:
-                            if (!_b.sent()) return [3 /*break*/, 9];
+                            if (!_d.sent()) return [3 /*break*/, 9];
                             if (!(!(abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted) && attemptsCount < maxAttempts)) return [3 /*break*/, 8];
                             delay = computeDelay(attemptsCount);
                             return [4 /*yield*/, cancellableSleep(delay, abortSignal)];
                         case 7:
-                            _b.sent();
-                            _b.label = 8;
+                            _d.sent();
+                            _d.label = 8;
                         case 8: return [3 /*break*/, 1];
                         case 9: return [2 /*return*/, handleTerminalErrorOrResponse()];
                         case 10: return [3 /*break*/, 1];

package/lib-esm/clients/middleware/signing/signer/signatureV4/utils/dataHashHelpers.js

@@ -11,7 +11,7 @@ import { toHex } from '@aws-sdk/util-hex-encoding';
  * @returns `Uint8Array` created from the data as input to a hash function.
  */
 export var getHashedData = function (key, data) {
-    var sha256 = new Sha256(key);
+    var sha256 = new Sha256(key !== null && key !== void 0 ? key : undefined);
     sha256.update(data);
     // TODO: V6 flip to async digest
     var hashedData = sha256.digestSync();

package/lib-esm/clients/serde/responseInfo.js

@@ -17,5 +17,5 @@ export var parseMetadata = function (response) {
     return __assign(__assign({}, (isMetadataBearer(response) ? response.$metadata : {})), { httpStatusCode: statusCode, requestId: (_b = (_a = headers['x-amzn-requestid']) !== null && _a !== void 0 ? _a : headers['x-amzn-request-id']) !== null && _b !== void 0 ? _b : headers['x-amz-request-id'], extendedRequestId: headers['x-amz-id-2'], cfId: headers['x-amz-cf-id'] });
 };
 var isMetadataBearer = function (response) {
-    return typeof (response === null || response === void 0 ? void 0 : response['$metadata']) === 'object';
+    return typeof (response === null || response === void 0 ? void 0 : response.$metadata) === 'object';
 };

package/lib-esm/clients/types/aws.d.ts

@@ -18,3 +18,7 @@ export interface ServiceClientOptions {
  * This function is protocol-specific (e.g. JSON, XML, etc.)
  */
 export type ErrorParser = (response?: HttpResponse) => Promise<(Error & MetadataBearer) | undefined>;
+/**
+ *  Default config options for the `composeServiceApi`.
+ */
+export type DefaultConfigOptions<TransferHandlerOptions extends Record<string, unknown> = Record<string, unknown>> = Partial<TransferHandlerOptions & ServiceClientOptions>;

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

@@ -1,3 +1,3 @@
 export { Middleware, MiddlewareHandler, Request, Response, TransferHandler, Endpoint, } from './core';
 export { Headers, HttpRequest, HttpResponse, HttpTransferHandler, HttpTransferOptions, ResponseBodyMixin, } from './http';
-export { Credentials, EndpointResolverOptions, ErrorParser, ServiceClientOptions, } from './aws';
+export { Credentials, EndpointResolverOptions, ErrorParser, ServiceClientOptions, DefaultConfigOptions, } from './aws';

package/lib-esm/constants.d.ts

@@ -1,2 +1,9 @@
 export declare const INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER: string | symbol;
 export declare const USER_AGENT_HEADER = "x-amz-user-agent";
+export declare const AUTH_CONFING_EXCEPTION = "AuthConfigException";
+export declare const AWS_CLOUD_WATCH_PROVIDER_OPTIONS_EXCEPTION = "AWSCloudWatchProviderOptionsException";
+export declare const CACHE_LIST_EXCEPTION = "CacheListException";
+export declare const I18N_EXCEPTION = "I18NException";
+export declare const SERVICE_WORKER_EXCEPTION = "ServiceWorkerException";
+export declare const STORAGE_CACHE_EXCEPTION = "StorageCacheException";
+export declare const APPLICATION_ID_EXCEPTION = "ApplicationIdException";

package/lib-esm/constants.js

@@ -9,3 +9,11 @@ export var INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER = hasSymbol
     ? Symbol.for('INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER')
     : '@@INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER';
 export var USER_AGENT_HEADER = 'x-amz-user-agent';
+// Error exception code constants
+export var AUTH_CONFING_EXCEPTION = 'AuthConfigException';
+export var AWS_CLOUD_WATCH_PROVIDER_OPTIONS_EXCEPTION = 'AWSCloudWatchProviderOptionsException';
+export var CACHE_LIST_EXCEPTION = 'CacheListException';
+export var I18N_EXCEPTION = 'I18NException';
+export var SERVICE_WORKER_EXCEPTION = 'ServiceWorkerException';
+export var STORAGE_CACHE_EXCEPTION = 'StorageCacheException';
+export var APPLICATION_ID_EXCEPTION = 'ApplicationIdException';

package/lib-esm/index.d.ts

@@ -1,9 +1,9 @@
 import { Amplify } from './Amplify';
-export { Amplify } from './Amplify';
+export { Amplify };
 export { AmplifyClass } from './Amplify';
 export { ClientDevice } from './ClientDevice';
 export { ConsoleLogger, ConsoleLogger as Logger } from './Logger';
-export { invalidParameter, missingConfig } from './Errors';
+export { invalidParameter, missingConfig, AmplifyError, AmplifyErrorString, } from './Errors';
 export { Hub, HubCapsule, HubCallback, HubPayload } from './Hub';
 export { I18n } from './I18n';
 export { browserOrNode, filenameToContentType, generateRandomString, isEmpty, isStrictObject, isTextFile, isWebWorker, makeQuerablePromise, objectLessAttributes, sortByField, transferKeyToLowerCase, transferKeyToUpperCase, } from './JS';
@@ -14,8 +14,8 @@ export { FacebookOAuth, GoogleOAuth } from './OAuthHelper';
 export { AppState, AsyncStorage, Linking } from './RNComponents';
 export { Credentials, CredentialsClass } from './Credentials';
 export { ServiceWorker } from './ServiceWorker';
-export { ICredentials } from './types';
-export { StorageHelper, MemoryStorage } from './StorageHelper';
+export { ICredentials, ErrorParams, AmplifyErrorMap, ServiceError, KeyValueStorageInterface, } from './types';
+export { StorageHelper, MemoryStorage, LocalStorage, CookieStorage, SessionStorage, MemoryKeyValueStorage, } from './StorageHelper';
 export { UniversalStorage } from './UniversalStorage';
 export { Platform, getAmplifyUserAgentObject, getAmplifyUserAgent, } from './Platform';
 export { ApiAction, AuthAction, AnalyticsAction, Category, CustomUserAgentDetails, DataStoreAction, Framework, GeoAction, InteractionsAction, InAppMessagingAction, PredictionsAction, PubSubAction, PushNotificationAction, StorageAction, } from './Platform/types';
@@ -24,6 +24,20 @@ export declare const Constants: {
     userAgent: string;
 };
 export { AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, BackgroundManagerNotOpenError, BackgroundProcessManager, BackgroundProcessManagerState, DateUtils, Mutex, NO_CREDS_ERROR_STRING, NonRetryableError, RETRY_ERROR_CODES, Reachability, isNonRetryableError, jitteredBackoff, jitteredExponentialRetry, retry, urlSafeDecode, urlSafeEncode, } from './Util';
+import { BrowserStorageCache } from './Cache/BrowserStorageCache';
+export { asserts } from './Util/errors/AssertError';
+export { isTokenExpired } from './singleton/Auth';
+export { InMemoryCache } from './Cache/InMemoryCache';
+export { CacheConfig } from './Cache/types';
+export { ICache } from './Cache/types';
+export { BrowserStorageCache };
+export { BrowserStorageCache as Cache };
+export { decodeJWT, assertTokenProviderConfig, assertIdentityPooIdConfig, } from './singleton/Auth/utils';
+export { TokenProvider, AuthTokens, FetchAuthSessionOptions, AWSCredentialsAndIdentityIdProvider, AWSCredentialsAndIdentityId, Identity, } from './singleton/Auth/types';
+export { AuthConfig, UserPoolConfig, UserPoolConfigAndIdentityPoolConfig, StorageAccessLevel, StorageConfig, GetCredentialsOptions, } from './singleton/types';
+export { getCredentialsForIdentity, getId, GetCredentialsForIdentityInput, GetCredentialsForIdentityOutput, } from './AwsClients/CognitoIdentity';
+export { AmplifyV6, fetchAuthSession } from './singleton';
+export { LibraryOptions, ResourcesConfig } from './singleton/types';
 /**
  * @deprecated use named import
  */

package/lib-esm/index.js

@@ -2,11 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 import { Amplify } from './Amplify';
 import { Platform } from './Platform';
-export { Amplify } from './Amplify';
+export { Amplify };
 export { AmplifyClass } from './Amplify';
 export { ClientDevice } from './ClientDevice';
 export { ConsoleLogger, ConsoleLogger as Logger } from './Logger';
-export { invalidParameter, missingConfig } from './Errors';
+export { invalidParameter, missingConfig, AmplifyError, AmplifyErrorString, } from './Errors';
 export { Hub } from './Hub';
 export { I18n } from './I18n';
 export { browserOrNode, filenameToContentType, generateRandomString, isEmpty, isStrictObject, isTextFile, isWebWorker, makeQuerablePromise, objectLessAttributes, sortByField, transferKeyToLowerCase, transferKeyToUpperCase, } from './JS';
@@ -17,7 +17,7 @@ export { FacebookOAuth, GoogleOAuth } from './OAuthHelper';
 export { AppState, AsyncStorage, Linking } from './RNComponents';
 export { Credentials, CredentialsClass } from './Credentials';
 export { ServiceWorker } from './ServiceWorker';
-export { StorageHelper, MemoryStorage } from './StorageHelper';
+export { StorageHelper, MemoryStorage, LocalStorage, CookieStorage, SessionStorage, MemoryKeyValueStorage, } from './StorageHelper';
 export { UniversalStorage } from './UniversalStorage';
 export { Platform, getAmplifyUserAgentObject, getAmplifyUserAgent, } from './Platform';
 export { ApiAction, AuthAction, AnalyticsAction, Category, DataStoreAction, Framework, GeoAction, InteractionsAction, InAppMessagingAction, PredictionsAction, PubSubAction, PushNotificationAction, StorageAction, } from './Platform/types';
@@ -26,6 +26,18 @@ export var Constants = {
     userAgent: Platform.userAgent,
 };
 export { AWS_CLOUDWATCH_BASE_BUFFER_SIZE, AWS_CLOUDWATCH_CATEGORY, AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE, AWS_CLOUDWATCH_MAX_EVENT_SIZE, AWS_CLOUDWATCH_PROVIDER_NAME, BackgroundManagerNotOpenError, BackgroundProcessManager, BackgroundProcessManagerState, DateUtils, Mutex, NO_CREDS_ERROR_STRING, NonRetryableError, RETRY_ERROR_CODES, Reachability, isNonRetryableError, jitteredBackoff, jitteredExponentialRetry, retry, urlSafeDecode, urlSafeEncode, } from './Util';
+// Cache exports
+import { BrowserStorageCache } from './Cache/BrowserStorageCache';
+export { asserts } from './Util/errors/AssertError';
+export { isTokenExpired } from './singleton/Auth';
+export { InMemoryCache } from './Cache/InMemoryCache';
+export { BrowserStorageCache };
+export { BrowserStorageCache as Cache }; // Maintain interoperability with React Native
+// Singleton exports
+export { decodeJWT, assertTokenProviderConfig, assertIdentityPooIdConfig, } from './singleton/Auth/utils';
+// AWSClients exports
+export { getCredentialsForIdentity, getId, } from './AwsClients/CognitoIdentity';
+export { AmplifyV6, fetchAuthSession } from './singleton';
 /**
  * @deprecated use named import
  */

package/lib-esm/parseAWSExports.d.ts

@@ -1,2 +1,2 @@
 import { AmplifyConfig } from './types';
-export declare const parseAWSExports: (config: any) => AmplifyConfig;
+export declare const parseAWSExports: (config: Record<string, any>) => AmplifyConfig;

package/lib-esm/singleton/Auth/index.d.ts

@@ -0,0 +1,30 @@
+import { Observable } from 'rxjs';
+import { AuthConfig, AuthSession, FetchAuthSessionOptions, LibraryAuthOptions } from './types';
+export declare function isTokenExpired({ expiresAt, clockDrift, }: {
+    expiresAt: number;
+    clockDrift: number;
+}): boolean;
+export declare class AuthClass {
+    private authSessionObservers;
+    private authConfig?;
+    private authOptions?;
+    constructor();
+    /**
+     * Configure Auth category
+     *
+     * @internal
+     *
+     * @param authResourcesConfig - Resources configurations required by Auth providers.
+     * @param authOptions - Client options used by library
+     *
+     * @returns void
+     */
+    configure(authResourcesConfig: AuthConfig, authOptions?: LibraryAuthOptions): void;
+    fetchAuthSession(options?: FetchAuthSessionOptions): Promise<AuthSession>;
+    /**
+     * Obtain an Observable that notifies on session changes
+     *
+     * @returns Observable<AmplifyUserSession>
+     */
+    listenSessionChanges(): Observable<AuthSession>;
+}

package/lib-esm/singleton/Auth/index.js

@@ -0,0 +1,129 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Observable } from 'rxjs';
+import { asserts } from '../../Util/errors/AssertError';
+import { AUTH_CONFING_EXCEPTION } from '../../constants';
+export function isTokenExpired(_a) {
+    var expiresAt = _a.expiresAt, clockDrift = _a.clockDrift;
+    var currentTime = Date.now();
+    return currentTime + clockDrift > expiresAt;
+}
+var AuthClass = /** @class */ (function () {
+    function AuthClass() {
+        this.authSessionObservers = new Set();
+    }
+    /**
+     * Configure Auth category
+     *
+     * @internal
+     *
+     * @param authResourcesConfig - Resources configurations required by Auth providers.
+     * @param authOptions - Client options used by library
+     *
+     * @returns void
+     */
+    AuthClass.prototype.configure = function (authResourcesConfig, authOptions) {
+        this.authConfig = authResourcesConfig;
+        this.authOptions = authOptions;
+    };
+    AuthClass.prototype.fetchAuthSession = function (options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (options === void 0) { options = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var tokens, credentialsAndIdentityId;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0: return [4 /*yield*/, ((_b = (_a = this.authOptions) === null || _a === void 0 ? void 0 : _a.tokenProvider) === null || _b === void 0 ? void 0 : _b.getTokens(options))];
+                    case 1:
+                        // Get tokens will throw if session cannot be refreshed (network or service error) or return null if not available
+                        tokens =
+                            (_c = (_h.sent())) !== null && _c !== void 0 ? _c : undefined;
+                        asserts(!!this.authConfig, {
+                            name: AUTH_CONFING_EXCEPTION,
+                            message: 'AuthConfig is required',
+                            recoverySuggestion: 'call Amplify.configure in your app with a valid AuthConfig',
+                        });
+                        if (!tokens) return [3 /*break*/, 3];
+                        return [4 /*yield*/, ((_e = (_d = this.authOptions) === null || _d === void 0 ? void 0 : _d.credentialsProvider) === null || _e === void 0 ? void 0 : _e.getCredentialsAndIdentityId({
+                                authConfig: this.authConfig,
+                                tokens: tokens,
+                                authenticated: true,
+                                forceRefresh: options.forceRefresh,
+                            }))];
+                    case 2:
+                        // getCredentialsAndIdentityId will throw if cannot get credentials (network or service error)
+                        credentialsAndIdentityId =
+                            _h.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, ((_g = (_f = this.authOptions) === null || _f === void 0 ? void 0 : _f.credentialsProvider) === null || _g === void 0 ? void 0 : _g.getCredentialsAndIdentityId({
+                            authConfig: this.authConfig,
+                            authenticated: false,
+                            forceRefresh: options.forceRefresh,
+                        }))];
+                    case 4:
+                        // getCredentialsAndIdentityId will throw if cannot get credentials (network or service error)
+                        credentialsAndIdentityId =
+                            _h.sent();
+                        _h.label = 5;
+                    case 5: return [2 /*return*/, {
+                            tokens: tokens,
+                            credentials: credentialsAndIdentityId === null || credentialsAndIdentityId === void 0 ? void 0 : credentialsAndIdentityId.credentials,
+                            identityId: credentialsAndIdentityId === null || credentialsAndIdentityId === void 0 ? void 0 : credentialsAndIdentityId.identityId,
+                        }];
+                }
+            });
+        });
+    };
+    /**
+     * Obtain an Observable that notifies on session changes
+     *
+     * @returns Observable<AmplifyUserSession>
+     */
+    AuthClass.prototype.listenSessionChanges = function () {
+        var _this = this;
+        return new Observable(function (observer) {
+            _this.authSessionObservers.add(observer);
+            return function () {
+                _this.authSessionObservers.delete(observer);
+            };
+        });
+    };
+    return AuthClass;
+}());
+export { AuthClass };

package/lib-esm/singleton/Auth/types.d.ts

@@ -0,0 +1,95 @@
+interface JwtPayloadStandardFields {
+    exp?: number;
+    iss?: string;
+    aud?: string | string[];
+    nbf?: number;
+    iat?: number;
+    scope?: string;
+    jti?: string;
+}
+/** JSON type */
+type Json = null | string | number | boolean | Json[] | JsonObject;
+/** JSON Object type */
+type JsonObject = {
+    [name: string]: Json;
+};
+type JwtPayload = JwtPayloadStandardFields & JsonObject;
+export type JWT = {
+    payload: JwtPayload;
+    toString: () => string;
+};
+export type JWTCreator = (stringJWT: string) => JWT;
+export type AuthSession = {
+    tokens?: AuthTokens;
+    credentials?: AWSCredentials;
+    identityId?: string;
+};
+export type LibraryAuthOptions = {
+    tokenProvider?: TokenProvider;
+    credentialsProvider?: AWSCredentialsAndIdentityIdProvider;
+};
+export type Identity = {
+    id: string;
+    type: 'guest' | 'primary';
+};
+export interface AWSCredentialsAndIdentityIdProvider {
+    getCredentialsAndIdentityId: (getCredentialsOptions: GetCredentialsOptions) => Promise<AWSCredentialsAndIdentityId>;
+    clearCredentials: () => void;
+}
+export type TokenProvider = {
+    getTokens: ({ forceRefresh, }: {
+        forceRefresh?: boolean;
+    }) => Promise<AuthTokens | null>;
+};
+export type FetchAuthSessionOptions = {
+    forceRefresh?: boolean;
+};
+export type AuthTokens = {
+    idToken?: JWT;
+    accessToken: JWT;
+};
+export type AuthConfig = IdentityPoolConfig | UserPoolConfig | UserPoolConfigAndIdentityPoolConfig;
+export type IdentityPoolConfig = {
+    identityPoolId: string;
+    userPoolWebClientId?: never;
+    userPoolId?: never;
+    clientMetadata?: never;
+    isMandatorySignInEnabled?: never;
+};
+export type UserPoolConfig = {
+    userPoolWebClientId: string;
+    userPoolId: string;
+    identityPoolId?: never;
+    clientMetadata?: Record<string, string>;
+};
+export type UserPoolConfigAndIdentityPoolConfig = {
+    userPoolWebClientId: string;
+    userPoolId: string;
+    identityPoolId: string;
+    clientMetadata?: Record<string, string>;
+    isMandatorySignInEnabled?: boolean;
+};
+export type GetCredentialsOptions = GetCredentialsAuthenticatedUser | GetCredentialsUnauthenticatedUser;
+type GetCredentialsAuthenticatedUser = {
+    authenticated: true;
+    forceRefresh?: boolean;
+    authConfig: AuthConfig;
+    tokens?: AuthTokens;
+};
+type GetCredentialsUnauthenticatedUser = {
+    authenticated: false;
+    forceRefresh?: boolean;
+    authConfig: AuthConfig;
+    tokens?: never;
+};
+export type AWSCredentialsAndIdentityId = {
+    credentials: AWSCredentials;
+    identityId?: string;
+};
+type AWSCredentials = {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    expiration?: Date;
+};
+export {};

package/lib-esm/singleton/Auth/types.js

@@ -0,0 +1,5 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+// From https://github.com/awslabs/aws-jwt-verify/blob/main/src/safe-json-parse.ts
+// From https://github.com/awslabs/aws-jwt-verify/blob/main/src/jwt-model.ts
+export {};

package/lib-esm/singleton/Auth/utils/index.d.ts

@@ -0,0 +1,5 @@
+import { AuthConfig, IdentityPoolConfig, JWT, UserPoolConfig, UserPoolConfigAndIdentityPoolConfig } from '../types';
+export declare function assertTokenProviderConfig(authConfig?: AuthConfig): asserts authConfig is UserPoolConfig;
+export declare function assertIdentityPooIdConfig(authConfig: AuthConfig): asserts authConfig is IdentityPoolConfig;
+export declare function assertUserPoolAndIdentityPooConfig(authConfig: AuthConfig): asserts authConfig is UserPoolConfigAndIdentityPoolConfig;
+export declare function decodeJWT(token: string): JWT;

package/lib-esm/singleton/Auth/utils/index.js

@@ -0,0 +1,45 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Buffer } from 'buffer';
+import { asserts } from '../../../Util/errors/AssertError';
+export function assertTokenProviderConfig(authConfig) {
+    var validConfig = !!(authConfig === null || authConfig === void 0 ? void 0 : authConfig.userPoolId) && !!(authConfig === null || authConfig === void 0 ? void 0 : authConfig.userPoolWebClientId);
+    return asserts(validConfig, {
+        name: 'AuthTokenConfigException',
+        message: 'Auth Token Provider not configured',
+        recoverySuggestion: 'Make sure to call Amplify.configure in your app',
+    });
+}
+export function assertIdentityPooIdConfig(authConfig) {
+    var validConfig = !!(authConfig === null || authConfig === void 0 ? void 0 : authConfig.identityPoolId);
+    return asserts(validConfig, {
+        name: 'AuthIdentityPoolIdException',
+        message: 'Auth IdentityPoolId not configured',
+        recoverySuggestion: 'Make sure to call Amplify.configure in your app with a valid IdentityPoolId',
+    });
+}
+export function assertUserPoolAndIdentityPooConfig(authConfig) {
+    var validConfig = !!(authConfig === null || authConfig === void 0 ? void 0 : authConfig.identityPoolId) && !!(authConfig === null || authConfig === void 0 ? void 0 : authConfig.userPoolId);
+    return asserts(validConfig, {
+        name: 'AuthUserPoolAndIdentityPoolException',
+        message: 'Auth UserPool and IdentityPool not configured',
+        recoverySuggestion: 'Make sure to call Amplify.configure in your app with UserPoolId and IdentityPoolId',
+    });
+}
+export function decodeJWT(token) {
+    var tokenSplitted = token.split('.');
+    if (tokenSplitted.length !== 3) {
+        throw new Error('Invalid token');
+    }
+    var payloadString = tokenSplitted[1];
+    var payload = JSON.parse(Buffer.from(payloadString, 'base64').toString('utf8'));
+    try {
+        return {
+            toString: function () { return token; },
+            payload: payload,
+        };
+    }
+    catch (err) {
+        throw new Error('Invalid token payload');
+    }
+}

package/lib-esm/singleton/Storage/types.d.ts

@@ -0,0 +1,14 @@
+export type StorageAccessLevel = 'guest' | 'protected' | 'private';
+export interface StorageConfig {
+    bucket?: string;
+    region?: string;
+}
+type StoragePrefixResolver = (params: {
+    accessLevel: StorageAccessLevel;
+    targetIdentityId?: string;
+}) => Promise<string>;
+export interface LibraryStorageOptions {
+    prefixResolver?: StoragePrefixResolver;
+    defaultAccessLevel?: StorageAccessLevel;
+}
+export {};

package/lib-esm/singleton/Storage/types.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export {};