@aws-amplify/core 6.0.1-console-preview.7739091.0 → 6.0.1-preview-testing.ddb17c0.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/clients/handlers/authenticated.ts

@@ -11,7 +11,8 @@ import { HttpRequest, HttpResponse } from '../types';
 export const authenticatedHandler = composeTransferHandler<
 	[UserAgentOptions, RetryOptions<HttpResponse>, SigningOptions],
 	HttpRequest,
-	HttpResponse
+	HttpResponse,
+	typeof fetchTransferHandler
 >(fetchTransferHandler, [
 	userAgentMiddleware,
 	retryMiddleware,

package/src/clients/handlers/fetch.ts

@@ -13,7 +13,7 @@ export const fetchTransferHandler: TransferHandler<
 	HttpRequest,
 	HttpResponse,
 	HttpTransferOptions
-> = async ({ url, method, headers, body }, { abortSignal }) => {
+> = async ({ url, method, headers, body }, { abortSignal, cache }) => {
 	let resp: Response;
 	try {
 		resp = await fetch(url, {
@@ -21,6 +21,7 @@ export const fetchTransferHandler: TransferHandler<
 			headers,
 			body: shouldSendBody(method) ? body : undefined,
 			signal: abortSignal,
+			cache,
 		});
 	} catch (e) {
 		// TODO: needs to revise error handling in v6

package/src/clients/handlers/unauthenticated.ts

@@ -10,5 +10,6 @@ import { HttpRequest, HttpResponse } from '../types';
 export const unauthenticatedHandler = composeTransferHandler<
 	[UserAgentOptions, RetryOptions<HttpResponse>],
 	HttpRequest,
-	HttpResponse
+	HttpResponse,
+	typeof fetchTransferHandler
 >(fetchTransferHandler, [userAgentMiddleware, retryMiddleware]);

package/src/clients/internal/composeServiceApi.ts

@@ -29,7 +29,7 @@ export const composeServiceApi = <
 				ServiceClientOptions &
 				Partial<DefaultConfig> &
 				InferEndpointResolverOptionType<DefaultConfig>,
-			keyof DefaultConfig
+			DefaultConfig
 		>,
 		input: Input
 	) => {
@@ -54,8 +54,15 @@ export const composeServiceApi = <
 	};
 };
 
-type OptionalizeKey<T, K extends keyof T> = Omit<T, K> & {
-	[P in K & keyof T]?: T[P];
+type OptionalizeKey<InputType, InputDefaultsType> = {
+	[KeyWithDefaultValue in keyof InputDefaultsType]?: KeyWithDefaultValue extends keyof InputType
+		? InputType[KeyWithDefaultValue]
+		: never;
+} & {
+	[KeyWithoutDefaultValue in keyof Omit<
+		InputType,
+		keyof InputDefaultsType
+	>]: InputType[KeyWithoutDefaultValue];
 };
 
 type InferEndpointResolverOptionType<T> = T extends {

package/src/clients/types/aws.ts

@@ -5,7 +5,10 @@ import { MetadataBearer } from '@aws-sdk/types';
 import { Endpoint } from './core';
 import { HttpResponse } from './http';
 
-export type { Credentials, MetadataBearer } from '@aws-sdk/types';
+export type {
+	AwsCredentialIdentity as Credentials,
+	MetadataBearer,
+} from '@aws-sdk/types';
 
 export type SourceData = string | ArrayBuffer | ArrayBufferView;
 
@@ -26,13 +29,3 @@ 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/http.ts

@@ -34,6 +34,14 @@ export interface HttpResponse extends Response {
 
 export interface HttpTransferOptions {
 	abortSignal?: AbortSignal;
+	/**
+	 * Cache mode for the request. Note that this is only effective when the underlying HTTP handler is fetch.
+	 * For XHR handler, or Node.js `"http(s)"` module or running on React Native, this option is ignored.
+	 * Instead, you can configure the `Cache-Control` headers to achieve similar effects.
+	 * @default 'default'
+	 * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/cache}
+	 */
+	cache?: RequestCache;
 }
 
 export type HttpTransferHandler = TransferHandler<

package/src/clients/types/index.ts

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

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/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 = {