feat(clients): adding throwable waiters WaitUntil[operationState] (#2302)

* feat(waiter-utils): adding reasons for waiter states and exceptions

* feat(clients): adding waitUtilState from codegen

* fix: moving waiter types to aws-sdk/types

* fix: re-word documentation in generated clients

* fix: updating documentation

* fix: renaming errors

Author: alexforsyth

Diff for: clients/client-acm-pca/waiters/waitForAuditReportCreated.ts

@@ -3,37 +3,40 @@ import {
   DescribeCertificateAuthorityAuditReportCommand,
   DescribeCertificateAuthorityAuditReportCommandInput,
 } from "../commands/DescribeCertificateAuthorityAuditReportCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ACMPCAClient,
   input: DescribeCertificateAuthorityAuditReportCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeCertificateAuthorityAuditReportCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         return result.AuditReportStatus;
       };
       if (returnComparator() === "SUCCESS") {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
       let returnComparator = () => {
         return result.AuditReportStatus;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a Audit Report is created
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeCertificateAuthorityAuditReportCommand for polling.
+ *  @deprecated Use waitUntilAuditReportCreated instead. waitForAuditReportCreated does not throw error in non-success cases.
  */
 export const waitForAuditReportCreated = async (
   params: WaiterConfiguration<ACMPCAClient>,
@@ -42,3 +45,16 @@ export const waitForAuditReportCreated = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a Audit Report is created
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeCertificateAuthorityAuditReportCommand for polling.
+ */
+export const waitUntilAuditReportCreated = async (
+  params: WaiterConfiguration<ACMPCAClient>,
+  input: DescribeCertificateAuthorityAuditReportCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};

Diff for: clients/client-acm-pca/waiters/waitForCertificateAuthorityCSRCreated.ts

@@ -3,26 +3,28 @@ import {
   GetCertificateAuthorityCsrCommand,
   GetCertificateAuthorityCsrCommandInput,
 } from "../commands/GetCertificateAuthorityCsrCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (
   client: ACMPCAClient,
   input: GetCertificateAuthorityCsrCommandInput
 ): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetCertificateAuthorityCsrCommand(input));
-    return { state: WaiterState.SUCCESS };
+    reason = result;
+    return { state: WaiterState.SUCCESS, reason };
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "RequestInProgressException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a Certificate Authority CSR is created
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetCertificateAuthorityCsrCommand for polling.
+ *  @deprecated Use waitUntilCertificateAuthorityCSRCreated instead. waitForCertificateAuthorityCSRCreated does not throw error in non-success cases.
  */
 export const waitForCertificateAuthorityCSRCreated = async (
   params: WaiterConfiguration<ACMPCAClient>,
@@ -31,3 +33,16 @@ export const waitForCertificateAuthorityCSRCreated = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a Certificate Authority CSR is created
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetCertificateAuthorityCsrCommand for polling.
+ */
+export const waitUntilCertificateAuthorityCSRCreated = async (
+  params: WaiterConfiguration<ACMPCAClient>,
+  input: GetCertificateAuthorityCsrCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};

Diff for: clients/client-acm-pca/waiters/waitForCertificateIssued.ts

@@ -1,22 +1,24 @@
 import { ACMPCAClient } from "../ACMPCAClient";
 import { GetCertificateCommand, GetCertificateCommandInput } from "../commands/GetCertificateCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: ACMPCAClient, input: GetCertificateCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new GetCertificateCommand(input));
-    return { state: WaiterState.SUCCESS };
+    reason = result;
+    return { state: WaiterState.SUCCESS, reason };
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "RequestInProgressException") {
-      return { state: WaiterState.RETRY };
+      return { state: WaiterState.RETRY, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  * Wait until a certificate is issued
- *  @param params : Waiter configuration options.
- *  @param input : the input to GetCertificateCommand for polling.
+ *  @deprecated Use waitUntilCertificateIssued instead. waitForCertificateIssued does not throw error in non-success cases.
  */
 export const waitForCertificateIssued = async (
   params: WaiterConfiguration<ACMPCAClient>,
@@ -25,3 +27,16 @@ export const waitForCertificateIssued = async (
   const serviceDefaults = { minDelay: 3, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ * Wait until a certificate is issued
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetCertificateCommand for polling.
+ */
+export const waitUntilCertificateIssued = async (
+  params: WaiterConfiguration<ACMPCAClient>,
+  input: GetCertificateCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};

Diff for: clients/client-acm/waiters/waitForCertificateValidated.ts

@@ -1,10 +1,12 @@
 import { ACMClient } from "../ACMClient";
 import { DescribeCertificateCommand, DescribeCertificateCommandInput } from "../commands/DescribeCertificateCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: ACMClient, input: DescribeCertificateCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeCertificateCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Certificate.DomainValidationOptions);
@@ -18,7 +20,7 @@ const checkState = async (client: ACMClient, input: DescribeCertificateCommandIn
         allStringEq_5 = allStringEq_5 && element_4 == "SUCCESS";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: ACMClient, input: DescribeCertificateCommandIn
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "PENDING_VALIDATION") {
-          return { state: WaiterState.RETRY };
+          return { state: WaiterState.RETRY, reason };
         }
       }
     } catch (e) {}
@@ -40,20 +42,20 @@ const checkState = async (client: ACMClient, input: DescribeCertificateCommandIn
         return result.Certificate.Status;
       };
       if (returnComparator() === "FAILED") {
-        return { state: WaiterState.FAILURE };
+        return { state: WaiterState.FAILURE, reason };
       }
     } catch (e) {}
   } catch (exception) {
+    reason = exception;
     if (exception.name && exception.name == "ResourceNotFoundException") {
-      return { state: WaiterState.FAILURE };
+      return { state: WaiterState.FAILURE, reason };
     }
   }
-  return { state: WaiterState.RETRY };
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeCertificateCommand for polling.
+ *  @deprecated Use waitUntilCertificateValidated instead. waitForCertificateValidated does not throw error in non-success cases.
  */
 export const waitForCertificateValidated = async (
   params: WaiterConfiguration<ACMClient>,
@@ -62,3 +64,16 @@ export const waitForCertificateValidated = async (
   const serviceDefaults = { minDelay: 60, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeCertificateCommand for polling.
+ */
+export const waitUntilCertificateValidated = async (
+  params: WaiterConfiguration<ACMClient>,
+  input: DescribeCertificateCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};

Diff for: clients/client-appstream/waiters/waitForFleetStarted.ts

@@ -1,10 +1,12 @@
 import { AppStreamClient } from "../AppStreamClient";
 import { DescribeFleetsCommand, DescribeFleetsCommandInput } from "../commands/DescribeFleetsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeFleetsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Fleets);
@@ -18,7 +20,7 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
         allStringEq_5 = allStringEq_5 && element_4 == "ACTIVE";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "PENDING_DEACTIVATE") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,17 +47,18 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "INACTIVE") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeFleetsCommand for polling.
+ *  @deprecated Use waitUntilFleetStarted instead. waitForFleetStarted does not throw error in non-success cases.
  */
 export const waitForFleetStarted = async (
   params: WaiterConfiguration<AppStreamClient>,
@@ -64,3 +67,16 @@ export const waitForFleetStarted = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeFleetsCommand for polling.
+ */
+export const waitUntilFleetStarted = async (
+  params: WaiterConfiguration<AppStreamClient>,
+  input: DescribeFleetsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};

Diff for: clients/client-appstream/waiters/waitForFleetStopped.ts

@@ -1,10 +1,12 @@
 import { AppStreamClient } from "../AppStreamClient";
 import { DescribeFleetsCommand, DescribeFleetsCommandInput } from "../commands/DescribeFleetsCommand";
-import { WaiterConfiguration, WaiterResult, WaiterState, createWaiter } from "@aws-sdk/util-waiter";
+import { WaiterConfiguration, WaiterResult, WaiterState, checkExceptions, createWaiter } from "@aws-sdk/util-waiter";
 
 const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandInput): Promise<WaiterResult> => {
+  let reason;
   try {
     let result: any = await client.send(new DescribeFleetsCommand(input));
+    reason = result;
     try {
       let returnComparator = () => {
         let flat_1: any[] = [].concat(...result.Fleets);
@@ -18,7 +20,7 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
         allStringEq_5 = allStringEq_5 && element_4 == "INACTIVE";
       }
       if (allStringEq_5) {
-        return { state: WaiterState.SUCCESS };
+        return { state: WaiterState.SUCCESS, reason };
       }
     } catch (e) {}
     try {
@@ -31,7 +33,7 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "PENDING_ACTIVATE") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
@@ -45,17 +47,18 @@ const checkState = async (client: AppStreamClient, input: DescribeFleetsCommandI
       };
       for (let anyStringEq_4 of returnComparator()) {
         if (anyStringEq_4 == "ACTIVE") {
-          return { state: WaiterState.FAILURE };
+          return { state: WaiterState.FAILURE, reason };
         }
       }
     } catch (e) {}
-  } catch (exception) {}
-  return { state: WaiterState.RETRY };
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: WaiterState.RETRY, reason };
 };
 /**
  *
- *  @param params : Waiter configuration options.
- *  @param input : the input to DescribeFleetsCommand for polling.
+ *  @deprecated Use waitUntilFleetStopped instead. waitForFleetStopped does not throw error in non-success cases.
  */
 export const waitForFleetStopped = async (
   params: WaiterConfiguration<AppStreamClient>,
@@ -64,3 +67,16 @@ export const waitForFleetStopped = async (
   const serviceDefaults = { minDelay: 30, maxDelay: 120 };
   return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeFleetsCommand for polling.
+ */
+export const waitUntilFleetStopped = async (
+  params: WaiterConfiguration<AppStreamClient>,
+  input: DescribeFleetsCommandInput
+): Promise<WaiterResult> => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+  return checkExceptions(result);
+};