@aws-amplify/api-rest 0.0.0-unstable-1ca644b-20260128091132

package/dist/esm/utils/serviceError.mjs

@@ -0,0 +1,97 @@
+import { parseJsonError } from '@aws-amplify/core/internals/aws-client-utils';
+import { RestApiError } from '../errors/RestApiError.mjs';
+import '../errors/validation.mjs';
+
+/**
+ * Parses both AWS and non-AWS error responses coming from the users' backend code.
+ * * AWS errors generated by the AWS services(e.g. API Gateway, Bedrock). They can be Signature errors,
+ *   ClockSkew errors, etc. These responses will be parsed to errors with proper name and message from the AWS
+ *   services.
+ * * non-AWS errors thrown by the user code. They can contain any headers or body. Users need to access the
+ *   error.response to get the headers and body and parse them accordingly. The JS error name and message will
+ *   be `UnknownError` and `Unknown error` respectively.
+ */
+const parseRestApiServiceError = async (response) => {
+    if (!response) {
+        // Response is not considered an error.
+        return;
+    }
+    const parsedAwsError = await parseJsonError(stubErrorResponse(response));
+    if (!parsedAwsError) ;
+    else {
+        const bodyText = await response.body?.text();
+        return buildRestApiError(parsedAwsError, {
+            statusCode: response.statusCode,
+            headers: response.headers,
+            body: bodyText,
+        });
+    }
+};
+/**
+ * The response object needs to be stub here because the parseAwsJsonError assumes the response body to be valid JSON.
+ * Although this is true for AWS services, it is not true for responses from user's code. Once the response body is
+ * unwrapped as JSON(and fail), it cannot be read as text again. Therefore, we need to stub the response body here to
+ * make sure we can read the error response body as a JSON, and may fall back to read as text if it is not a valid JSON.
+ */
+const stubErrorResponse = (response) => {
+    let bodyTextPromise;
+    const bodyProxy = new Proxy(response.body, {
+        get(target, prop, receiver) {
+            if (prop === 'json') {
+                // For potential AWS errors, error parser will try to parse the body as JSON first.
+                return async () => {
+                    if (!bodyTextPromise) {
+                        bodyTextPromise = target.text();
+                    }
+                    try {
+                        return JSON.parse(await bodyTextPromise);
+                    }
+                    catch (error) {
+                        // If response body is not a valid JSON, we stub it to be an empty object and eventually parsed
+                        // as an unknown error
+                        return {};
+                    }
+                };
+            }
+            else if (prop === 'text') {
+                // For non-AWS errors, users can access the body as a string as a fallback.
+                return async () => {
+                    if (!bodyTextPromise) {
+                        bodyTextPromise = target.text();
+                    }
+                    return bodyTextPromise;
+                };
+            }
+            else {
+                return Reflect.get(target, prop, receiver);
+            }
+        },
+    });
+    const responseProxy = new Proxy(response, {
+        get(target, prop, receiver) {
+            if (prop === 'body') {
+                return bodyProxy;
+            }
+            else {
+                return Reflect.get(target, prop, receiver);
+            }
+        },
+    });
+    return responseProxy;
+};
+/**
+ * Utility to create a new RestApiError from a service error.
+ */
+const buildRestApiError = (error, response) => {
+    const restApiError = new RestApiError({
+        name: error?.name,
+        message: error.message,
+        underlyingError: error,
+        response,
+    });
+    // $metadata is only required for backwards compatibility.
+    return Object.assign(restApiError, { $metadata: error.$metadata });
+};
+
+export { parseRestApiServiceError };
+//# sourceMappingURL=serviceError.mjs.map

