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

package/src/StorageHelper/cookieStorage.ts

@@ -0,0 +1,99 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+// @ts-ignore
+import * as Cookies from 'js-cookie';
+import {
+	CookieStorageData,
+	KeyValueStorageInterface,
+	SameSite,
+} from '../types';
+
+export class CookieStorage implements KeyValueStorageInterface {
+	domain?: string;
+	path: string;
+	expires?: number; // days;
+	secure?: boolean;
+	sameSite?: SameSite;
+
+	constructor(data: CookieStorageData = {}) {
+		if (data.domain) {
+			this.domain = data.domain;
+		}
+		if (data.path) {
+			this.path = data.path;
+		} else {
+			this.path = '/';
+		}
+		if (Object.prototype.hasOwnProperty.call(data, 'expires')) {
+			this.expires = data.expires;
+		} else {
+			this.expires = 365;
+		}
+		if (Object.prototype.hasOwnProperty.call(data, 'secure')) {
+			this.secure = data.secure;
+		} else {
+			this.secure = true;
+		}
+		if (data.hasOwnProperty('sameSite')) {
+			if (
+				!data.sameSite ||
+				!['strict', 'lax', 'none'].includes(data.sameSite)
+			) {
+				throw new Error(
+					'The sameSite value of cookieStorage must be "lax", "strict" or "none".'
+				);
+			}
+			if (data.sameSite === 'none' && !this.secure) {
+				throw new Error(
+					'sameSite = None requires the Secure attribute in latest browser versions.'
+				);
+			}
+			this.sameSite = data.sameSite;
+		}
+	}
+
+	async setItem(key: string, value: string): Promise<void> {
+		const options: CookieStorageData = {
+			path: this.path,
+			expires: this.expires,
+			domain: this.domain,
+			secure: this.secure,
+		};
+
+		if (this.sameSite) {
+			options.sameSite = this.sameSite;
+		}
+
+		Cookies.set(key, value, options);
+		return Cookies.get(key);
+	}
+
+	async getItem(key: string): Promise<string> {
+		return Cookies.get(key);
+	}
+
+	async removeItem(key: string): Promise<void> {
+		const options: CookieStorageData = {
+			path: this.path,
+			expires: this.expires,
+			domain: this.domain,
+			secure: this.secure,
+		};
+
+		if (this.sameSite) {
+			options.sameSite = this.sameSite;
+		}
+
+		Cookies.remove(key, options);
+	}
+
+	async clear(): Promise<void> {
+		const cookies = Cookies.get();
+		const numKeys = Object.keys(cookies).length;
+		const promiseArray: Promise<void>[] = [];
+		for (let index = 0; index < numKeys; ++index) {
+			promiseArray.push(this.removeItem(Object.keys(cookies)[index]));
+		}
+		await Promise.all(promiseArray);
+	}
+}

package/src/StorageHelper/inMemoryStorage.ts

@@ -0,0 +1,32 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { KeyValueStorageInterface } from '../types';
+
+class MemoryKeyValueStorageClass implements KeyValueStorageInterface {
+	myStorage: Record<string, string> = {};
+
+	async setItem(key: string, value: string): Promise<void> {
+		this.myStorage[key] = value;
+		return;
+	}
+
+	async getItem(key: string): Promise<string | null> {
+		return this.myStorage[key];
+	}
+
+	async removeItem(key: string): Promise<void> {
+		delete this.myStorage[key];
+		return;
+	}
+
+	async clear(): Promise<void> {
+		Object.keys(this.myStorage).forEach(key => {
+			delete this.myStorage[key];
+		});
+
+		return;
+	}
+}
+
+export const MemoryKeyValueStorage = new MemoryKeyValueStorageClass();

package/src/StorageHelper/index.ts

@@ -1,7 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-let dataMemory = {};
+let dataMemory: Record<string, string> = {};
 
 /** @class */
 export class MemoryStorage {
@@ -71,3 +71,8 @@ export class StorageHelper {
 		return this.storageWindow;
 	}
 }
+
+export { SessionStorage } from './sessionStorage';
+export { LocalStorage } from './localStorage';
+export { MemoryKeyValueStorage } from './inMemoryStorage';
+export { CookieStorage } from './cookieStorage';

package/src/StorageHelper/localStorage.ts

