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

package/lib/utils/resolveApiUrl.js

@@ -4,6 +4,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveApiUrl = void 0;
 var tslib_1 = require("tslib");
+var utils_1 = require("@aws-amplify/core/internals/utils");
 var errors_1 = require("../errors");
 /**
  * Resolve the REST API request URL by:
@@ -20,14 +21,14 @@ 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;
     (0, errors_1.assertValidationError)(!!urlStr, errors_1.RestApiValidationErrorCode.InvalidApiName);
     try {
-        var url = new URL(urlStr + path);
+        var url = new utils_1.AmplifyUrl(urlStr + path);
         if (queryParams) {
-            var mergedQueryParams_1 = new URLSearchParams(url.searchParams);
+            var mergedQueryParams_1 = new utils_1.AmplifyUrlSearchParams(url.searchParams);
             Object.entries(queryParams).forEach(function (_a) {
                 var _b = tslib_1.__read(_a, 2), key = _b[0], value = _b[1];
                 mergedQueryParams_1.set(key, value);
             });
-            url.search = new URLSearchParams(mergedQueryParams_1).toString();
+            url.search = new utils_1.AmplifyUrlSearchParams(mergedQueryParams_1).toString();
         }
         return url;
     }

package/lib/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/lib-esm/apis/common/handler.js

@@ -13,7 +13,7 @@ import { normalizeHeaders } from '../../utils/normalizeHeaders';
  * @internal
  */
 export var transferHandler = function (amplify, options, signingServiceInfo) { return __awaiter(void 0, void 0, void 0, function () {
-    var url, method, headers, body, withCredentials, abortSignal, resolvedBody, resolvedHeaders, request, baseOptions, isIamAuthApplicable, signingInfoFromUrl, signingService, signingRegion, credentials;
+    var url, method, headers, body, withCredentials, abortSignal, resolvedBody, resolvedHeaders, request, baseOptions, isIamAuthApplicable, response, signingInfoFromUrl, signingService, signingRegion, credentials;
     var _a, _b;
     return __generator(this, function (_c) {
         switch (_c.label) {
@@ -52,9 +52,20 @@ export var transferHandler = function (amplify, options, signingServiceInfo) { r
             case 1:
                 credentials = _c.sent();
                 return [4 /*yield*/, authenticatedHandler(request, __assign(__assign({}, baseOptions), { credentials: credentials, region: signingRegion, service: signingService }))];
-            case 2: return [2 /*return*/, _c.sent()];
+            case 2:
+                response = _c.sent();
+                return [3 /*break*/, 5];
             case 3: return [4 /*yield*/, unauthenticatedHandler(request, __assign({}, baseOptions))];
-            case 4: return [2 /*return*/, _c.sent()];
+            case 4:
+                response = _c.sent();
+                _c.label = 5;
+            case 5: 
+            // Clean-up un-modeled properties from response.
+            return [2 /*return*/, {
+                    statusCode: response.statusCode,
+                    headers: response.headers,
+                    body: response.body,
+                }];
         }
     });
 }); };

package/lib-esm/apis/common/internalPost.js

@@ -42,7 +42,7 @@ export var cancel = function (promise, message) {
     var 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/lib-esm/apis/index.d.ts

@@ -1,25 +1,203 @@
 import { DeleteInput, DeleteOperation, GetInput, GetOperation, HeadInput, HeadOperation, PatchInput, PatchOperation, PostInput, PostOperation, PutInput, PutOperation } from '../types';
 /**
  * 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 declare const get: (input: GetInput) => GetOperation;
 /**
  * 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 declare const post: (input: PostInput) => PostOperation;
 /**
  * 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 declare const put: (input: PutInput) => PutOperation;
 /**
  * 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 declare const del: (input: DeleteInput) => DeleteOperation;
 /**
  * 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 declare const head: (input: HeadInput) => HeadOperation;
 /**
  * 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 declare const patch: (input: PatchInput) => PatchOperation;

package/lib-esm/apis/index.js

@@ -4,32 +4,210 @@ import { Amplify } from '@aws-amplify/core';
 import { get as commonGet, post as commonPost, put as commonPut, del as commonDel, head as commonHead, patch as commonPatch, } from './common/publicApis';
 /**
  * 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 var get = function (input) { return 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 var post = function (input) {
     return 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 var put = function (input) { return 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 var del = function (input) {
     return 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 var head = function (input) {
     return 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 var patch = function (input) {
     return commonPatch(Amplify, input);

package/lib-esm/apis/server.d.ts

@@ -2,25 +2,150 @@ import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
 import { DeleteInput, DeleteOperation, GetInput, GetOperation, HeadInput, HeadOperation, PatchInput, PatchOperation, PostInput, PostOperation, PutInput, PutOperation } from '../types';
 /**
  * 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 declare const get: (contextSpec: AmplifyServer.ContextSpec, input: GetInput) => GetOperation;
 /**
  * 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 declare const post: (contextSpec: AmplifyServer.ContextSpec, input: PostInput) => PostOperation;
 /**
  * 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 declare const put: (contextSpec: AmplifyServer.ContextSpec, input: PutInput) => PutOperation;
 /**
  * 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 declare const del: (contextSpec: AmplifyServer.ContextSpec, input: DeleteInput) => DeleteOperation;
 /**
  * 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 declare const head: (contextSpec: AmplifyServer.ContextSpec, input: HeadInput) => HeadOperation;
 /**
  * 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 declare const patch: (contextSpec: AmplifyServer.ContextSpec, input: PatchInput) => PatchOperation;