package/dist/esm/utils/serviceError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serviceError.mjs","sources":["../../../src/utils/serviceError.ts"],"sourcesContent":["import { parseJsonError as parseAwsJsonError, } from '@aws-amplify/core/internals/aws-client-utils';\nimport { RestApiError } from '../errors';\n/**\n * Parses both AWS and non-AWS error responses coming from the users' backend code.\n * * AWS errors generated by the AWS services(e.g. API Gateway, Bedrock). They can be Signature errors,\n *   ClockSkew errors, etc. These responses will be parsed to errors with proper name and message from the AWS\n *   services.\n * * non-AWS errors thrown by the user code. They can contain any headers or body. Users need to access the\n *   error.response to get the headers and body and parse them accordingly. The JS error name and message will\n *   be `UnknownError` and `Unknown error` respectively.\n */\nexport const parseRestApiServiceError = async (response) => {\n    if (!response) {\n        // Response is not considered an error.\n        return;\n    }\n    const parsedAwsError = await parseAwsJsonError(stubErrorResponse(response));\n    if (!parsedAwsError) {\n        // Response is not considered an error.\n    }\n    else {\n        const bodyText = await response.body?.text();\n        return buildRestApiError(parsedAwsError, {\n            statusCode: response.statusCode,\n            headers: response.headers,\n            body: bodyText,\n        });\n    }\n};\n/**\n * The response object needs to be stub here because the parseAwsJsonError assumes the response body to be valid JSON.\n * Although this is true for AWS services, it is not true for responses from user's code. Once the response body is\n * unwrapped as JSON(and fail), it cannot be read as text again. Therefore, we need to stub the response body here to\n * make sure we can read the error response body as a JSON, and may fall back to read as text if it is not a valid JSON.\n */\nconst stubErrorResponse = (response) => {\n    let bodyTextPromise;\n    const bodyProxy = new Proxy(response.body, {\n        get(target, prop, receiver) {\n            if (prop === 'json') {\n                // For potential AWS errors, error parser will try to parse the body as JSON first.\n                return async () => {\n                    if (!bodyTextPromise) {\n                        bodyTextPromise = target.text();\n                    }\n                    try {\n                        return JSON.parse(await bodyTextPromise);\n                    }\n                    catch (error) {\n                        // If response body is not a valid JSON, we stub it to be an empty object and eventually parsed\n                        // as an unknown error\n                        return {};\n                    }\n                };\n            }\n            else if (prop === 'text') {\n                // For non-AWS errors, users can access the body as a string as a fallback.\n                return async () => {\n                    if (!bodyTextPromise) {\n                        bodyTextPromise = target.text();\n                    }\n                    return bodyTextPromise;\n                };\n            }\n            else {\n                return Reflect.get(target, prop, receiver);\n            }\n        },\n    });\n    const responseProxy = new Proxy(response, {\n        get(target, prop, receiver) {\n            if (prop === 'body') {\n                return bodyProxy;\n            }\n            else {\n                return Reflect.get(target, prop, receiver);\n            }\n        },\n    });\n    return responseProxy;\n};\n/**\n * Utility to create a new RestApiError from a service error.\n */\nconst buildRestApiError = (error, response) => {\n    const restApiError = new RestApiError({\n        name: error?.name,\n        message: error.message,\n        underlyingError: error,\n        response,\n    });\n    // $metadata is only required for backwards compatibility.\n    return Object.assign(restApiError, { $metadata: error.$metadata });\n};\n"],"names":["parseAwsJsonError"],"mappings":"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"}

package/internals/package.json

@@ -0,0 +1,8 @@
+{
+	"name": "@aws-amplify/api-rest/internals",
+	"types": "../dist/esm/internals/index.d.ts",
+	"main": "../dist/cjs/internals/index.js",
+	"module": "../dist/esm/internals/index.mjs",
+	"react-native": "../dist/cjs/internals/index.js",
+	"sideEffects": false
+}

package/internals/server/package.json

@@ -0,0 +1,7 @@
+{
+	"name": "@aws-amplify/api-rest/internals/server",
+	"types": "../../dist/esm/internals/server.d.ts",
+	"main": "../../dist/cjs/internals/server.js",
+	"module": "../../dist/esm/internals/server.mjs",
+	"sideEffects": false
+}

package/package.json

@@ -0,0 +1,94 @@
+{
+	"name": "@aws-amplify/api-rest",
+	"private": false,
+	"version": "0.0.0-unstable-1ca644b-20260128091132",
+	"description": "Api-rest category of aws-amplify",
+	"main": "./dist/cjs/index.js",
+	"module": "./dist/esm/index.mjs",
+	"typings": "./dist/esm/index.d.ts",
+	"react-native": "./dist/cjs/index.js",
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"test": "npm run lint && jest -w 1 --coverage --logHeapUsage",
+		"test:watch": "jest -w 1 --watch",
+		"build-with-test": "npm test && npm build",
+		"build:umd": "webpack && webpack --config ./webpack.config.dev.js",
+		"build:esm-cjs": "rollup --forceExit -c rollup.config.mjs",
+		"build:watch": "npm run build:esm-cjs -- --watch",
+		"build": "npm run clean && npm run build:esm-cjs && npm run build:umd",
+		"clean": "npm run clean:size && rimraf dist lib lib-esm",
+		"clean:size": "rimraf dual-publish-tmp tmp*",
+		"format": "echo \"Not implemented\"",
+		"lint": "eslint '**/*.{ts,tsx}' && npm run ts-coverage",
+		"lint:fix": "eslint '**/*.{ts,tsx}' --fix",
+		"ts-coverage": "typescript-coverage-report -p ./tsconfig.build.json -t 70.0"
+	},
+	"exports": {
+		".": {
+			"react-native": "./dist/cjs/index.js",
+			"types": "./dist/esm/index.d.ts",
+			"import": "./dist/esm/index.mjs",
+			"require": "./dist/cjs/index.js"
+		},
+		"./server": {
+			"types": "./dist/esm/server.d.ts",
+			"import": "./dist/esm/server.mjs",
+			"require": "./dist/cjs/server.js"
+		},
+		"./internals": {
+			"react-native": "./dist/cjs/internals/index.js",
+			"types": "./dist/esm/internals/index.d.ts",
+			"import": "./dist/esm/internals/index.mjs",
+			"require": "./dist/cjs/internals/index.js"
+		},
+		"./internals/server": {
+			"types": "./dist/esm/internals/server.d.ts",
+			"import": "./dist/esm/internals/server.mjs",
+			"require": "./dist/cjs/internals/server.js"
+		},
+		"./package.json": "./package.json"
+	},
+	"typesVersions": {
+		">=4.2": {
+			"server": [
+				"./dist/esm/server.d.ts"
+			],
+			"internals": [
+				"./dist/esm/internals/index.d.ts"
+			],
+			"internals/server": [
+				"./dist/esm/internals/server.d.ts"
+			]
+		}
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/aws-amplify/amplify-js.git"
+	},
+	"author": "Amazon Web Services",
+	"license": "Apache-2.0",
+	"bugs": {
+		"url": "https://github.com/aws/aws-amplify/issues"
+	},
+	"homepage": "https://aws-amplify.github.io/",
+	"files": [
+		"dist/cjs",
+		"dist/esm",
+		"src",
+		"internals",
+		"server"
+	],
+	"dependencies": {
+		"tslib": "^2.5.0"
+	},
+	"peerDependencies": {
+		"@aws-amplify/core": "0.0.0-unstable-1ca644b-20260128091132"
+	},
+	"devDependencies": {
+		"@aws-amplify/core": "0.0.0-unstable-1ca644b-20260128091132",
+		"@aws-amplify/react-native": "0.0.0-unstable-1ca644b-20260128091132",
+		"@aws-sdk/types": "3.723.0"
+	}
+}

package/server/package.json

@@ -0,0 +1,7 @@
+{
+	"name": "@aws-amplify/api-rest/server",
+	"types": "../dist/esm/server.d.ts",
+	"main": "../dist/cjs/server.js",
+	"module": "../dist/esm/server.mjs",
+	"sideEffects": false
+}

package/src/apis/common/baseHandlers/authenticatedHandler.ts

@@ -0,0 +1,28 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import {
+	HttpRequest,
+	HttpResponse,
+	RetryOptions,
+	SigningOptions,
+	UserAgentOptions,
+	fetchTransferHandler,
+	retryMiddlewareFactory,
+	signingMiddlewareFactory,
+	userAgentMiddlewareFactory,
+} from '@aws-amplify/core/internals/aws-client-utils';
+import { composeTransferHandler } from '@aws-amplify/core/internals/aws-client-utils/composers';
+
+/**
+ * @internal
+ */
+export const authenticatedHandler = composeTransferHandler<
+	[UserAgentOptions, RetryOptions<HttpResponse>, SigningOptions],
+	HttpRequest,
+	HttpResponse,
+	typeof fetchTransferHandler
+>(fetchTransferHandler, [
+	userAgentMiddlewareFactory,
+	retryMiddlewareFactory,
+	signingMiddlewareFactory,
+]);

package/src/apis/common/baseHandlers/unauthenticatedHandler.ts

@@ -0,0 +1,22 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import {
+	HttpRequest,
+	HttpResponse,
+	RetryOptions,
+	UserAgentOptions,
+	fetchTransferHandler,
+	retryMiddlewareFactory,
+	userAgentMiddlewareFactory,
+} from '@aws-amplify/core/internals/aws-client-utils';
+import { composeTransferHandler } from '@aws-amplify/core/internals/aws-client-utils/composers';
+
+/**
+ * @internal
+ */
+export const unauthenticatedHandler = composeTransferHandler<
+	[UserAgentOptions, RetryOptions<HttpResponse>],
+	HttpRequest,
+	HttpResponse,
+	typeof fetchTransferHandler
+>(fetchTransferHandler, [userAgentMiddlewareFactory, retryMiddlewareFactory]);

package/src/apis/common/internalPost.ts

@@ -0,0 +1,123 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AmplifyClassV6 } from '@aws-amplify/core';
+
+import { InternalPostInput, RestApiResponse } from '../../types';
+import { createCancellableOperation } from '../../utils';
+import { CanceledError } from '../../errors';
+import { isIamAuthApplicableForGraphQL } from '../../utils/isIamAuthApplicable';
+
+import { transferHandler } from './transferHandler';
+
+/**
+ * This weak map provides functionality to cancel a request given the promise containing the `post` request.
+ *
+ * 1. For every GraphQL POST request, an abort controller is created and supplied to the request.
+ * 2. The promise fulfilled by GraphGL POST request is then mapped to that abort controller.
+ * 3. The promise is returned to the external caller.
+ * 4. The caller can either wait for the promise to fulfill or call `cancel(promise)` to cancel the request.
+ * 5. If `cancel(promise)` is called, then the corresponding abort controller is retrieved from the map below.
+ * 6. GraphQL POST request will be rejected with the error message provided during cancel.
+ * 7. Caller can check if the error is because of cancelling by calling `isCancelError(error)`.
+ */
+const cancelTokenMap = new WeakMap<Promise<any>, AbortController>();
+
+/**
+ * @internal
+ *
+ * REST POST handler to send GraphQL request to given endpoint. By default, it will use IAM to authorize
+ * the request. In some auth modes, the IAM auth has to be disabled. Here's how to set up the request auth correctly:
+ * * If auth mode is 'iam', you MUST NOT set 'authorization' header and 'x-api-key' header, since it would disable IAM
+ *   auth. You MUST also set 'input.options.signingServiceInfo' option.
+ *   * The including 'input.options.signingServiceInfo.service' and 'input.options.signingServiceInfo.region' are
+ *     optional. If omitted, the signing service and region will be inferred from url.
+ * * If auth mode is 'none', you MUST NOT set 'options.signingServiceInfo' option.
+ * * If auth mode is 'apiKey', you MUST set 'x-api-key' custom header.
+ * * If auth mode is 'oidc' or 'lambda' or 'userPool', you MUST set 'authorization' header.
+ *
+ * To make the internal post cancellable, you must also call `updateRequestToBeCancellable()` with the promise from
+ * internal post call and the abort controller supplied to the internal post call.
+ *
+ * @param amplify the AmplifyClassV6 instance - it may be the singleton used on Web, or an instance created within
+ * a context created by `runWithAmplifyServerContext`
+ * @param postInput an object of {@link InternalPostInput}
+ * @param postInput.url The URL that the POST request sends to
+ * @param postInput.options Options of the POST request
+ * @param postInput.abortController The abort controller used to cancel the POST request
+ * @returns a {@link RestApiResponse}
+ *
+ * @throws an {@link AmplifyError} with `Network Error` as the `message` when the external resource is unreachable due to one
+ * of the following reasons:
+ *   1. no network connection
+ *   2. CORS error
+ * @throws a {@link CanceledError} when the ongoing POST request get cancelled
+ */
+export const post = (
+	amplify: AmplifyClassV6,
+	{ url, options, abortController }: InternalPostInput,
+): Promise<RestApiResponse> => {
+	const controller = abortController ?? new AbortController();
+	const responsePromise = createCancellableOperation(
+		async () => {
+			const response = transferHandler(
+				amplify,
+				{
+					url,
+					method: 'POST',
+					...options,
+					abortSignal: controller.signal,
+					retryStrategy: {
+						strategy: 'jittered-exponential-backoff',
+					},
+				},
+				isIamAuthApplicableForGraphQL,
+				options?.signingServiceInfo,
+			);
+
+			return response;
+		},
+		controller,
+		'internal', // operation Type
+	);
+
+	const responseWithCleanUp = responsePromise.finally(() => {
+		cancelTokenMap.delete(responseWithCleanUp);
+	});
+
+	return responseWithCleanUp;
+};
+
+/**
+ * Cancels a request given the promise returned by `post`.
+ * If the request is already completed, this function does nothing.
+ * It MUST be used after `updateRequestToBeCancellable` is called.
+ */
+export const cancel = (
+	promise: Promise<RestApiResponse>,
+	message?: string,
+): boolean => {
+	const controller = cancelTokenMap.get(promise);
+	if (controller) {
+		controller.abort(message);
+		if (message && controller.signal.reason !== message) {
+			// In runtimes where `AbortSignal.reason` is not supported, we track the reason ourselves.
+			// @ts-expect-error reason is read-only property.
+			controller.signal.reason = message;
+		}
+
+		return true;
+	}
+
+	return false;
+};
+
+/**
+ * MUST be used to make a promise including internal `post` API call cancellable.
+ */
+export const updateRequestToBeCancellable = (
+	promise: Promise<any>,
+	controller: AbortController,
+) => {
+	cancelTokenMap.set(promise, controller);
+};