@@ -0,0 +1,60 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { KeyValueStorageInterface } from "../types";
+import { PlatformNotSupportedError } from '../Errors';
+
+class LocalStorageClass implements KeyValueStorageInterface {
+	storage?: Storage;
+
+	constructor() {
+		if (typeof window !== undefined) {
+			try {
+				this.storage = window?.localStorage;
+			} catch (error) {}
+		}
+	}
+
+	/**
+	 * This is used to set a specific item in storage
+	 * @param {string} key - the key for the item
+	 * @param {object} value - the value
+	 * @returns {string} value that was set
+	 */
+	async setItem(key: string, value: string): Promise<void> {
+		if (!this.storage) throw PlatformNotSupportedError;
+		this.storage.setItem(key, value);
+	}
+
+	/**
+	 * This is used to get a specific key from storage
+	 * @param {string} key - the key for the item
+	 * This is used to clear the storage
+	 * @returns {string} the data item
+	 */
+	async getItem(key: string): Promise<string | null> {
+		if (!this.storage) throw PlatformNotSupportedError;
+		return this.storage.getItem(key);
+	}
+
+	/**
+	 * This is used to remove an item from storage
+	 * @param {string} key - the key being set
+	 * @returns {string} value - value that was deleted
+	 */
+	async removeItem(key: string): Promise<void> {
+		if (!this.storage) throw PlatformNotSupportedError;
+		this.storage.removeItem(key);
+	}
+
+	/**
+	 * This is used to clear the storage
+	 * @returns {string} nothing
+	 */
+	async clear(): Promise<void> {
+		if (!this.storage) throw PlatformNotSupportedError;
+		this.storage.clear();
+	}
+}
+
+export const LocalStorage = new LocalStorageClass();

package/src/StorageHelper/reactnative.ts

@@ -1,20 +1,21 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { KeyValueStorageInterface } from '../types';
 
 const MEMORY_KEY_PREFIX = '@MemoryStorage:';
