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

package/lib/apis/common/handler.js

@@ -16,7 +16,7 @@ var normalizeHeaders_1 = require("../../utils/normalizeHeaders");
  * @internal
  */
 var transferHandler = function (amplify, options, signingServiceInfo) { return tslib_1.__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 tslib_1.__generator(this, function (_c) {
         switch (_c.label) {
@@ -55,9 +55,20 @@ var transferHandler = function (amplify, options, signingServiceInfo) { return t
             case 1:
                 credentials = _c.sent();
                 return [4 /*yield*/, (0, aws_client_utils_1.authenticatedHandler)(request, tslib_1.__assign(tslib_1.__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*/, (0, aws_client_utils_1.unauthenticatedHandler)(request, tslib_1.__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/apis/common/internalPost.js

@@ -46,7 +46,7 @@ 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/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/apis/index.js

@@ -7,11 +7,83 @@ var core_1 = require("@aws-amplify/core");
 var publicApis_1 = require("./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
+ *   }
+ *   //...
+ * }
+ * ```
  */
 var get = function (input) { return (0, publicApis_1.get)(core_1.Amplify, input); };
 exports.get = get;
 /**
  * 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
+ *   }
+ *   //...
+ * }
+ * ```
  */
 var post = function (input) {
     return (0, publicApis_1.post)(core_1.Amplify, input);
@@ -19,11 +91,63 @@ var post = function (input) {
 exports.post = post;
 /**
  * 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
+ *   }
+ * //...
+ * }
+ * ```
  */
 var put = function (input) { return (0, publicApis_1.put)(core_1.Amplify, input); };
 exports.put = put;
 /**
  * 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;
+ * ```
  */
 var del = function (input) {
     return (0, publicApis_1.del)(core_1.Amplify, input);
@@ -31,6 +155,24 @@ var del = function (input) {
 exports.del = del;
 /**
  * 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;
+ * ```
+ *
  */
 var head = function (input) {
     return (0, publicApis_1.head)(core_1.Amplify, input);
@@ -38,6 +180,42 @@ var head = function (input) {
 exports.head = head;
 /**
  * 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
+ *  }
+ * //...
+ * }
+ * ```
  */
 var patch = function (input) {
     return (0, publicApis_1.patch)(core_1.Amplify, input);

package/lib/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;