package/src/apis/common/publicApis.ts

@@ -0,0 +1,118 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AmplifyClassV6 } from '@aws-amplify/core';
+
+import {
+	ApiInput,
+	DeleteInput,
+	DeleteOperation,
+	GetInput,
+	GetOperation,
+	HeadInput,
+	HeadOperation,
+	PatchInput,
+	PatchOperation,
+	PostInput,
+	PostOperation,
+	PutInput,
+	PutOperation,
+	RestApiOptionsBase,
+} from '../../types';
+import {
+	createCancellableOperation,
+	logger,
+	parseSigningInfo,
+	resolveApiUrl,
+} from '../../utils';
+import { isIamAuthApplicableForRest } from '../../utils/isIamAuthApplicable';
+
+import { transferHandler } from './transferHandler';
+
+const publicHandler = (
+	amplify: AmplifyClassV6,
+	options: ApiInput<RestApiOptionsBase>,
+	method: string,
+) => {
+	const { apiName, options: apiOptions = {}, path: apiPath } = options;
+	const libraryConfigTimeout = amplify.libraryOptions?.API?.REST?.timeout?.({
+		apiName,
+		method,
+	});
+	const timeout = apiOptions?.timeout || libraryConfigTimeout || undefined;
+	const publicApisAbortController = new AbortController();
+	const abortSignal = publicApisAbortController.signal;
+
+	return createCancellableOperation(
+		async () => {
+			const url = resolveApiUrl(
+				amplify,
+				apiName,
+				apiPath,
+				apiOptions?.queryParams,
+			);
+			const libraryConfigHeaders =
+				await amplify.libraryOptions?.API?.REST?.headers?.({
+					apiName,
+				});
+			const { headers: invocationHeaders = {} } = apiOptions;
+			const headers = {
+				// custom headers from invocation options should precede library options
+				...libraryConfigHeaders,
+				...invocationHeaders,
+			};
+			const signingServiceInfo = parseSigningInfo(url, {
+				amplify,
+				apiName,
+			});
+			logger.debug(
+				method,
+				url,
+				headers,
+				`IAM signing options: ${JSON.stringify(signingServiceInfo)}`,
+			);
+
+			return transferHandler(
+				amplify,
+				{
+					...apiOptions,
+					url,
+					method,
+					headers,
+					abortSignal,
+				},
+				isIamAuthApplicableForRest,
+				signingServiceInfo,
+			);
+		},
+		publicApisAbortController,
+		'public', // operation Type
+		timeout,
+	);
+};
+
+export const get = (amplify: AmplifyClassV6, input: GetInput): GetOperation =>
+	publicHandler(amplify, input, 'GET');
+
+export const post = (
+	amplify: AmplifyClassV6,
+	input: PostInput,
+): PostOperation => publicHandler(amplify, input, 'POST');
+
+export const put = (amplify: AmplifyClassV6, input: PutInput): PutOperation =>
+	publicHandler(amplify, input, 'PUT');
+
+export const del = (
+	amplify: AmplifyClassV6,
+	input: DeleteInput,
+): DeleteOperation => publicHandler(amplify, input, 'DELETE');
+
+export const head = (
+	amplify: AmplifyClassV6,
+	input: HeadInput,
+): HeadOperation => publicHandler(amplify, input, 'HEAD');
+
+export const patch = (
+	amplify: AmplifyClassV6,
+	input: PatchInput,
+): PatchOperation => publicHandler(amplify, input, 'PATCH');