-let dataMemory = {};
+let dataMemory: Record<string, string | null> = {};
 
 /** @class */
 class MemoryStorage {
-	static syncPromise = null;
+	static syncPromise: Promise<void> | null = null;
 	/**
 	 * This is used to set a specific item in storage
 	 * @param {string} key - the key for the item
 	 * @param {object} value - the value
 	 * @returns {string} value that was set
 	 */
-	static setItem(key, value) {
+	static setItem(key: string, value: string) {
 		if (value) {
 			AsyncStorage.setItem(MEMORY_KEY_PREFIX + key, value);
 			dataMemory[key] = value;
@@ -28,7 +29,7 @@ class MemoryStorage {
 	 * This is used to clear the storage
 	 * @returns {string} the data item
 	 */
-	static getItem(key) {
+	static getItem(key: string) {
 		return Object.prototype.hasOwnProperty.call(dataMemory, key)
 			? dataMemory[key]
 			: undefined;
@@ -39,7 +40,7 @@ class MemoryStorage {
 	 * @param {string} key - the key being set
 	 * @returns {string} value - value that was deleted
 	 */
-	static removeItem(key) {
+	static removeItem(key: string) {
 		AsyncStorage.removeItem(MEMORY_KEY_PREFIX + key);
 		return delete dataMemory[key];
 	}
@@ -62,17 +63,19 @@ class MemoryStorage {
 			MemoryStorage.syncPromise = new Promise<void>((res, rej) => {
 				AsyncStorage.getAllKeys((errKeys, keys) => {
 					if (errKeys) rej(errKeys);
-					const memoryKeys = keys.filter(key =>
-						key.startsWith(MEMORY_KEY_PREFIX)
-					);
+
+					const memoryKeys =
+						keys?.filter(key => key.startsWith(MEMORY_KEY_PREFIX)) ?? [];
+
 					AsyncStorage.multiGet(memoryKeys, (err, stores) => {
 						if (err) rej(err);
-						stores.map((result, index, store) => {
-							const key = store[index][0];
-							const value = store[index][1];
-							const memoryKey = key.replace(MEMORY_KEY_PREFIX, '');
-							dataMemory[memoryKey] = value;
-						});
+						stores &&
+							stores.map((result, index, store) => {
+								const key = store[index][0];
+								const value = store[index][1];
+								const memoryKey = key.replace(MEMORY_KEY_PREFIX, '');
+								dataMemory[memoryKey] = value;
+							});
 						res();
 					});
 				});
@@ -100,3 +103,80 @@ export class StorageHelper {
 		return this.storageWindow;
 	}
 }
+
+class AsyncStorageClass implements KeyValueStorageInterface {
+	syncPromise: Promise<void> | null = null;
+	/**
+	 * This is used to set a specific item in storage
+	 * @param {string} key - the key for the item
+	 * @param {object} value - the value
+	 * @returns {string} value that was set
+	 */
+	async setItem(key: string, value: string): Promise<void> {
+		if (value) {
+			await AsyncStorage.setItem(MEMORY_KEY_PREFIX + key, value);
+			dataMemory[key] = value;
+		}
+	}
+
+	/**
+	 * This is used to get a specific key from storage
+	 * @param {string} key - the key for the item
+	 * This is used to clear the storage
+	 * @returns {string} the data item
+	 */
+	async getItem(key: string): Promise<string | null> {
+		return Object.prototype.hasOwnProperty.call(dataMemory, key)
+			? dataMemory[key]
+			: null;
+	}
+
+	/**
+	 * This is used to remove an item from storage
+	 * @param {string} key - the key being set
+	 * @returns {string} value - value that was deleted
+	 */
+	async removeItem(key: string): Promise<void> {
+		await AsyncStorage.removeItem(MEMORY_KEY_PREFIX + key);
+		delete dataMemory[key];
+	}
+
+	/**
+	 * This is used to clear the storage
+	 * @returns {string} nothing
+	 */
+	async clear(): Promise<void> {
+		dataMemory = {};
+	}
+
+	/**
+	 * Will sync the MemoryStorage data from AsyncStorage to storageWindow MemoryStorage
+	 * @returns {void}
+	 */
+	async sync() {
+		if (!this.syncPromise) {
+			this.syncPromise = new Promise<void>((res, rej) => {
+				AsyncStorage.getAllKeys((errKeys, keys) => {
+					if (errKeys) rej(errKeys);
+					const memoryKeys =
+						keys?.filter(key => key.startsWith(MEMORY_KEY_PREFIX)) ?? [];
+
+					AsyncStorage.multiGet(memoryKeys, (err, stores) => {
+						if (err) rej(err);
+						stores &&
+							stores.map((result, index, store) => {
+								const key = store[index][0];
+								const value = store[index][1];
+								const memoryKey = key.replace(MEMORY_KEY_PREFIX, '');
+								dataMemory[memoryKey] = value;
+							});
+						res();
+					});
+				});
+			});
+		}
+	}
+}
+
+// TODO: Add this to the react-native Amplify package.
+export const AsyncStorageKeyValue = new AsyncStorageClass();

package/src/StorageHelper/sessionStorage.ts

@@ -0,0 +1,60 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PlatformNotSupportedError } from '../Errors';
+import { KeyValueStorageInterface } from '../types';
+
+class SessionStorageClass implements KeyValueStorageInterface {
+	storage?: Storage;
+
+	constructor() {
+		if (typeof window !== undefined) {
+			try {
+				this.storage = window?.sessionStorage;
+			} catch (error) {}
+		}
+	}
+
+	/**
+	 * This is used to set a specific item in storage
+	 * @param {string} key - the key for the item
+	 * @param {object} value - the value
+	 * @returns {string} value that was set
+	 */
+	async setItem(key: string, value: string): Promise<void> {
+		if (!this.storage) throw PlatformNotSupportedError;
+		this.storage.setItem(key, value);
+	}
+
+	/**
+	 * This is used to get a specific key from storage
+	 * @param {string} key - the key for the item
+	 * This is used to clear the storage
+	 * @returns {string} the data item
+	 */
+	async getItem(key: string): Promise<string | null> {
+		if (!this.storage) throw PlatformNotSupportedError;
+		return this.storage.getItem(key);
+	}
+
+	/**
+	 * This is used to remove an item from storage
+	 * @param {string} key - the key being set
+	 * @returns {string} value - value that was deleted
+	 */
+	async removeItem(key: string): Promise<void> {
+		if (!this.storage) throw PlatformNotSupportedError;
+		this.storage.removeItem(key);
+	}
+
+	/**
+	 * This is used to clear the storage
+	 * @returns {string} nothing
+	 */
+	async clear(): Promise<void> {
+		if (!this.storage) throw PlatformNotSupportedError;
+		this.storage.clear();
+	}
+}
+
+export const SessionStorage = new SessionStorageClass();

package/src/Util/BackgroundProcessManager.ts

@@ -85,10 +85,19 @@ export class BackgroundProcessManager {
 	 * @param job The inner job manager to await.
 	 * @param description Optional description to help identify pending jobs.
 	 */
-	add(job: BackgroundProcessManager, description?: string);
+	add<T>(job: BackgroundProcessManager, description?: string): Promise<T>;
 
-	add(jobOrDescription?, optionalDescription?) {
-		let job;
+	add<T>(
+		jobOrDescription?:
+			| string
+			| BackgroundProcessManager
+			| ((...args: any) => Promise<T>),
+		optionalDescription?: string
+	) {
+		let job:
+			| BackgroundProcessManager
+			| ((...args: any) => Promise<T>)
+			| undefined;
 		let description: string;
 
 		if (typeof jobOrDescription === 'string') {
@@ -96,7 +105,7 @@ export class BackgroundProcessManager {
 			description = jobOrDescription;
 		} else {
 			job = jobOrDescription;
-			description = optionalDescription;
+			description = optionalDescription!;
 		}
 
 		const error = this.closedFailure(description);
@@ -149,12 +158,15 @@ export class BackgroundProcessManager {
 		job: (onTerminate: Promise<void>) => Promise<T>,
 		description?: string
 	): Promise<T>;
-	private addFunction(job, description) {
+	private addFunction<T>(
+		job: (() => Promise<T>) | ((onTerminate: Promise<void>) => Promise<T>),
+		description?: string
+	) {
 		// the function we call when we want to try to terminate this job.
 		let terminate;
 
 		// the promise the job can opt into listening to for termination.
-		const onTerminate = new Promise(resolve => {
+		const onTerminate = new Promise<void>(resolve => {
 			terminate = resolve;
 		});
 
@@ -164,7 +176,11 @@ export class BackgroundProcessManager {
 		// depending on what the job gives back, register the result
 		// so we can monitor for completion.
 		if (typeof jobResult?.then === 'function') {
-			this.registerPromise(jobResult, terminate, description);
+			this.registerPromise(
+				jobResult,
+				terminate as unknown as () => void,
+				description
+			);
 		}
 
 		// At the end of the day, or you know, method call, it doesn't matter
@@ -208,7 +224,11 @@ export class BackgroundProcessManager {
 			terminate = resolveTerminate;
 		});
 
-		this.registerPromise(promise, terminate, description);
+		this.registerPromise(
+			promise,
+			terminate as unknown as () => void,
+			description
+		);
 
 		return {
 			resolve,
@@ -355,7 +375,9 @@ export class BackgroundProcessManager {
 					// reasonable to expect the termination call to fail. Hence,
 					// not logging as an error.
 					console.warn(
-						`Failed to send termination signal to job. Error: ${error.message}`,
+						`Failed to send termination signal to job. Error: ${
+							(error as Error).message
+						}`,
 						job
 					);
 				}
@@ -449,3 +471,5 @@ type JobEntry = {
 	 */
 	description?: string;
 };
+
+const process = new BackgroundProcessManager();

package/src/Util/DateUtils.ts

@@ -10,8 +10,17 @@
 // Comment - TODO: remove
 
 const FIVE_MINUTES_IN_MS = 1000 * 60 * 5;
-
-export const DateUtils = {
+type DateUtils = {
+	clockOffset: number;
+	getDateWithClockOffset: () => Date;
+	getClockOffset: () => number;
+	getHeaderStringFromDate: (date: Date) => string;
+	getDateFromHeaderString: (header: string) => Date;
+	isClockSkewed: (serverDate: Date) => boolean;
+	isClockSkewError: (error: any) => boolean;
+	setClockOffset: (offset: number) => void;
+};
+export const DateUtils: DateUtils = {
 	/**
 	 * Milliseconds to offset the date to compensate for clock skew between device & services
 	 */
@@ -37,9 +46,9 @@ export const DateUtils = {
 	},
 
 	getDateFromHeaderString(header: string) {
-		const [, year, month, day, hour, minute, second] = header.match(
+		const [,year, month, day, hour, minute, second] = header.match(
 			/^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2}).+/
-		);
+		) as any[];
 
 		return new Date(
 			Date.UTC(
@@ -62,7 +71,7 @@ export const DateUtils = {
 		);
 	},
 
-	isClockSkewError(error: any) {
+	isClockSkewError(error: { response: { headers: any } }) {
 		if (!error.response || !error.response.headers) {
 			return false;
 		}

package/src/Util/Reachability.native.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import Observable from 'zen-observable-ts';
 import { ConsoleLogger as Logger } from '../Logger';
+import type NetInfo from '@react-native-community/netinfo';
 
 const logger = new Logger('Reachability', 'DEBUG');
 
@@ -10,7 +11,7 @@ type NetworkStatus = {
 };
 
 export default class ReachabilityNavigator implements Reachability {
-	networkMonitor(netInfo?: any): Observable<NetworkStatus> {
+	networkMonitor(netInfo?: typeof NetInfo): Observable<NetworkStatus> {
 		/**
 		 * Here netinfo refers to @react-native-community/netinfo
 		 * This is needed in React Native to enable network detection
@@ -46,5 +47,5 @@ export default class ReachabilityNavigator implements Reachability {
 }
 
 interface Reachability {
-	networkMonitor(netInfo?: any): Observable<NetworkStatus>;
+	networkMonitor(netInfo?: typeof NetInfo): Observable<NetworkStatus>;
 }

package/src/Util/Reachability.ts

@@ -1,7 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { browserOrNode, isWebWorker } from '@aws-amplify/core';
 import Observable, { ZenObservable } from 'zen-observable-ts';
+import { browserOrNode, isWebWorker } from '../JS';
 
 type NetworkStatus = {
 	online: boolean;
@@ -34,9 +34,10 @@ export default class ReachabilityNavigator implements Reachability {
 				globalObj.removeEventListener('online', notifyOnline);
 				globalObj.removeEventListener('offline', notifyOffline);
 
-				ReachabilityNavigator._observers = ReachabilityNavigator._observers.filter(
-					_observer => _observer !== observer
-				);
+				ReachabilityNavigator._observers =
+					ReachabilityNavigator._observers.filter(
+						_observer => _observer !== observer
+					);
 			};
 		});
 	}
@@ -45,9 +46,10 @@ export default class ReachabilityNavigator implements Reachability {
 	private static _observerOverride(status: NetworkStatus): void {
 		for (const observer of ReachabilityNavigator._observers) {
 			if (observer.closed) {
-				ReachabilityNavigator._observers = ReachabilityNavigator._observers.filter(
-					_observer => _observer !== observer
-				);
+				ReachabilityNavigator._observers =
+					ReachabilityNavigator._observers.filter(
+						_observer => _observer !== observer
+					);
 				continue;
 			}
 			observer.next(status);

package/src/Util/Retry.ts

@@ -37,7 +37,7 @@ export async function retry<T>(
 		let wakeUp: any = () => {}; // will be replaced with a resolver()
 
 		// used after the loop if terminated while waiting for a timer.
-		let lastError: Error;
+		let lastError: unknown;
 
 		onTerminate &&
 			onTerminate.then(() => {
@@ -61,6 +61,7 @@ export async function retry<T>(
 			try {
 				return resolve(await functionToRetry(...args));
 			} catch (err) {
+				
 				lastError = err;
 				logger.debug(`error on ${functionToRetry.name}`, err);
 

package/src/Util/StringUtils.ts

@@ -3,18 +3,11 @@
 export function urlSafeEncode(str: string) {
 	return str
 		.split('')
-		.map(char =>
-			char
-				.charCodeAt(0)
-				.toString(16)
-				.padStart(2, '0')
-		)
+		.map(char => char.charCodeAt(0).toString(16).padStart(2, '0'))
 		.join('');
 }
 
 export function urlSafeDecode(hex: string) {
-	return hex
-		.match(/.{2}/g)
-		.map(char => String.fromCharCode(parseInt(char, 16)))
-		.join('');
+	const matchArr = hex.match(/.{2}/g) || [];
+	return matchArr.map(char => String.fromCharCode(parseInt(char, 16))).join('');
 }

package/src/Util/errors/AssertError.ts

@@ -0,0 +1,11 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AmplifyError } from '../../Errors';
+import { ErrorParams } from '../../types';
+
+export function asserts(
+	assertion: boolean,
+	errorParams: ErrorParams
+): asserts assertion {
+	if (!assertion) throw new AmplifyError(errorParams);
+}

package/src/clients/handlers/fetch.ts

@@ -32,8 +32,8 @@ export const fetchTransferHandler: TransferHandler<
 		throw e;
 	}
 
-	const responseHeaders = {};
-	resp.headers?.forEach((value, key) => {
+	const responseHeaders: Record<string, string> = {};
+	resp.headers?.forEach((value: string, key: string) => {
 		responseHeaders[key.toLowerCase()] = value;
 	});
 	const httpResponse = {