athena-query-execution-waiter 0.5.7 → 0.6.0

package/README.md

@@ -3,13 +3,13 @@
 [![npm version](https://img.shields.io/npm/v/athena-query-execution-waiter.svg)](https://www.npmjs.com/package/athena-query-execution-waiter)
 [![License](https://img.shields.io/npm/l/athena-query-execution-waiter.svg)](https://github.com/gammarers-aws-sdk-extensions/athena-query-execution-waiter/blob/main/LICENSE)
 
-A small library that waits for an AWS Athena query execution to complete. It polls the Athena API until the execution reaches a terminal state: **SUCCEEDED**, **FAILED**, or **CANCELLED**.
+A small library that waits for an AWS Athena query execution to complete. It repeatedly calls the Athena API until the execution reaches a terminal state: **SUCCEEDED**, **FAILED**, or **CANCELLED**.
 
 ## Features
 
-- Polls `GetQueryExecution` until the run finishes or an **overall wall-clock timeout** is exceeded (separate from **polling interval**).
-- Configurable **overall timeout** and **poll spacing** via `wait()` options; default overall cap is **`DEFAULT_TIMEOUT_MS`** (2 minutes).
-- Typed errors: **`AthenaQueryExecutionWaiterTimeoutError`**, **`AthenaQueryExecutionWaiterStateError`** (failed or cancelled runs), **`AthenaQueryExecutionWaiterMissingStateError`**, **`AthenaQueryExecutionWaiterUnsupportedStateError`**.
+- Waits on `GetQueryExecution` until the run finishes or an **overall wall-clock timeout** is exceeded (separate from **wait interval**).
+- Configurable **overall timeout**, **wait interval**, and **`AbortSignal`** cancellation via `wait()` options; default overall cap is **`DEFAULT_TIMEOUT_MS`** (2 minutes).
+- Typed errors: **`AthenaQueryExecutionWaiterTimeoutError`**, **`AthenaQueryExecutionWaiterAbortedError`**, **`AthenaQueryExecutionWaiterStateError`** (failed or cancelled runs), **`AthenaQueryExecutionWaiterMissingStateError`**, **`AthenaQueryExecutionWaiterUnsupportedStateError`**.
 - Built for **AWS SDK for JavaScript v3** (`@aws-sdk/client-athena`).
 
 ## Installation
@@ -64,12 +64,12 @@ try {
 }
 ```
 
-### Overall timeout vs polling interval
+### Overall timeout vs wait interval
 
 | | Meaning |
 |---|--------|
-| **`waitOptions.timeoutMs` / `DEFAULT_TIMEOUT_MS`** | **Overall** wall-clock limit from when `wait()` starts until **SUCCEEDED**, **FAILED**, or **CANCELLED** (or this cap is exceeded). Omit `timeoutMs` to use `DEFAULT_TIMEOUT_MS`. This is **not** how often Athena is polled. |
-| **`pollIntervalMs`** | Delay **between** `GetQueryExecution` calls. Independent of the overall timeout; a long poll interval still respects `waitOptions.timeoutMs` / `DEFAULT_TIMEOUT_MS`. |
+| **`waitOptions.timeoutMs` / `DEFAULT_TIMEOUT_MS`** | **Overall** wall-clock limit from when `wait()` starts until **SUCCEEDED**, **FAILED**, or **CANCELLED** (or this cap is exceeded). Omit `timeoutMs` to use `DEFAULT_TIMEOUT_MS`. This is **not** how often status is checked. |
+| **`waitIntervalMs`** | Delay **between** `GetQueryExecution` calls. Independent of the overall timeout; a long wait interval still respects `waitOptions.timeoutMs` / `DEFAULT_TIMEOUT_MS`. |
 
 Long-running jobs should pass a higher `timeoutMs` when needed:
 
@@ -79,17 +79,46 @@ const state = await waiter.wait(queryExecutionId, {
 });
 ```
 
-Default polling interval is **1 second**. Increase it to reduce API calls (constructor or per `wait()`):
+Default wait interval is **1 second**. Increase it to reduce API calls (constructor or per `wait()`):
 
 ```typescript
-const waiter = new AthenaQueryExecutionWaiter(client, { pollIntervalMs: 5000 });
+const waiter = new AthenaQueryExecutionWaiter(client, { waitIntervalMs: 5000 });
 
 const state = await waiter.wait(queryExecutionId, {
   timeoutMs: 60_000,
-  pollIntervalMs: 3000,
+  waitIntervalMs: 3000,
 });
 ```
 
+### Cancelling a wait with `AbortSignal`
+
+Pass an `AbortSignal` to stop waiting early—for example on request teardown, deploy shutdown, or user cancellation:
+
+```typescript
+import {
+  AthenaQueryExecutionWaiter,
+  AthenaQueryExecutionWaiterAbortedError,
+} from 'athena-query-execution-waiter';
+
+const controller = new AbortController();
+
+try {
+  const state = await waiter.wait(queryExecutionId, {
+    signal: controller.signal,
+  });
+  console.log('Query completed:', state);
+} catch (err) {
+  if (err instanceof AthenaQueryExecutionWaiterAbortedError) {
+    console.error('Wait was aborted');
+  }
+  throw err;
+}
+
+// Elsewhere: controller.abort();
+```
+
+Waiting stops when the signal is aborted—before the next status check, after a status check returns, or during the wait interval.
+
 ## Options
 
 ### `AthenaQueryExecutionWaiterOptions` (constructor)
@@ -98,7 +127,7 @@ Passed to `new AthenaQueryExecutionWaiter(client, options?)`.
 
 | Option | Type | Description |
 |--------|------|-------------|
-| `pollIntervalMs` | `number` (optional) | Default milliseconds **between** `GetQueryExecution` calls when `wait()` omits `pollIntervalMs`. Default: `1000`. |
+| `waitIntervalMs` | `number` (optional) | Default milliseconds **between** `GetQueryExecution` calls when `wait()` omits `waitIntervalMs`. Default: `1000`. |
 
 ### `AthenaQueryExecutionWaitOptions` (`wait()`)
 
@@ -107,7 +136,8 @@ Passed to `wait(queryExecutionId, waitOptions?)`.
 | Option | Type | Description |
 |--------|------|-------------|
 | `timeoutMs` | `number` (optional) | **Overall** wall-clock timeout in ms from the start of `wait()` until a terminal state. Default: `DEFAULT_TIMEOUT_MS` (**2 minutes**). |
-| `pollIntervalMs` | `number` (optional) | Milliseconds **between** polls for this call. Default: constructor’s `pollIntervalMs` or `1000`. |
+| `waitIntervalMs` | `number` (optional) | Milliseconds **between** status checks for this call. Default: constructor’s `waitIntervalMs` or `1000`. |
+| `signal` | `AbortSignal` (optional) | When aborted, waiting stops and `AthenaQueryExecutionWaiterAbortedError` is thrown. |
 
 ## API reference
 
@@ -117,8 +147,9 @@ Passed to `wait(queryExecutionId, waitOptions?)`.
 - **`wait(queryExecutionId: string, waitOptions?: AthenaQueryExecutionWaitOptions): Promise<QueryExecutionState>`**
   - **Returns** `SUCCEEDED` on success.
   - **Throws** `AthenaQueryExecutionWaiterTimeoutError` if overall wait exceeds the effective timeout.
+  - **Throws** `AthenaQueryExecutionWaiterAbortedError` when `waitOptions.signal` is aborted.
   - **Throws** `AthenaQueryExecutionWaiterStateError` when the state is `FAILED` or `CANCELLED`.
-  - **Throws** `AthenaQueryExecutionWaiterMissingStateError` when `QueryExecution`, `Status`, or `State` is missing from the API response (fail-fast; no polling until timeout).
+  - **Throws** `AthenaQueryExecutionWaiterMissingStateError` when `QueryExecution`, `Status`, or `State` is missing from the API response (fail-fast; does not keep waiting until timeout).
   - **Throws** `AthenaQueryExecutionWaiterUnsupportedStateError` when `State` is present but not a known `QueryExecutionState` (e.g. a future Athena enum value).
 
 ### Constants
@@ -129,9 +160,10 @@ Passed to `wait(queryExecutionId, waitOptions?)`.
 
 - **`AthenaQueryExecutionWaiterError`** — Base class for waiter errors.
 - **`AthenaQueryExecutionWaiterTimeoutError`** — Overall elapsed time since `wait()` started exceeded `waitOptions.timeoutMs` or `DEFAULT_TIMEOUT_MS`. Constructor: `(elapsedTime: number)`.
+- **`AthenaQueryExecutionWaiterAbortedError`** — Wait was cancelled via `AbortSignal`. Property: `signal`. Constructor: `(signal?: AbortSignal)`.
 - **`AthenaQueryExecutionWaiterStateError`** — Query ended in `FAILED` or `CANCELLED`. Properties: `state`, `reason`. Constructor: `(state: QueryExecutionState, reason?: string)`.
-- **`AthenaQueryExecutionWaiterMissingStateError`** — `GetQueryExecution` response is missing `QueryExecution`, `Status`, or `State`. Property: `detail`. Fails on the first poll.
-- **`AthenaQueryExecutionWaiterUnsupportedStateError`** — `State` is not one of the known values (`QUEUED`, `RUNNING`, `SUCCEEDED`, `FAILED`, `CANCELLED`). Property: `state`. Fails on the first poll.
+- **`AthenaQueryExecutionWaiterMissingStateError`** — `GetQueryExecution` response is missing `QueryExecution`, `Status`, or `State`. Property: `detail`. Fails on the first status check.
+- **`AthenaQueryExecutionWaiterUnsupportedStateError`** — `State` is not one of the known values (`QUEUED`, `RUNNING`, `SUCCEEDED`, `FAILED`, `CANCELLED`). Property: `state`. Fails on the first status check.
 
 ## License
 

package/lib/index.d.ts

@@ -3,7 +3,7 @@ import { QueryExecutionState, AthenaClient } from '@aws-sdk/client-athena';
  * Default overall wait timeout (milliseconds) when `wait()` is called without
  * `waitOptions.timeoutMs`.
  * This caps total wall-clock time from the start of `wait()` until a terminal state
- * (or error)—it is not the delay between polls (`pollIntervalMs`).
+ * (or error)—it is not the delay between status checks (`waitIntervalMs`).
  *
  * **Why 2 minutes:** Athena often exceeds a few seconds (queueing, cold start, moderate
  * scans). Ten seconds fails too often as a library default; unbounded or very large
@@ -12,53 +12,63 @@ import { QueryExecutionState, AthenaClient } from '@aws-sdk/client-athena';
  * `wait(..., { timeoutMs })` for heavy analytics or ETL.
  */
 export declare const DEFAULT_TIMEOUT_MS: number;
-/** Options for AthenaQueryExecutionWaiter constructor. */
+/** Constructor options for {@link AthenaQueryExecutionWaiter}. */
 export interface AthenaQueryExecutionWaiterOptions {
     /**
-     * Polling interval in milliseconds.
+     * Default wait interval in milliseconds between status checks for `wait()` calls
+     * that omit `waitIntervalMs`.
      * Increase for long-running queries to reduce API calls.
-     * Defaults to DEFAULT_POLL_INTERVAL_MS (1000) when omitted.
+     * Defaults to `1000` when omitted.
      */
-    pollIntervalMs?: number;
+    waitIntervalMs?: number;
 }
-/** Options for wait(). */
+/** Per-call options for {@link AthenaQueryExecutionWaiter.wait}. */
 export interface AthenaQueryExecutionWaitOptions {
     /**
      * Overall wall-clock timeout in milliseconds for this wait (from the start of `wait()`
-     * until a terminal state). Not the delay between polls.
+     * until a terminal state). Not the delay between status checks.
      * Defaults to {@link DEFAULT_TIMEOUT_MS} when omitted.
      */
     timeoutMs?: number;
     /**
-     * Polling interval in milliseconds for this wait.
-     * Overrides the waiter's default poll interval when specified.
+     * Wait interval in milliseconds between status checks for this wait.
+     * Overrides the waiter's default wait interval when specified.
      */
-    pollIntervalMs?: number;
+    waitIntervalMs?: number;
+    /**
+     * Optional abort signal. When aborted, waiting stops immediately and
+     * {@link AthenaQueryExecutionWaiterAbortedError} is thrown—before the next status
+     * check, after a status check returns, or during the wait interval.
+     */
+    signal?: AbortSignal;
 }
 /**
- * Waits for Athena query execution to complete.
- * Polls execution status until it becomes SUCCEEDED, FAILED, or CANCELLED.
- * Overall time is bounded by `waitOptions.timeoutMs` (or {@link DEFAULT_TIMEOUT_MS});
- * spacing between polls is controlled separately by `pollIntervalMs`.
+ * Waits for an Athena query execution to reach a terminal state.
+ *
+ * Repeatedly calls `GetQueryExecution` until the execution becomes
+ * `SUCCEEDED`, `FAILED`, or `CANCELLED`. Overall wall-clock time is bounded by
+ * `waitOptions.timeoutMs` (or {@link DEFAULT_TIMEOUT_MS}); spacing between status
+ * checks is controlled separately by `waitIntervalMs`.
  */
 export declare class AthenaQueryExecutionWaiter {
     private readonly client;
-    private readonly defaultPollIntervalMs;
+    private readonly defaultWaitIntervalMs;
     /**
      * @param client Athena API client
-     * @param options Optional settings (e.g. pollIntervalMs)
+     * @param options Optional settings (e.g. waitIntervalMs)
      */
     constructor(client: AthenaClient, options?: AthenaQueryExecutionWaiterOptions);
     /**
-     * Waits until the given query execution completes (or fails/cancels).
+     * Waits until the given query execution completes, fails, or is cancelled.
      *
-     * @param queryExecutionId Query execution ID to wait for
-     * @param waitOptions Optional per-call settings (`timeoutMs`, `pollIntervalMs`)
-     * @returns Execution state on success (SUCCEEDED)
-     * @throws AthenaQueryExecutionWaiterTimeoutError On timeout
-     * @throws AthenaQueryExecutionWaiterStateError When state is FAILED or CANCELLED
-     * @throws AthenaQueryExecutionWaiterMissingStateError When QueryExecution or Status.State is missing
-     * @throws AthenaQueryExecutionWaiterUnsupportedStateError When state is not a known QueryExecutionState
+     * @param queryExecutionId Query execution ID returned by `StartQueryExecution`
+     * @param waitOptions Optional per-call settings (`timeoutMs`, `waitIntervalMs`, `signal`)
+     * @returns `QueryExecutionState.SUCCEEDED` when the query completes successfully
+     * @throws AthenaQueryExecutionWaiterTimeoutError When overall wait exceeds the effective timeout
+     * @throws AthenaQueryExecutionWaiterAbortedError When `waitOptions.signal` is aborted
+     * @throws AthenaQueryExecutionWaiterStateError When the final state is `FAILED` or `CANCELLED`
+     * @throws AthenaQueryExecutionWaiterMissingStateError When `QueryExecution`, `Status`, or `State` is missing
+     * @throws AthenaQueryExecutionWaiterUnsupportedStateError When `State` is not a known {@link QueryExecutionState}
      */
     wait(queryExecutionId: string, waitOptions?: AthenaQueryExecutionWaitOptions): Promise<QueryExecutionState>;
 }
@@ -72,7 +82,19 @@ export declare class AthenaQueryExecutionWaiterError extends Error {
     constructor(message: string);
 }
 /**
- * Thrown when waiting for query execution times out.
+ * Thrown when waiting is aborted via {@link AbortSignal}.
+ *
+ * @property signal Abort signal that triggered cancellation, if available
+ */
+export declare class AthenaQueryExecutionWaiterAbortedError extends AthenaQueryExecutionWaiterError {
+    readonly signal?: AbortSignal | undefined;
+    /**
+     * @param signal Abort signal that triggered cancellation, if available
+     */
+    constructor(signal?: AbortSignal | undefined);
+}
+/**
+ * Thrown when the overall wait exceeds `timeoutMs` or {@link DEFAULT_TIMEOUT_MS}.
  */
 export declare class AthenaQueryExecutionWaiterTimeoutError extends AthenaQueryExecutionWaiterError {
     /**
@@ -81,19 +103,24 @@ export declare class AthenaQueryExecutionWaiterTimeoutError extends AthenaQueryE
     constructor(elapsedTime: number);
 }
 /**
- * Thrown when the query ends in FAILED or CANCELLED state.
+ * Thrown when the query ends in `FAILED` or `CANCELLED` state.
+ *
+ * @property state Terminal execution state (`FAILED` or `CANCELLED`)
+ * @property reason Athena-provided reason for the state change, or `'unknown'` when omitted
  */
 export declare class AthenaQueryExecutionWaiterStateError extends AthenaQueryExecutionWaiterError {
     readonly state: QueryExecutionState;
     readonly reason: string;
     /**
-     * @param state Final execution state (FAILED or CANCELLED)
-     * @param reason Reason for the state change (e.g. error details). Defaults to 'unknown' when omitted
+     * @param state Final execution state (`FAILED` or `CANCELLED`)
+     * @param reason Reason for the state change (e.g. error details). Defaults to `'unknown'` when omitted
      */
     constructor(state: QueryExecutionState, reason?: string);
 }
 /**
- * Thrown when GetQueryExecution response lacks QueryExecution, Status, or State.
+ * Thrown when `GetQueryExecution` response lacks `QueryExecution`, `Status`, or `State`.
+ *
+ * @property detail Description of which part of the response was missing
  */
 export declare class AthenaQueryExecutionWaiterMissingStateError extends AthenaQueryExecutionWaiterError {
     readonly detail: string;
@@ -103,7 +130,9 @@ export declare class AthenaQueryExecutionWaiterMissingStateError extends AthenaQ
     constructor(detail: string);
 }
 /**
- * Thrown when State is present but not a known {@link QueryExecutionState} value.
+ * Thrown when `State` is present but not a known {@link QueryExecutionState} value.
+ *
+ * @property state Unsupported state string returned by Athena
  */
 export declare class AthenaQueryExecutionWaiterUnsupportedStateError extends AthenaQueryExecutionWaiterError {
     readonly state: string;

package/lib/index.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AthenaQueryExecutionWaiterUnsupportedStateError = exports.AthenaQueryExecutionWaiterMissingStateError = exports.AthenaQueryExecutionWaiterStateError = exports.AthenaQueryExecutionWaiterTimeoutError = exports.AthenaQueryExecutionWaiterError = exports.AthenaQueryExecutionWaiter = exports.DEFAULT_TIMEOUT_MS = void 0;
+exports.AthenaQueryExecutionWaiterUnsupportedStateError = exports.AthenaQueryExecutionWaiterMissingStateError = exports.AthenaQueryExecutionWaiterStateError = exports.AthenaQueryExecutionWaiterTimeoutError = exports.AthenaQueryExecutionWaiterAbortedError = exports.AthenaQueryExecutionWaiterError = exports.AthenaQueryExecutionWaiter = exports.DEFAULT_TIMEOUT_MS = void 0;
 const client_athena_1 = require("@aws-sdk/client-athena");
 const wait_predicates_1 = require("./wait-predicates");
-/** Default polling interval (milliseconds) for query execution status. */
-const DEFAULT_POLL_INTERVAL_MS = 1000;
+/** Default wait interval in milliseconds between status checks. */
+const DEFAULT_WAIT_INTERVAL_MS = 1000;
 /**
  * Default overall wait timeout (milliseconds) when `wait()` is called without
  * `waitOptions.timeoutMs`.
  * This caps total wall-clock time from the start of `wait()` until a terminal state
- * (or error)—it is not the delay between polls (`pollIntervalMs`).
+ * (or error)—it is not the delay between status checks (`waitIntervalMs`).
  *
  * **Why 2 minutes:** Athena often exceeds a few seconds (queueing, cold start, moderate
  * scans). Ten seconds fails too often as a library default; unbounded or very large
@@ -19,36 +19,77 @@ const DEFAULT_POLL_INTERVAL_MS = 1000;
  */
 exports.DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
 /**
- * Waits for Athena query execution to complete.
- * Polls execution status until it becomes SUCCEEDED, FAILED, or CANCELLED.
- * Overall time is bounded by `waitOptions.timeoutMs` (or {@link DEFAULT_TIMEOUT_MS});
- * spacing between polls is controlled separately by `pollIntervalMs`.
+ * Throws {@link AthenaQueryExecutionWaiterAbortedError} when `signal` is already aborted.
+ *
+ * @param signal Optional abort signal from `wait()` options
+ * @throws AthenaQueryExecutionWaiterAbortedError When `signal.aborted` is true
+ */
+const throwIfAborted = (signal) => {
+    if (signal?.aborted) {
+        throw new AthenaQueryExecutionWaiterAbortedError(signal);
+    }
+};
+/**
+ * Waits for `ms` milliseconds, rejecting early when `signal` is aborted.
+ *
+ * @param ms Delay in milliseconds
+ * @param signal Optional abort signal from `wait()` options
+ * @throws AthenaQueryExecutionWaiterAbortedError When `signal` is aborted before or during the delay
+ */
+const delay = async (ms, signal) => {
+    throwIfAborted(signal);
+    await new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            cleanup();
+            reject(new AthenaQueryExecutionWaiterAbortedError(signal));
+        };
+        const cleanup = () => {
+            clearTimeout(timeoutId);
+            signal?.removeEventListener('abort', onAbort);
+        };
+        signal?.addEventListener('abort', onAbort);
+    });
+};
+/**
+ * Waits for an Athena query execution to reach a terminal state.
+ *
+ * Repeatedly calls `GetQueryExecution` until the execution becomes
+ * `SUCCEEDED`, `FAILED`, or `CANCELLED`. Overall wall-clock time is bounded by
+ * `waitOptions.timeoutMs` (or {@link DEFAULT_TIMEOUT_MS}); spacing between status
+ * checks is controlled separately by `waitIntervalMs`.
  */
 class AthenaQueryExecutionWaiter {
     /**
      * @param client Athena API client
-     * @param options Optional settings (e.g. pollIntervalMs)
+     * @param options Optional settings (e.g. waitIntervalMs)
      */
     constructor(client, options) {
         this.client = client;
-        this.defaultPollIntervalMs = options?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        this.defaultWaitIntervalMs = options?.waitIntervalMs ?? DEFAULT_WAIT_INTERVAL_MS;
     }
     /**
-     * Waits until the given query execution completes (or fails/cancels).
+     * Waits until the given query execution completes, fails, or is cancelled.
      *
-     * @param queryExecutionId Query execution ID to wait for
-     * @param waitOptions Optional per-call settings (`timeoutMs`, `pollIntervalMs`)
-     * @returns Execution state on success (SUCCEEDED)
-     * @throws AthenaQueryExecutionWaiterTimeoutError On timeout
-     * @throws AthenaQueryExecutionWaiterStateError When state is FAILED or CANCELLED
-     * @throws AthenaQueryExecutionWaiterMissingStateError When QueryExecution or Status.State is missing
-     * @throws AthenaQueryExecutionWaiterUnsupportedStateError When state is not a known QueryExecutionState
+     * @param queryExecutionId Query execution ID returned by `StartQueryExecution`
+     * @param waitOptions Optional per-call settings (`timeoutMs`, `waitIntervalMs`, `signal`)
+     * @returns `QueryExecutionState.SUCCEEDED` when the query completes successfully
+     * @throws AthenaQueryExecutionWaiterTimeoutError When overall wait exceeds the effective timeout
+     * @throws AthenaQueryExecutionWaiterAbortedError When `waitOptions.signal` is aborted
+     * @throws AthenaQueryExecutionWaiterStateError When the final state is `FAILED` or `CANCELLED`
+     * @throws AthenaQueryExecutionWaiterMissingStateError When `QueryExecution`, `Status`, or `State` is missing
+     * @throws AthenaQueryExecutionWaiterUnsupportedStateError When `State` is not a known {@link QueryExecutionState}
      */
     async wait(queryExecutionId, waitOptions) {
         const effectiveTimeoutMs = waitOptions?.timeoutMs ?? exports.DEFAULT_TIMEOUT_MS;
-        const pollIntervalMs = waitOptions?.pollIntervalMs ?? this.defaultPollIntervalMs;
+        const waitIntervalMs = waitOptions?.waitIntervalMs ?? this.defaultWaitIntervalMs;
+        const signal = waitOptions?.signal;
         const startTime = Date.now();
         do {
+            throwIfAborted(signal);
             const elapsedTime = Date.now() - startTime;
             if (elapsedTime > effectiveTimeoutMs) {
                 throw new AthenaQueryExecutionWaiterTimeoutError(elapsedTime);
@@ -56,7 +97,8 @@ class AthenaQueryExecutionWaiter {
             const res = await this.client.send(new client_athena_1.GetQueryExecutionCommand({
                 QueryExecutionId: queryExecutionId,
             }));
-            const outcome = (0, wait_predicates_1.classifyQueryExecutionPoll)(res);
+            throwIfAborted(signal);
+            const outcome = (0, wait_predicates_1.classifyQueryExecutionWait)(res);
             if (outcome.kind === 'succeeded') {
                 return client_athena_1.QueryExecutionState.SUCCEEDED;
             }
@@ -69,7 +111,7 @@ class AthenaQueryExecutionWaiter {
             if (outcome.kind === 'unsupported') {
                 throw new AthenaQueryExecutionWaiterUnsupportedStateError(outcome.state);
             }
-            await new Promise((r) => setTimeout(r, pollIntervalMs));
+            await delay(waitIntervalMs, signal);
         } while (true);
     }
 }
@@ -88,7 +130,23 @@ class AthenaQueryExecutionWaiterError extends Error {
 }
 exports.AthenaQueryExecutionWaiterError = AthenaQueryExecutionWaiterError;
 /**
- * Thrown when waiting for query execution times out.
+ * Thrown when waiting is aborted via {@link AbortSignal}.
+ *
+ * @property signal Abort signal that triggered cancellation, if available
+ */
+class AthenaQueryExecutionWaiterAbortedError extends AthenaQueryExecutionWaiterError {
+    /**
+     * @param signal Abort signal that triggered cancellation, if available
+     */
+    constructor(signal) {
+        super('Athena query execution wait was aborted');
+        this.signal = signal;
+        this.name = 'AthenaQueryExecutionWaiterAbortedError';
+    }
+}
+exports.AthenaQueryExecutionWaiterAbortedError = AthenaQueryExecutionWaiterAbortedError;
+/**
+ * Thrown when the overall wait exceeds `timeoutMs` or {@link DEFAULT_TIMEOUT_MS}.
  */
 class AthenaQueryExecutionWaiterTimeoutError extends AthenaQueryExecutionWaiterError {
     /**
@@ -101,12 +159,15 @@ class AthenaQueryExecutionWaiterTimeoutError extends AthenaQueryExecutionWaiterE
 }
 exports.AthenaQueryExecutionWaiterTimeoutError = AthenaQueryExecutionWaiterTimeoutError;
 /**
- * Thrown when the query ends in FAILED or CANCELLED state.
+ * Thrown when the query ends in `FAILED` or `CANCELLED` state.
+ *
+ * @property state Terminal execution state (`FAILED` or `CANCELLED`)
+ * @property reason Athena-provided reason for the state change, or `'unknown'` when omitted
  */
 class AthenaQueryExecutionWaiterStateError extends AthenaQueryExecutionWaiterError {
     /**
-     * @param state Final execution state (FAILED or CANCELLED)
-     * @param reason Reason for the state change (e.g. error details). Defaults to 'unknown' when omitted
+     * @param state Final execution state (`FAILED` or `CANCELLED`)
+     * @param reason Reason for the state change (e.g. error details). Defaults to `'unknown'` when omitted
      */
     constructor(state, reason = 'unknown') {
         super(`Athena query execution failed with state ${state}: ${reason}`);
@@ -117,7 +178,9 @@ class AthenaQueryExecutionWaiterStateError extends AthenaQueryExecutionWaiterErr
 }
 exports.AthenaQueryExecutionWaiterStateError = AthenaQueryExecutionWaiterStateError;
 /**
- * Thrown when GetQueryExecution response lacks QueryExecution, Status, or State.
+ * Thrown when `GetQueryExecution` response lacks `QueryExecution`, `Status`, or `State`.
+ *
+ * @property detail Description of which part of the response was missing
  */
 class AthenaQueryExecutionWaiterMissingStateError extends AthenaQueryExecutionWaiterError {
     /**
@@ -131,7 +194,9 @@ class AthenaQueryExecutionWaiterMissingStateError extends AthenaQueryExecutionWa
 }
 exports.AthenaQueryExecutionWaiterMissingStateError = AthenaQueryExecutionWaiterMissingStateError;
 /**
- * Thrown when State is present but not a known {@link QueryExecutionState} value.
+ * Thrown when `State` is present but not a known {@link QueryExecutionState} value.
+ *
+ * @property state Unsupported state string returned by Athena
  */
 class AthenaQueryExecutionWaiterUnsupportedStateError extends AthenaQueryExecutionWaiterError {
     /**
@@ -144,4 +209,4 @@ class AthenaQueryExecutionWaiterUnsupportedStateError extends AthenaQueryExecuti
     }
 }
 exports.AthenaQueryExecutionWaiterUnsupportedStateError = AthenaQueryExecutionWaiterUnsupportedStateError;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,0DAAqG;AACrG,uDAA+D;AAE/D,0EAA0E;AAC1E,MAAM,wBAAwB,GAAG,IAAI,CAAC;AAEtC;;;;;;;;;;;GAWG;AACU,QAAA,kBAAkB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AA2BhD;;;;;GAKG;AACH,MAAa,0BAA0B;IAIrC;;;OAGG;IACH,YACmB,MAAoB,EACrC,OAA2C;QAD1B,WAAM,GAAN,MAAM,CAAc;QAGrC,IAAI,CAAC,qBAAqB,GAAG,OAAO,EAAE,cAAc,IAAI,wBAAwB,CAAC;IACnF,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,IAAI,CACR,gBAAwB,EACxB,WAA6C;QAE7C,MAAM,kBAAkB,GAAG,WAAW,EAAE,SAAS,IAAI,0BAAkB,CAAC;QACxE,MAAM,cAAc,GAAG,WAAW,EAAE,cAAc,IAAI,IAAI,CAAC,qBAAqB,CAAC;QACjF,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,GAAG,CAAC;YACF,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;YAC3C,IAAI,WAAW,GAAG,kBAAkB,EAAE,CAAC;gBACrC,MAAM,IAAI,sCAAsC,CAAC,WAAW,CAAC,CAAC;YAChE,CAAC;YAED,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,wCAAwB,CAAC;gBAC9D,gBAAgB,EAAE,gBAAgB;aACnC,CAAC,CAAC,CAAC;YACJ,MAAM,OAAO,GAAG,IAAA,4CAA0B,EAAC,GAAG,CAAC,CAAC;YAEhD,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;gBACjC,OAAO,mCAAmB,CAAC,SAAS,CAAC;YACvC,CAAC;YACD,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC9B,MAAM,IAAI,oCAAoC,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;YAChF,CAAC;YACD,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC/B,MAAM,IAAI,2CAA2C,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YACxE,CAAC;YACD,IAAI,OAAO,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;gBACnC,MAAM,IAAI,+CAA+C,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC3E,CAAC;YAED,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;QAC1D,CAAC,QAAQ,IAAI,EAAE;IACjB,CAAC;CACF;AA5DD,gEA4DC;AAED;;GAEG;AACH,MAAa,+BAAgC,SAAQ,KAAK;IAExD;;OAEG;IACH,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,iCAAiC,CAAC;IAChD,CAAC;CACF;AATD,0EASC;AAED;;GAEG;AACH,MAAa,sCAAuC,SAAQ,+BAA+B;IAEzF;;OAEG;IACH,YAAY,WAAmB;QAC7B,KAAK,CAAC,gCAAgC,WAAW,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,IAAI,GAAG,wCAAwC,CAAC;IACvD,CAAC;CACF;AATD,wFASC;AAED;;GAEG;AACH,MAAa,oCAAqC,SAAQ,+BAA+B;IAEvF;;;OAGG;IACH,YAA4B,KAA0B,EAAkB,SAAiB,SAAS;QAChG,KAAK,CAAC,4CAA4C,KAAK,KAAK,MAAM,EAAE,CAAC,CAAC;QAD5C,UAAK,GAAL,KAAK,CAAqB;QAAkB,WAAM,GAAN,MAAM,CAAoB;QAEhG,IAAI,CAAC,IAAI,GAAG,sCAAsC,CAAC;IACrD,CAAC;CACF;AAVD,oFAUC;AAED;;GAEG;AACH,MAAa,2CAA4C,SAAQ,+BAA+B;IAE9F;;OAEG;IACH,YAA4B,MAAc;QACxC,KAAK,CAAC,2DAA2D,MAAM,EAAE,CAAC,CAAC;QADjD,WAAM,GAAN,MAAM,CAAQ;QAExC,IAAI,CAAC,IAAI,GAAG,6CAA6C,CAAC;IAC5D,CAAC;CACF;AATD,kGASC;AAED;;GAEG;AACH,MAAa,+CAAgD,SAAQ,+BAA+B;IAElG;;OAEG;IACH,YAA4B,KAAa;QACvC,KAAK,CAAC,sDAAsD,KAAK,EAAE,CAAC,CAAC;QAD3C,UAAK,GAAL,KAAK,CAAQ;QAEvC,IAAI,CAAC,IAAI,GAAG,iDAAiD,CAAC;IAChE,CAAC;CACF;AATD,0GASC","sourcesContent":["import { GetQueryExecutionCommand, QueryExecutionState, AthenaClient } from '@aws-sdk/client-athena';\nimport { classifyQueryExecutionPoll } from './wait-predicates';\n\n/** Default polling interval (milliseconds) for query execution status. */\nconst DEFAULT_POLL_INTERVAL_MS = 1000;\n\n/**\n * Default overall wait timeout (milliseconds) when `wait()` is called without\n * `waitOptions.timeoutMs`.\n * This caps total wall-clock time from the start of `wait()` until a terminal state\n * (or error)—it is not the delay between polls (`pollIntervalMs`).\n *\n * **Why 2 minutes:** Athena often exceeds a few seconds (queueing, cold start, moderate\n * scans). Ten seconds fails too often as a library default; unbounded or very large\n * defaults risk hanging callers. Two minutes is a practical middle ground—tight enough\n * to surface stuck work, long enough for many interactive workloads. Use a larger\n * `wait(..., { timeoutMs })` for heavy analytics or ETL.\n */\nexport const DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;\n\n/** Options for AthenaQueryExecutionWaiter constructor. */\nexport interface AthenaQueryExecutionWaiterOptions {\n  /**\n   * Polling interval in milliseconds.\n   * Increase for long-running queries to reduce API calls.\n   * Defaults to DEFAULT_POLL_INTERVAL_MS (1000) when omitted.\n   */\n  pollIntervalMs?: number;\n}\n\n/** Options for wait(). */\nexport interface AthenaQueryExecutionWaitOptions {\n  /**\n   * Overall wall-clock timeout in milliseconds for this wait (from the start of `wait()`\n   * until a terminal state). Not the delay between polls.\n   * Defaults to {@link DEFAULT_TIMEOUT_MS} when omitted.\n   */\n  timeoutMs?: number;\n  /**\n   * Polling interval in milliseconds for this wait.\n   * Overrides the waiter's default poll interval when specified.\n   */\n  pollIntervalMs?: number;\n}\n\n/**\n * Waits for Athena query execution to complete.\n * Polls execution status until it becomes SUCCEEDED, FAILED, or CANCELLED.\n * Overall time is bounded by `waitOptions.timeoutMs` (or {@link DEFAULT_TIMEOUT_MS});\n * spacing between polls is controlled separately by `pollIntervalMs`.\n */\nexport class AthenaQueryExecutionWaiter {\n\n  private readonly defaultPollIntervalMs: number;\n\n  /**\n   * @param client Athena API client\n   * @param options Optional settings (e.g. pollIntervalMs)\n   */\n  constructor(\n    private readonly client: AthenaClient,\n    options?: AthenaQueryExecutionWaiterOptions,\n  ) {\n    this.defaultPollIntervalMs = options?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;\n  }\n\n  /**\n   * Waits until the given query execution completes (or fails/cancels).\n   *\n   * @param queryExecutionId Query execution ID to wait for\n   * @param waitOptions Optional per-call settings (`timeoutMs`, `pollIntervalMs`)\n   * @returns Execution state on success (SUCCEEDED)\n   * @throws AthenaQueryExecutionWaiterTimeoutError On timeout\n   * @throws AthenaQueryExecutionWaiterStateError When state is FAILED or CANCELLED\n   * @throws AthenaQueryExecutionWaiterMissingStateError When QueryExecution or Status.State is missing\n   * @throws AthenaQueryExecutionWaiterUnsupportedStateError When state is not a known QueryExecutionState\n   */\n  async wait(\n    queryExecutionId: string,\n    waitOptions?: AthenaQueryExecutionWaitOptions,\n  ): Promise<QueryExecutionState> {\n    const effectiveTimeoutMs = waitOptions?.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n    const pollIntervalMs = waitOptions?.pollIntervalMs ?? this.defaultPollIntervalMs;\n    const startTime = Date.now();\n    do {\n      const elapsedTime = Date.now() - startTime;\n      if (elapsedTime > effectiveTimeoutMs) {\n        throw new AthenaQueryExecutionWaiterTimeoutError(elapsedTime);\n      }\n\n      const res = await this.client.send(new GetQueryExecutionCommand({\n        QueryExecutionId: queryExecutionId,\n      }));\n      const outcome = classifyQueryExecutionPoll(res);\n\n      if (outcome.kind === 'succeeded') {\n        return QueryExecutionState.SUCCEEDED;\n      }\n      if (outcome.kind === 'failed') {\n        throw new AthenaQueryExecutionWaiterStateError(outcome.state, outcome.reason);\n      }\n      if (outcome.kind === 'missing') {\n        throw new AthenaQueryExecutionWaiterMissingStateError(outcome.detail);\n      }\n      if (outcome.kind === 'unsupported') {\n        throw new AthenaQueryExecutionWaiterUnsupportedStateError(outcome.state);\n      }\n\n      await new Promise((r) => setTimeout(r, pollIntervalMs));\n    } while (true);\n  }\n}\n\n/**\n * Base error for Athena query execution waiter.\n */\nexport class AthenaQueryExecutionWaiterError extends Error {\n\n  /**\n   * @param message Error message\n   */\n  constructor(message: string) {\n    super(message);\n    this.name = 'AthenaQueryExecutionWaiterError';\n  }\n}\n\n/**\n * Thrown when waiting for query execution times out.\n */\nexport class AthenaQueryExecutionWaiterTimeoutError extends AthenaQueryExecutionWaiterError {\n\n  /**\n   * @param elapsedTime Elapsed time in milliseconds until timeout\n   */\n  constructor(elapsedTime: number) {\n    super(`Athena query timed out after ${elapsedTime}ms`);\n    this.name = 'AthenaQueryExecutionWaiterTimeoutError';\n  }\n}\n\n/**\n * Thrown when the query ends in FAILED or CANCELLED state.\n */\nexport class AthenaQueryExecutionWaiterStateError extends AthenaQueryExecutionWaiterError {\n\n  /**\n   * @param state Final execution state (FAILED or CANCELLED)\n   * @param reason Reason for the state change (e.g. error details). Defaults to 'unknown' when omitted\n   */\n  constructor(public readonly state: QueryExecutionState, public readonly reason: string = 'unknown') {\n    super(`Athena query execution failed with state ${state}: ${reason}`);\n    this.name = 'AthenaQueryExecutionWaiterStateError';\n  }\n}\n\n/**\n * Thrown when GetQueryExecution response lacks QueryExecution, Status, or State.\n */\nexport class AthenaQueryExecutionWaiterMissingStateError extends AthenaQueryExecutionWaiterError {\n\n  /**\n   * @param detail Which part of the response was missing\n   */\n  constructor(public readonly detail: string) {\n    super(`Athena query execution status is missing or incomplete: ${detail}`);\n    this.name = 'AthenaQueryExecutionWaiterMissingStateError';\n  }\n}\n\n/**\n * Thrown when State is present but not a known {@link QueryExecutionState} value.\n */\nexport class AthenaQueryExecutionWaiterUnsupportedStateError extends AthenaQueryExecutionWaiterError {\n\n  /**\n   * @param state Unsupported state string returned by Athena\n   */\n  constructor(public readonly state: string) {\n    super(`Athena query execution returned unsupported state: ${state}`);\n    this.name = 'AthenaQueryExecutionWaiterUnsupportedStateError';\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { GetQueryExecutionCommand, QueryExecutionState, AthenaClient } from '@aws-sdk/client-athena';\nimport { classifyQueryExecutionWait } from './wait-predicates';\n\n/** Default wait interval in milliseconds between status checks. */\nconst DEFAULT_WAIT_INTERVAL_MS = 1000;\n\n/**\n * Default overall wait timeout (milliseconds) when `wait()` is called without\n * `waitOptions.timeoutMs`.\n * This caps total wall-clock time from the start of `wait()` until a terminal state\n * (or error)—it is not the delay between status checks (`waitIntervalMs`).\n *\n * **Why 2 minutes:** Athena often exceeds a few seconds (queueing, cold start, moderate\n * scans). Ten seconds fails too often as a library default; unbounded or very large\n * defaults risk hanging callers. Two minutes is a practical middle ground—tight enough\n * to surface stuck work, long enough for many interactive workloads. Use a larger\n * `wait(..., { timeoutMs })` for heavy analytics or ETL.\n */\nexport const DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;\n\n/**\n * Throws {@link AthenaQueryExecutionWaiterAbortedError} when `signal` is already aborted.\n *\n * @param signal Optional abort signal from `wait()` options\n * @throws AthenaQueryExecutionWaiterAbortedError When `signal.aborted` is true\n */\nconst throwIfAborted = (signal?: AbortSignal): void => {\n  if (signal?.aborted) {\n    throw new AthenaQueryExecutionWaiterAbortedError(signal);\n  }\n};\n\n/**\n * Waits for `ms` milliseconds, rejecting early when `signal` is aborted.\n *\n * @param ms Delay in milliseconds\n * @param signal Optional abort signal from `wait()` options\n * @throws AthenaQueryExecutionWaiterAbortedError When `signal` is aborted before or during the delay\n */\nconst delay = async (ms: number, signal?: AbortSignal): Promise<void> => {\n  throwIfAborted(signal);\n  await new Promise<void>((resolve, reject) => {\n    const timeoutId = setTimeout(() => {\n      cleanup();\n      resolve();\n    }, ms);\n    const onAbort = (): void => {\n      cleanup();\n      reject(new AthenaQueryExecutionWaiterAbortedError(signal));\n    };\n    const cleanup = (): void => {\n      clearTimeout(timeoutId);\n      signal?.removeEventListener('abort', onAbort);\n    };\n    signal?.addEventListener('abort', onAbort);\n  });\n};\n\n/** Constructor options for {@link AthenaQueryExecutionWaiter}. */\nexport interface AthenaQueryExecutionWaiterOptions {\n  /**\n   * Default wait interval in milliseconds between status checks for `wait()` calls\n   * that omit `waitIntervalMs`.\n   * Increase for long-running queries to reduce API calls.\n   * Defaults to `1000` when omitted.\n   */\n  waitIntervalMs?: number;\n}\n\n/** Per-call options for {@link AthenaQueryExecutionWaiter.wait}. */\nexport interface AthenaQueryExecutionWaitOptions {\n  /**\n   * Overall wall-clock timeout in milliseconds for this wait (from the start of `wait()`\n   * until a terminal state). Not the delay between status checks.\n   * Defaults to {@link DEFAULT_TIMEOUT_MS} when omitted.\n   */\n  timeoutMs?: number;\n  /**\n   * Wait interval in milliseconds between status checks for this wait.\n   * Overrides the waiter's default wait interval when specified.\n   */\n  waitIntervalMs?: number;\n  /**\n   * Optional abort signal. When aborted, waiting stops immediately and\n   * {@link AthenaQueryExecutionWaiterAbortedError} is thrown—before the next status\n   * check, after a status check returns, or during the wait interval.\n   */\n  signal?: AbortSignal;\n}\n\n/**\n * Waits for an Athena query execution to reach a terminal state.\n *\n * Repeatedly calls `GetQueryExecution` until the execution becomes\n * `SUCCEEDED`, `FAILED`, or `CANCELLED`. Overall wall-clock time is bounded by\n * `waitOptions.timeoutMs` (or {@link DEFAULT_TIMEOUT_MS}); spacing between status\n * checks is controlled separately by `waitIntervalMs`.\n */\nexport class AthenaQueryExecutionWaiter {\n\n  private readonly defaultWaitIntervalMs: number;\n\n  /**\n   * @param client Athena API client\n   * @param options Optional settings (e.g. waitIntervalMs)\n   */\n  constructor(\n    private readonly client: AthenaClient,\n    options?: AthenaQueryExecutionWaiterOptions,\n  ) {\n    this.defaultWaitIntervalMs = options?.waitIntervalMs ?? DEFAULT_WAIT_INTERVAL_MS;\n  }\n\n  /**\n   * Waits until the given query execution completes, fails, or is cancelled.\n   *\n   * @param queryExecutionId Query execution ID returned by `StartQueryExecution`\n   * @param waitOptions Optional per-call settings (`timeoutMs`, `waitIntervalMs`, `signal`)\n   * @returns `QueryExecutionState.SUCCEEDED` when the query completes successfully\n   * @throws AthenaQueryExecutionWaiterTimeoutError When overall wait exceeds the effective timeout\n   * @throws AthenaQueryExecutionWaiterAbortedError When `waitOptions.signal` is aborted\n   * @throws AthenaQueryExecutionWaiterStateError When the final state is `FAILED` or `CANCELLED`\n   * @throws AthenaQueryExecutionWaiterMissingStateError When `QueryExecution`, `Status`, or `State` is missing\n   * @throws AthenaQueryExecutionWaiterUnsupportedStateError When `State` is not a known {@link QueryExecutionState}\n   */\n  async wait(\n    queryExecutionId: string,\n    waitOptions?: AthenaQueryExecutionWaitOptions,\n  ): Promise<QueryExecutionState> {\n    const effectiveTimeoutMs = waitOptions?.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n    const waitIntervalMs = waitOptions?.waitIntervalMs ?? this.defaultWaitIntervalMs;\n    const signal = waitOptions?.signal;\n    const startTime = Date.now();\n    do {\n      throwIfAborted(signal);\n\n      const elapsedTime = Date.now() - startTime;\n      if (elapsedTime > effectiveTimeoutMs) {\n        throw new AthenaQueryExecutionWaiterTimeoutError(elapsedTime);\n      }\n\n      const res = await this.client.send(new GetQueryExecutionCommand({\n        QueryExecutionId: queryExecutionId,\n      }));\n      throwIfAborted(signal);\n\n      const outcome = classifyQueryExecutionWait(res);\n\n      if (outcome.kind === 'succeeded') {\n        return QueryExecutionState.SUCCEEDED;\n      }\n      if (outcome.kind === 'failed') {\n        throw new AthenaQueryExecutionWaiterStateError(outcome.state, outcome.reason);\n      }\n      if (outcome.kind === 'missing') {\n        throw new AthenaQueryExecutionWaiterMissingStateError(outcome.detail);\n      }\n      if (outcome.kind === 'unsupported') {\n        throw new AthenaQueryExecutionWaiterUnsupportedStateError(outcome.state);\n      }\n\n      await delay(waitIntervalMs, signal);\n    } while (true);\n  }\n}\n\n/**\n * Base error for Athena query execution waiter.\n */\nexport class AthenaQueryExecutionWaiterError extends Error {\n\n  /**\n   * @param message Error message\n   */\n  constructor(message: string) {\n    super(message);\n    this.name = 'AthenaQueryExecutionWaiterError';\n  }\n}\n\n/**\n * Thrown when waiting is aborted via {@link AbortSignal}.\n *\n * @property signal Abort signal that triggered cancellation, if available\n */\nexport class AthenaQueryExecutionWaiterAbortedError extends AthenaQueryExecutionWaiterError {\n\n  /**\n   * @param signal Abort signal that triggered cancellation, if available\n   */\n  constructor(public readonly signal?: AbortSignal) {\n    super('Athena query execution wait was aborted');\n    this.name = 'AthenaQueryExecutionWaiterAbortedError';\n  }\n}\n\n/**\n * Thrown when the overall wait exceeds `timeoutMs` or {@link DEFAULT_TIMEOUT_MS}.\n */\nexport class AthenaQueryExecutionWaiterTimeoutError extends AthenaQueryExecutionWaiterError {\n\n  /**\n   * @param elapsedTime Elapsed time in milliseconds until timeout\n   */\n  constructor(elapsedTime: number) {\n    super(`Athena query timed out after ${elapsedTime}ms`);\n    this.name = 'AthenaQueryExecutionWaiterTimeoutError';\n  }\n}\n\n/**\n * Thrown when the query ends in `FAILED` or `CANCELLED` state.\n *\n * @property state Terminal execution state (`FAILED` or `CANCELLED`)\n * @property reason Athena-provided reason for the state change, or `'unknown'` when omitted\n */\nexport class AthenaQueryExecutionWaiterStateError extends AthenaQueryExecutionWaiterError {\n\n  /**\n   * @param state Final execution state (`FAILED` or `CANCELLED`)\n   * @param reason Reason for the state change (e.g. error details). Defaults to `'unknown'` when omitted\n   */\n  constructor(public readonly state: QueryExecutionState, public readonly reason: string = 'unknown') {\n    super(`Athena query execution failed with state ${state}: ${reason}`);\n    this.name = 'AthenaQueryExecutionWaiterStateError';\n  }\n}\n\n/**\n * Thrown when `GetQueryExecution` response lacks `QueryExecution`, `Status`, or `State`.\n *\n * @property detail Description of which part of the response was missing\n */\nexport class AthenaQueryExecutionWaiterMissingStateError extends AthenaQueryExecutionWaiterError {\n\n  /**\n   * @param detail Which part of the response was missing\n   */\n  constructor(public readonly detail: string) {\n    super(`Athena query execution status is missing or incomplete: ${detail}`);\n    this.name = 'AthenaQueryExecutionWaiterMissingStateError';\n  }\n}\n\n/**\n * Thrown when `State` is present but not a known {@link QueryExecutionState} value.\n *\n * @property state Unsupported state string returned by Athena\n */\nexport class AthenaQueryExecutionWaiterUnsupportedStateError extends AthenaQueryExecutionWaiterError {\n\n  /**\n   * @param state Unsupported state string returned by Athena\n   */\n  constructor(public readonly state: string) {\n    super(`Athena query execution returned unsupported state: ${state}`);\n    this.name = 'AthenaQueryExecutionWaiterUnsupportedStateError';\n  }\n}\n"]}

package/lib/wait-predicates.d.ts

@@ -1,6 +1,9 @@
 import { QueryExecutionState } from '@aws-sdk/client-athena';
-/** Minimal GetQueryExecution shape used for polling (State may be unknown at runtime). */
-export interface QueryExecutionPollResponse {
+/**
+ * Minimal `GetQueryExecution` response shape used while waiting.
+ * `State` may be an unknown string at runtime.
+ */
+export interface QueryExecutionWaitResponse {
     QueryExecution?: {
         Status?: {
             State?: string;
@@ -8,8 +11,16 @@ export interface QueryExecutionPollResponse {
         };
     };
 }
-/** Result of classifying a single GetQueryExecution poll. */
-export type QueryExecutionPollOutcome = {
+/**
+ * Result of classifying a single `GetQueryExecution` response during a wait.
+ *
+ * - `succeeded` — execution completed successfully
+ * - `failed` — execution ended in `FAILED` or `CANCELLED`
+ * - `continue` — execution is still in progress (`QUEUED` or `RUNNING`)
+ * - `missing` — required fields are absent from the response
+ * - `unsupported` — `State` is not a known {@link QueryExecutionState}
+ */
+export type QueryExecutionWaitOutcome = {
     readonly kind: 'succeeded';
 } | {
     readonly kind: 'failed';
@@ -25,14 +36,16 @@ export type QueryExecutionPollOutcome = {
     readonly state: string;
 };
 /**
- * Classifies GetQueryExecution response for the waiter poll loop.
+ * Classifies a `GetQueryExecution` response for the waiter loop.
  *
- * @param response GetQueryExecution API response (or subset)
- * @returns How the waiter should proceed for this poll
+ * @param response `GetQueryExecution` API response (or a compatible subset)
+ * @returns How the waiter should proceed for this status check
  */
-export declare const classifyQueryExecutionPoll: (response: QueryExecutionPollResponse) => QueryExecutionPollOutcome;
+export declare const classifyQueryExecutionWait: (response: QueryExecutionWaitResponse) => QueryExecutionWaitOutcome;
 /**
- * @param outcome Outcome from {@link classifyQueryExecutionPoll}
- * @returns Whether the waiter should poll again after the interval
+ * Returns whether the waiter should perform another status check after the wait interval.
+ *
+ * @param outcome Outcome from {@link classifyQueryExecutionWait}
+ * @returns `true` when `outcome.kind` is `'continue'`; otherwise `false`
  */
-export declare const shouldContinuePolling: (outcome: QueryExecutionPollOutcome) => boolean;
+export declare const shouldContinueWaiting: (outcome: QueryExecutionWaitOutcome) => boolean;

package/lib/wait-predicates.js

@@ -1,18 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldContinuePolling = exports.classifyQueryExecutionPoll = void 0;
+exports.shouldContinueWaiting = exports.classifyQueryExecutionWait = void 0;
 const client_athena_1 = require("@aws-sdk/client-athena");
+/** Execution states that require further waiting before a terminal outcome. */
 const IN_PROGRESS_STATES = new Set([
     client_athena_1.QueryExecutionState.QUEUED,
     client_athena_1.QueryExecutionState.RUNNING,
 ]);
 /**
- * Classifies GetQueryExecution response for the waiter poll loop.
+ * Classifies a `GetQueryExecution` response for the waiter loop.
  *
- * @param response GetQueryExecution API response (or subset)
- * @returns How the waiter should proceed for this poll
+ * @param response `GetQueryExecution` API response (or a compatible subset)
+ * @returns How the waiter should proceed for this status check
  */
-const classifyQueryExecutionPoll = (response) => {
+const classifyQueryExecutionWait = (response) => {
     const queryExecution = response.QueryExecution;
     if (queryExecution === undefined) {
         return {
@@ -56,11 +57,13 @@ const classifyQueryExecutionPoll = (response) => {
     }
     return { kind: 'unsupported', state };
 };
-exports.classifyQueryExecutionPoll = classifyQueryExecutionPoll;
+exports.classifyQueryExecutionWait = classifyQueryExecutionWait;
 /**
- * @param outcome Outcome from {@link classifyQueryExecutionPoll}
- * @returns Whether the waiter should poll again after the interval
+ * Returns whether the waiter should perform another status check after the wait interval.
+ *
+ * @param outcome Outcome from {@link classifyQueryExecutionWait}
+ * @returns `true` when `outcome.kind` is `'continue'`; otherwise `false`
  */
-const shouldContinuePolling = (outcome) => outcome.kind === 'continue';
-exports.shouldContinuePolling = shouldContinuePolling;
-//# sourceMappingURL=data:application/json;base64,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
+const shouldContinueWaiting = (outcome) => outcome.kind === 'continue';
+exports.shouldContinueWaiting = shouldContinueWaiting;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "athena-query-execution-waiter",
-  "description": "A small library that waits for an AWS Athena query execution to complete. It polls the Athena API until the execution reaches a terminal state: SUCCEEDED, FAILED, or CANCELLED.",
+  "description": "A small library that waits for an AWS Athena query execution to complete. It repeatedly checks the Athena API until the execution reaches a terminal state: SUCCEEDED, FAILED, or CANCELLED.",
   "repository": {
     "type": "git",
     "url": "https://github.com/gammarers-aws-sdk-extensions/athena-query-execution-waiter.git"
@@ -64,8 +64,7 @@
   },
   "devEngines": {
     "packageManager": {
-      "name": "yarn",
-      "version": "1.22.22",
+      "name": "npm",
       "onFail": "ignore"
     }
   },
@@ -74,7 +73,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.7",
+  "version": "0.6.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [
@@ -121,6 +120,5 @@
     }
   },
   "types": "lib/index.d.ts",
-  "packageManager": "yarn@1.22.22",
   "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
 }