package/src/apis/common/transferHandler.ts

@@ -0,0 +1,154 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AmplifyClassV6 } from '@aws-amplify/core';
+import {
+	Headers,
+	HttpRequest,
+	RetryOptions,
+	getRetryDecider,
+	jitteredBackoff,
+} from '@aws-amplify/core/internals/aws-client-utils';
+import {
+	AWSCredentials,
+	DocumentType,
+	RESTAuthMode,
+	RetryStrategy,
+} from '@aws-amplify/core/internals/utils';
+
+import {
+	logger,
+	parseRestApiServiceError,
+	parseSigningInfo,
+	resolveLibraryOptions,
+} from '../../utils';
+import { resolveHeaders } from '../../utils/resolveHeaders';
+import { RestApiResponse, SigningServiceInfo } from '../../types';
+
+import { authenticatedHandler } from './baseHandlers/authenticatedHandler';
+import { unauthenticatedHandler } from './baseHandlers/unauthenticatedHandler';
+
+type HandlerOptions = Omit<HttpRequest, 'body' | 'headers'> & {
+	body?: DocumentType | FormData;
+	headers?: Headers;
+	withCredentials?: boolean;
+	retryStrategy?: RetryStrategy;
+	defaultAuthMode?: RESTAuthMode;
+};
+
+type RetryDecider = RetryOptions['retryDecider'];
+
+/**
+ * Make REST API call with best-effort IAM auth.
+ * @param amplify Amplify instance to to resolve credentials and tokens. Should use different instance in client-side
+ *   and SSR
+ * @param options Options accepted from public API options when calling the handlers.
+ * @param signingServiceInfo Internal-only options enable IAM auth as well as to to overwrite the IAM signing service
+ *   and region. If specified, and NONE of API Key header or Auth header is present, IAM auth will be used.
+ * @param iamAuthApplicable Callback function that is used to determine if IAM Auth should be used or not.
+ *
+ * @internal
+ */
+export const transferHandler = async (
+	amplify: AmplifyClassV6,
+	options: HandlerOptions & { abortSignal: AbortSignal },
+	iamAuthApplicable: (
+		{ headers }: HttpRequest,
+		signingServiceInfo?: SigningServiceInfo,
+	) => boolean,
+	signingServiceInfo?: SigningServiceInfo,
+): Promise<RestApiResponse> => {
+	const {
+		url,
+		method,
+		headers,
+		body,
+		withCredentials,
+		abortSignal,
+		retryStrategy,
+	} = options;
+	const resolvedBody = body
+		? body instanceof FormData
+			? body
+			: JSON.stringify(body ?? '')
+		: undefined;
+	const resolvedHeaders: Headers = resolveHeaders(headers, body);
+	const request = {
+		url,
+		headers: resolvedHeaders,
+		method,
+		body: resolvedBody,
+	};
+	const {
+		retryStrategy: libraryRetryStrategy,
+		defaultAuthMode: libraryDefaultAuthMode,
+	} = resolveLibraryOptions(amplify);
+	const baseOptions = {
+		retryDecider: getRetryDeciderFromStrategy(
+			retryStrategy ?? libraryRetryStrategy,
+		),
+		computeDelay: jitteredBackoff,
+		withCrossDomainCredentials: withCredentials,
+		abortSignal,
+	};
+
+	const defaultAuthMode = options.defaultAuthMode ?? libraryDefaultAuthMode;
+
+	let credentials: AWSCredentials | null = null;
+	if (defaultAuthMode !== 'none') {
+		credentials = await resolveCredentials(amplify);
+	}
+
+	let response: RestApiResponse;
+	const isIamAuthApplicable = iamAuthApplicable(request, signingServiceInfo);
+
+	if (isIamAuthApplicable && credentials) {
+		const signingInfoFromUrl = parseSigningInfo(url);
+		const signingService =
+			signingServiceInfo?.service ?? signingInfoFromUrl.service;
+		const signingRegion =
+			signingServiceInfo?.region ?? signingInfoFromUrl.region;
+		response = await authenticatedHandler(request, {
+			...baseOptions,
+			credentials,
+			region: signingRegion,
+			service: signingService,
+		});
+	} else {
+		response = await unauthenticatedHandler(request, {
+			...baseOptions,
+		});
+	}
+
+	// Clean-up un-modeled properties from response.
+	return {
+		statusCode: response.statusCode,
+		headers: response.headers,
+		body: response.body,
+	};
+};
+
+const getRetryDeciderFromStrategy = (
+	retryStrategy: RetryStrategy | undefined,
+): RetryDecider => {
+	const strategy = retryStrategy?.strategy;
+	if (strategy === 'no-retry') {
+		return () => Promise.resolve({ retryable: false });
+	}
+
+	return getRetryDecider(parseRestApiServiceError);
+};
+
+const resolveCredentials = async (
+	amplify: AmplifyClassV6,
+): Promise<AWSCredentials | null> => {
+	try {
+		const { credentials } = await amplify.Auth.fetchAuthSession();
+		if (credentials) {
+			return credentials;
+		}
+	} catch (e) {
+		logger.debug('No credentials available, the request will be unsigned.');
+	}
+
+	return null;
+};