@aws-amplify/core 5.3.2-unstable.ffe65ea.1 → 5.4.0

package/src/AwsClients/Pinpoint/updateEndpoint.ts

@@ -0,0 +1,60 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { authenticatedHandler } from '../../clients/handlers/authenticated';
+import { composeServiceApi } from '../../clients/internal/composeServiceApi';
+import { extendedEncodeURIComponent } from '../../clients/middleware/signing/utils/extendedEncodeURIComponent';
+import {
+	parseJsonBody,
+	parseJsonError,
+	parseMetadata,
+} from '../../clients/serde';
+import { Endpoint, HttpRequest, HttpResponse } from '../../clients/types';
+import { defaultConfig, getSharedHeaders } from './base';
+import type {
+	UpdateEndpointCommandInput as UpdateEndpointInput,
+	UpdateEndpointCommandOutput as UpdateEndpointOutput,
+} from './types';
+
+export type { UpdateEndpointInput, UpdateEndpointOutput };
+
+const updateEndpointSerializer = (
+	{ ApplicationId, EndpointId, EndpointRequest }: UpdateEndpointInput,
+	endpoint: Endpoint
+): HttpRequest => {
+	const headers = getSharedHeaders();
+	const url = new URL(endpoint.url);
+	url.pathname = `v1/apps/${extendedEncodeURIComponent(
+		ApplicationId
+	)}/endpoints/${extendedEncodeURIComponent(EndpointId)}`;
+	const body = JSON.stringify(EndpointRequest ?? {});
+	return { method: 'PUT', headers, url, body };
+};
+
+const updateEndpointDeserializer = async (
+	response: HttpResponse
+): Promise<UpdateEndpointOutput> => {
+	if (response.statusCode >= 300) {
+		const error = await parseJsonError(response);
+		throw error;
+	} else {
+		const { Message, RequestID } = await parseJsonBody(response);
+		return {
+			MessageBody: {
+				Message,
+				RequestID,
+			},
+			$metadata: parseMetadata(response),
+		};
+	}
+};
+
+/**
+ * @internal
+ */
+export const updateEndpoint = composeServiceApi(
+	authenticatedHandler,
+	updateEndpointSerializer,
+	updateEndpointDeserializer,
+	defaultConfig
+);

package/src/Credentials.ts

@@ -5,20 +5,9 @@ import { FacebookOAuth, GoogleOAuth } from './OAuthHelper';
 import { jitteredExponentialRetry } from './Util';
 import { ICredentials } from './types';
 import { Amplify } from './Amplify';
-import {
-	fromCognitoIdentity,
-	FromCognitoIdentityParameters,
-	fromCognitoIdentityPool,
-	FromCognitoIdentityPoolParameters,
-} from '@aws-sdk/credential-provider-cognito-identity';
-import {
-	GetIdCommand,
-	GetCredentialsForIdentityCommand,
-} from '@aws-sdk/client-cognito-identity';
-import { CredentialProvider } from '@aws-sdk/types';
+import { getId, getCredentialsForIdentity } from './AwsClients/CognitoIdentity';
 import { parseAWSExports } from './parseAWSExports';
 import { Hub } from './Hub';
-import { createCognitoIdentityClient } from './Util/CognitoIdentityClient';
 
 const logger = new Logger('Credentials');
 
