@aws-amplify/core 5.8.6-api-v6-models.b3abc9b.0 → 6.0.0

package/src/clients/internal/composeServiceApi.ts

@@ -9,7 +9,7 @@ export const composeServiceApi = <
 	TransferHandlerOptions,
 	Input,
 	Output,
-	DefaultConfig extends Partial<TransferHandlerOptions & ServiceClientOptions>
+	DefaultConfig
 >(
 	transferHandler: TransferHandler<
 		HttpRequest,
@@ -21,12 +21,15 @@ export const composeServiceApi = <
 		endpoint: Endpoint
 	) => Promise<HttpRequest> | HttpRequest,
 	deserializer: (output: HttpResponse) => Promise<Output>,
-	defaultConfig: DefaultConfig
+	defaultConfig: Partial<DefaultConfig>
 ) => {
 	return async (
 		config: OptionalizeKey<
-			TransferHandlerOptions & ServiceClientOptions & DefaultConfig,
-			keyof DefaultConfig
+			TransferHandlerOptions &
+				ServiceClientOptions &
+				Partial<DefaultConfig> &
+				InferEndpointResolverOptionType<DefaultConfig>,
+			DefaultConfig
 		>,
 		input: Input
 	) => {
@@ -51,6 +54,19 @@ export const composeServiceApi = <
 	};
 };
 
-type OptionalizeKey<T, K> = Omit<T, K & keyof T> & {
-	[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 {
+	endpointResolver: (options: infer EndpointOptions) => any;
+}
+	? EndpointOptions
+	: never;

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/jitteredBackoff.ts

@@ -3,7 +3,7 @@
 
 import type { RetryOptions } from './middleware';
 // TODO: [v6] The separate retry utility is used by Data packages now and will replaced by retry middleware.
-import { jitteredBackoff as jitteredBackoffUtil } from '../../../Util/Retry';
+import { jitteredBackoff as jitteredBackoffUtil } from '../../../utils';
 
 const DEFAULT_MAX_DELAY_MS = 5 * 60 * 1000;
 

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/index.ts

@@ -1,7 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-// TODO: V6 replace Signer
 export { signRequest } from './signRequest';
 export { presignUrl } from './presignUrl';
 export { TOKEN_QUERY_PARAM } from './constants';

package/src/clients/middleware/signing/signer/signatureV4/presignUrl.ts

@@ -15,6 +15,7 @@ import {
 } from './constants';
 import { getSigningValues } from './utils/getSigningValues';
 import { getSignature } from './utils/getSignature';
+import { AmplifyUrl } from '../../../../../utils/amplifyUrl';
 
 /**
  * Given a `Presignable` object, returns a Signature Version 4 presigned `URL` object.
@@ -33,7 +34,7 @@ export const presignUrl = (
 
 	// create the request to sign
 	// @ts-ignore URL constructor accepts a URL object
-	const presignedUrl = new URL(url);
+	const presignedUrl = new AmplifyUrl(url);
 	Object.entries({
 		[ALGORITHM_QUERY_PARAM]: SHA256_ALGORITHM_IDENTIFIER,
 		[CREDENTIAL_QUERY_PARAM]: `${accessKeyId}/${credentialScope}`,

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

@@ -4,7 +4,7 @@
 // TODO: V6 update to different crypto dependency?
 import { Sha256 } from '@aws-crypto/sha256-js';
 import { SourceData } from '@aws-sdk/types';
-import { toHex } from '@aws-sdk/util-hex-encoding';
+import { toHex } from '@smithy/util-hex-encoding';
 
 /**
  * Returns the hashed data a `Uint8Array`.
@@ -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

@@ -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;
 

package/src/clients/types/http.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { Request, Response, TransferHandler } from './core';
+import type { fetchTransferHandler } from '../handlers/fetch';
 
 /**
  * Use basic Record interface to workaround fetch Header class not available in Node.js
@@ -24,7 +25,7 @@ export interface HttpRequest extends Request {
 export type ResponseBodyMixin = Pick<Body, 'blob' | 'json' | 'text'>;
 
 export interface HttpResponse extends Response {
-	body: (ResponseBodyMixin & ReadableStream) | ResponseBodyMixin | null;
+	body: (ResponseBodyMixin & ReadableStream) | ResponseBodyMixin;
 	statusCode: number;
 	/**
 	 * @see {@link HttpRequest.headers}
@@ -34,6 +35,31 @@ 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;
+
+	/**
+	 * Internal-only option controls whether or not cross-site Access-Control requests should be made using credentials
+	 * such as cookies, authorization headers or TLS client certificates. It has no effect on same-origin requests.
+	 * If set to `true`, the request will include credentials such as cookies, authorization headers, TLS
+	 * client certificates, and so on. Moreover the response cookies will also be set.
+	 * If set to `false`, the cross-site request will not include credentials, and the response cookies from a different
+	 * domain will be ignored.
+	 *
+	 * This option is only conformed by {@link fetchTransferHandler | fetchTransferHandler	}
+	 *
+	 * @default 'same-origin'
+	 * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials}
+	 * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/credentials}
+	 * @internal
+	 */
+	withCrossDomainCredentials?: boolean;
 }
 
 export type HttpTransferHandler = TransferHandler<

package/src/constants.ts

@@ -1,6 +1,9 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+// Logging constants
+export const AWS_CLOUDWATCH_CATEGORY = 'Logging';
+
 /**
  * This Symbol is used to reference an internal-only PubSub provider that
  * is used for AppSync/GraphQL subscriptions in the API category.
@@ -13,3 +16,7 @@ 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 NO_HUBCALLBACK_PROVIDED_EXCEPTION =
+	'NoHubcallbackProvidedException';

package/src/errors/AmplifyError.ts

@@ -0,0 +1,34 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AmplifyErrorParams } from '../types/errors';
+
+export class AmplifyError extends Error {
+	underlyingError?: Error | unknown;
+	recoverySuggestion?: string;
+	/**
+	 *  Constructs an AmplifyError.
+	 *
+	 * @param message text that describes the main problem.
+	 * @param underlyingError the underlying cause of the error.
+	 * @param recoverySuggestion suggestion to recover from the error.
+	 *
+	 */
+	constructor({
+		message,
+		name,
+		recoverySuggestion,
+		underlyingError,
+	}: AmplifyErrorParams) {
+		super(message);
+
+		this.name = name;
+		this.underlyingError = underlyingError;
+		this.recoverySuggestion = recoverySuggestion;
+
+		// Hack for making the custom error class work when transpiled to es5
+		// TODO: Delete the following 2 lines after we change the build target to >= es2015
+		this.constructor = AmplifyError;
+		Object.setPrototypeOf(this, AmplifyError.prototype);
+	}
+}

