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

package/src/clients/middleware/retry/defaultRetryDecider.ts

@@ -10,8 +10,12 @@ import { isClockSkewError } from './isClockSkewError';
  */
 export const getRetryDecider =
 	(errorParser: ErrorParser) =>
-	async (response?: HttpResponse, error?: Error): Promise<boolean> => {
-		const { name: errorCode } = error ?? (await errorParser(response)) ?? {};
+	async (response?: HttpResponse, error?: unknown): Promise<boolean> => {
+		const parsedError =
+			(error as Error & { code: string }) ??
+			(await errorParser(response)) ??
+			undefined;
+		const errorCode = parsedError?.['code'];
 		const statusCode = response?.statusCode;
 		return (
 			isConnectionError(error) ||
@@ -45,10 +49,12 @@ const TIMEOUT_ERROR_CODES = [
 ];
 
 const isThrottlingError = (statusCode?: number, errorCode?: string) =>
-	statusCode === 429 || THROTTLING_ERROR_CODES.includes(errorCode);
+	statusCode === 429 ||
+	(!!errorCode && THROTTLING_ERROR_CODES.includes(errorCode));
 
-const isConnectionError = (error?: Error) => error?.name === 'Network error';
+const isConnectionError = (error?: unknown) =>
+	(error as Error)?.['name'] === 'Network error';
 
 const isServerSideError = (statusCode?: number, errorCode?: string) =>
-	[500, 502, 503, 504].includes(statusCode) ||
-	TIMEOUT_ERROR_CODES.includes(errorCode);
+	(!!statusCode && [500, 502, 503, 504].includes(statusCode)) ||
+	(!!errorCode && TIMEOUT_ERROR_CODES.includes(errorCode));

package/src/clients/middleware/retry/isClockSkewError.ts

@@ -21,4 +21,4 @@ const CLOCK_SKEW_ERROR_CODES = [
  * @internal
  */
 export const isClockSkewError = (errorCode?: string) =>
-	CLOCK_SKEW_ERROR_CODES.includes(errorCode);
+	!!errorCode && CLOCK_SKEW_ERROR_CODES.includes(errorCode);

package/src/clients/middleware/retry/middleware.ts

@@ -56,9 +56,9 @@ export const retryMiddleware = <TInput = Request, TOutput = Response>({
 		context: MiddlewareContext
 	) =>
 		async function retryMiddleware(request: TInput) {
-			let error: Error;
-			let attemptsCount = context.attemptsCount ?? 0;
-			let response: TOutput;
+			let error: unknown;
+			let attemptsCount: number = context.attemptsCount ?? 0;
+			let response: TOutput | undefined;
 
 			// When retry is not needed or max attempts is reached, either error or response will be set. This function handles either cases.
 			const handleTerminalErrorOrResponse = () => {
@@ -66,7 +66,7 @@ export const retryMiddleware = <TInput = Request, TOutput = Response>({
 					addOrIncrementMetadataAttempts(response, attemptsCount);
 					return response;
 				} else {
-					addOrIncrementMetadataAttempts(error, attemptsCount);
+					addOrIncrementMetadataAttempts(error as object, attemptsCount);
 					throw error;
 				}
 			};
@@ -81,8 +81,8 @@ export const retryMiddleware = <TInput = Request, TOutput = Response>({
 				}
 				// context.attemptsCount may be updated after calling next handler which may retry the request by itself.
 				attemptsCount =
-					context.attemptsCount > attemptsCount
-						? context.attemptsCount
+					(context.attemptsCount ?? 0) > attemptsCount
+						? context.attemptsCount ?? 0
 						: attemptsCount + 1;
 				context.attemptsCount = attemptsCount;
 				if (await retryDecider(response, error)) {
@@ -109,8 +109,8 @@ const cancellableSleep = (timeoutMs: number, abortSignal?: AbortSignal) => {
 	if (abortSignal?.aborted) {
 		return Promise.resolve();
 	}
-	let timeoutId;
-	let sleepPromiseResolveFn;
+	let timeoutId: number;
+	let sleepPromiseResolveFn: Function;
 	const sleepPromise = new Promise<void>(resolve => {
 		sleepPromiseResolveFn = resolve;
 		timeoutId = setTimeout(resolve, timeoutMs);
@@ -124,7 +124,7 @@ const cancellableSleep = (timeoutMs: number, abortSignal?: AbortSignal) => {
 };
 
 const addOrIncrementMetadataAttempts = (
-	nextHandlerOutput: Object,
+	nextHandlerOutput: Record<string, any>,
 	attempts: number
 ) => {
 	if (Object.prototype.toString.call(nextHandlerOutput) !== '[object Object]') {

package/src/clients/middleware/signing/middleware.ts

@@ -38,7 +38,7 @@ export const signingMiddleware = ({
 	service,
 	uriEscapePath = true,
 }: SigningOptions) => {
-	let currentSystemClockOffset;
+	let currentSystemClockOffset: number;
 	return (next: MiddlewareHandler<HttpRequest, HttpResponse>) =>
 		async function signingMiddleware(request: HttpRequest) {
 			currentSystemClockOffset = currentSystemClockOffset ?? 0;

package/src/clients/middleware/signing/signer/signatureV4/utils/dataHashHelpers.ts

@@ -17,7 +17,7 @@ export const getHashedData = (
 	key: SourceData | null,
 	data: SourceData
 ): Uint8Array => {
-	const sha256 = new Sha256(key);
+	const sha256 = new Sha256(key ?? undefined);
 	sha256.update(data);
 	// TODO: V6 flip to async digest
 	const hashedData = sha256.digestSync();

package/src/clients/serde/responseInfo.ts

@@ -18,5 +18,6 @@ export const parseMetadata = (response: HttpResponse): ResponseMetadata => {
 	};
 };
 
+type IsResponse = { $metadata: any };
 const isMetadataBearer = (response: unknown): response is MetadataBearer =>
-	typeof response?.['$metadata'] === 'object';
+	typeof (response as IsResponse)?.$metadata === 'object';

package/src/clients/types/aws.ts

@@ -26,3 +26,13 @@ export interface ServiceClientOptions {
 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/src/clients/types/index.ts

@@ -22,4 +22,5 @@ export {
 	EndpointResolverOptions,
 	ErrorParser,
 	ServiceClientOptions,
+	DefaultConfigOptions,
 } from './aws';

package/src/constants.ts

@@ -13,3 +13,19 @@ export const INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER = hasSymbol
 	: '@@INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER';
 
 export const USER_AGENT_HEADER = 'x-amz-user-agent';
+
+// Error exception code constants
+export const AUTH_CONFING_EXCEPTION = 'AuthConfigException';
+
+export const AWS_CLOUD_WATCH_PROVIDER_OPTIONS_EXCEPTION =
+	'AWSCloudWatchProviderOptionsException';
+
+export const CACHE_LIST_EXCEPTION = 'CacheListException';
+
+export const I18N_EXCEPTION = 'I18NException';
+
+export const SERVICE_WORKER_EXCEPTION = 'ServiceWorkerException';
+
+export const STORAGE_CACHE_EXCEPTION = 'StorageCacheException';
+
+export const APPLICATION_ID_EXCEPTION = 'ApplicationIdException';

package/src/global.d.ts

@@ -0,0 +1,11 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+declare global {
+	interface Window {
+		FB: any;
+        gapi: any;
+	}
+}
+
+export {};

package/src/index.ts

@@ -4,11 +4,16 @@
 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, HubCapsule, HubCallback, HubPayload } from './Hub';
 export { I18n } from './I18n';
 export {
@@ -32,8 +37,21 @@ 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,
@@ -88,6 +106,50 @@ export {
 	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 { CacheConfig } from './Cache/types';
+export { ICache } from './Cache/types';
+export { BrowserStorageCache };
+export { BrowserStorageCache as Cache }; // Maintain interoperability with React Native
+
+// Singleton exports
+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';
+
+// AWSClients exports
+export {
+	getCredentialsForIdentity,
+	getId,
+	GetCredentialsForIdentityInput,
+	GetCredentialsForIdentityOutput,
+} from './AwsClients/CognitoIdentity';
+
+export { AmplifyV6, fetchAuthSession } from './singleton';
+export { LibraryOptions, ResourcesConfig } from './singleton/types';
+
 /**
  * @deprecated use named import
  */

package/src/parseAWSExports.ts

@@ -5,7 +5,7 @@ import { ConsoleLogger as Logger } from './Logger';
 
 const logger = new Logger('Parser');
 
-export const parseAWSExports = (config): AmplifyConfig => {
+export const parseAWSExports = (config:Record<string,any>): AmplifyConfig => {
 	const amplifyConfig: AmplifyConfig = {};
 	// Analytics
 	if (config['aws_mobile_analytics_app_id']) {

package/src/singleton/Auth/index.ts

@@ -0,0 +1,113 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Observable, Observer } from 'rxjs';
+
+import {
+	AWSCredentialsAndIdentityId,
+	AuthConfig,
+	AuthSession,
+	AuthTokens,
+	FetchAuthSessionOptions,
+	LibraryAuthOptions,
+} from './types';
+import { asserts } from '../../Util/errors/AssertError';
+import { AUTH_CONFING_EXCEPTION } from '../../constants';
+
+export function isTokenExpired({
+	expiresAt,
+	clockDrift,
+}: {
+	expiresAt: number;
+	clockDrift: number;
+}): boolean {
+	const currentTime = Date.now();
+	return currentTime + clockDrift > expiresAt;
+}
+
+export class AuthClass {
+	private authSessionObservers: Set<Observer<AuthSession>>;
+	private authConfig?: AuthConfig;
+	private authOptions?: LibraryAuthOptions;
+
+	constructor() {
+		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
+	 */
+	configure(
+		authResourcesConfig: AuthConfig,
+		authOptions?: LibraryAuthOptions
+	): void {
+		this.authConfig = authResourcesConfig;
+		this.authOptions = authOptions;
+	}
+
+	async fetchAuthSession(
+		options: FetchAuthSessionOptions = {}
+	): Promise<AuthSession> {
+		let tokens: AuthTokens | undefined;
+		let credentialsAndIdentityId: AWSCredentialsAndIdentityId | undefined;
+
+		// Get tokens will throw if session cannot be refreshed (network or service error) or return null if not available
+		tokens =
+			(await this.authOptions?.tokenProvider?.getTokens(options)) ?? 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) {
+			// getCredentialsAndIdentityId will throw if cannot get credentials (network or service error)
+			credentialsAndIdentityId =
+				await this.authOptions?.credentialsProvider?.getCredentialsAndIdentityId(
+					{
+						authConfig: this.authConfig,
+						tokens,
+						authenticated: true,
+						forceRefresh: options.forceRefresh,
+					}
+				);
+		} else {
+			// getCredentialsAndIdentityId will throw if cannot get credentials (network or service error)
+			credentialsAndIdentityId =
+				await this.authOptions?.credentialsProvider?.getCredentialsAndIdentityId(
+					{
+						authConfig: this.authConfig,
+						authenticated: false,
+						forceRefresh: options.forceRefresh,
+					}
+				);
+		}
+
+		return {
+			tokens,
+			credentials: credentialsAndIdentityId?.credentials,
+			identityId: credentialsAndIdentityId?.identityId,
+		};
+	}
+
+	/**
+	 * Obtain an Observable that notifies on session changes
+	 *
+	 * @returns Observable<AmplifyUserSession>
+	 */
+	listenSessionChanges(): Observable<AuthSession> {
+		return new Observable(observer => {
+			this.authSessionObservers.add(observer);
+
+			return () => {
+				this.authSessionObservers.delete(observer);
+			};
+		});
+	}
+}

package/src/singleton/Auth/types.ts

@@ -0,0 +1,129 @@
+// 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
+
+import { Credentials } from '@aws-sdk/types';
+
+interface JwtPayloadStandardFields {
+	exp?: number; // expires: https://tools.ietf.org/html/rfc7519#section-4.1.4
+	iss?: string; // issuer: https://tools.ietf.org/html/rfc7519#section-4.1.1
+	aud?: string | string[]; // audience: https://tools.ietf.org/html/rfc7519#section-4.1.3
+	nbf?: number; // not before: https://tools.ietf.org/html/rfc7519#section-4.1.5
+	iat?: number; // issued at: https://tools.ietf.org/html/rfc7519#section-4.1.6
+	scope?: string; // scopes: https://tools.ietf.org/html/rfc6749#section-3.3
+	jti?: string; // JWT ID: https://datatracker.ietf.org/doc/html/rfc7519#section-4.1.7
+}
+
+/** 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;
+};

package/src/singleton/Auth/utils/index.ts

@@ -0,0 +1,68 @@
+// 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';
+import {
+	AuthConfig,
+	IdentityPoolConfig,
+	JWT,
+	UserPoolConfig,
+	UserPoolConfigAndIdentityPoolConfig,
+} from '../types';
+
+export function assertTokenProviderConfig(
+	authConfig?: AuthConfig
+): asserts authConfig is UserPoolConfig {
+	const validConfig =
+		!!authConfig?.userPoolId && !!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: AuthConfig
+): asserts authConfig is IdentityPoolConfig {
+	const validConfig = !!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: AuthConfig
+): asserts authConfig is UserPoolConfigAndIdentityPoolConfig {
+	const validConfig = !!authConfig?.identityPoolId && !!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: string): JWT {
+	const tokenSplitted = token.split('.');
+	if (tokenSplitted.length !== 3) {
+		throw new Error('Invalid token');
+	}
+
+	const payloadString = tokenSplitted[1];
+	const payload = JSON.parse(
+		Buffer.from(payloadString, 'base64').toString('utf8')
+	);
+
+	try {
+		return {
+			toString: () => token,
+			payload,
+		};
+	} catch (err) {
+		throw new Error('Invalid token payload');
+	}
+}

package/src/singleton/Storage/types.ts

@@ -0,0 +1,21 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export type StorageAccessLevel = 'guest' | 'protected' | 'private';
+
+export interface StorageConfig {
+	bucket?: string;
+	region?: string;
+}
+
+type StoragePrefixResolver = (params: {
+	accessLevel: StorageAccessLevel;
+	targetIdentityId?: string;
+}) => Promise<string>;
+
+// TODO[AllanZhengYP]: support isObjectLockEnabled config to S3 plugin config
+// TODO[AllanZhengYP]: need to finalize the decision whether to move defaultAccessLevel to StorageConfig
+export interface LibraryStorageOptions {
+	prefixResolver?: StoragePrefixResolver;
+	defaultAccessLevel?: StorageAccessLevel;
+}