@aws-amplify/api-rest 3.5.6-unstable.7762f1a.0 → 4.0.0

package/lib-esm/utils/logger.js

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { ConsoleLogger } from '@aws-amplify/core';
+export const logger = new ConsoleLogger('RestApis');

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

@@ -0,0 +1 @@
+export declare const normalizeHeaders: (headers?: Record<string, string>) => Record<string, string>;

package/lib-esm/utils/normalizeHeaders.js

@@ -0,0 +1,9 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export const normalizeHeaders = (headers) => {
+    const normalizedHeaders = {};
+    for (const key in headers) {
+        normalizedHeaders[key.toLowerCase()] = headers[key];
+    }
+    return normalizedHeaders;
+};

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

@@ -0,0 +1,14 @@
+import { AmplifyClassV6 } from '@aws-amplify/core';
+/**
+ * Infer the signing service and region from the given URL, and for REST API only, from the Amplify configuration.
+ * It supports raw API Gateway endpoint and AppSync endpoint.
+ *
+ * @internal
+ */
+export declare const parseSigningInfo: (url: URL, restApiOptions?: {
+    amplify: AmplifyClassV6;
+    apiName: string;
+}) => {
+    service: string;
+    region: string;
+};

package/lib-esm/utils/parseSigningInfo.js

@@ -0,0 +1,37 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { APIG_HOSTNAME_PATTERN, DEFAULT_IAM_SIGNING_REGION, DEFAULT_REST_IAM_SIGNING_SERVICE, } from './constants';
+/**
+ * Infer the signing service and region from the given URL, and for REST API only, from the Amplify configuration.
+ * It supports raw API Gateway endpoint and AppSync endpoint.
+ *
+ * @internal
+ */
+export const parseSigningInfo = (url, restApiOptions) => {
+    const { service: signingService = DEFAULT_REST_IAM_SIGNING_SERVICE, region: signingRegion = DEFAULT_IAM_SIGNING_REGION, } = restApiOptions?.amplify.getConfig()?.API?.REST?.[restApiOptions?.apiName] ??
+        {};
+    const { hostname } = url;
+    const [, service, region] = APIG_HOSTNAME_PATTERN.exec(hostname) ?? [];
+    if (service === DEFAULT_REST_IAM_SIGNING_SERVICE) {
+        // The configured endpoint is an API Gateway endpoint
+        // @see: https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-call-api.html
+        return {
+            service,
+            region: region ?? signingRegion,
+        };
+    }
+    else if (service === 'appsync-api') {
+        // AppSync endpoint is internally supported because GraphQL operation will send request using POST handler.
+        // example: https://xxxx.appsync-api.us-east-1.amazonaws.com/graphql
+        return {
+            service: 'appsync',
+            region: region ?? signingRegion,
+        };
+    }
+    else {
+        return {
+            service: signingService,
+            region: signingRegion,
+        };
+    }
+};

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

@@ -0,0 +1,12 @@
+import { AmplifyClassV6 } from '@aws-amplify/core';
+/**
+ * Resolve the REST API request URL by:
+ * 1. Loading the REST API endpoint from the Amplify configuration with corresponding API name.
+ * 2. Appending the path to the endpoint.
+ * 3. Merge the query parameters from path and the queryParameter argument which is taken from the public REST API
+ *   options.
+ * 4. Validating the resulting URL string.
+ *
+ * @internal
+ */
+export declare const resolveApiUrl: (amplify: AmplifyClassV6, apiName: string, path: string, queryParams?: Record<string, string>) => URL;

package/lib-esm/utils/resolveApiUrl.js