package/src/errors/PlatformNotSupportedError.ts

@@ -0,0 +1,14 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AmplifyErrorCode } from '../types';
+import { AmplifyError } from './AmplifyError';
+
+export class PlatformNotSupportedError extends AmplifyError {
+	constructor() {
+		super({
+			name: AmplifyErrorCode.PlatformNotSupported,
+			message: 'Function not supported on current platform',
+		});
+	}
+}

package/src/errors/createAssertionFunction.ts

@@ -0,0 +1,23 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AmplifyErrorMap, AssertionFunction } from '../types';
+import { AmplifyError } from './AmplifyError';
+
+export const createAssertionFunction =
+	(
+		errorMap: AmplifyErrorMap,
+		AssertionError = AmplifyError
+	): AssertionFunction =>
+	(assertion, name, additionalContext) => {
+		const { message, recoverySuggestion } = errorMap[name];
+		if (!assertion) {
+			throw new AssertionError({
+				name,
+				message: additionalContext
+					? `${message} ${additionalContext}`
+					: message,
+				recoverySuggestion,
+			});
+		}
+	};

package/src/errors/errorHelpers.ts

@@ -0,0 +1,20 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { createAssertionFunction } from './createAssertionFunction';
+import { AmplifyErrorCode, AmplifyErrorMap, AssertionFunction } from '../types';
+
+const amplifyErrorMap: AmplifyErrorMap<AmplifyErrorCode> = {
+	[AmplifyErrorCode.NoEndpointId]: {
+		message: 'Endpoint ID was not found and was unable to be created.',
+	},
+	[AmplifyErrorCode.PlatformNotSupported]: {
+		message: 'Function not supported on current platform.',
+	},
+	[AmplifyErrorCode.Unknown]: {
+		message: 'An unknown error occurred.',
+	},
+};
+
+export const assert: AssertionFunction<AmplifyErrorCode> =
+	createAssertionFunction(amplifyErrorMap);

package/src/errors/index.ts

@@ -0,0 +1,7 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { AmplifyError } from './AmplifyError';
+export { createAssertionFunction } from './createAssertionFunction';
+export { PlatformNotSupportedError } from './PlatformNotSupportedError';
+export { assert } from './errorHelpers';

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

