athena-query-execution-waiter 0.4.7 → 0.5.0

package/README.md

@@ -9,7 +9,7 @@ A small library that waits for an AWS Athena query execution to complete. It pol
 
 - 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).
+- Typed errors: **`AthenaQueryExecutionWaiterTimeoutError`**, **`AthenaQueryExecutionWaiterStateError`** (failed or cancelled runs), **`AthenaQueryExecutionWaiterMissingStateError`**, **`AthenaQueryExecutionWaiterUnsupportedStateError`**.
 - Built for **AWS SDK for JavaScript v3** (`@aws-sdk/client-athena`).
 
 ## Installation
@@ -118,6 +118,8 @@ Passed to `wait(queryExecutionId, waitOptions?)`.
   - **Returns** `SUCCEEDED` on success.
   - **Throws** `AthenaQueryExecutionWaiterTimeoutError` if overall wait exceeds the effective timeout.
   - **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** `AthenaQueryExecutionWaiterUnsupportedStateError` when `State` is present but not a known `QueryExecutionState` (e.g. a future Athena enum value).
 
 ### Constants
 
@@ -128,6 +130,8 @@ 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)`.
 - **`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.
 
 ## License
 

package/lib/index.d.ts

@@ -57,6 +57,8 @@ export declare class AthenaQueryExecutionWaiter {
      * @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
      */
     wait(queryExecutionId: string, waitOptions?: AthenaQueryExecutionWaitOptions): Promise<QueryExecutionState>;
 }
@@ -90,3 +92,23 @@ export declare class AthenaQueryExecutionWaiterStateError extends AthenaQueryExe
      */
     constructor(state: QueryExecutionState, reason?: string);
 }
+/**
+ * Thrown when GetQueryExecution response lacks QueryExecution, Status, or State.
+ */
+export declare class AthenaQueryExecutionWaiterMissingStateError extends AthenaQueryExecutionWaiterError {
+    readonly detail: string;
+    /**
+     * @param detail Which part of the response was missing
+     */
+    constructor(detail: string);
+}
+/**
+ * Thrown when State is present but not a known {@link QueryExecutionState} value.
+ */
+export declare class AthenaQueryExecutionWaiterUnsupportedStateError extends AthenaQueryExecutionWaiterError {
+    readonly state: string;
+    /**
+     * @param state Unsupported state string returned by Athena
+     */
+    constructor(state: string);
+}