@@ -0,0 +1,36 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AmplifyUrl, AmplifyUrlSearchParams, } from '@aws-amplify/core/internals/utils';
+import { RestApiError, RestApiValidationErrorCode, assertValidationError, validationErrorMap, } from '../errors';
+/**
+ * Resolve the REST API request URL by:
+ * 1. Loading the REST API endpoint from the Amplify configuration with corresponding API name.
+ * 2. Appending the path to the endpoint.
+ * 3. Merge the query parameters from path and the queryParameter argument which is taken from the public REST API
+ *   options.
+ * 4. Validating the resulting URL string.
+ *
+ * @internal
+ */
+export const resolveApiUrl = (amplify, apiName, path, queryParams) => {
+    const urlStr = amplify.getConfig()?.API?.REST?.[apiName]?.endpoint;
+    assertValidationError(!!urlStr, RestApiValidationErrorCode.InvalidApiName);
+    try {
+        const url = new AmplifyUrl(urlStr + path);
+        if (queryParams) {
+            const mergedQueryParams = new AmplifyUrlSearchParams(url.searchParams);
+            Object.entries(queryParams).forEach(([key, value]) => {
+                mergedQueryParams.set(key, value);
+            });
+            url.search = new AmplifyUrlSearchParams(mergedQueryParams).toString();
+        }
+        return url;
+    }
+    catch (error) {
+        throw new RestApiError({
+            name: RestApiValidationErrorCode.InvalidApiName,
+            ...validationErrorMap[RestApiValidationErrorCode.InvalidApiName],
+            recoverySuggestion: `Please make sure the REST endpoint URL is a valid URL string. Got ${urlStr}`,
+        });
+    }
+};

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

@@ -0,0 +1,5 @@
+import { AmplifyClassV6 } from '@aws-amplify/core';
+/**
+ * @internal
+ */
+export declare const resolveCredentials: (amplify: AmplifyClassV6) => Promise<import("@aws-amplify/core/lib-esm/libraryUtils").AWSCredentials>;

package/lib-esm/utils/resolveCredentials.js

@@ -0,0 +1,11 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { RestApiValidationErrorCode, assertValidationError } from '../errors';
+/**
+ * @internal
+ */
+export const resolveCredentials = async (amplify) => {
+    const { credentials } = await amplify.Auth.fetchAuthSession();
+    assertValidationError(!!credentials && !!credentials.accessKeyId && !!credentials.secretAccessKey, RestApiValidationErrorCode.NoCredentials);
+    return credentials;
+};

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

@@ -0,0 +1,10 @@
+import { MetadataBearer } from '@aws-sdk/types';
+import { HttpResponse } from '@aws-amplify/core/internals/aws-client-utils';
+import { RestApiError } from '../errors';
+/**
+ * Internal-only method to create a new RestApiError from a service error.
+ *
+ * @internal
+ */
+export declare const buildRestApiServiceError: (error: Error) => RestApiError;
+export declare const parseRestApiServiceError: (response?: HttpResponse) => Promise<(RestApiError & MetadataBearer) | undefined>;

package/lib-esm/utils/serviceError.js

@@ -0,0 +1,25 @@
+import { parseJsonError, } from '@aws-amplify/core/internals/aws-client-utils';
+import { RestApiError } from '../errors';
+/**
+ * Internal-only method to create a new RestApiError from a service error.
+ *
+ * @internal
+ */
+export const buildRestApiServiceError = (error) => {
+    const restApiError = new RestApiError({
+        name: error?.name,
+        message: error.message,
+        underlyingError: error,
+    });
+    return restApiError;
+};
+export const parseRestApiServiceError = async (response) => {
+    const parsedError = await parseJsonError(response);
+    if (!parsedError) {
+        // Response is not an error.
+        return;
+    }
+    return Object.assign(buildRestApiServiceError(parsedError), {
+        $metadata: parsedError.$metadata,
+    });
+};

package/package.json

@@ -1,107 +1,115 @@
 {
-  "name": "@aws-amplify/api-rest",
-  "version": "3.5.6-unstable.7762f1a.0+7762f1a",
-  "description": "Api-rest category of aws-amplify",
-  "main": "./lib/index.js",
-  "module": "./lib-esm/index.js",
-  "typings": "./lib-esm/index.d.ts",
-  "react-native": {
-    "./lib/index": "./lib-esm/index.js"
-  },
-  "sideEffects": [
-    "./lib/RestAPI.js",
-    "./lib-esm/RestAPI.js"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "test": "npm run lint && jest --coverage",
-    "test:size": "size-limit",
-    "build-with-test": "npm test && npm run build",
-    "build:cjs": "node ./build es5 && webpack && webpack --config ./webpack.config.dev.js",
-    "build:esm": "node ./build es6",
-    "build:cjs:watch": "node ./build es5 --watch",
-    "build:esm:watch": "node ./build es6 --watch",
-    "build": "npm run clean && npm run build:esm && npm run build:cjs",
-    "clean": "npm run clean:size && rimraf lib-esm lib dist",
-    "clean:size": "rimraf dual-publish-tmp tmp*",
-    "format": "echo \"Not implemented\"",
-    "lint": "tslint 'src/**/*.ts' && npm run ts-coverage",
-    "ts-coverage": "typescript-coverage-report -p ./tsconfig.build.json -t 65.41"
-  },
-  "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": [
-    "lib",
-    "lib-esm",
-    "src"
-  ],
-  "dependencies": {
-    "@aws-amplify/core": "5.8.6-unstable.7762f1a.0+7762f1a",
-    "axios": "0.26.0",
-    "tslib": "^1.8.0",
-    "url": "0.11.0"
-  },
-  "size-limit": [
-    {
-      "name": "API (rest client)",
-      "path": "./lib-esm/index.js",
-      "import": "{ Amplify, RestAPI }",
-      "limit": "31 kB"
-    }
-  ],
-  "jest": {
-    "globals": {
-      "ts-jest": {
-        "diagnostics": false,
-        "tsConfig": {
-          "lib": [
-            "es5",
-            "es2015",
-            "dom",
-            "esnext.asynciterable",
-            "es2017.object"
-          ],
-          "allowJs": true
-        }
-      }
-    },
-    "transform": {
-      "^.+\\.(js|jsx|ts|tsx)$": "ts-jest"
-    },
-    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(tsx?|jsx?)$",
-    "moduleFileExtensions": [
-      "ts",
-      "tsx",
-      "js",
-      "json",
-      "jsx"
-    ],
-    "testEnvironment": "jsdom",
-    "testURL": "http://localhost/",
-    "coverageThreshold": {
-      "global": {
-        "branches": 0,
-        "functions": 0,
-        "lines": 0,
-        "statements": 0
-      }
-    },
-    "coveragePathIgnorePatterns": [
-      "/node_modules/",
-      "dist",
-      "lib",
-      "lib-esm"
-    ]
-  },
-  "gitHead": "7762f1a7076e622ec354c24539a3b57ce3ec4290"
+	"name": "@aws-amplify/api-rest",
+	"private": false,
+	"version": "4.0.0",
+	"description": "Api-rest category of aws-amplify",
+	"main": "./lib/index.js",
+	"module": "./lib-esm/index.js",
+	"typings": "./lib-esm/index.d.ts",
+	"react-native": {
+		"./lib/index": "./lib-esm/index.js"
+	},
+	"sideEffects": [
+		"./lib/RestAPI.js",
+		"./lib-esm/RestAPI.js"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"test": "npm run lint && jest -w 1 --coverage",
+		"test:watch": "tslint 'src/**/*.ts' && jest -w 1 --watch",
+		"build-with-test": "npm run clean && npm test && tsc && webpack",
+		"build:cjs": "rimraf lib && tsc -m commonjs --outDir lib && webpack && webpack --config ./webpack.config.dev.js",
+		"build:esm": "rimraf lib-esm && tsc -m esnext --outDir lib-esm",
+		"build:cjs:watch": "rimraf lib && tsc -m commonjs --outDir lib --watch",
+		"build:esm:watch": "rimraf lib-esm && tsc -m esnext --outDir lib-esm --watch",
+		"build": "npm run clean && npm run build:esm && npm run build:cjs",
+		"clean": "npm run clean:size && rimraf lib-esm lib dist",
+		"clean:size": "rimraf dual-publish-tmp tmp*",
+		"format": "echo \"Not implemented\"",
+		"lint": "tslint 'src/**/*.ts' && npm run ts-coverage",
+		"ts-coverage": "typescript-coverage-report -p ./tsconfig.json -t 70.0"
+	},
+	"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": [
+		"lib",
+		"lib-esm",
+		"src",
+		"internals",
+		"server"
+	],
+	"dependencies": {
+		"tslib": "^2.5.0"
+	},
+	"peerDependencies": {
+		"@aws-amplify/core": "^6.0.0"
+	},
+	"devDependencies": {
+		"@aws-amplify/core": "6.0.0",
+		"@aws-amplify/react-native": "^1.0.0",
+		"typescript": "5.0.2"
+	},
+	"size-limit": [
+		{
+			"name": "API (rest client)",
+			"path": "./lib-esm/index.js",
+			"import": "{ Amplify, RestAPI }",
+			"limit": "31.5 kB"
+		}
+	],
+	"jest": {
+		"globals": {
+			"ts-jest": {
+				"diagnostics": false,
+				"tsConfig": {
+					"allowJs": true,
+					"noEmitOnError": false
+				}
+			}
+		},
+		"transform": {
+			"^.+\\.(js|jsx|ts|tsx)$": "ts-jest"
+		},
+		"testPathIgnorePatterns": [
+			"/testUtils/"
+		],
+		"testRegex": "(/__tests__/.*|\\.(test|spec))\\.(tsx?|jsx?)$",
+		"moduleFileExtensions": [
+			"ts",
+			"tsx",
+			"js",
+			"json",
+			"jsx"
+		],
+		"testEnvironment": "jsdom",
+		"testURL": "http://localhost/",
+		"coverageThreshold": {
+			"global": {
+				"branches": 0,
+				"functions": 0,
+				"lines": 0,
+				"statements": 0
+			}
+		},
+		"coveragePathIgnorePatterns": [
+			"node_modules",
+			"dist",
+			"lib",
+			"lib-esm"
+		],
+		"setupFiles": [
+			"<rootDir>/setupTests.ts"
+		]
+	},
+	"gitHead": "d505105326d7f6214f6bd1e06eb20be3a3651377"
 }

package/server/package.json

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

package/src/apis/common/handler.ts

@@ -0,0 +1,109 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AmplifyClassV6 } from '@aws-amplify/core';
+import {
+	HttpRequest,
+	unauthenticatedHandler,
+	Headers,
+	getRetryDecider,
+	jitteredBackoff,
+	authenticatedHandler,
+} from '@aws-amplify/core/internals/aws-client-utils';
+import { DocumentType } from '@aws-amplify/core/internals/utils';
+
+import {
+	parseRestApiServiceError,
+	parseSigningInfo,
+	resolveCredentials,
+} from '../../utils';
+import { normalizeHeaders } from '../../utils/normalizeHeaders';
+import { RestApiResponse } from '../../types';
+
+type HandlerOptions = Omit<HttpRequest, 'body' | 'headers'> & {
+	body?: DocumentType | FormData;
+	headers?: Headers;
+	withCredentials?: boolean;
+};
+
+type SigningServiceInfo = {
+	service?: string;
+	region?: string;
+};
+
+/**
+ * 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.
+ *
+ * @internal
+ */
+export const transferHandler = async (
+	amplify: AmplifyClassV6,
+	options: HandlerOptions & { abortSignal: AbortSignal },
+	signingServiceInfo?: SigningServiceInfo
+): Promise<RestApiResponse> => {
+	const { url, method, headers, body, withCredentials, abortSignal } = options;
+	const resolvedBody = body
+		? body instanceof FormData
+			? body
+			: JSON.stringify(body ?? '')
+		: undefined;
+	const resolvedHeaders: Headers = {
+		...normalizeHeaders(headers),
+		...(resolvedBody
+			? {
+					'content-type':
+						body instanceof FormData
+							? 'multipart/form-data'
+							: 'application/json; charset=UTF-8',
+			  }
+			: {}),
+	};
+	const request = {
+		url,
+		headers: resolvedHeaders,
+		method,
+		body: resolvedBody,
+	};
+	const baseOptions = {
+		retryDecider: getRetryDecider(parseRestApiServiceError),
+		computeDelay: jitteredBackoff,
+		withCrossDomainCredentials: withCredentials,
+		abortSignal,
+	};
+
+	const isIamAuthApplicable = iamAuthApplicable(request, signingServiceInfo);
+	let response: RestApiResponse;
+	if (isIamAuthApplicable) {
+		const signingInfoFromUrl = parseSigningInfo(url);
+		const signingService =
+			signingServiceInfo?.service ?? signingInfoFromUrl.service;
+		const signingRegion =
+			signingServiceInfo?.region ?? signingInfoFromUrl.region;
+		const credentials = await resolveCredentials(amplify);
+		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 iamAuthApplicable = (
+	{ headers }: HttpRequest,
+	signingServiceInfo?: SigningServiceInfo
+) => !headers.authorization && !headers['x-api-key'] && !!signingServiceInfo;

package/src/apis/common/internalPost.ts

@@ -0,0 +1,81 @@
+// 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 { transferHandler } from './handler';
+import { createCancellableOperation } from '../../utils';
+
+/**
+ * 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
+ */
+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,
+			},
+			options?.signingServiceInfo
+		);
+		return response;
+	}, controller);
+
+	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);
+};