@@ -49,7 +38,7 @@ export class CredentialsClass {
 	private _storage;
 	private _storageSync;
 	private _identityId;
-	private _nextCredentialsRefresh: Number;
+	private _nextCredentialsRefresh: number;
 
 	// Allow `Auth` to be injected for SSR, but Auth isn't a required dependency for Credentials
 	Auth = undefined;
@@ -291,47 +280,29 @@ export class CredentialsClass {
 
 		const identityId = (this._identityId = await this._getGuestIdentityId());
 
-		const cognitoClient = createCognitoIdentityClient({
-			region: identityPoolRegion || region,
-		});
+		const cognitoConfig = { region: identityPoolRegion ?? region };
 
-		let credentials = undefined;
-		if (identityId) {
-			const cognitoIdentityParams: FromCognitoIdentityParameters = {
-				identityId,
-				client: cognitoClient,
-			};
-			credentials = fromCognitoIdentity(cognitoIdentityParams)();
-		} else {
-			/*
-			Retreiving identityId with GetIdCommand to mimic the behavior in the following code in aws-sdk-v3:
-			https://git.io/JeDxU
-
-			Note: Retreive identityId from CredentialsProvider once aws-sdk-js v3 supports this.
-			*/
-			const credentialsProvider: CredentialProvider = async () => {
-				const { IdentityId } = await cognitoClient.send(
-					new GetIdCommand({
-						IdentityPoolId: identityPoolId,
-					})
-				);
+		const guestCredentialsProvider = async () => {
+			if (!identityId) {
+				const { IdentityId } = await getId(cognitoConfig, {
+					IdentityPoolId: identityPoolId,
+				});
 				this._identityId = IdentityId;
-				const cognitoIdentityParams: FromCognitoIdentityParameters = {
-					client: cognitoClient,
-					identityId: IdentityId,
-				};
-
-				const credentialsFromCognitoIdentity = fromCognitoIdentity(
-					cognitoIdentityParams
-				);
-
-				return credentialsFromCognitoIdentity();
-			};
-
-			credentials = credentialsProvider().catch(async err => {
-				throw err;
+			}
+			const { Credentials } = await getCredentialsForIdentity(cognitoConfig, {
+				IdentityId: this._identityId,
 			});
-		}
+			return {
+				identityId: this._identityId,
+				accessKeyId: Credentials.AccessKeyId,
+				secretAccessKey: Credentials.SecretKey,
+				sessionToken: Credentials.SessionToken,
+				expiration: Credentials.Expiration,
+			};
+		};
+		let credentials = guestCredentialsProvider().catch(async err => {
+			throw err;
+		});
 
 		return this._loadCredentials(credentials, 'guest', false, null)
 			.then(res => {
@@ -347,26 +318,28 @@ export class CredentialsClass {
 					logger.debug('Failed to load guest credentials');
 					await this._removeGuestIdentityId();
 
-					const credentialsProvider: CredentialProvider = async () => {
-						const { IdentityId } = await cognitoClient.send(
-							new GetIdCommand({
-								IdentityPoolId: identityPoolId,
-							})
-						);
+					const guestCredentialsProvider = async () => {
+						const { IdentityId } = await getId(cognitoConfig, {
+							IdentityPoolId: identityPoolId,
+						});
 						this._identityId = IdentityId;
-						const cognitoIdentityParams: FromCognitoIdentityParameters = {
-							client: cognitoClient,
-							identityId: IdentityId,
-						};
-
-						const credentialsFromCognitoIdentity = fromCognitoIdentity(
-							cognitoIdentityParams
+						const { Credentials } = await getCredentialsForIdentity(
+							cognitoConfig,
+							{
+								IdentityId,
+							}
 						);
 
-						return credentialsFromCognitoIdentity();
+						return {
+							identityId: IdentityId,
+							accessKeyId: Credentials.AccessKeyId,
+							secretAccessKey: Credentials.SecretKey,
+							sessionToken: Credentials.SessionToken,
+							expiration: Credentials.Expiration,
+						};
 					};
 
-					credentials = credentialsProvider().catch(async err => {
+					credentials = guestCredentialsProvider().catch(async err => {
 						throw err;
 					});
 
@@ -378,7 +351,8 @@ export class CredentialsClass {
 	}
 
 	private _setCredentialsFromFederation(params) {
-		const { provider, token, identity_id } = params;
+		const { provider, token } = params;
+		let { identity_id } = params;
 		const domains = {
 			google: 'accounts.google.com',
 			facebook: 'graph.facebook.com',
@@ -407,26 +381,33 @@ export class CredentialsClass {
 			);
 		}
 
-		const cognitoClient = createCognitoIdentityClient({
-			region: identityPoolRegion || region,
-		});
+		const cognitoConfig = { region: identityPoolRegion ?? region };
 
-		let credentials = undefined;
-		if (identity_id) {
-			const cognitoIdentityParams: FromCognitoIdentityParameters = {
+		const authenticatedCredentialsProvider = async () => {
+			if (!identity_id) {
+				const { IdentityId } = await getId(cognitoConfig, {
+					IdentityPoolId: identityPoolId,
+					Logins: logins,
+				});
+				identity_id = IdentityId;
+			}
+			const { Credentials } = await getCredentialsForIdentity(cognitoConfig, {
+				IdentityId: identity_id,
+				Logins: logins,
+			});
+			return {
 				identityId: identity_id,
-				logins,
-				client: cognitoClient,
-			};
-			credentials = fromCognitoIdentity(cognitoIdentityParams)();
-		} else {
-			const cognitoIdentityParams: FromCognitoIdentityPoolParameters = {
-				logins,
-				identityPoolId,
-				client: cognitoClient,
+				accessKeyId: Credentials.AccessKeyId,
+				secretAccessKey: Credentials.SecretKey,
+				sessionToken: Credentials.SessionToken,
+				expiration: Credentials.Expiration,
 			};
-			credentials = fromCognitoIdentityPool(cognitoIdentityParams)();
-		}
+		};
+
+		const credentials = authenticatedCredentialsProvider().catch(async err => {
+			throw err;
+		});
+
 		return this._loadCredentials(credentials, 'federated', true, params);
 	}
 
@@ -449,9 +430,7 @@ export class CredentialsClass {
 		const logins = {};
 		logins[key] = idToken;
 
-		const cognitoClient = createCognitoIdentityClient({
-			region: identityPoolRegion || region,
-		});
+		const cognitoConfig = { region: identityPoolRegion ?? region };
 
 		/* 
 			Retreiving identityId with GetIdCommand to mimic the behavior in the following code in aws-sdk-v3:
@@ -459,7 +438,7 @@ export class CredentialsClass {
 
 			Note: Retreive identityId from CredentialsProvider once aws-sdk-js v3 supports this.
 		*/
-		const credentialsProvider: CredentialProvider = async () => {
+		const credentialsProvider = async () => {
 			// try to fetch the local stored guest identity, if found, we will associate it with the logins
 			const guestIdentityId = await this._getGuestIdentityId();
 
@@ -467,12 +446,10 @@ export class CredentialsClass {
 			if (!guestIdentityId) {
 				// for a first-time user, this will return a brand new identity
 				// for a returning user, this will retrieve the previous identity assocaited with the logins
-				const { IdentityId } = await cognitoClient.send(
-					new GetIdCommand({
-						IdentityPoolId: identityPoolId,
-						Logins: logins,
-					})
-				);
+				const { IdentityId } = await getId(cognitoConfig, {
+					IdentityPoolId: identityPoolId,
+					Logins: logins,
+				});
 				generatedOrRetrievedIdentityId = IdentityId;
 			}
 
@@ -481,12 +458,10 @@ export class CredentialsClass {
 				// single source of truth for the primary identity associated with the logins
 				// only if a guest identity is used for a first-time user, that guest identity will become its primary identity
 				IdentityId: primaryIdentityId,
-			} = await cognitoClient.send(
-				new GetCredentialsForIdentityCommand({
-					IdentityId: guestIdentityId || generatedOrRetrievedIdentityId,
-					Logins: logins,
-				})
-			);
+			} = await getCredentialsForIdentity(cognitoConfig, {
+				IdentityId: guestIdentityId || generatedOrRetrievedIdentityId,
+				Logins: logins,
+			});
 
 			this._identityId = primaryIdentityId;
 			if (guestIdentityId) {

package/src/OAuthHelper/FacebookOAuth.ts

@@ -6,7 +6,7 @@ import { NonRetryableError } from '../Util';
 
 const logger = new Logger('CognitoCredentials');
 
-const waitForInit = new Promise((res, rej) => {
+const waitForInit = new Promise<void>((res, rej) => {
 	if (!browserOrNode().isBrowser) {
 		logger.debug('not in the browser, directly resolved');
 		return res();

package/src/OAuthHelper/GoogleOAuth.ts

@@ -6,7 +6,7 @@ import { NonRetryableError } from '../Util';
 
 const logger = new Logger('CognitoCredentials');
 
-const waitForInit = new Promise((res, rej) => {
+const waitForInit = new Promise<void>((res, rej) => {
 	if (!browserOrNode().isBrowser) {
 		logger.debug('not in the browser, directly resolved');
 		return res();

package/src/Platform/version.ts

@@ -1,2 +1,2 @@
 // generated by genversion
-export const version = '5.2.5-unstable.ffe65ea.1+ffe65eaed';
+export const version = '5.2.5';

package/src/StorageHelper/reactnative.ts

@@ -59,7 +59,7 @@ class MemoryStorage {
 	 */
 	static sync() {
 		if (!MemoryStorage.syncPromise) {
-			MemoryStorage.syncPromise = new Promise((res, rej) => {
+			MemoryStorage.syncPromise = new Promise<void>((res, rej) => {
 				AsyncStorage.getAllKeys((errKeys, keys) => {
 					if (errKeys) rej(errKeys);
 					const memoryKeys = keys.filter(key =>

package/src/clients/endpoints/getDnsSuffix.ts

@@ -0,0 +1,25 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { defaultPartition, partitionsInfo } from './partitions';
+
+/**
+ * Get the AWS Services endpoint URL's DNS suffix for a given region. A typical AWS regional service endpoint URL will
+ * follow this pattern: {endpointPrefix}.{region}.{dnsSuffix}. For example, the endpoint URL for Cognito Identity in
+ * us-east-1 will be cognito-identity.us-east-1.amazonaws.com. Here the DnsSuffix is `amazonaws.com`.
+ *
+ * @param region
+ * @returns The DNS suffix
+ *
+ * @internal
+ */
+export const getDnsSuffix = (region: string): string => {
+	const { partitions } = partitionsInfo;
+	for (const { regions, outputs, regionRegex } of partitions) {
+		const regex = new RegExp(regionRegex);
+		if (regions.includes(region) || regex.test(region)) {
+			return outputs.dnsSuffix;
+		}
+	}
+	return defaultPartition.outputs.dnsSuffix;
+};

package/src/clients/endpoints/index.ts

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

package/src/clients/endpoints/partitions.ts

@@ -0,0 +1,40 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Default partition for AWS services. This is used when the region is not provided or the region is not recognized.
+ *
+ * @internal
+ */
+export const defaultPartition = {
+	id: 'aws',
+	outputs: {
+		dnsSuffix: 'amazonaws.com',
+	},
+	regionRegex: '^(us|eu|ap|sa|ca|me|af)\\-\\w+\\-\\d+$',
+	regions: ['aws-global'],
+};
+
+/**
+ * This data is adapted from the partition file from AWS SDK shared utilities but remove some contents for bundle size
+ * concern. Information removed are `dualStackDnsSuffix`, `supportDualStack`, `supportFIPS`, restricted partitions, and
+ * list of regions for each partition other than global regions.
+ *
+ * * Ref: https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints
+ * * Ref: https://github.com/aws/aws-sdk-js-v3/blob/0201baef03c2379f1f6f7150b9d401d4b230d488/packages/util-endpoints/src/lib/aws/partitions.json#L1
+ *
+ * @internal
+ */
+export const partitionsInfo = {
+	partitions: [
+		defaultPartition,
+		{
+			id: 'aws-cn',
+			outputs: {
+				dnsSuffix: 'amazonaws.com.cn',
+			},
+			regionRegex: '^cn\\-\\w+\\-\\d+$',
+			regions: ['aws-cn-global'],
+		},
+	],
+};

package/src/clients/handlers/authenticated.ts

@@ -0,0 +1,19 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { retryMiddleware, RetryOptions } from '../middleware/retry';
+import { signingMiddleware, SigningOptions } from '../middleware/signing';
+import { userAgentMiddleware, UserAgentOptions } from '../middleware/userAgent';
+import { composeTransferHandler } from '../internal/composeTransferHandler';
+import { fetchTransferHandler } from './fetch';
+import { HttpRequest, HttpResponse } from '../types';
+
+export const authenticatedHandler = composeTransferHandler<
+	[UserAgentOptions, RetryOptions<HttpResponse>, SigningOptions],
+	HttpRequest,
+	HttpResponse
+>(fetchTransferHandler, [
+	userAgentMiddleware,
+	retryMiddleware,
+	signingMiddleware,
+]);

package/src/clients/handlers/fetch.ts

@@ -0,0 +1,75 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import 'isomorphic-unfetch'; // TODO: remove this dependency in v6
+import { HttpRequest, HttpResponse, HttpTransferOptions } from '../types/http';
+import { TransferHandler } from '../types/core';
+
+const shouldSendBody = (method: string) =>
+	!['HEAD', 'GET', 'DELETE'].includes(method.toUpperCase());
+
+export const fetchTransferHandler: TransferHandler<
+	HttpRequest,
+	HttpResponse,
+	HttpTransferOptions
+> = async ({ url, method, headers, body }, { abortSignal }) => {
+	let resp: Response;
+	try {
+		resp = await fetch(url, {
+			method,
+			headers,
+			body: shouldSendBody(method) ? body : undefined,
+			signal: abortSignal,
+		});
+	} catch (e) {
+		// TODO: needs to revise error handling in v6
+		// For now this is a thin wrapper over original fetch error similar to cognito-identity-js package.
+		// Ref: https://github.com/aws-amplify/amplify-js/blob/4fbc8c0a2be7526aab723579b4c95b552195a80b/packages/amazon-cognito-identity-js/src/Client.js#L103-L108
+		if (e instanceof TypeError) {
+			throw new Error('Network error');
+		}
+		throw e;
+	}
+
+	const responseHeaders = {};
+	resp.headers?.forEach((value, key) => {
+		responseHeaders[key.toLowerCase()] = value;
+	});
+	const httpResponse = {
+		statusCode: resp.status,
+		headers: responseHeaders,
+		body: null,
+	};
+
+	// resp.body is a ReadableStream according to Fetch API spec, but React Native
+	// does not implement it.
+	const bodyWithMixin = Object.assign(resp.body ?? {}, {
+		text: withMemoization(() => resp.text()),
+		blob: withMemoization(() => resp.blob()),
+		json: withMemoization(() => resp.json()),
+	});
+
+	return {
+		...httpResponse,
+		body: bodyWithMixin,
+	};
+};
+
+/**
+ * Cache the payload of a response body. It allows multiple calls to the body,
+ * for example, when reading the body in both retry decider and error deserializer.
+ * Caching body is allowed here because we call the body accessor(blob(), json(),
+ * etc.) when body is small or streaming implementation is not available(RN).
+ */
+const withMemoization = <T>(payloadAccessor: () => Promise<T>) => {
+	let cached: Promise<T>;
+	return () => {
+		if (!cached) {
+			// Explicitly not awaiting. Intermediate await would add overhead and
+			// introduce a possible race in the event that this wrapper is called
+			// again before the first `payloadAccessor` call resolves.
+			cached = payloadAccessor();
+		}
+		return cached;
+	};
+};

package/src/clients/handlers/unauthenticated.ts

@@ -0,0 +1,14 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { retryMiddleware, RetryOptions } from '../middleware/retry';
+import { userAgentMiddleware, UserAgentOptions } from '../middleware/userAgent';
+import { composeTransferHandler } from '../internal/composeTransferHandler';
+import { fetchTransferHandler } from './fetch';
+import { HttpRequest, HttpResponse } from '../types';
+
+export const unauthenticatedHandler = composeTransferHandler<
+	[UserAgentOptions, RetryOptions<HttpResponse>],
+	HttpRequest,
+	HttpResponse
+>(fetchTransferHandler, [userAgentMiddleware, retryMiddleware]);

package/src/clients/index.ts

@@ -0,0 +1,15 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { getDnsSuffix } from './endpoints';
+
+export { fetchTransferHandler } from './handlers/fetch';
+export { unauthenticatedHandler } from './handlers/unauthenticated';
+export { authenticatedHandler } from './handlers/authenticated';
+export { composeServiceApi } from './internal/composeServiceApi';
+export {
+	signRequest,
+	presignUrl,
+} from './middleware/signing/signer/signatureV4';
+export { parseJsonBody, parseJsonError, parseMetadata } from './serde';
+export * from './types';

package/src/clients/internal/composeServiceApi.ts

@@ -0,0 +1,50 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { ServiceClientOptions } from '../types/aws';
+import { TransferHandler, Endpoint } from '../types/core';
+import { HttpRequest, HttpResponse } from '../types/http';
+
+export const composeServiceApi = <
+	TransferHandlerOptions,
+	Input,
+	Output,
+	DefaultConfig extends Partial<TransferHandlerOptions & ServiceClientOptions>
+>(
+	transferHandler: TransferHandler<
+		HttpRequest,
+		HttpResponse,
+		TransferHandlerOptions
+	>,
+	serializer: (input: Input, endpoint: Endpoint) => HttpRequest,
+	deserializer: (output: HttpResponse) => Promise<Output>,
+	defaultConfig: DefaultConfig
+) => {
+	return async (
+		config: OptionalizeKey<
+			TransferHandlerOptions & ServiceClientOptions,
+			keyof DefaultConfig
+		>,
+		input: Input
+	) => {
+		const resolvedConfig = {
+			...defaultConfig,
+			...config,
+		} as unknown as TransferHandlerOptions & ServiceClientOptions;
+		const endpoint = await resolvedConfig.endpointResolver({
+			region: resolvedConfig.region,
+		});
+		// Unlike AWS SDK clients, a serializer should NOT populate the `host` or `content-length` headers.
+		// Both of these headers are prohibited per Spec(https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name).
+		// They will be populated automatically by browser, or node-fetch polyfill.
+		const request = serializer(input, endpoint);
+		const response = await transferHandler(request, {
+			...resolvedConfig,
+		});
+		return await deserializer(response);
+	};
+};
+
+type OptionalizeKey<T, K> = Omit<T, K & keyof T> & {
+	[P in K & keyof T]?: T[P];
+};