athena-query-execution-waiter 0.3.13 → 0.4.0

package/README.md

@@ -1,7 +1,17 @@
 # Athena Query Execution Waiter
 
+[![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**.
 
+## 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).
+- Built for **AWS SDK for JavaScript v3** (`@aws-sdk/client-athena`).
+
 ## Installation
 
 **@aws-sdk/client-athena** is a normal **dependency** of this package: installing `athena-query-execution-waiter` pulls in a compatible AWS SDK v3 Athena client. If your app also depends on `@aws-sdk/client-athena`, npm/yarn will dedupe when versions are compatible; otherwise you may have two copies under different semver ranges.
@@ -29,6 +39,7 @@ npm install athena-query-execution-waiter
 import { AthenaClient } from '@aws-sdk/client-athena';
 import {
   AthenaQueryExecutionWaiter,
+  DEFAULT_TIMEOUT_MS,
   AthenaQueryExecutionWaiterTimeoutError,
   AthenaQueryExecutionWaiterStateError,
 } from 'athena-query-execution-waiter';
@@ -36,7 +47,7 @@ import {
 const client = new AthenaClient({ region: 'us-east-1' });
 const waiter = new AthenaQueryExecutionWaiter(client);
 
-// Start a query with StartQueryExecution, then wait for it to complete
+// After StartQueryExecution, wait until the execution completes
 const queryExecutionId = 'your-query-execution-id';
 
 try {
@@ -53,59 +64,70 @@ try {
 }
 ```
 
-### Custom timeout
+### Overall timeout vs polling 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`. |
 
-The default timeout is 10 seconds. You can pass a custom timeout in milliseconds:
+Long-running jobs should pass a higher `timeoutMs` when needed:
 
 ```typescript
-const state = await waiter.wait(queryExecutionId, 60_000); // 60 seconds
+const state = await waiter.wait(queryExecutionId, {
+  timeoutMs: 15 * 60_000, // 15 minutes overall
+});
 ```
 
-### Polling interval
-
-The default polling interval is 1 second. For long-running queries, you can increase it to reduce API calls. Set it at construction time or per `wait()` call:
+Default polling interval is **1 second**. Increase it to reduce API calls (constructor or per `wait()`):
 
 ```typescript
-// Waiter-wide: poll every 5 seconds
 const waiter = new AthenaQueryExecutionWaiter(client, { pollIntervalMs: 5000 });
 
-// Or per call (overrides the waiter default)
-const state = await waiter.wait(queryExecutionId, 60_000, { pollIntervalMs: 3000 });
+const state = await waiter.wait(queryExecutionId, {
+  timeoutMs: 60_000,
+  pollIntervalMs: 3000,
+});
 ```
 
-## API
+## Options
+
+### `AthenaQueryExecutionWaiterOptions` (constructor)
+
+Passed to `new AthenaQueryExecutionWaiter(client, options?)`.
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `pollIntervalMs` | `number` (optional) | Default milliseconds **between** `GetQueryExecution` calls when `wait()` omits `pollIntervalMs`. Default: `1000`. |
+
+### `AthenaQueryExecutionWaitOptions` (`wait()`)
+
+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`. |
+
+## API reference
 
 ### `AthenaQueryExecutionWaiter`
 
 - **Constructor:** `new AthenaQueryExecutionWaiter(client: AthenaClient, options?: AthenaQueryExecutionWaiterOptions)`
-  - `client` – An AWS SDK v3 `AthenaClient` instance.
-  - `options.pollIntervalMs` – Optional. Polling interval in ms (default: 1000).
-
-- **`wait(queryExecutionId: string, timeoutMs?: number, waitOptions?: AthenaQueryExecutionWaitOptions): Promise<QueryExecutionState>`**
-  - Polls the query execution status until it completes.
-  - **Returns** the execution state (`SUCCEEDED`) on success.
-  - **Throws** `AthenaQueryExecutionWaiterTimeoutError` if the timeout is exceeded.
+- **`wait(queryExecutionId: string, waitOptions?: AthenaQueryExecutionWaitOptions): Promise<QueryExecutionState>`**
+  - **Returns** `SUCCEEDED` on success.
+  - **Throws** `AthenaQueryExecutionWaiterTimeoutError` if overall wait exceeds the effective timeout.
   - **Throws** `AthenaQueryExecutionWaiterStateError` when the state is `FAILED` or `CANCELLED`.
-  - `timeoutMs` defaults to 10,000 ms when omitted.
-  - `waitOptions.pollIntervalMs` – Optional. Overrides the polling interval for this call (default: use constructor value or 1000).
 
-### Types
+### Constants
 
-- **`AthenaQueryExecutionWaiterOptions`** – `{ pollIntervalMs?: number }` (constructor options).
-- **`AthenaQueryExecutionWaitOptions`** – `{ pollIntervalMs?: number }` (options for `wait()`).
+- **`DEFAULT_TIMEOUT_MS`** — Default overall wait cap in milliseconds (2 minutes) when `waitOptions.timeoutMs` is omitted. Safe to import for your own guards or logging.
 
 ### Errors
 
-- **`AthenaQueryExecutionWaiterError`** – Base class for all waiter errors.
-
-- **`AthenaQueryExecutionWaiterTimeoutError`** – Thrown when the wait duration exceeds `timeoutMs`.
-  - Extends `AthenaQueryExecutionWaiterError`.
-  - Constructor: `(elapsedTime: number)`.
-
-- **`AthenaQueryExecutionWaiterStateError`** – Thrown when the query ends in `FAILED` or `CANCELLED`.
-  - Extends `AthenaQueryExecutionWaiterError`.
-  - Properties: `state` (`QueryExecutionState`), `reason` (string).
-  - Constructor: `(state: QueryExecutionState, reason?: string)`.
+- **`AthenaQueryExecutionWaiterError`** — Base class for waiter errors.
+- **`AthenaQueryExecutionWaiterTimeoutError`** — Overall elapsed time since `wait()` started exceeded `waitOptions.timeoutMs` or `DEFAULT_TIMEOUT_MS`. Constructor: `(elapsedTime: number)`.
+- **`AthenaQueryExecutionWaiterStateError`** — Query ended in `FAILED` or `CANCELLED`. Properties: `state`, `reason`. Constructor: `(state: QueryExecutionState, reason?: string)`.
 
 ## License
 

package/lib/index.d.ts

@@ -1,4 +1,17 @@
 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`).
+ *
+ * **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
+ * defaults risk hanging callers. Two minutes is a practical middle ground—tight enough
+ * to surface stuck work, long enough for many interactive workloads. Use a larger
+ * `wait(..., { timeoutMs })` for heavy analytics or ETL.
+ */
+export declare const DEFAULT_TIMEOUT_MS: number;
 /** Options for AthenaQueryExecutionWaiter constructor. */
 export interface AthenaQueryExecutionWaiterOptions {
     /**
@@ -10,6 +23,12 @@ export interface AthenaQueryExecutionWaiterOptions {
 }
 /** Options for 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.
+     * 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.
@@ -19,26 +38,27 @@ export interface AthenaQueryExecutionWaitOptions {
 /**
  * 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`.
  */
 export declare class AthenaQueryExecutionWaiter {
     private readonly client;
     private readonly defaultPollIntervalMs;
     /**
      * @param client Athena API client
-     * @param options Optional settings (e.g. pollIntervalMs for polling interval)
+     * @param options Optional settings (e.g. pollIntervalMs)
      */
     constructor(client: AthenaClient, options?: AthenaQueryExecutionWaiterOptions);
     /**
      * Waits until the given query execution completes (or fails/cancels).
      *
      * @param queryExecutionId Query execution ID to wait for
-     * @param timeoutMs Timeout in milliseconds. Defaults to DEFAULT_TIMEOUT_MS when omitted
-     * @param waitOptions Optional per-call options (e.g. pollIntervalMs overrides default)
+     * @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
      */
-    wait(queryExecutionId: string, timeoutMs?: number, waitOptions?: AthenaQueryExecutionWaitOptions): Promise<QueryExecutionState>;
+    wait(queryExecutionId: string, waitOptions?: AthenaQueryExecutionWaitOptions): Promise<QueryExecutionState>;
 }
 /**
  * Base error for Athena query execution waiter.

package/lib/index.js

@@ -1,19 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AthenaQueryExecutionWaiterStateError = exports.AthenaQueryExecutionWaiterTimeoutError = exports.AthenaQueryExecutionWaiterError = exports.AthenaQueryExecutionWaiter = void 0;
+exports.AthenaQueryExecutionWaiterStateError = exports.AthenaQueryExecutionWaiterTimeoutError = exports.AthenaQueryExecutionWaiterError = exports.AthenaQueryExecutionWaiter = exports.DEFAULT_TIMEOUT_MS = void 0;
 const client_athena_1 = require("@aws-sdk/client-athena");
 /** Default polling interval (milliseconds) for query execution status. */
 const DEFAULT_POLL_INTERVAL_MS = 1000;
-/** Default timeout (milliseconds) for waiting for query execution to complete. */
-const DEFAULT_TIMEOUT_MS = 1000 * 10;
+/**
+ * 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`).
+ *
+ * **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
+ * defaults risk hanging callers. Two minutes is a practical middle ground—tight enough
+ * to surface stuck work, long enough for many interactive workloads. Use a larger
+ * `wait(..., { timeoutMs })` for heavy analytics or ETL.
+ */
+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`.
  */
 class AthenaQueryExecutionWaiter {
     /**
      * @param client Athena API client
-     * @param options Optional settings (e.g. pollIntervalMs for polling interval)
+     * @param options Optional settings (e.g. pollIntervalMs)
      */
     constructor(client, options) {
         this.client = client;
@@ -23,18 +36,18 @@ class AthenaQueryExecutionWaiter {
      * Waits until the given query execution completes (or fails/cancels).
      *
      * @param queryExecutionId Query execution ID to wait for
-     * @param timeoutMs Timeout in milliseconds. Defaults to DEFAULT_TIMEOUT_MS when omitted
-     * @param waitOptions Optional per-call options (e.g. pollIntervalMs overrides default)
+     * @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
      */
-    async wait(queryExecutionId, timeoutMs = DEFAULT_TIMEOUT_MS, waitOptions) {
+    async wait(queryExecutionId, waitOptions) {
+        const effectiveTimeoutMs = waitOptions?.timeoutMs ?? exports.DEFAULT_TIMEOUT_MS;
         const pollIntervalMs = waitOptions?.pollIntervalMs ?? this.defaultPollIntervalMs;
         const startTime = Date.now();
         do {
             const elapsedTime = Date.now() - startTime;
-            if (elapsedTime > timeoutMs) {
+            if (elapsedTime > effectiveTimeoutMs) {
                 throw new AthenaQueryExecutionWaiterTimeoutError(elapsedTime);
             }
             const res = await this.client.send(new client_athena_1.GetQueryExecutionCommand({
@@ -96,4 +109,4 @@ class AthenaQueryExecutionWaiterStateError extends AthenaQueryExecutionWaiterErr
     }
 }
 exports.AthenaQueryExecutionWaiterStateError = AthenaQueryExecutionWaiterStateError;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,0DAAqG;AAErG,0EAA0E;AAC1E,MAAM,wBAAwB,GAAG,IAAI,CAAC;AAEtC,kFAAkF;AAClF,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAE,CAAC;AAqBrC;;;GAGG;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;;;;;;;;;OASG;IACH,KAAK,CAAC,IAAI,CACR,gBAAwB,EACxB,YAAoB,kBAAkB,EACtC,WAA6C;QAE7C,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,SAAS,EAAE,CAAC;gBAC5B,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,EAAE,GAAG,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC;YACtC,MAAM,KAAK,GAAG,EAAE,EAAE,KAAwC,CAAC;YAC3D,MAAM,MAAM,GAAG,EAAE,EAAE,iBAAiB,CAAC;YAErC,IAAI,KAAK,KAAK,mCAAmB,CAAC,SAAS,EAAE,CAAC;gBAC5C,OAAO,KAAK,CAAC;YACf,CAAC;YACD,IAAI,KAAK,KAAK,mCAAmB,CAAC,MAAM,IAAI,KAAK,KAAK,mCAAmB,CAAC,SAAS,EAAE,CAAC;gBACpF,MAAM,IAAI,oCAAoC,CAAC,KAAK,EAAE,MAAM,IAAI,SAAS,CAAC,CAAC;YAC7E,CAAC;YACD,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;AAtDD,gEAsDC;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","sourcesContent":["import { GetQueryExecutionCommand, QueryExecutionState, AthenaClient } from '@aws-sdk/client-athena';\n\n/** Default polling interval (milliseconds) for query execution status. */\nconst DEFAULT_POLL_INTERVAL_MS = 1000;\n\n/** Default timeout (milliseconds) for waiting for query execution to complete. */\nconst DEFAULT_TIMEOUT_MS = 1000 * 10;\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   * 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 */\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 for polling interval)\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 timeoutMs Timeout in milliseconds. Defaults to DEFAULT_TIMEOUT_MS when omitted\n   * @param waitOptions Optional per-call options (e.g. pollIntervalMs overrides default)\n   * @returns Execution state on success (SUCCEEDED)\n   * @throws AthenaQueryExecutionWaiterTimeoutError On timeout\n   * @throws AthenaQueryExecutionWaiterStateError When state is FAILED or CANCELLED\n   */\n  async wait(\n    queryExecutionId: string,\n    timeoutMs: number = DEFAULT_TIMEOUT_MS,\n    waitOptions?: AthenaQueryExecutionWaitOptions,\n  ): Promise<QueryExecutionState> {\n    const pollIntervalMs = waitOptions?.pollIntervalMs ?? this.defaultPollIntervalMs;\n    const startTime = Date.now();\n    do {\n      const elapsedTime = Date.now() - startTime;\n      if (elapsedTime > timeoutMs) {\n        throw new AthenaQueryExecutionWaiterTimeoutError(elapsedTime);\n      }\n\n      const res = await this.client.send(new GetQueryExecutionCommand({\n        QueryExecutionId: queryExecutionId,\n      }));\n      const st = res.QueryExecution?.Status;\n      const state = st?.State as QueryExecutionState | undefined;\n      const reason = st?.StateChangeReason;\n\n      if (state === QueryExecutionState.SUCCEEDED) {\n        return state;\n      }\n      if (state === QueryExecutionState.FAILED || state === QueryExecutionState.CANCELLED) {\n        throw new AthenaQueryExecutionWaiterStateError(state, reason ?? 'unknown');\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,0DAAqG;AAErG,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;;;;;;;;OAQG;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,EAAE,GAAG,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC;YACtC,MAAM,KAAK,GAAG,EAAE,EAAE,KAAwC,CAAC;YAC3D,MAAM,MAAM,GAAG,EAAE,EAAE,iBAAiB,CAAC;YAErC,IAAI,KAAK,KAAK,mCAAmB,CAAC,SAAS,EAAE,CAAC;gBAC5C,OAAO,KAAK,CAAC;YACf,CAAC;YACD,IAAI,KAAK,KAAK,mCAAmB,CAAC,MAAM,IAAI,KAAK,KAAK,mCAAmB,CAAC,SAAS,EAAE,CAAC;gBACpF,MAAM,IAAI,oCAAoC,CAAC,KAAK,EAAE,MAAM,IAAI,SAAS,CAAC,CAAC;YAC7E,CAAC;YACD,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;AArDD,gEAqDC;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","sourcesContent":["import { GetQueryExecutionCommand, QueryExecutionState, AthenaClient } from '@aws-sdk/client-athena';\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   */\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 st = res.QueryExecution?.Status;\n      const state = st?.State as QueryExecutionState | undefined;\n      const reason = st?.StateChangeReason;\n\n      if (state === QueryExecutionState.SUCCEEDED) {\n        return state;\n      }\n      if (state === QueryExecutionState.FAILED || state === QueryExecutionState.CANCELLED) {\n        throw new AthenaQueryExecutionWaiterStateError(state, reason ?? 'unknown');\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"]}

package/package.json

@@ -65,7 +65,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.13",
+  "version": "0.4.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [