@aws-amplify/core 6.0.17-unstable.e316a2e.0 → 6.0.17

package/src/awsClients/pinpoint/base.ts

@@ -3,8 +3,8 @@
 
 import { getDnsSuffix } from '../../clients/endpoints';
 import {
-	jitteredBackoff,
 	getRetryDecider,
+	jitteredBackoff,
 } from '../../clients/middleware/retry';
 import { parseJsonError } from '../../clients/serde/json';
 import type { EndpointResolverOptions, Headers } from '../../clients/types';

package/src/awsClients/pinpoint/getInAppMessages.ts

@@ -10,35 +10,38 @@ import {
 	parseMetadata,
 } from '../../clients/serde';
 import { Endpoint, HttpRequest, HttpResponse } from '../../clients/types';
+import { AmplifyUrl } from '../../utils/amplifyUrl';
+
 import { defaultConfig, getSharedHeaders } from './base';
 import type {
 	GetInAppMessagesCommandInput as GetInAppMessagesInput,
 	GetInAppMessagesCommandOutput as GetInAppMessagesOutput,
 } from './types';
-import { AmplifyUrl } from '../../utils/amplifyUrl';
 
 export type { GetInAppMessagesInput, GetInAppMessagesOutput };
 
 const getInAppMessagesSerializer = (
 	{ ApplicationId = '', EndpointId = '' }: GetInAppMessagesInput,
-	endpoint: Endpoint
+	endpoint: Endpoint,
 ): HttpRequest => {
 	const headers = getSharedHeaders();
 	const url = new AmplifyUrl(endpoint.url);
 	url.pathname = `v1/apps/${extendedEncodeURIComponent(
-		ApplicationId
+		ApplicationId,
 	)}/endpoints/${extendedEncodeURIComponent(EndpointId)}/inappmessages`;
+
 	return { method: 'GET', headers, url };
 };
 
 const getInAppMessagesDeserializer = async (
-	response: HttpResponse
+	response: HttpResponse,
 ): Promise<GetInAppMessagesOutput> => {
 	if (response.statusCode >= 300) {
 		const error = await parseJsonError(response);
 		throw error;
 	} else {
 		const { InAppMessageCampaigns } = await parseJsonBody(response);
+
 		return {
 			InAppMessagesResponse: { InAppMessageCampaigns },
 			$metadata: parseMetadata(response),
@@ -53,5 +56,5 @@ export const getInAppMessages = composeServiceApi(
 	authenticatedHandler,
 	getInAppMessagesSerializer,
 	getInAppMessagesDeserializer,
-	defaultConfig
+	defaultConfig,
 );

package/src/awsClients/pinpoint/putEvents.ts

@@ -10,36 +10,39 @@ import {
 	parseMetadata,
 } from '../../clients/serde';
 import { Endpoint, HttpRequest, HttpResponse } from '../../clients/types';
+import { AmplifyUrl } from '../../utils/amplifyUrl';
+
 import { defaultConfig, getSharedHeaders } from './base';
-import { assert, PinpointValidationErrorCode } from './errorHelpers';
+import { PinpointValidationErrorCode, assert } from './errorHelpers';
 import type {
 	PutEventsCommandInput as PutEventsInput,
 	PutEventsCommandOutput as PutEventsOutput,
 } from './types';
-import { AmplifyUrl } from '../../utils/amplifyUrl';
 
 export type { PutEventsInput, PutEventsOutput };
 
 const putEventsSerializer = (
 	{ ApplicationId, EventsRequest }: PutEventsInput,
-	endpoint: Endpoint
+	endpoint: Endpoint,
 ): HttpRequest => {
 	assert(!!ApplicationId, PinpointValidationErrorCode.NoAppId);
 	const headers = getSharedHeaders();
 	const url = new AmplifyUrl(endpoint.url);
 	url.pathname = `v1/apps/${extendedEncodeURIComponent(ApplicationId)}/events`;
 	const body = JSON.stringify(EventsRequest ?? {});
+
 	return { method: 'POST', headers, url, body };
 };
 
 const putEventsDeserializer = async (
-	response: HttpResponse
+	response: HttpResponse,
 ): Promise<PutEventsOutput> => {
 	if (response.statusCode >= 300) {
 		const error = await parseJsonError(response);
 		throw error;
 	} else {
 		const { Results } = await parseJsonBody(response);
+
 		return {
 			EventsResponse: { Results },
 			$metadata: parseMetadata(response),
@@ -54,5 +57,5 @@ export const putEvents = composeServiceApi(
 	authenticatedHandler,
 	putEventsSerializer,
 	putEventsDeserializer,
-	defaultConfig
+	defaultConfig,
 );

package/src/awsClients/pinpoint/types.ts

@@ -1,4 +1,3 @@
-/* tslint:disable:max-line-length */
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
@@ -377,7 +376,7 @@ export interface EventsResponse {
  *
  * The input for {@link GetInAppMessagesCommand}.
  */
-export interface GetInAppMessagesCommandInput extends GetInAppMessagesRequest {}
+export type GetInAppMessagesCommandInput = GetInAppMessagesRequest;
 /**
  * @public
  *
@@ -691,7 +690,7 @@ export interface PublicEndpoint {
  *
  * The input for {@link PutEventsCommand}.
  */
-export interface PutEventsCommandInput extends PutEventsRequest {}
+export type PutEventsCommandInput = PutEventsRequest;
 /**
  * @public
  *
@@ -777,7 +776,7 @@ export interface SetDimension {
  *
  * The input for {@link UpdateEndpointCommand}.
  */
-export interface UpdateEndpointCommandInput extends UpdateEndpointRequest {}
+export type UpdateEndpointCommandInput = UpdateEndpointRequest;
 /**
  * @public
  *

package/src/awsClients/pinpoint/updateEndpoint.ts

@@ -10,36 +10,39 @@ import {
 	parseMetadata,
 } from '../../clients/serde';
 import { Endpoint, HttpRequest, HttpResponse } from '../../clients/types';
+import { AmplifyUrl } from '../../utils/amplifyUrl';
+
 import { defaultConfig, getSharedHeaders } from './base';
 import type {
 	UpdateEndpointCommandInput as UpdateEndpointInput,
 	UpdateEndpointCommandOutput as UpdateEndpointOutput,
 } from './types';
-import { AmplifyUrl } from '../../utils/amplifyUrl';
 
 export type { UpdateEndpointInput, UpdateEndpointOutput };
 
 const updateEndpointSerializer = (
 	{ ApplicationId = '', EndpointId = '', EndpointRequest }: UpdateEndpointInput,
-	endpoint: Endpoint
+	endpoint: Endpoint,
 ): HttpRequest => {
 	const headers = getSharedHeaders();
 	const url = new AmplifyUrl(endpoint.url);
 	url.pathname = `v1/apps/${extendedEncodeURIComponent(
-		ApplicationId
+		ApplicationId,
 	)}/endpoints/${extendedEncodeURIComponent(EndpointId)}`;
 	const body = JSON.stringify(EndpointRequest);
+
 	return { method: 'PUT', headers, url, body };
 };
 
 const updateEndpointDeserializer = async (
-	response: HttpResponse
+	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,
@@ -57,5 +60,5 @@ export const updateEndpoint = composeServiceApi(
 	authenticatedHandler,
 	updateEndpointSerializer,
 	updateEndpointDeserializer,
-	defaultConfig
+	defaultConfig,
 );

package/src/clients/endpoints/getDnsSuffix.ts

@@ -21,5 +21,6 @@ export const getDnsSuffix = (region: string): string => {
 			return outputs.dnsSuffix;
 		}
 	}
+
 	return defaultPartition.outputs.dnsSuffix;
 };

package/src/clients/handlers/authenticated.ts

@@ -1,20 +1,27 @@
 // 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 { RetryOptions, retryMiddlewareFactory } from '../middleware/retry';
+import {
+	SigningOptions,
+	signingMiddlewareFactory,
+} from '../middleware/signing';
+import {
+	UserAgentOptions,
+	userAgentMiddlewareFactory,
+} from '../middleware/userAgent';
 import { composeTransferHandler } from '../internal/composeTransferHandler';
-import { fetchTransferHandler } from './fetch';
 import { HttpRequest, HttpResponse } from '../types';
 
+import { fetchTransferHandler } from './fetch';
+
 export const authenticatedHandler = composeTransferHandler<
 	[UserAgentOptions, RetryOptions<HttpResponse>, SigningOptions],
 	HttpRequest,
 	HttpResponse,
 	typeof fetchTransferHandler
 >(fetchTransferHandler, [
-	userAgentMiddleware,
-	retryMiddleware,
-	signingMiddleware,
+	userAgentMiddlewareFactory,
+	retryMiddlewareFactory,
+	signingMiddlewareFactory,
 ]);

package/src/clients/handlers/fetch.ts

@@ -15,7 +15,7 @@ export const fetchTransferHandler: TransferHandler<
 	HttpTransferOptions
 > = async (
 	{ url, method, headers, body },
-	{ abortSignal, cache, withCrossDomainCredentials }
+	{ abortSignal, cache, withCrossDomainCredentials },
 ) => {
 	let resp: Response;
 	try {

package/src/clients/handlers/unauthenticated.ts

@@ -1,15 +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 { userAgentMiddleware, UserAgentOptions } from '../middleware/userAgent';
+import { RetryOptions, retryMiddlewareFactory } from '../middleware/retry';
+import {
+	UserAgentOptions,
+	userAgentMiddlewareFactory,
+} from '../middleware/userAgent';
 import { composeTransferHandler } from '../internal/composeTransferHandler';
-import { fetchTransferHandler } from './fetch';
 import { HttpRequest, HttpResponse } from '../types';
 
+import { fetchTransferHandler } from './fetch';
+
 export const unauthenticatedHandler = composeTransferHandler<
 	[UserAgentOptions, RetryOptions<HttpResponse>],
 	HttpRequest,
 	HttpResponse,
 	typeof fetchTransferHandler
->(fetchTransferHandler, [userAgentMiddleware, retryMiddleware]);
+>(fetchTransferHandler, [userAgentMiddlewareFactory, retryMiddlewareFactory]);

package/src/clients/index.ts

@@ -15,14 +15,17 @@ export {
 } from './middleware/signing/signer/signatureV4';
 export { EMPTY_HASH as EMPTY_SHA256_HASH } from './middleware/signing/signer/signatureV4/constants';
 export { extendedEncodeURIComponent } from './middleware/signing/utils/extendedEncodeURIComponent';
-export { signingMiddleware, SigningOptions } from './middleware/signing';
+export { signingMiddlewareFactory, SigningOptions } from './middleware/signing';
 export {
 	getRetryDecider,
 	jitteredBackoff,
-	retryMiddleware,
+	retryMiddlewareFactory,
 	RetryOptions,
 } from './middleware/retry';
-export { userAgentMiddleware, UserAgentOptions } from './middleware/userAgent';
+export {
+	userAgentMiddlewareFactory,
+	UserAgentOptions,
+} from './middleware/userAgent';
 export { parseJsonBody, parseJsonError, parseMetadata } from './serde';
 export { withMemoization } from './utils/memoization';
 export * from './types';

package/src/clients/internal/composeServiceApi.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ServiceClientOptions } from '../types/aws';
-import { TransferHandler, Endpoint } from '../types/core';
+import { Endpoint, TransferHandler } from '../types/core';
 import { HttpRequest, HttpResponse } from '../types/http';
 
 export const composeServiceApi = <
@@ -18,10 +18,10 @@ export const composeServiceApi = <
 	>,
 	serializer: (
 		input: Input,
-		endpoint: Endpoint
+		endpoint: Endpoint,
 	) => Promise<HttpRequest> | HttpRequest,
 	deserializer: (output: HttpResponse) => Promise<Output>,
-	defaultConfig: Partial<DefaultConfig>
+	defaultConfig: Partial<DefaultConfig>,
 ) => {
 	return async (
 		config: OptionalizeKey<
@@ -31,7 +31,7 @@ export const composeServiceApi = <
 				InferEndpointResolverOptionType<DefaultConfig>,
 			DefaultConfig
 		>,
-		input: Input
+		input: Input,
 	) => {
 		const resolvedConfig = {
 			...defaultConfig,
@@ -41,7 +41,7 @@ export const composeServiceApi = <
 		// Currently S3 supports additional `useAccelerateEndpoint` option to use accelerate endpoint.
 		const endpoint = await resolvedConfig.endpointResolver(
 			resolvedConfig,
-			input
+			input,
 		);
 		// 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).
@@ -50,7 +50,8 @@ export const composeServiceApi = <
 		const response = await transferHandler(request, {
 			...resolvedConfig,
 		});
-		return await deserializer(response);
+
+		return deserializer(response);
 	};
 };
 
@@ -66,7 +67,7 @@ type OptionalizeKey<InputType, InputDefaultsType> = {
 };
 
 type InferEndpointResolverOptionType<T> = T extends {
-	endpointResolver: (options: infer EndpointOptions) => any;
+	endpointResolver(options: infer EndpointOptions): any;
 }
 	? EndpointOptions
 	: never;

package/src/clients/internal/composeTransferHandler.ts

@@ -4,9 +4,9 @@
 import {
 	Middleware,
 	MiddlewareHandler,
-	TransferHandler,
 	Request as RequestBase,
 	Response as ResponseBase,
+	TransferHandler,
 } from '../types';
 
 /**
@@ -26,26 +26,27 @@ export const composeTransferHandler =
 			Request,
 			Response,
 			any
-		> = TransferHandler<Request, Response, {}>,
+		> = TransferHandler<Request, Response, Record<string, unknown>>,
 	>(
 		coreHandler: CoreHandler,
-		middleware: OptionToMiddleware<Request, Response, MiddlewareOptionsArr>
+		middleware: OptionToMiddleware<Request, Response, MiddlewareOptionsArr>,
 	) =>
 	(
 		request: Request,
 		options: MergeNoConflictKeys<
 			[...MiddlewareOptionsArr, InferOptionTypeFromTransferHandler<CoreHandler>]
-		>
+		>,
 	) => {
 		const context = {};
 		let composedHandler: MiddlewareHandler<Request, Response> = (
-			request: Request
-		) => coreHandler(request, options);
+			composeHandlerRequest: Request,
+		) => coreHandler(composeHandlerRequest, options);
 		for (let i = middleware.length - 1; i >= 0; i--) {
 			const m = middleware[i];
 			const resolvedMiddleware = m(options);
 			composedHandler = resolvedMiddleware(composedHandler, context);
 		}
+
 		return composedHandler(request);
 	};
 
@@ -60,13 +61,13 @@ type OptionToMiddleware<
 > = Options extends []
 	? []
 	: Options extends [infer LastOption]
-	  ? [Middleware<Request, Response, LastOption>]
-	  : Options extends [infer FirstOption, ...infer RestOptions]
-	    ? [
+		? [Middleware<Request, Response, LastOption>]
+		: Options extends [infer FirstOption, ...infer RestOptions]
+			? [
 					Middleware<Request, Response, FirstOption>,
 					...OptionToMiddleware<Request, Response, RestOptions>,
-	      ]
-	    : never;
+				]
+			: never;
 
 /**
  * Type to intersect multiple types if they have no conflict keys.
@@ -76,10 +77,10 @@ type MergeNoConflictKeys<Options extends any[]> = Options extends [
 ]
 	? OnlyOption
 	: Options extends [infer FirstOption, infer SecondOption]
-	  ? FirstOption & SecondOption
-	  : Options extends [infer FirstOption, ...infer RestOptions]
-	    ? FirstOption & MergeNoConflictKeys<RestOptions>
-	    : never;
+		? FirstOption & SecondOption
+		: Options extends [infer FirstOption, ...infer RestOptions]
+			? FirstOption & MergeNoConflictKeys<RestOptions>
+			: never;
 
 /**
  * Type to infer the option type of a transfer handler type.

package/src/clients/middleware/retry/defaultRetryDecider.ts

@@ -1,7 +1,8 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { HttpResponse, ErrorParser } from '../../types';
+import { ErrorParser, HttpResponse } from '../../types';
+
 import { isClockSkewError } from './isClockSkewError';
 
 /**
@@ -15,8 +16,9 @@ export const getRetryDecider =
 			(error as Error & { code: string }) ??
 			(await errorParser(response)) ??
 			undefined;
-		const errorCode = parsedError?.['code'];
+		const errorCode = parsedError?.code;
 		const statusCode = response?.statusCode;
+
 		return (
 			isConnectionError(error) ||
 			isThrottlingError(statusCode, errorCode) ||
@@ -53,7 +55,7 @@ const isThrottlingError = (statusCode?: number, errorCode?: string) =>
 	(!!errorCode && THROTTLING_ERROR_CODES.includes(errorCode));
 
 const isConnectionError = (error?: unknown) =>
-	(error as Error)?.['name'] === 'Network error';
+	(error as Error)?.name === 'Network error';
 
 const isServerSideError = (statusCode?: number, errorCode?: string) =>
 	(!!statusCode && [500, 502, 503, 504].includes(statusCode)) ||

package/src/clients/middleware/retry/index.ts

@@ -1,6 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export { RetryOptions, retryMiddleware } from './middleware';
+export { RetryOptions, retryMiddlewareFactory } from './middleware';
 export { jitteredBackoff } from './jitteredBackoff';
 export { getRetryDecider } from './defaultRetryDecider';

package/src/clients/middleware/retry/jitteredBackoff.ts

@@ -1,15 +1,17 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+import { jitteredBackoff as jitteredBackoffUtil } from '../../../utils';
+
 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 '../../../utils';
 
 const DEFAULT_MAX_DELAY_MS = 5 * 60 * 1000;
 
 export const jitteredBackoff: RetryOptions['computeDelay'] = attempt => {
 	const delayFunction = jitteredBackoffUtil(DEFAULT_MAX_DELAY_MS);
 	const delay = delayFunction(attempt);
+
 	// The delayFunction returns false when the delay is greater than the max delay(5 mins).
 	// In this case, the retry middleware will delay 5 mins instead, as a ceiling of the delay.
 	return delay === false ? DEFAULT_MAX_DELAY_MS : delay;

package/src/clients/middleware/retry/middleware.ts

@@ -21,14 +21,14 @@ export interface RetryOptions<TResponse = Response> {
 	 * @param error Optional error thrown from previous attempts.
 	 * @returns True if the request should be retried.
 	 */
-	retryDecider: (response?: TResponse, error?: unknown) => Promise<boolean>;
+	retryDecider(response?: TResponse, error?: unknown): Promise<boolean>;
 	/**
 	 * Function to compute the delay in milliseconds before the next retry based
 	 * on the number of attempts.
 	 * @param attempt Current number of attempts, including the first attempt.
 	 * @returns Delay in milliseconds.
 	 */
-	computeDelay: (attempt: number) => number;
+	computeDelay(attempt: number): number;
 	/**
 	 * Maximum number of retry attempts, starting from 1. Defaults to 3.
 	 */
@@ -42,7 +42,7 @@ export interface RetryOptions<TResponse = Response> {
 /**
  * Retry middleware
  */
-export const retryMiddleware = <TInput = Request, TOutput = Response>({
+export const retryMiddlewareFactory = <TInput = Request, TOutput = Response>({
 	maxAttempts = DEFAULT_RETRY_ATTEMPTS,
 	retryDecider,
 	computeDelay,
@@ -51,9 +51,10 @@ export const retryMiddleware = <TInput = Request, TOutput = Response>({
 	if (maxAttempts < 1) {
 		throw new Error('maxAttempts must be greater than 0');
 	}
+
 	return (
 		next: MiddlewareHandler<TInput, TOutput>,
-		context: MiddlewareContext
+		context: MiddlewareContext,
 	) =>
 		async function retryMiddleware(request: TInput) {
 			let error: unknown;
@@ -64,6 +65,7 @@ export const retryMiddleware = <TInput = Request, TOutput = Response>({
 			const handleTerminalErrorOrResponse = () => {
 				if (response) {
 					addOrIncrementMetadataAttempts(response, attemptsCount);
+
 					return response;
 				} else {
 					addOrIncrementMetadataAttempts(error as object, attemptsCount);
@@ -110,28 +112,29 @@ const cancellableSleep = (timeoutMs: number, abortSignal?: AbortSignal) => {
 		return Promise.resolve();
 	}
 	let timeoutId: ReturnType<typeof setTimeout>;
-	let sleepPromiseResolveFn: Function;
+	let sleepPromiseResolveFn: () => void;
 	const sleepPromise = new Promise<void>(resolve => {
 		sleepPromiseResolveFn = resolve;
 		timeoutId = setTimeout(resolve, timeoutMs);
 	});
-	abortSignal?.addEventListener('abort', function cancelSleep(event) {
+	abortSignal?.addEventListener('abort', function cancelSleep(_) {
 		clearTimeout(timeoutId);
 		abortSignal?.removeEventListener('abort', cancelSleep);
 		sleepPromiseResolveFn();
 	});
+
 	return sleepPromise;
 };
 
 const addOrIncrementMetadataAttempts = (
 	nextHandlerOutput: Record<string, any>,
-	attempts: number
+	attempts: number,
 ) => {
 	if (Object.prototype.toString.call(nextHandlerOutput) !== '[object Object]') {
 		return;
 	}
-	nextHandlerOutput['$metadata'] = {
-		...(nextHandlerOutput['$metadata'] ?? {}),
+	nextHandlerOutput.$metadata = {
+		...(nextHandlerOutput.$metadata ?? {}),
 		attempts,
 	};
 };

package/src/clients/middleware/signing/index.ts

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

package/src/clients/middleware/signing/middleware.ts

@@ -7,6 +7,7 @@ import {
 	HttpResponse,
 	MiddlewareHandler,
 } from '../../types';
+
 import { signRequest } from './signer/signatureV4';
 import { getSkewCorrectedDate } from './utils/getSkewCorrectedDate';
 import { getUpdatedSystemClockOffset } from './utils/getUpdatedSystemClockOffset';
@@ -32,13 +33,14 @@ export interface SigningOptions {
  * Middleware that SigV4 signs request with AWS credentials, and correct system clock offset.
  * This middleware is expected to be placed after retry middleware.
  */
-export const signingMiddleware = ({
+export const signingMiddlewareFactory = ({
 	credentials,
 	region,
 	service,
 	uriEscapePath = true,
 }: SigningOptions) => {
 	let currentSystemClockOffset: number;
+
 	return (next: MiddlewareHandler<HttpRequest, HttpResponse>) =>
 		async function signingMiddleware(request: HttpRequest) {
 			currentSystemClockOffset = currentSystemClockOffset ?? 0;
@@ -59,9 +61,10 @@ export const signingMiddleware = ({
 			if (dateString) {
 				currentSystemClockOffset = getUpdatedSystemClockOffset(
 					Date.parse(dateString),
-					currentSystemClockOffset
+					currentSystemClockOffset,
 				);
 			}
+
 			return response;
 		};
 };

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

@@ -1,7 +1,9 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { Presignable, PresignUrlOptions } from './types';
+import { AmplifyUrl } from '../../../../../utils/amplifyUrl';
+
+import { PresignUrlOptions, Presignable } from './types';
 import {
 	ALGORITHM_QUERY_PARAM,
 	AMZ_DATE_QUERY_PARAM,
@@ -15,7 +17,6 @@ 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.
@@ -26,14 +27,13 @@ import { AmplifyUrl } from '../../../../../utils/amplifyUrl';
  */
 export const presignUrl = (
 	{ body, method = 'GET', url }: Presignable,
-	{ expiration, ...options }: PresignUrlOptions
+	{ expiration, ...options }: PresignUrlOptions,
 ): URL => {
 	const signingValues = getSigningValues(options);
 	const { accessKeyId, credentialScope, longDate, sessionToken } =
 		signingValues;
 
 	// create the request to sign
-	// @ts-ignore URL constructor accepts a URL object
 	const presignedUrl = new AmplifyUrl(url);
 	Object.entries({
 		[ALGORITHM_QUERY_PARAM]: SHA256_ALGORITHM_IDENTIFIER,

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { HttpRequest } from '../../../../types';
+
 import { SignRequestOptions } from './types/signer';
 import { getSignedHeaders } from './utils/getSignedHeaders';
 import { getSigningValues } from './utils/getSigningValues';
@@ -23,7 +24,7 @@ import { getSignature } from './utils/getSignature';
  */
 export const signRequest = (
 	request: HttpRequest,
-	options: SignRequestOptions
+	options: SignRequestOptions,
 ): HttpRequest => {
 	const signingValues = getSigningValues(options);
 	const { accessKeyId, credentialScope, longDate, sessionToken } =