@aws-amplify/core 6.0.1-console-preview.047a1dd.0 → 6.0.1-next.3e9fc9c.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

@@ -0,0 +1,78 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+let dataMemory: Record<string, string> = {};
+
+/** @class */
+export class MemoryStorage {
+	/**
+	 * 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: string, value: any) {
+		dataMemory[key] = value;
+		return dataMemory[key];
+	}
+
+	/**
+	 * 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
+	 */
+	static getItem(key: string) {
+		return Object.prototype.hasOwnProperty.call(dataMemory, key)
+			? dataMemory[key]
+			: undefined;
+	}
+
+	/**
+	 * This is used to remove an item from storage
+	 * @param {string} key - the key being set
+	 * @returns {string} value - value that was deleted
+	 */
+	static removeItem(key: string) {
+		return delete dataMemory[key];
+	}
+
+	/**
+	 * This is used to clear the storage
+	 * @returns {string} nothing
+	 */
+	static clear() {
+		dataMemory = {};
+		return dataMemory;
+	}
+}
+
+export class StorageHelper {
+	private storageWindow: any;
+	/**
+	 * This is used to get a storage object
+	 * @returns {object} the storage
+	 */
+	constructor() {
+		try {
+			this.storageWindow = window.localStorage;
+			this.storageWindow.setItem('aws.amplify.test-ls', 1);
+			this.storageWindow.removeItem('aws.amplify.test-ls');
+		} catch (exception) {
+			this.storageWindow = MemoryStorage;
+		}
+	}
+
+	/**
+	 * This is used to return the storage
+	 * @returns {object} the storage
+	 */
+	getStorage(): any {
+		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 '../Util/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

@@ -0,0 +1,182 @@
+// 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: Record<string, string | null> = {};
+
+/** @class */
+class MemoryStorage {
+	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: string, value: string) {
+		if (value) {
+			AsyncStorage.setItem(MEMORY_KEY_PREFIX + key, value);
+			dataMemory[key] = value;
+			return dataMemory[key];
+		}
+	}
+
+	/**
+	 * 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
+	 */
+	static getItem(key: string) {
+		return Object.prototype.hasOwnProperty.call(dataMemory, key)
+			? dataMemory[key]
+			: undefined;
+	}
+
+	/**
+	 * This is used to remove an item from storage
+	 * @param {string} key - the key being set
+	 * @returns {string} value - value that was deleted
+	 */
+	static removeItem(key: string) {
+		AsyncStorage.removeItem(MEMORY_KEY_PREFIX + key);
+		return delete dataMemory[key];
+	}
+
+	/**
+	 * This is used to clear the storage
+	 * @returns {string} nothing
+	 */
+	static clear() {
+		dataMemory = {};
+		return dataMemory;
+	}
+
+	/**
+	 * Will sync the MemoryStorage data from AsyncStorage to storageWindow MemoryStorage
+	 * @returns {void}
+	 */
+	static sync() {
+		if (!MemoryStorage.syncPromise) {
+			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)) ?? [];
+
+					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();
+					});
+				});
+			});
+		}
+		return MemoryStorage.syncPromise;
+	}
+}
+
+export class StorageHelper {
+	private storageWindow;
+	/**
+	 * This is used to get a storage object
+	 * @returns {object} the storage
+	 */
+	constructor() {
+		this.storageWindow = MemoryStorage;
+	}
+
+	/**
+	 * This is used to return the storage
+	 * @returns {object} the storage
+	 */
+	getStorage() {
+		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/{storage/KeyValueStorage.ts → StorageHelper/sessionStorage.ts}

@@ -4,14 +4,15 @@
 import { PlatformNotSupportedError } from '../Util/Errors';
 import { KeyValueStorageInterface } from '../types';
 
-/**
- * @internal
- */
-export class KeyValueStorage implements KeyValueStorageInterface {
+class SessionStorageClass implements KeyValueStorageInterface {
 	storage?: Storage;
 
-	constructor(storage?: Storage) {
-		this.storage = storage;
+	constructor() {
+		if (typeof window !== undefined) {
+			try {
+				this.storage = window?.sessionStorage;
+			} catch (error) {}
+		}
 	}
 
 	/**
@@ -20,7 +21,7 @@ export class KeyValueStorage implements KeyValueStorageInterface {
 	 * @param {object} value - the value
 	 * @returns {string} value that was set
 	 */
-	async setItem(key: string, value: string) {
+	async setItem(key: string, value: string): Promise<void> {
 		if (!this.storage) throw PlatformNotSupportedError;
 		this.storage.setItem(key, value);
 	}
@@ -31,7 +32,7 @@ export class KeyValueStorage implements KeyValueStorageInterface {
 	 * This is used to clear the storage
 	 * @returns {string} the data item
 	 */
-	async getItem(key: string) {
+	async getItem(key: string): Promise<string | null> {
 		if (!this.storage) throw PlatformNotSupportedError;
 		return this.storage.getItem(key);
 	}
@@ -41,7 +42,7 @@ export class KeyValueStorage implements KeyValueStorageInterface {
 	 * @param {string} key - the key being set
 	 * @returns {string} value - value that was deleted
 	 */
-	async removeItem(key: string) {
+	async removeItem(key: string): Promise<void> {
 		if (!this.storage) throw PlatformNotSupportedError;
 		this.storage.removeItem(key);
 	}
@@ -50,8 +51,10 @@ export class KeyValueStorage implements KeyValueStorageInterface {
 	 * This is used to clear the storage
 	 * @returns {string} nothing
 	 */
-	async clear() {
+	async clear(): Promise<void> {
 		if (!this.storage) throw PlatformNotSupportedError;
 		this.storage.clear();
 	}
 }
+
+export const SessionStorage = new SessionStorageClass();

package/src/index.ts

@@ -50,11 +50,13 @@ export { UserProfile } from './types';
 
 // Storage helpers
 export {
+	StorageHelper,
+	MemoryStorage,
+	LocalStorage,
 	CookieStorage,
-	defaultStorage,
-	sessionStorage,
-	sharedInMemoryStorage,
-} from './storage';
+	SessionStorage,
+	MemoryKeyValueStorage,
+} from './StorageHelper';
 export { KeyValueStorageInterface } from './types';
 
 // Cache exports

package/src/libraryUtils.ts

@@ -97,6 +97,7 @@ export {
 	AmplifyError,
 	AmplifyErrorString,
 } from './Util/Errors';
+export { AppState, AsyncStorage, Linking } from './RNComponents';
 export { ErrorParams, AmplifyErrorMap, ServiceError } from './types';
 export {
 	INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER,

package/src/parseAWSExports.ts

@@ -3,12 +3,6 @@
 import { OAuthConfig } from './singleton/Auth/types';
 import { ResourcesConfig } from './singleton/types';
 
-const authTypeMapping: Record<any, any> = {
-	API_KEY: 'apiKey',
-	AWS_IAM: 'iam',
-	AMAZON_COGNITO_USER_POOLS: 'jwt',
-};
-
 /**
  * This utility converts the `aws-exports.js` file generated by the Amplify CLI into a {@link ResourcesConfig} object
  * consumable by Amplify.
@@ -17,15 +11,10 @@ const authTypeMapping: Record<any, any> = {
  *
  * @returns A {@link ResourcesConfig} object.
  */
-
 export const parseAWSExports = (
 	config: Record<string, any> = {}
 ): ResourcesConfig => {
 	const {
-		aws_appsync_apiKey,
-		aws_appsync_authenticationType,
-		aws_appsync_graphqlEndpoint,
-		aws_appsync_region,
 		aws_cognito_identity_pool_id,
 		aws_cognito_sign_up_verification_method,
 		aws_mandatory_sign_in,
@@ -51,21 +40,6 @@ export const parseAWSExports = (
 		};
 	}
 
-	// TODO: Need to support all API configurations
-	// API
-	if (aws_appsync_graphqlEndpoint) {
-		amplifyConfig.API = {
-			AppSync: {
-				defaultAuthMode: {
-					type: authTypeMapping[aws_appsync_authenticationType],
-					apiKey: aws_appsync_apiKey,
-				},
-				endpoint: aws_appsync_graphqlEndpoint,
-				region: aws_appsync_region,
-			},
-		};
-	}
-
 	// Auth
 	if (aws_cognito_identity_pool_id || aws_user_pools_id) {
 		amplifyConfig.Auth = {

package/src/providers/pinpoint/utils/PinpointEventBuffer.ts

@@ -8,14 +8,14 @@ import {
 	PutEventsInput,
 	PutEventsOutput,
 } from '../../../AwsClients/Pinpoint';
-import {
+import { 
 	EventBufferConfig,
 	BufferedEvent,
 	BufferedEventMap,
-	EventBuffer,
+	EventBuffer
 } from '../types/buffer';
 import { AuthSession } from '../../../singleton/Auth/types';
-import { isAppInForeground } from './isAppInForeground';
+import { isAppInForeground } from '../../../RNComponents/isAppInForeground';
 
 const logger = new Logger('PinpointEventBuffer');
 const RETRYABLE_CODES = [429, 500];
@@ -39,9 +39,7 @@ export class PinpointEventBuffer {
 
 	public push(event: BufferedEvent) {
 		if (this._buffer.length >= this._config.bufferSize) {
-			logger.debug('Exceeded Pinpoint event buffer limits, event dropped.', {
-				eventId: event.eventId,
-			});
+			logger.debug('Exceeded Pinpoint event buffer limits, event dropped.', { eventId: event.eventId });
 
 			return;
 		}
@@ -114,18 +112,16 @@ export class PinpointEventBuffer {
 		}
 	}
 
-	private _generateBatchEventParams(
-		eventMap: BufferedEventMap
-	): PutEventsInput {
+	private _generateBatchEventParams(eventMap: BufferedEventMap): PutEventsInput {
 		const batchItem: Record<string, EventsBatch> = {};
 
 		Object.values(eventMap).forEach(item => {
 			const { event, timestamp, endpointId, eventId, session } = item;
 			const { name, attributes, metrics } = event;
-
+	
 			batchItem[endpointId] = {
 				Endpoint: {
-					...batchItem[endpointId]?.Endpoint,
+					...batchItem[endpointId]?.Endpoint
 				},
 				Events: {
 					...batchItem[endpointId]?.Events,
@@ -135,11 +131,11 @@ export class PinpointEventBuffer {
 						Attributes: attributes,
 						Metrics: metrics,
 						Session: session,
-					},
+					}
 				},
 			};
 		});
-
+	
 		return {
 			ApplicationId: this._config.appId,
 			EventsRequest: {
@@ -204,7 +200,7 @@ export class PinpointEventBuffer {
 				logger.warn('Pinpoint event failed to send.', {
 					eventId,
 					name,
-					message: Message,
+					message: Message
 				});
 			});
 		});
@@ -226,7 +222,7 @@ export class PinpointEventBuffer {
 				logger.debug('Resending event.', {
 					eventId,
 					name,
-					remainingAttempts: bufferedEvent.resendLimit,
+					remainingAttempts: bufferedEvent.resendLimit
 				});
 				eligibleEvents.push({ [eventId!]: bufferedEvent });
 				return;
@@ -234,7 +230,7 @@ export class PinpointEventBuffer {
 
 			logger.debug('No retry attempts remaining for event.', {
 				eventId,
-				name,
+				name
 			});
 		});