@@ -1,94 +1,74 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { Amplify } from './Amplify';
-import { Platform } from './Platform';
+/*
+This file maps top-level exports from `@aws-amplify/core`. These are intended to be potentially customer-facing exports.
+*/
+// Hub exports
+export { Hub } from './Hub';
+export { HubCapsule, HubCallback, HubPayload } from './Hub/types';
 
-export { Amplify } from './Amplify';
-export { AmplifyClass } from './Amplify';
-export { ClientDevice } from './ClientDevice';
-export { ConsoleLogger, ConsoleLogger as Logger } from './Logger';
-export { invalidParameter, missingConfig } from './Errors';
-export { Hub, HubCapsule, HubCallback, HubPayload } from './Hub';
-export { I18n } from './I18n';
+// Singleton exports
 export {
-	browserOrNode,
-	filenameToContentType,
-	generateRandomString,
-	isEmpty,
-	isStrictObject,
-	isTextFile,
-	isWebWorker,
-	makeQuerablePromise,
-	objectLessAttributes,
-	sortByField,
-	transferKeyToLowerCase,
-	transferKeyToUpperCase,
-} from './JS';
-export { Signer } from './Signer';
-export { parseAWSExports } from './parseAWSExports';
-export { AWSCloudWatchProvider } from './Providers';
-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 { UniversalStorage } from './UniversalStorage';
+	TokenProvider,
+	AuthTokens,
+	FetchAuthSessionOptions,
+	AWSCredentialsAndIdentityIdProvider,
+	AWSCredentialsAndIdentityId,
+	Identity,
+	OAuthConfig,
+	CognitoUserPoolConfig,
+} from './singleton/Auth/types';
 export {
-	Platform,
-	getAmplifyUserAgentObject,
-	getAmplifyUserAgent,
-} from './Platform';
+	AuthConfig,
+	AuthUserPoolConfig,
+	AuthUserPoolAndIdentityPoolConfig,
+	APIConfig,
+	PredictionsConfig,
+	StorageAccessLevel,
+	StorageConfig,
+	GetCredentialsOptions,
+	ResourcesConfig,
+	LibraryOptions,
+	AnalyticsConfig,
+	GeoConfig,
+} from './singleton/types';
 export {
-	ApiAction,
-	AuthAction,
-	AnalyticsAction,
-	Category,
-	CustomUserAgentDetails,
-	DataStoreAction,
-	Framework,
-	GeoAction,
-	InteractionsAction,
-	InAppMessagingAction,
-	PredictionsAction,
-	PubSubAction,
-	PushNotificationAction,
-	StorageAction,
-} from './Platform/types';
+	Amplify,
+	fetchAuthSession,
+	AmplifyClass as AmplifyClassV6,
+	clearCredentials,
+} from './singleton';
+
+// AWSClients exports
 export {
-	INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER,
-	USER_AGENT_HEADER,
-} from './constants';
+	getCredentialsForIdentity,
+	getId,
+	GetCredentialsForIdentityInput,
+	GetCredentialsForIdentityOutput,
+} from './awsClients/cognitoIdentity';
 
-export const Constants = {
-	userAgent: Platform.userAgent,
-};
+// Amplify-wide constructs
+export { UserProfile } from './types';
 
+// Storage helpers
 export {
-	AWS_CLOUDWATCH_BASE_BUFFER_SIZE,
-	AWS_CLOUDWATCH_CATEGORY,
-	AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE,
-	AWS_CLOUDWATCH_MAX_EVENT_SIZE,
-	AWS_CLOUDWATCH_PROVIDER_NAME,
-	BackgroundManagerNotOpenError,
-	BackgroundProcessManager,
-	BackgroundProcessManagerState,
-	DateUtils,
-	Mutex,
-	NO_CREDS_ERROR_STRING,
-	NonRetryableError,
-	RETRY_ERROR_CODES,
-	Reachability,
-	isNonRetryableError,
-	jitteredBackoff,
-	jitteredExponentialRetry,
-	retry,
-	urlSafeDecode,
-	urlSafeEncode,
-} from './Util';
+	CookieStorage,
+	defaultStorage,
+	sessionStorage,
+	sharedInMemoryStorage,
+} from './storage';
+export { KeyValueStorageInterface } from './types';
+
+// Cache exports
+export { Cache } from './Cache';
+export { CacheConfig } from './Cache/types';
 
-/**
- * @deprecated use named import
- */
-export default Amplify;
+// Internationalization utilities
+export { I18n } from './I18n';
+
+// Logging utilities
+export { ConsoleLogger } from './Logger';
+
+// Service worker
+export { ServiceWorker } from './ServiceWorker';