package/lib/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AthenaQueryExecutionWaiterStateError = exports.AthenaQueryExecutionWaiterTimeoutError = exports.AthenaQueryExecutionWaiterError = exports.AthenaQueryExecutionWaiter = exports.DEFAULT_TIMEOUT_MS = void 0;
+exports.AthenaQueryExecutionWaiterUnsupportedStateError = exports.AthenaQueryExecutionWaiterMissingStateError = exports.AthenaQueryExecutionWaiterStateError = exports.AthenaQueryExecutionWaiterTimeoutError = 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;
 /**
@@ -40,6 +41,8 @@ class AthenaQueryExecutionWaiter {
      * @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
      */
     async wait(queryExecutionId, waitOptions) {
         const effectiveTimeoutMs = waitOptions?.timeoutMs ?? exports.DEFAULT_TIMEOUT_MS;
@@ -53,14 +56,18 @@ class AthenaQueryExecutionWaiter {
             const res = await this.client.send(new client_athena_1.GetQueryExecutionCommand({
                 QueryExecutionId: queryExecutionId,
             }));
-            const st = res.QueryExecution?.Status;
-            const state = st?.State;
-            const reason = st?.StateChangeReason;
-            if (state === client_athena_1.QueryExecutionState.SUCCEEDED) {
-                return state;
+            const outcome = (0, wait_predicates_1.classifyQueryExecutionPoll)(res);
+            if (outcome.kind === 'succeeded') {
+                return client_athena_1.QueryExecutionState.SUCCEEDED;
             }
-            if (state === client_athena_1.QueryExecutionState.FAILED || state === client_athena_1.QueryExecutionState.CANCELLED) {
-                throw new AthenaQueryExecutionWaiterStateError(state, reason ?? 'unknown');
+            if (outcome.kind === 'failed') {
+                throw new AthenaQueryExecutionWaiterStateError(outcome.state, outcome.reason);
+            }
+            if (outcome.kind === 'missing') {
+                throw new AthenaQueryExecutionWaiterMissingStateError(outcome.detail);
+            }
+            if (outcome.kind === 'unsupported') {
+                throw new AthenaQueryExecutionWaiterUnsupportedStateError(outcome.state);
             }
             await new Promise((r) => setTimeout(r, pollIntervalMs));
         } while (true);
@@ -109,4 +116,32 @@ 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;;;;;;;;;;;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"]}
+/**
+ * Thrown when GetQueryExecution response lacks QueryExecution, Status, or State.
+ */
+class AthenaQueryExecutionWaiterMissingStateError extends AthenaQueryExecutionWaiterError {
+    /**
+     * @param detail Which part of the response was missing
+     */
+    constructor(detail) {
+        super(`Athena query execution status is missing or incomplete: ${detail}`);
+        this.detail = detail;
+        this.name = 'AthenaQueryExecutionWaiterMissingStateError';
+    }
+}
+exports.AthenaQueryExecutionWaiterMissingStateError = AthenaQueryExecutionWaiterMissingStateError;
+/**
+ * Thrown when State is present but not a known {@link QueryExecutionState} value.
+ */
+class AthenaQueryExecutionWaiterUnsupportedStateError extends AthenaQueryExecutionWaiterError {
+    /**
+     * @param state Unsupported state string returned by Athena
+     */
+    constructor(state) {
+        super(`Athena query execution returned unsupported state: ${state}`);
+        this.state = state;
+        this.name = 'AthenaQueryExecutionWaiterUnsupportedStateError';
+    }
+}
+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"]}

package/lib/wait-predicates.d.ts

@@ -0,0 +1,38 @@
+import { QueryExecutionState } from '@aws-sdk/client-athena';
+/** Minimal GetQueryExecution shape used for polling (State may be unknown at runtime). */
+export interface QueryExecutionPollResponse {
+    QueryExecution?: {
+        Status?: {
+            State?: string;
+            StateChangeReason?: string;
+        };
+    };
+}
+/** Result of classifying a single GetQueryExecution poll. */
+export type QueryExecutionPollOutcome = {
+    readonly kind: 'succeeded';
+} | {
+    readonly kind: 'failed';
+    readonly state: typeof QueryExecutionState.FAILED | typeof QueryExecutionState.CANCELLED;
+    readonly reason: string;
+} | {
+    readonly kind: 'continue';
+} | {
+    readonly kind: 'missing';
+    readonly detail: string;
+} | {
+    readonly kind: 'unsupported';
+    readonly state: string;
+};
+/**
+ * Classifies GetQueryExecution response for the waiter poll loop.
+ *
+ * @param response GetQueryExecution API response (or subset)
+ * @returns How the waiter should proceed for this poll
+ */
+export declare const classifyQueryExecutionPoll: (response: QueryExecutionPollResponse) => QueryExecutionPollOutcome;
+/**
+ * @param outcome Outcome from {@link classifyQueryExecutionPoll}
+ * @returns Whether the waiter should poll again after the interval
+ */
+export declare const shouldContinuePolling: (outcome: QueryExecutionPollOutcome) => boolean;

package/lib/wait-predicates.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldContinuePolling = exports.classifyQueryExecutionPoll = void 0;
+const client_athena_1 = require("@aws-sdk/client-athena");
+const IN_PROGRESS_STATES = new Set([
+    client_athena_1.QueryExecutionState.QUEUED,
+    client_athena_1.QueryExecutionState.RUNNING,
+]);
+/**
+ * Classifies GetQueryExecution response for the waiter poll loop.
+ *
+ * @param response GetQueryExecution API response (or subset)
+ * @returns How the waiter should proceed for this poll
+ */
+const classifyQueryExecutionPoll = (response) => {
+    const queryExecution = response.QueryExecution;
+    if (queryExecution === undefined) {
+        return {
+            kind: 'missing',
+            detail: 'QueryExecution is missing from GetQueryExecution response',
+        };
+    }
+    const status = queryExecution.Status;
+    if (status === undefined) {
+        return {
+            kind: 'missing',
+            detail: 'QueryExecution.Status is missing',
+        };
+    }
+    const state = status.State;
+    if (state === undefined) {
+        return {
+            kind: 'missing',
+            detail: 'QueryExecution.Status.State is missing',
+        };
+    }
+    if (state === client_athena_1.QueryExecutionState.SUCCEEDED) {
+        return { kind: 'succeeded' };
+    }
+    if (state === client_athena_1.QueryExecutionState.FAILED) {
+        return {
+            kind: 'failed',
+            state: client_athena_1.QueryExecutionState.FAILED,
+            reason: status.StateChangeReason ?? 'unknown',
+        };
+    }
+    if (state === client_athena_1.QueryExecutionState.CANCELLED) {
+        return {
+            kind: 'failed',
+            state: client_athena_1.QueryExecutionState.CANCELLED,
+            reason: status.StateChangeReason ?? 'unknown',
+        };
+    }
+    if (IN_PROGRESS_STATES.has(state)) {
+        return { kind: 'continue' };
+    }
+    return { kind: 'unsupported', state };
+};
+exports.classifyQueryExecutionPoll = classifyQueryExecutionPoll;
+/**
+ * @param outcome Outcome from {@link classifyQueryExecutionPoll}
+ * @returns Whether the waiter should poll again after the interval
+ */
+const shouldContinuePolling = (outcome) => outcome.kind === 'continue';
+exports.shouldContinuePolling = shouldContinuePolling;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,5 +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.",
   "repository": {
     "type": "git",
     "url": "https://github.com/gammarers-aws-sdk-extensions/athena-query-execution-waiter.git"
@@ -50,6 +51,14 @@
   "dependencies": {
     "@aws-sdk/client-athena": "^3.983.0"
   },
+  "keywords": [
+    "athena",
+    "aws",
+    "aws-sdk",
+    "execution",
+    "query",
+    "waiter"
+  ],
   "engines": {
     "node": ">= 20.0.0"
   },
@@ -65,7 +74,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.4.7",
+  "version": "0.5.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [