@aws-amplify/api-rest 4.0.1-console-preview.a1c533e.0 → 4.0.1-console-preview.23dc225.0

package/lib-esm/utils/resolveApiUrl.js

@@ -1,6 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { __assign, __read } from "tslib";
+import { AmplifyUrl, AmplifyUrlSearchParams, } from '@aws-amplify/core/internals/utils';
 import { RestApiError, RestApiValidationErrorCode, assertValidationError, validationErrorMap, } from '../errors';
 /**
  * Resolve the REST API request URL by:
@@ -17,14 +18,14 @@ export var resolveApiUrl = function (amplify, apiName, path, queryParams) {
     var urlStr = (_d = (_c = (_b = (_a = amplify.getConfig()) === null || _a === void 0 ? void 0 : _a.API) === null || _b === void 0 ? void 0 : _b.REST) === null || _c === void 0 ? void 0 : _c[apiName]) === null || _d === void 0 ? void 0 : _d.endpoint;
     assertValidationError(!!urlStr, RestApiValidationErrorCode.InvalidApiName);
     try {
-        var url = new URL(urlStr + path);
+        var url = new AmplifyUrl(urlStr + path);
         if (queryParams) {
-            var mergedQueryParams_1 = new URLSearchParams(url.searchParams);
+            var mergedQueryParams_1 = new AmplifyUrlSearchParams(url.searchParams);
             Object.entries(queryParams).forEach(function (_a) {
                 var _b = __read(_a, 2), key = _b[0], value = _b[1];
                 mergedQueryParams_1.set(key, value);
             });
-            url.search = new URLSearchParams(mergedQueryParams_1).toString();
+            url.search = new AmplifyUrlSearchParams(mergedQueryParams_1).toString();
         }
         return url;
     }

package/lib-esm/utils/resolveCredentials.d.ts

@@ -2,9 +2,4 @@ import { AmplifyClassV6 } from '@aws-amplify/core';
 /**
  * @internal
  */
-export declare const resolveCredentials: (amplify: AmplifyClassV6) => Promise<{
-    accessKeyId: string;
-    secretAccessKey: string;
-    sessionToken?: string | undefined;
-    expiration?: Date | undefined;
-}>;
+export declare const resolveCredentials: (amplify: AmplifyClassV6) => Promise<import("@aws-amplify/core/lib-esm/libraryUtils").AWSCredentials>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-amplify/api-rest",
   "private": false,
-  "version": "4.0.1-console-preview.a1c533e.0+a1c533e",
+  "version": "4.0.1-console-preview.23dc225.0+23dc225",
   "description": "Api-rest category of aws-amplify",
   "main": "./lib/index.js",
   "module": "./lib-esm/index.js",
@@ -52,11 +52,11 @@
     "tslib": "^2.5.0"
   },
   "peerDependencies": {
-    "@aws-amplify/core": "6.0.1-console-preview.a1c533e.0+a1c533e"
+    "@aws-amplify/core": "6.0.1-console-preview.23dc225.0+23dc225"
   },
   "devDependencies": {
-    "@aws-amplify/core": "6.0.1-console-preview.a1c533e.0+a1c533e",
-    "@aws-amplify/react-native": "1.0.1-console-preview.a1c533e.0+a1c533e",
+    "@aws-amplify/core": "6.0.1-console-preview.23dc225.0+23dc225",
+    "@aws-amplify/react-native": "1.0.1-console-preview.23dc225.0+23dc225",
     "typescript": "5.0.2"
   },
   "size-limit": [
@@ -111,5 +111,5 @@
       "<rootDir>/setupTests.ts"
     ]
   },
-  "gitHead": "a1c533eae82c5386864fb15fc101bb3cb9bd93ae"
+  "gitHead": "23dc22531b963319f2b421f6f7c6cf867635b20e"
 }

package/src/apis/common/handler.ts

@@ -76,6 +76,7 @@ export const transferHandler = async (
 	};
 
 	const isIamAuthApplicable = iamAuthApplicable(request, signingServiceInfo);
+	let response: RestApiResponse;
 	if (isIamAuthApplicable) {
 		const signingInfoFromUrl = parseSigningInfo(url);
 		const signingService =
@@ -83,17 +84,23 @@ export const transferHandler = async (
 		const signingRegion =
 			signingServiceInfo?.region ?? signingInfoFromUrl.region;
 		const credentials = await resolveCredentials(amplify);
-		return await authenticatedHandler(request, {
+		response = await authenticatedHandler(request, {
 			...baseOptions,
 			credentials,
 			region: signingRegion,
 			service: signingService,
 		});
 	} else {
-		return await unauthenticatedHandler(request, {
+		response = await unauthenticatedHandler(request, {
 			...baseOptions,
 		});
 	}
+	// Clean-up un-modeled properties from response.
+	return {
+		statusCode: response.statusCode,
+		headers: response.headers,
+		body: response.body,
+	};
 };
 
 const iamAuthApplicable = (

package/src/apis/common/internalPost.ts

@@ -60,7 +60,7 @@ export const cancel = (
 	const controller = cancelTokenMap.get(promise);
 	if (controller) {
 		controller.abort(message);
-		if (controller.signal.reason !== 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;

package/src/apis/index.ts

@@ -24,37 +24,216 @@ import {
 	PutInput,
 	PutOperation,
 } from '../types';
+import { RestApiError } from '../errors';
 
 /**
  * GET HTTP request
+ * @param {GetInput} input - Input for GET operation
+ * @returns {GetOperation} Operation for GET request
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a GET request
+ * ```js
+ * import { get, isCancelError } from '@aws-amplify/api';
+ *
+ * const { body } = await get({
+ *   apiName,
+ *   path,
+ *   options: {
+ *     headers, // Optional, A map of custom header key/values
+ *     body, // Optional, JSON object or FormData
+ *     queryParams, // Optional, A map of query strings
+ *   }
+ * }).response;
+ * const data = await body.json();
+ * ```
+ * @example
+ * Cancel a GET request
+ *
+ * ```js
+ * import { get, isCancelError } from '@aws-amplify/api';
+ *
+ * const { response, cancel } = get({apiName, path, options});
+ * cancel(message);
+ * try {
+ *   await response;
+ * } cache (e) {
+ *   if (isCancelError(e)) {
+ *    // handle request cancellation
+ *   }
+ *   //...
+ * }
+ * ```
  */
 export const get = (input: GetInput): GetOperation => commonGet(Amplify, input);
 
 /**
  * POST HTTP request
+ * @param {PostInput} input - Input for POST operation
+ * @returns {PostOperation} Operation for POST request
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a POST request
+ * ```js
+ * import { post, isCancelError } from '@aws-amplify/api';
+ *
+ * const { body } = await post({
+ *   apiName,
+ *   path,
+ *   options: {
+ *     headers, // Optional, A map of custom header key/values
+ *     body, // Optional, JSON object or FormData
+ *     queryParams, // Optional, A map of query strings
+ *   }
+ * }).response;
+ * const data = await body.json();
+ * ```
+ * @example
+ * Cancel a POST request
+ *
+ * ```js
+ * import { post, isCancelError } from '@aws-amplify/api';
+ *
+ * const { response, cancel } = post({apiName, path, options});
+ * cancel(message);
+ * try {
+ *   await response;
+ * } cache (e) {
+ *   if (isCancelError(e)) {
+ *    // handle request cancellation
+ *   }
+ *   //...
+ * }
+ * ```
  */
 export const post = (input: PostInput): PostOperation =>
 	commonPost(Amplify, input);
 
 /**
  * PUT HTTP request
+ * @param {PutInput} input - Input for PUT operation
+ * @returns {PutOperation} Operation for PUT request
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a PUT request
+ * ```js
+ * import { put, isCancelError } from '@aws-amplify/api';
+ *
+ * const { body } = await put({
+ *   apiName,
+ *   path,
+ *   options: {
+ *     headers, // Optional, A map of custom header key/values
+ *     body, // Optional, JSON object or FormData
+ *     queryParams, // Optional, A map of query strings
+ *   }
+ * }).response;
+ * const data = await body.json();
+ * ```
+ * @example
+ * Cancel a PUT request
+ * ```js
+ * import { put, isCancelError } from '@aws-amplify/api';
+ *
+ * const { response, cancel } = put({apiName, path, options});
+ * cancel(message);
+ * try {
+ *  await response;
+ * } cache (e) {
+ *   if (isCancelError(e)) {
+ *     // handle request cancellation
+ *   }
+ * //...
+ * }
+ * ```
  */
 export const put = (input: PutInput): PutOperation => commonPut(Amplify, input);
 
 /**
  * DELETE HTTP request
+ * @param {DeleteInput} input - Input for DELETE operation
+ * @returns {DeleteOperation} Operation for DELETE request
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a DELETE request
+ * ```js
+ * import { del } from '@aws-amplify/api';
+ *
+ * const { statusCode } = await del({
+ *   apiName,
+ *   path,
+ *   options: {
+ *     headers, // Optional, A map of custom header key/values
+ *     queryParams, // Optional, A map of query strings
+ *   }
+ * }).response;
+ * ```
  */
 export const del = (input: DeleteInput): DeleteOperation =>
 	commonDel(Amplify, input);
 
 /**
  * HEAD HTTP request
+ * @param {HeadInput} input - Input for HEAD operation
+ * @returns {HeadOperation} Operation for HEAD request
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a HEAD request
+ * ```js
+ * import { head, isCancelError } from '@aws-amplify/api';
+ *
+ * const { headers, statusCode } = await head({
+ *   apiName,
+ *   path,
+ *   options: {
+ *     headers, // Optional, A map of custom header key/values
+ *     queryParams, // Optional, A map of query strings
+ *   }
+ * }),response;
+ * ```
+ *
  */
 export const head = (input: HeadInput): HeadOperation =>
 	commonHead(Amplify, input);
 
 /**
  * PATCH HTTP request
+ * @param {PatchInput} input - Input for PATCH operation
+ * @returns {PatchOperation} Operation for PATCH request
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a PATCH request
+ * ```js
+ * import { patch } from '@aws-amplify/api';
+ *
+ * const { body } = await patch({
+ *   apiName,
+ *   path,
+ *   options: {
+ *     headers, // Optional, A map of custom header key/values
+ *     body, // Optional, JSON object or FormData
+ *     queryParams, // Optional, A map of query strings
+ *   }
+ * }).response;
+ * const data = await body.json();
+ * ```
+ *
+ * @example
+ * Cancel a PATCH request
+ * ```js
+ * import { patch, isCancelError } from '@aws-amplify/api';
+ *
+ * const { response, cancel } = patch({apiName, path, options});
+ * cancel(message);
+ * try {
+ *  await response;
+ * } cache (e) {
+ *  if (isCancelError(e)) {
+ *   // handle request cancellation
+ *  }
+ * //...
+ * }
+ * ```
  */
 export const patch = (input: PatchInput): PatchOperation =>
 	commonPatch(Amplify, input);

package/src/apis/server.ts

@@ -27,9 +27,32 @@ import {
 	PutInput,
 	PutOperation,
 } from '../types';
+import { RestApiError } from '../errors';
 
 /**
  * GET HTTP request (server-side)
+ * @param {AmplifyServer.ContextSpec} contextSpec - The context spec used to get the Amplify server context.
+ * @param {GetInput} input - Input for GET operation.
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a GET request
+ * ```js
+ * import { get } from 'aws-amplify/api/server';
+ * //...
+ * const restApiResponse = await runWithAmplifyServerContext({
+ *   nextServerContext: { request, response },
+ *   operation: async (contextSpec) => {
+ *     try {
+ *       const { body } = await get(contextSpec, input).response;
+ *       return await body.json();
+ *     } catch (error) {
+ *       console.log(error);
+ *       return false;
+ *     }
+ *   },
+ * });
+ * ```
+ * @see {@link clientGet}
  */
 export const get = (
 	contextSpec: AmplifyServer.ContextSpec,
@@ -39,6 +62,27 @@ export const get = (
 
 /**
  * POST HTTP request (server-side)
+ * @param {AmplifyServer.ContextSpec} contextSpec - The context spec used to get the Amplify server context.
+ * @param {PostInput} input - Input for POST operation.
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a POST request
+ * ```js
+ * import { post } from 'aws-amplify/api/server';
+ * //...
+ * const restApiResponse = await runWithAmplifyServerContext({
+ *   nextServerContext: { request, response },
+ *   operation: async (contextSpec) => {
+ *     try {
+ *       const { body } = await post(contextSpec, input).response;
+ *       return await body.json();
+ *     } catch (error) {
+ *       console.log(error);
+ *       return false;
+ *     }
+ *   },
+ * });
+ * ```
  */
 export const post = (
 	contextSpec: AmplifyServer.ContextSpec,
@@ -48,6 +92,27 @@ export const post = (
 
 /**
  * PUT HTTP request (server-side)
+ * @param {AmplifyServer.ContextSpec} contextSpec - The context spec used to get the Amplify server context.
+ * @param {PutInput} input - Input for PUT operation.
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a PUT request
+ * ```js
+ * import { put } from 'aws-amplify/api/server';
+ * //...
+ * const restApiResponse = await runWithAmplifyServerContext({
+ *   nextServerContext: { request, response },
+ *   operation: async (contextSpec) => {
+ *     try {
+ *       const { body } = await put(contextSpec, input).response;
+ *       return await body.json();
+ *     } catch (error) {
+ *       console.log(error);
+ *       return false;
+ *     }
+ *   },
+ * });
+ * ```
  */
 export const put = (
 	contextSpec: AmplifyServer.ContextSpec,
@@ -57,6 +122,26 @@ export const put = (
 
 /**
  * DELETE HTTP request (server-side)
+ * @param {AmplifyServer.ContextSpec} contextSpec - The context spec used to get the Amplify server context.
+ * @param {DeleteInput} input - Input for DELETE operation.
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a DELETE request
+ * ```js
+ * import { del } from 'aws-amplify/api/server';
+ * //...
+ * const restApiResponse = await runWithAmplifyServerContext({
+ *   nextServerContext: { request, response },
+ *   operation: async (contextSpec) => {
+ *     try {
+ *       const { headers } = await del(contextSpec, input).response;
+ *     } catch (error) {
+ *       console.log(error);
+ *       return false;
+ *     }
+ *   },
+ * });
+ * ```
  */
 export const del = (
 	contextSpec: AmplifyServer.ContextSpec,
@@ -66,6 +151,26 @@ export const del = (
 
 /**
  * HEAD HTTP request (server-side)
+ * @param {AmplifyServer.ContextSpec} contextSpec - The context spec used to get the Amplify server context.
+ * @param {HeadInput} input - Input for HEAD operation.
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a HEAD request
+ * ```js
+ * import { head } from 'aws-amplify/api/server';
+ * //...
+ * const restApiResponse = await runWithAmplifyServerContext({
+ *   nextServerContext: { request, response },
+ *   operation: async (contextSpec) => {
+ *     try {
+ *       const { headers } = await head(contextSpec, input).response;
+ *     } catch (error) {
+ *       console.log(error);
+ *       return false;
+ *     }
+ *   },
+ * });
+ * ```
  */
 export const head = (
 	contextSpec: AmplifyServer.ContextSpec,
@@ -75,6 +180,27 @@ export const head = (
 
 /**
  * PATCH HTTP request (server-side)
+ * @param {AmplifyServer.ContextSpec} contextSpec - The context spec used to get the Amplify server context.
+ * @param {PatchInput} input - Input for PATCH operation.
+ * @throws - {@link RestApiError}
+ * @example
+ * Send a PATCH request
+ * ```js
+ * import { patch } from 'aws-amplify/api/server';
+ * //...
+ * const restApiResponse = await runWithAmplifyServerContext({
+ *   nextServerContext: { request, response },
+ *   operation: async (contextSpec) => {
+ *     try {
+ *       const { body } = await patch(contextSpec, input).response;
+ *       return await body.json();
+ *     } catch (error) {
+ *       console.log(error);
+ *       return false;
+ *     }
+ *   },
+ * });
+ * ```
  */
 export const patch = (
 	contextSpec: AmplifyServer.ContextSpec,

package/src/errors/CanceledError.ts

@@ -0,0 +1,33 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AmplifyErrorParams } from '@aws-amplify/core/internals/utils';
+import { RestApiError } from './RestApiError';
+
+/**
+ * Internal-only class for CanceledError.
+ *
+ * @internal
+ */
+export class CanceledError extends RestApiError {
+	constructor(params: Partial<AmplifyErrorParams> = {}) {
+		super({
+			name: 'CanceledError',
+			message: 'Request is canceled by user',
+			...params,
+		});
+
+		// TODO: Delete the following 2 lines after we change the build target to >= es2015
+		this.constructor = CanceledError;
+		Object.setPrototypeOf(this, CanceledError.prototype);
+	}
+}
+
+/**
+ * Check if an error is caused by user calling `cancel()` in REST API.
+ *
+ * @note This function works **ONLY** for errors thrown by REST API. For GraphQL APIs, use `client.isCancelError(error)`
+ *   instead. `client` is generated from  `generateClient()` API from `aws-amplify/api`.
+ */
+export const isCancelError = (error: unknown): error is CanceledError =>
+	!!error && error instanceof CanceledError;

package/src/errors/index.ts

@@ -1,7 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export { CancelledError, isCancelError } from './CancelledError';
+export { CanceledError, isCancelError } from './CanceledError';
 export { RestApiError } from './RestApiError';
 export { assertValidationError } from './assertValidatonError';
 export { RestApiValidationErrorCode, validationErrorMap } from './validation';

package/src/index.ts

@@ -1,5 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export { isCancelError } from './errors/CancelledError';
+export { isCancelError } from './errors/CanceledError';
 export { get, post, put, del, head, patch } from './apis';

package/src/server.ts

@@ -1,5 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export { isCancelError } from './errors/CancelledError';
+export { isCancelError } from './errors/CanceledError';
 export { get, post, put, del, head, patch } from './apis/server';

package/src/types/index.ts

@@ -40,7 +40,7 @@ export type RestApiOptionsBase = {
 type Headers = Record<string, string>;
 
 /**
- * Type representing an operation that can be cancelled.
+ * Type representing an operation that can be canceled.
  *
  * @internal
  */

package/src/utils/createCancellableOperation.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { HttpResponse } from '@aws-amplify/core/internals/aws-client-utils';
-import { CancelledError, RestApiError } from '../errors';
+import { CanceledError } from '../errors';
 import { Operation } from '../types';
 import { parseRestApiServiceError } from './serviceError';
 import { logger } from './logger';
@@ -59,13 +59,12 @@ export function createCancellableOperation(
 		} catch (error: any) {
 			const abortSignal = internalPostAbortSignal ?? publicApisAbortSignal;
 			if (error.name === 'AbortError' || abortSignal?.aborted === true) {
-				const cancelledError = new CancelledError({
-					name: error.name,
-					message: abortSignal.reason ?? error.message,
+				const canceledError = new CanceledError({
+					...(abortSignal.reason ? { message: abortSignal.reason } : undefined),
 					underlyingError: error,
 				});
 				logger.debug(error);
-				throw cancelledError;
+				throw canceledError;
 			}
 			logger.debug(error);
 			throw error;
@@ -82,7 +81,7 @@ export function createCancellableOperation(
 			publicApisAbortController.abort(abortMessage);
 			// Abort reason is not widely support enough across runtimes and and browsers, so we set it
 			// if it is not already set.
-			if (publicApisAbortSignal.reason !== abortMessage) {
+			if (abortMessage && publicApisAbortSignal.reason !== abortMessage) {
 				type AbortSignalWithReasonSupport = Omit<AbortSignal, 'reason'> & {
 					reason?: string;
 				};

package/src/utils/index.ts

@@ -1,8 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import './polyfills';
-
 export { createCancellableOperation } from './createCancellableOperation';
 export { resolveCredentials } from './resolveCredentials';
 export { parseSigningInfo } from './parseSigningInfo';

package/src/utils/resolveApiUrl.ts

@@ -2,6 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { AmplifyClassV6 } from '@aws-amplify/core';
+import {
+	AmplifyUrl,
+	AmplifyUrlSearchParams,
+} from '@aws-amplify/core/internals/utils';
 import {
 	RestApiError,
 	RestApiValidationErrorCode,
@@ -28,13 +32,13 @@ export const resolveApiUrl = (
 	const urlStr = amplify.getConfig()?.API?.REST?.[apiName]?.endpoint;
 	assertValidationError(!!urlStr, RestApiValidationErrorCode.InvalidApiName);
 	try {
-		const url = new URL(urlStr + path);
+		const url = new AmplifyUrl(urlStr + path);
 		if (queryParams) {
-			const mergedQueryParams = new URLSearchParams(url.searchParams);
+			const mergedQueryParams = new AmplifyUrlSearchParams(url.searchParams);
 			Object.entries(queryParams).forEach(([key, value]) => {
 				mergedQueryParams.set(key, value);
 			});
-			url.search = new URLSearchParams(mergedQueryParams).toString();
+			url.search = new AmplifyUrlSearchParams(mergedQueryParams).toString();
 		}
 		return url;
 	} catch (error) {

package/lib/errors/CancelledError.d.ts

@@ -1,14 +0,0 @@
-import { AmplifyErrorParams } from '@aws-amplify/core/internals/utils';
-import { RestApiError } from './RestApiError';
-/**
- * Internal-only class for CancelledError.
- *
- * @internal
- */
-export declare class CancelledError extends RestApiError {
-    constructor(params: AmplifyErrorParams);
-}
-/**
- * Check if an error is caused by user calling `cancel()` REST API.
- */
-export declare const isCancelError: (error: unknown) => boolean;