athena-query-result-pager 0.2.8 → 0.3.0

package/README.md

@@ -3,17 +3,16 @@
 ![npm](https://img.shields.io/npm/v/athena-query-result-pager)
 ![license](https://img.shields.io/npm/l/athena-query-result-pager)
 
-Paginate AWS Athena query results with AWS SDK v3. This package fetches results page by page and supports raw rows or custom row parsing via [athena-query-result-parser](https://www.npmjs.com/package/athena-query-result-parser).
+Paginate [AWS Athena](https://docs.aws.amazon.com/athena/latest/ug/v3-sdk.html) **`GetQueryResults`** calls with AWS SDK v3. This library walks **`NextToken`**, parses tabular rows with [athena-query-result-parser](https://www.npmjs.com/package/athena-query-result-parser), and forwards **`MaxResults`** and **`QueryResultType`** from **[PagerOptions](#options)** on every [`GetQueryResults`](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/athena/command/GetQueryResultsCommand/) request.
 
 ## Features
 
-- Paginates Athena `GetQueryResults` responses with `nextToken`.
-- Supports raw rows (`ParsedRow`) and custom typed row parsing.
-- Provides async generators for page-by-page and row-by-row iteration.
-- Includes fail-fast input validation:
-  - `maxResults` must be an integer in `1..1000`.
-  - `queryExecutionId` must be a non-empty string.
-- Exposes a simple static utility: `AthenaQueryResultPager.hasNextPage(...)`.
+- Sends paginated Athena **`GetQueryResults`** requests (`NextToken` / **`MaxResults`**).
+- Forwards **`QueryResultType`** from the pager constructor (`DATA_ROWS`, **`DATA_MANIFEST`**, etc.) on each request — suitable for CTAS / UNLOAD / INSERT manifest workflows when Athena allows it.
+- Supports raw **`ParsedRow`** dictionaries and typed rows via **`RowParser<T>`** (including async generators).
+- Async generators iterate **page-by-page** (**`iteratePages`**, **`iteratePagesWith`**) or **row-by-row** (**`iterateRows`**) without holding full result sets in memory.
+- Fail-fast validation: **`maxResults`** must be an integer in **`1..1000`**; **`queryExecutionId`** must be non-empty ( **`fetchPage`**, **`fetchPageWith`** ).
+- Helpers: **`AthenaQueryResultPager.hasNextPage`**, **`reset()`** when reusing one pager across different executions (parser/header state).
 
 ## Installation
 
@@ -25,21 +24,30 @@ npm install athena-query-result-pager
 yarn add athena-query-result-pager
 ```
 
-Dependencies: `@aws-sdk/client-athena`, `athena-query-result-parser`.
+```bash
+pnpm add athena-query-result-pager
+```
+
+Runtime dependencies (**direct** once you publish): `@aws-sdk/client-athena`, `athena-query-result-parser`. Your application typically already instantiates **`AthenaClient`** with credentials and Region.
 
 ## Usage
 
 ### Create a pager instance
 
+**`AthenaQueryResultPager`** options are normalized at construction time (**defaults**: **`maxResults`** `1000`, **`queryResultType`** `QueryResultType.DATA_ROWS`). Both fields are populated on **`GetQueryResults`** for **`fetchPage`**, **`fetchPageWith`**, and all iterators built on those methods.
+
 ```ts
-import { AthenaClient } from '@aws-sdk/client-athena';
+import { AthenaClient, QueryResultType } from '@aws-sdk/client-athena';
 import { AthenaQueryResultPager } from 'athena-query-result-pager';
 
 const client = new AthenaClient({ region: 'us-east-1' });
 const pager = new AthenaQueryResultPager(client, {
   maxResults: 1000,
-  queryResultType: 'DATA_ROWS',
+  queryResultType: QueryResultType.DATA_ROWS,
 });
+
+// Manifest-style outputs (only for supported Athena query types):
+// new AthenaQueryResultPager(client, { queryResultType: QueryResultType.DATA_MANIFEST })
 ```
 
 ### Fetch one page (raw rows)
@@ -59,7 +67,10 @@ if (AthenaQueryResultPager.hasNextPage(page)) {
 ```ts
 import type { RowParser } from 'athena-query-result-pager';
 
-interface MyRow { id: string; name: string; }
+interface MyRow {
+  id: string;
+  name: string;
+}
 const rowParser: RowParser<MyRow> = (row) => ({
   id: row['id'] ?? '',
   name: row['name'] ?? '',
@@ -72,7 +83,7 @@ const page = await pager.fetchPageWith('query-execution-id', rowParser);
 ### Iterate pages (async generator)
 
 ```ts
-// Raw ParsedRow
+// Raw ParsedRow pages
 for await (const page of pager.iteratePages('query-execution-id')) {
   console.log(page.rowCount, page.rows);
 }
@@ -85,15 +96,17 @@ for await (const page of pager.iteratePagesWith('query-execution-id', rowParser)
 
 ### Iterate row by row (memory-efficient)
 
+Requires a **`RowParser`** mapping **`ParsedRow`** to your row type (**`iterateRows`** wraps **`iteratePagesWith`**).
+
 ```ts
 for await (const row of pager.iterateRows('query-execution-id', rowParser)) {
   console.log(row);
 }
 ```
 
-### Reset before a new query
+### Reset before another execution
 
-When processing a different query with the same pager instance, reset the parser state:
+Reuse the same pager for a **new** **`queryExecutionId`** after resetting the bundled **`AthenaQueryResultParser`** header/skip logic:
 
 ```ts
 pager.reset();
@@ -103,43 +116,45 @@ pager.reset();
 
 ### `PagerOptions`
 
-- `maxResults?: number`
-  - Default: `1000`
-  - Valid range: integer `1..1000` (Athena limit)
-  - Throws `RangeError` when invalid
-- `queryResultType?: 'DATA_ROWS'`
-  - Default: `'DATA_ROWS'`
+- **`maxResults?: number`**
+  - Default **`1000`**.
+  - Valid range: integer **`1..1000`** (Athena **`GetQueryResults`** limit).
+  - Throws **`RangeError`** when invalid (**constructor**).
+- **`queryResultType?: QueryResultType`**
+  - Same flag as Athena **`GetQueryResults` `QueryResultType`** ( **`DATA_ROWS`**, **`DATA_MANIFEST`**, … ). Import **`QueryResultType`** from **`@aws-sdk/client-athena`** when typing options.
+  - Default **`QueryResultType.DATA_ROWS`**.
+  - When set (**including default**), the value appears on **`fetchPage`**, **`fetchPageWith`**, and iterator-driven calls alongside **`MaxResults`**.
 
 ### Method input validation
 
-- `fetchPage(queryExecutionId, nextToken?)`
-- `fetchPageWith(queryExecutionId, rowParser, nextToken?)`
+- **`fetchPage(queryExecutionId, nextToken?)`**
+- **`fetchPageWith(queryExecutionId, rowParser, nextToken?)`**
 
-Both methods throw an error if `queryExecutionId` is empty or whitespace only.
+Both throw if **`queryExecutionId`** is empty or whitespace-only (before invoking AWS).
 
 ## API
 
 ### `AthenaQueryResultPager`
 
 - **`constructor(client: AthenaClient, options?: PagerOptions)`**
-- **`fetchPage(queryExecutionId, nextToken?)`** → `Promise<PageResult<ParsedRow>>`
-- **`fetchPageWith<T>(queryExecutionId, rowParser, nextToken?)`** → `Promise<PageResult<T>>`
-- **`iteratePages(queryExecutionId)`** → `AsyncGenerator<PageResult<ParsedRow>>`
-- **`iteratePagesWith<T>(queryExecutionId, rowParser)`** → `AsyncGenerator<PageResult<T>>`
-- **`iterateRows<T>(queryExecutionId, rowParser)`** → `AsyncGenerator<T>`
-- **`reset()`** — resets parser state for a new query.
-- **`static hasNextPage<T>(pageResult: PageResult<T>)`** → `boolean`
+- **`fetchPage(queryExecutionId, nextToken?)`** → **`Promise<PageResult<ParsedRow>>`**
+- **`fetchPageWith<T>(queryExecutionId, rowParser, nextToken?)`** → **`Promise<PageResult<T>>`**
+- **`iteratePages(queryExecutionId)`** → **`AsyncGenerator<PageResult<ParsedRow>>`**
+- **`iteratePagesWith<T>(queryExecutionId, rowParser)`** → **`AsyncGenerator<PageResult<T>>`**
+- **`iterateRows<T>(queryExecutionId, rowParser)`** → **`AsyncGenerator<T>`**
+- **`reset()`** — new parser instance (**header row bookkeeping** resets).
+- **`static hasNextPage<T>(pageResult: PageResult<T>)`** → **`boolean`**
 
 ### Types
 
-- **`PageResult<T>`** — `{ rows: T[]; nextToken?: string; rowCount: number }`
-- **`PagerOptions`** — `{ maxResults?: number; queryResultType?: 'DATA_ROWS' }`
-- **`ParsedRow`**, **`RowParser<T>`** — re-exported from `athena-query-result-parser`.
+- **`PageResult<T>`** — **`{ rows: T[]; nextToken?: string; rowCount: number }`**
+- **`PagerOptions`** — **`{ maxResults?: number; queryResultType?: QueryResultType }`** (**`QueryResultType`** from **`@aws-sdk/client-athena`**)
+- **`ParsedRow`**, **`RowParser<T>`** — re-exported from **`athena-query-result-parser`**.
 
 ## Requirements
 
-- Node.js `>= 20.0.0`
-- AWS SDK v3 client: `@aws-sdk/client-athena`
+- Node.js **`>= 20.0.0`**
+- AWS SDK for JavaScript v3 — **`@aws-sdk/client-athena`** (`AthenaClient`, **`QueryResultType`**)
 
 ## License
 

package/lib/index.d.ts

@@ -1,75 +1,110 @@
-import { AthenaClient } from '@aws-sdk/client-athena';
+import { AthenaClient, QueryResultType } from '@aws-sdk/client-athena';
 import { type ParsedRow, type RowParser } from 'athena-query-result-parser';
 /**
- * Type for a single page of query results.
+ * One page of Athena query rows after a {@link AthenaQueryResultPager} fetch or generator step.
+ *
+ * @typeParam T - Row representation; use {@link ParsedRow} or a type produced by {@link RowParser}.
  */
 export interface PageResult<T> {
-    /** Parsed row data. */
+    /** Parsed rows for this page only. */
     rows: T[];
-    /** Token for the next page (undefined if no more pages). */
+    /** Continuation token for the following page (`undefined` when this is the last page). */
     nextToken?: string;
-    /** Number of rows in this page. */
+    /** Same as `rows.length` for convenience. */
     rowCount: number;
 }
 /**
- * Options for the pager.
+ * Settings applied to every `GetQueryResults` invocation made by {@link AthenaQueryResultPager}.
  */
 export interface PagerOptions {
-    /** Maximum number of rows per page (default: 1000). */
+    /**
+     * `MaxResults` per request — must be an integer from 1 through 1000 (Athena limits).
+     * @defaultValue 1000
+     */
     maxResults?: number;
-    /** Query result type (default: 'DATA_ROWS'). */
-    queryResultType?: 'DATA_ROWS';
+    /**
+     * `QueryResultType` forwarded to Athena (for example raw data rows versus manifest rows for CTAS/UNLOAD/INSERT outputs).
+     * @defaultValue `QueryResultType.DATA_ROWS`
+     */
+    queryResultType?: QueryResultType;
 }
 /**
- * AthenaQueryResultPager
- * Fetches Athena query results page by page.
+ * Paginates Athena `GetQueryResults` (AWS SDK for JavaScript v3): walks `NextToken` and parses tabular rows with
+ * `athena-query-result-parser` when needed.
+ *
+ * `maxResults` and `queryResultType` from the constructor are included on every `GetQueryResults` request.
+ *
+ * @see {@link https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/athena/command/GetQueryResultsCommand/ | GetQueryResultsCommand (AWS SDK)}
  */
 export declare class AthenaQueryResultPager {
     /**
-     * Returns whether there is a next page.
-     * @param pageResult - Previous page result.
+     * @typeParam T - Row type held in {@link PageResult.rows}.
+     * @param pageResult - The most recently retrieved page from `fetchPage`, `fetchPageWith`, or a page iterator.
+     * @returns `true` when {@link PageResult.nextToken} is defined and another page should be fetched.
      */
     static hasNextPage<T>(pageResult: PageResult<T>): boolean;
     private readonly client;
+    /** Normalized pager settings (every field set after merging defaults). */
     private readonly options;
+    /** Stateful parser reused across calls; recreated by {@link AthenaQueryResultPager.reset}. */
     private parser;
+    /**
+     * @param client - SDK v3 `AthenaClient` used to call `GetQueryResults`.
+     * @param options - Optional `MaxResults` and `QueryResultType`; defaults apply when omitted.
+     * @throws {RangeError} When `maxResults` is not an integer in `1..1000` inclusive.
+     */
     constructor(client: AthenaClient, options?: PagerOptions);
     /**
-     * Fetches one page of data as raw ParsedRow.
-     * @param queryExecutionId - Query execution ID.
-     * @param nextToken - Token for the next page (undefined on first call).
-     * @returns Page result.
+     * Retrieves a single results page using {@link AthenaQueryResultParser.parseResultSet} (dictionary-shaped rows).
+     *
+     * @param queryExecutionId - Athena query execution identifier.
+     * @param nextToken - Pass `undefined` first; subsequent calls use {@link PageResult.nextToken}.
+     * @returns Parsed rows plus pagination metadata from this response only.
+     * @throws {Error} When `queryExecutionId` is empty or whitespace only.
      */
     fetchPage(queryExecutionId: string, nextToken?: string): Promise<PageResult<ParsedRow>>;
     /**
-     * Fetches one page of data and transforms it with a custom row parser.
-     * @param queryExecutionId - Query execution ID.
-     * @param rowParser - Row parser.
-     * @param nextToken - Token for the next page (undefined on first call).
-     * @returns Page result.
+     * Retrieves one page and maps each {@link ParsedRow} through `rowParser`.
+     *
+     * @typeParam T - Output type produced by `rowParser`.
+     * @param queryExecutionId - Athena query execution identifier.
+     * @param rowParser - Converts each dictionary row into `T`.
+     * @param nextToken - Pass `undefined` first; subsequent calls use {@link PageResult.nextToken}.
+     * @returns Transformed rows plus pagination metadata from this response only.
+     * @throws {Error} When `queryExecutionId` is empty or whitespace only.
      */
     fetchPageWith<T>(queryExecutionId: string, rowParser: RowParser<T>, nextToken?: string): Promise<PageResult<T>>;
     /**
-     * Iterates page by page via AsyncGenerator (raw ParsedRow).
-     * @param queryExecutionId - Query execution ID.
+     * Lazily walks all pages for an execution, yielding {@link PageResult} of {@link ParsedRow} each step.
+     *
+     * @param queryExecutionId - Athena query execution identifier.
+     * @yields One page at a time until AWS returns no `NextToken`.
      */
     iteratePages(queryExecutionId: string): AsyncGenerator<PageResult<ParsedRow>>;
     /**
-     * Iterates page by page via AsyncGenerator with a custom row parser.
-     * @param queryExecutionId - Query execution ID.
-     * @param rowParser - Row parser.
+     * Same as {@link AthenaQueryResultPager.iteratePages} but applies `rowParser` per row on every page.
+     *
+     * @typeParam T - Output type emitted in {@link PageResult.rows}.
+     * @param queryExecutionId - Athena query execution identifier.
+     * @param rowParser - Converts each parsed row into `T`.
+     * @yields Successive {@link PageResult} values whose `rows` are typed as `T`.
      */
     iteratePagesWith<T>(queryExecutionId: string, rowParser: RowParser<T>): AsyncGenerator<PageResult<T>>;
     /**
-     * Iterates row by row via AsyncGenerator (memory-efficient).
-     * @param queryExecutionId - Query execution ID.
-     * @param rowParser - Row parser.
+     * Flattens {@link AthenaQueryResultPager.iteratePagesWith} into individual `T` values (one row per `next()`).
+     *
+     * @typeParam T - Output type produced by `rowParser`.
+     * @param queryExecutionId - Athena query execution identifier.
+     * @param rowParser - Converts each parsed row into `T`.
+     * @yields Each data row in execution order without buffering the full result set in memory.
      */
     iterateRows<T>(queryExecutionId: string, rowParser: RowParser<T>): AsyncGenerator<T>;
     /**
-     * Resets the parser state. Call before processing a new query.
+     * Instantiates a fresh {@link AthenaQueryResultParser} so header-row handling does not leak between queries.
+     *
+     * Call when reusing this pager for a different `queryExecutionId` than the previous parse sequence.
      */
     reset(): void;
 }
-/** Re-export of types from athena-query-result-parser. */
+/** Re-exports `ParsedRow` and `RowParser` from the `athena-query-result-parser` package. */
 export type { ParsedRow, RowParser };

package/lib/index.js

@@ -3,25 +3,36 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AthenaQueryResultPager = void 0;
 const client_athena_1 = require("@aws-sdk/client-athena");
 const athena_query_result_parser_1 = require("athena-query-result-parser");
-/** Default maximum number of rows per page. */
+/** Default maximum number of result rows requested per {@link AthenaQueryResultPager} API call (`MaxResults`). */
 const DEFAULT_MAX_RESULTS = 1000;
-/** Minimum and maximum allowed by Athena GetQueryResults. */
+/** Minimum `MaxResults` value allowed by Athena `GetQueryResults`. */
 const MIN_MAX_RESULTS = 1;
+/** Maximum `MaxResults` value allowed by Athena `GetQueryResults`. */
 const MAX_MAX_RESULTS = 1000;
-/** Default query result type for GetQueryResults. */
-const DEFAULT_QUERY_RESULT_TYPE = 'DATA_ROWS';
+/** Default `QueryResultType` forwarded to Athena `GetQueryResults`. */
+const DEFAULT_QUERY_RESULT_TYPE = client_athena_1.QueryResultType.DATA_ROWS;
 /**
- * AthenaQueryResultPager
- * Fetches Athena query results page by page.
+ * Paginates Athena `GetQueryResults` (AWS SDK for JavaScript v3): walks `NextToken` and parses tabular rows with
+ * `athena-query-result-parser` when needed.
+ *
+ * `maxResults` and `queryResultType` from the constructor are included on every `GetQueryResults` request.
+ *
+ * @see {@link https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/athena/command/GetQueryResultsCommand/ | GetQueryResultsCommand (AWS SDK)}
  */
 class AthenaQueryResultPager {
     /**
-     * Returns whether there is a next page.
-     * @param pageResult - Previous page result.
+     * @typeParam T - Row type held in {@link PageResult.rows}.
+     * @param pageResult - The most recently retrieved page from `fetchPage`, `fetchPageWith`, or a page iterator.
+     * @returns `true` when {@link PageResult.nextToken} is defined and another page should be fetched.
      */
     static hasNextPage(pageResult) {
         return pageResult.nextToken !== undefined;
     }
+    /**
+     * @param client - SDK v3 `AthenaClient` used to call `GetQueryResults`.
+     * @param options - Optional `MaxResults` and `QueryResultType`; defaults apply when omitted.
+     * @throws {RangeError} When `maxResults` is not an integer in `1..1000` inclusive.
+     */
     constructor(client, options = {}) {
         const maxResults = options.maxResults ?? DEFAULT_MAX_RESULTS;
         if (!Number.isInteger(maxResults) || maxResults < MIN_MAX_RESULTS || maxResults > MAX_MAX_RESULTS) {
@@ -35,10 +46,12 @@ class AthenaQueryResultPager {
         this.parser = new athena_query_result_parser_1.AthenaQueryResultParser();
     }
     /**
-     * Fetches one page of data as raw ParsedRow.
-     * @param queryExecutionId - Query execution ID.
-     * @param nextToken - Token for the next page (undefined on first call).
-     * @returns Page result.
+     * Retrieves a single results page using {@link AthenaQueryResultParser.parseResultSet} (dictionary-shaped rows).
+     *
+     * @param queryExecutionId - Athena query execution identifier.
+     * @param nextToken - Pass `undefined` first; subsequent calls use {@link PageResult.nextToken}.
+     * @returns Parsed rows plus pagination metadata from this response only.
+     * @throws {Error} When `queryExecutionId` is empty or whitespace only.
      */
     async fetchPage(queryExecutionId, nextToken) {
         if (queryExecutionId.trim() === '') {
@@ -48,6 +61,7 @@ class AthenaQueryResultPager {
             QueryExecutionId: queryExecutionId,
             NextToken: nextToken,
             MaxResults: this.options.maxResults,
+            QueryResultType: this.options.queryResultType,
         };
         const response = await this.client.send(new client_athena_1.GetQueryResultsCommand(input));
         const rows = this.parser.parseResultSet(response.ResultSet);
@@ -58,11 +72,14 @@ class AthenaQueryResultPager {
         };
     }
     /**
-     * Fetches one page of data and transforms it with a custom row parser.
-     * @param queryExecutionId - Query execution ID.
-     * @param rowParser - Row parser.
-     * @param nextToken - Token for the next page (undefined on first call).
-     * @returns Page result.
+     * Retrieves one page and maps each {@link ParsedRow} through `rowParser`.
+     *
+     * @typeParam T - Output type produced by `rowParser`.
+     * @param queryExecutionId - Athena query execution identifier.
+     * @param rowParser - Converts each dictionary row into `T`.
+     * @param nextToken - Pass `undefined` first; subsequent calls use {@link PageResult.nextToken}.
+     * @returns Transformed rows plus pagination metadata from this response only.
+     * @throws {Error} When `queryExecutionId` is empty or whitespace only.
      */
     async fetchPageWith(queryExecutionId, rowParser, nextToken) {
         if (queryExecutionId.trim() === '') {
@@ -72,6 +89,7 @@ class AthenaQueryResultPager {
             QueryExecutionId: queryExecutionId,
             NextToken: nextToken,
             MaxResults: this.options.maxResults,
+            QueryResultType: this.options.queryResultType,
         };
         const response = await this.client.send(new client_athena_1.GetQueryResultsCommand(input));
         const rows = this.parser.parseResultSetWith(response.ResultSet, rowParser);
@@ -82,8 +100,10 @@ class AthenaQueryResultPager {
         };
     }
     /**
-     * Iterates page by page via AsyncGenerator (raw ParsedRow).
-     * @param queryExecutionId - Query execution ID.
+     * Lazily walks all pages for an execution, yielding {@link PageResult} of {@link ParsedRow} each step.
+     *
+     * @param queryExecutionId - Athena query execution identifier.
+     * @yields One page at a time until AWS returns no `NextToken`.
      */
     async *iteratePages(queryExecutionId) {
         let nextToken;
@@ -94,9 +114,12 @@ class AthenaQueryResultPager {
         } while (nextToken);
     }
     /**
-     * Iterates page by page via AsyncGenerator with a custom row parser.
-     * @param queryExecutionId - Query execution ID.
-     * @param rowParser - Row parser.
+     * Same as {@link AthenaQueryResultPager.iteratePages} but applies `rowParser` per row on every page.
+     *
+     * @typeParam T - Output type emitted in {@link PageResult.rows}.
+     * @param queryExecutionId - Athena query execution identifier.
+     * @param rowParser - Converts each parsed row into `T`.
+     * @yields Successive {@link PageResult} values whose `rows` are typed as `T`.
      */
     async *iteratePagesWith(queryExecutionId, rowParser) {
         let nextToken;
@@ -107,9 +130,12 @@ class AthenaQueryResultPager {
         } while (nextToken);
     }
     /**
-     * Iterates row by row via AsyncGenerator (memory-efficient).
-     * @param queryExecutionId - Query execution ID.
-     * @param rowParser - Row parser.
+     * Flattens {@link AthenaQueryResultPager.iteratePagesWith} into individual `T` values (one row per `next()`).
+     *
+     * @typeParam T - Output type produced by `rowParser`.
+     * @param queryExecutionId - Athena query execution identifier.
+     * @param rowParser - Converts each parsed row into `T`.
+     * @yields Each data row in execution order without buffering the full result set in memory.
      */
     async *iterateRows(queryExecutionId, rowParser) {
         for await (const page of this.iteratePagesWith(queryExecutionId, rowParser)) {
@@ -119,11 +145,13 @@ class AthenaQueryResultPager {
         }
     }
     /**
-     * Resets the parser state. Call before processing a new query.
+     * Instantiates a fresh {@link AthenaQueryResultParser} so header-row handling does not leak between queries.
+     *
+     * Call when reusing this pager for a different `queryExecutionId` than the previous parse sequence.
      */
     reset() {
         this.parser = new athena_query_result_parser_1.AthenaQueryResultParser();
     }
 }
 exports.AthenaQueryResultPager = AthenaQueryResultPager;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { AthenaClient, GetQueryResultsCommand, type GetQueryResultsCommandInput } from '@aws-sdk/client-athena';\nimport { AthenaQueryResultParser, type ParsedRow, type RowParser } from 'athena-query-result-parser';\n\n/** Default maximum number of rows per page. */\nconst DEFAULT_MAX_RESULTS = 1000;\n/** Minimum and maximum allowed by Athena GetQueryResults. */\nconst MIN_MAX_RESULTS = 1;\nconst MAX_MAX_RESULTS = 1000;\n\n/** Default query result type for GetQueryResults. */\nconst DEFAULT_QUERY_RESULT_TYPE = 'DATA_ROWS' as const;\n\n/**\n * Type for a single page of query results.\n */\nexport interface PageResult<T> {\n  /** Parsed row data. */\n  rows: T[];\n  /** Token for the next page (undefined if no more pages). */\n  nextToken?: string;\n  /** Number of rows in this page. */\n  rowCount: number;\n}\n\n/**\n * Options for the pager.\n */\nexport interface PagerOptions {\n  /** Maximum number of rows per page (default: 1000). */\n  maxResults?: number;\n  /** Query result type (default: 'DATA_ROWS'). */\n  queryResultType?: 'DATA_ROWS';\n}\n\n/**\n * AthenaQueryResultPager\n * Fetches Athena query results page by page.\n */\nexport class AthenaQueryResultPager {\n\n  /**\n   * Returns whether there is a next page.\n   * @param pageResult - Previous page result.\n   */\n  static hasNextPage<T>(pageResult: PageResult<T>): boolean {\n    return pageResult.nextToken !== undefined;\n  }\n\n  private readonly client: AthenaClient;\n  private readonly options: Required<PagerOptions>;\n  private parser: AthenaQueryResultParser;\n\n  constructor(client: AthenaClient, options: PagerOptions = {}) {\n    const maxResults = options.maxResults ?? DEFAULT_MAX_RESULTS;\n    if (!Number.isInteger(maxResults) || maxResults < MIN_MAX_RESULTS || maxResults > MAX_MAX_RESULTS) {\n      throw new RangeError(\n        `options.maxResults must be an integer between ${MIN_MAX_RESULTS} and ${MAX_MAX_RESULTS}, got ${String(maxResults)}`,\n      );\n    }\n\n    this.client = client;\n    this.options = {\n      maxResults,\n      queryResultType: options.queryResultType ?? DEFAULT_QUERY_RESULT_TYPE,\n    };\n    this.parser = new AthenaQueryResultParser();\n  }\n\n  /**\n   * Fetches one page of data as raw ParsedRow.\n   * @param queryExecutionId - Query execution ID.\n   * @param nextToken - Token for the next page (undefined on first call).\n   * @returns Page result.\n   */\n  async fetchPage(\n    queryExecutionId: string,\n    nextToken?: string,\n  ): Promise<PageResult<ParsedRow>> {\n    if (queryExecutionId.trim() === '') {\n      throw new Error('queryExecutionId must be a non-empty string');\n    }\n\n    const input: GetQueryResultsCommandInput = {\n      QueryExecutionId: queryExecutionId,\n      NextToken: nextToken,\n      MaxResults: this.options.maxResults,\n    };\n\n    const response = await this.client.send(new GetQueryResultsCommand(input));\n\n    const rows = this.parser.parseResultSet(response.ResultSet);\n\n    return {\n      rows,\n      nextToken: response.NextToken,\n      rowCount: rows.length,\n    };\n  }\n\n  /**\n   * Fetches one page of data and transforms it with a custom row parser.\n   * @param queryExecutionId - Query execution ID.\n   * @param rowParser - Row parser.\n   * @param nextToken - Token for the next page (undefined on first call).\n   * @returns Page result.\n   */\n  async fetchPageWith<T>(\n    queryExecutionId: string,\n    rowParser: RowParser<T>,\n    nextToken?: string,\n  ): Promise<PageResult<T>> {\n    if (queryExecutionId.trim() === '') {\n      throw new Error('queryExecutionId must be a non-empty string');\n    }\n\n    const input: GetQueryResultsCommandInput = {\n      QueryExecutionId: queryExecutionId,\n      NextToken: nextToken,\n      MaxResults: this.options.maxResults,\n    };\n\n    const response = await this.client.send(new GetQueryResultsCommand(input));\n\n    const rows = this.parser.parseResultSetWith(response.ResultSet, rowParser);\n\n    return {\n      rows,\n      nextToken: response.NextToken,\n      rowCount: rows.length,\n    };\n  }\n\n  /**\n   * Iterates page by page via AsyncGenerator (raw ParsedRow).\n   * @param queryExecutionId - Query execution ID.\n   */\n  async *iteratePages(\n    queryExecutionId: string,\n  ): AsyncGenerator<PageResult<ParsedRow>> {\n    let nextToken: string | undefined;\n\n    do {\n      const page = await this.fetchPage(queryExecutionId, nextToken);\n      yield page;\n      nextToken = page.nextToken;\n    } while (nextToken);\n  }\n\n  /**\n   * Iterates page by page via AsyncGenerator with a custom row parser.\n   * @param queryExecutionId - Query execution ID.\n   * @param rowParser - Row parser.\n   */\n  async *iteratePagesWith<T>(\n    queryExecutionId: string,\n    rowParser: RowParser<T>,\n  ): AsyncGenerator<PageResult<T>> {\n    let nextToken: string | undefined;\n\n    do {\n      const page = await this.fetchPageWith(queryExecutionId, rowParser, nextToken);\n      yield page;\n      nextToken = page.nextToken;\n    } while (nextToken);\n  }\n\n  /**\n   * Iterates row by row via AsyncGenerator (memory-efficient).\n   * @param queryExecutionId - Query execution ID.\n   * @param rowParser - Row parser.\n   */\n  async *iterateRows<T>(\n    queryExecutionId: string,\n    rowParser: RowParser<T>,\n  ): AsyncGenerator<T> {\n    for await (const page of this.iteratePagesWith(queryExecutionId, rowParser)) {\n      for (const row of page.rows) {\n        yield row;\n      }\n    }\n  }\n\n  /**\n   * Resets the parser state. Call before processing a new query.\n   */\n  reset(): void {\n    this.parser = new AthenaQueryResultParser();\n  }\n}\n\n/** Re-export of types from athena-query-result-parser. */\nexport type { ParsedRow, RowParser };"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,0DAAiI;AACjI,2EAAqG;AAErG,kHAAkH;AAClH,MAAM,mBAAmB,GAAG,IAAI,CAAC;AACjC,sEAAsE;AACtE,MAAM,eAAe,GAAG,CAAC,CAAC;AAC1B,sEAAsE;AACtE,MAAM,eAAe,GAAG,IAAI,CAAC;AAE7B,uEAAuE;AACvE,MAAM,yBAAyB,GAAG,+BAAe,CAAC,SAAS,CAAC;AAgC5D;;;;;;;GAOG;AACH,MAAa,sBAAsB;IAEjC;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAI,UAAyB;QAC7C,OAAO,UAAU,CAAC,SAAS,KAAK,SAAS,CAAC;IAC5C,CAAC;IAQD;;;;OAIG;IACH,YAAY,MAAoB,EAAE,UAAwB,EAAE;QAC1D,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,mBAAmB,CAAC;QAC7D,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,UAAU,GAAG,eAAe,IAAI,UAAU,GAAG,eAAe,EAAE,CAAC;YAClG,MAAM,IAAI,UAAU,CAClB,iDAAiD,eAAe,QAAQ,eAAe,SAAS,MAAM,CAAC,UAAU,CAAC,EAAE,CACrH,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG;YACb,UAAU;YACV,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,yBAAyB;SACtE,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,IAAI,oDAAuB,EAAE,CAAC;IAC9C,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,SAAS,CACb,gBAAwB,EACxB,SAAkB;QAElB,IAAI,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QAED,MAAM,KAAK,GAAgC;YACzC,gBAAgB,EAAE,gBAAgB;YAClC,SAAS,EAAE,SAAS;YACpB,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU;YACnC,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,eAAe;SAC9C,CAAC;QAEF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,sCAAsB,CAAC,KAAK,CAAC,CAAC,CAAC;QAE3E,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAE5D,OAAO;YACL,IAAI;YACJ,SAAS,EAAE,QAAQ,CAAC,SAAS;YAC7B,QAAQ,EAAE,IAAI,CAAC,MAAM;SACtB,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,aAAa,CACjB,gBAAwB,EACxB,SAAuB,EACvB,SAAkB;QAElB,IAAI,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QAED,MAAM,KAAK,GAAgC;YACzC,gBAAgB,EAAE,gBAAgB;YAClC,SAAS,EAAE,SAAS;YACpB,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU;YACnC,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,eAAe;SAC9C,CAAC;QAEF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,sCAAsB,CAAC,KAAK,CAAC,CAAC,CAAC;QAE3E,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAE3E,OAAO;YACL,IAAI;YACJ,SAAS,EAAE,QAAQ,CAAC,SAAS;YAC7B,QAAQ,EAAE,IAAI,CAAC,MAAM;SACtB,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,CAAC,YAAY,CACjB,gBAAwB;QAExB,IAAI,SAA6B,CAAC;QAElC,GAAG,CAAC;YACF,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;YAC/D,MAAM,IAAI,CAAC;YACX,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAC7B,CAAC,QAAQ,SAAS,EAAE;IACtB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,gBAAgB,CACrB,gBAAwB,EACxB,SAAuB;QAEvB,IAAI,SAA6B,CAAC;QAElC,GAAG,CAAC;YACF,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;YAC9E,MAAM,IAAI,CAAC;YACX,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAC7B,CAAC,QAAQ,SAAS,EAAE;IACtB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,WAAW,CAChB,gBAAwB,EACxB,SAAuB;QAEvB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,EAAE,SAAS,CAAC,EAAE,CAAC;YAC5E,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBAC5B,MAAM,GAAG,CAAC;YACZ,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK;QACH,IAAI,CAAC,MAAM,GAAG,IAAI,oDAAuB,EAAE,CAAC;IAC9C,CAAC;CACF;AA/KD,wDA+KC","sourcesContent":["import { AthenaClient, GetQueryResultsCommand, QueryResultType, type GetQueryResultsCommandInput } from '@aws-sdk/client-athena';\nimport { AthenaQueryResultParser, type ParsedRow, type RowParser } from 'athena-query-result-parser';\n\n/** Default maximum number of result rows requested per {@link AthenaQueryResultPager} API call (`MaxResults`). */\nconst DEFAULT_MAX_RESULTS = 1000;\n/** Minimum `MaxResults` value allowed by Athena `GetQueryResults`. */\nconst MIN_MAX_RESULTS = 1;\n/** Maximum `MaxResults` value allowed by Athena `GetQueryResults`. */\nconst MAX_MAX_RESULTS = 1000;\n\n/** Default `QueryResultType` forwarded to Athena `GetQueryResults`. */\nconst DEFAULT_QUERY_RESULT_TYPE = QueryResultType.DATA_ROWS;\n\n/**\n * One page of Athena query rows after a {@link AthenaQueryResultPager} fetch or generator step.\n *\n * @typeParam T - Row representation; use {@link ParsedRow} or a type produced by {@link RowParser}.\n */\nexport interface PageResult<T> {\n  /** Parsed rows for this page only. */\n  rows: T[];\n  /** Continuation token for the following page (`undefined` when this is the last page). */\n  nextToken?: string;\n  /** Same as `rows.length` for convenience. */\n  rowCount: number;\n}\n\n/**\n * Settings applied to every `GetQueryResults` invocation made by {@link AthenaQueryResultPager}.\n */\nexport interface PagerOptions {\n  /**\n   * `MaxResults` per request — must be an integer from 1 through 1000 (Athena limits).\n   * @defaultValue 1000\n   */\n  maxResults?: number;\n  /**\n   * `QueryResultType` forwarded to Athena (for example raw data rows versus manifest rows for CTAS/UNLOAD/INSERT outputs).\n   * @defaultValue `QueryResultType.DATA_ROWS`\n   */\n  queryResultType?: QueryResultType;\n}\n\n/**\n * Paginates Athena `GetQueryResults` (AWS SDK for JavaScript v3): walks `NextToken` and parses tabular rows with\n * `athena-query-result-parser` when needed.\n *\n * `maxResults` and `queryResultType` from the constructor are included on every `GetQueryResults` request.\n *\n * @see {@link https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/athena/command/GetQueryResultsCommand/ | GetQueryResultsCommand (AWS SDK)}\n */\nexport class AthenaQueryResultPager {\n\n  /**\n   * @typeParam T - Row type held in {@link PageResult.rows}.\n   * @param pageResult - The most recently retrieved page from `fetchPage`, `fetchPageWith`, or a page iterator.\n   * @returns `true` when {@link PageResult.nextToken} is defined and another page should be fetched.\n   */\n  static hasNextPage<T>(pageResult: PageResult<T>): boolean {\n    return pageResult.nextToken !== undefined;\n  }\n\n  private readonly client: AthenaClient;\n  /** Normalized pager settings (every field set after merging defaults). */\n  private readonly options: Required<PagerOptions>;\n  /** Stateful parser reused across calls; recreated by {@link AthenaQueryResultPager.reset}. */\n  private parser: AthenaQueryResultParser;\n\n  /**\n   * @param client - SDK v3 `AthenaClient` used to call `GetQueryResults`.\n   * @param options - Optional `MaxResults` and `QueryResultType`; defaults apply when omitted.\n   * @throws {RangeError} When `maxResults` is not an integer in `1..1000` inclusive.\n   */\n  constructor(client: AthenaClient, options: PagerOptions = {}) {\n    const maxResults = options.maxResults ?? DEFAULT_MAX_RESULTS;\n    if (!Number.isInteger(maxResults) || maxResults < MIN_MAX_RESULTS || maxResults > MAX_MAX_RESULTS) {\n      throw new RangeError(\n        `options.maxResults must be an integer between ${MIN_MAX_RESULTS} and ${MAX_MAX_RESULTS}, got ${String(maxResults)}`,\n      );\n    }\n\n    this.client = client;\n    this.options = {\n      maxResults,\n      queryResultType: options.queryResultType ?? DEFAULT_QUERY_RESULT_TYPE,\n    };\n    this.parser = new AthenaQueryResultParser();\n  }\n\n  /**\n   * Retrieves a single results page using {@link AthenaQueryResultParser.parseResultSet} (dictionary-shaped rows).\n   *\n   * @param queryExecutionId - Athena query execution identifier.\n   * @param nextToken - Pass `undefined` first; subsequent calls use {@link PageResult.nextToken}.\n   * @returns Parsed rows plus pagination metadata from this response only.\n   * @throws {Error} When `queryExecutionId` is empty or whitespace only.\n   */\n  async fetchPage(\n    queryExecutionId: string,\n    nextToken?: string,\n  ): Promise<PageResult<ParsedRow>> {\n    if (queryExecutionId.trim() === '') {\n      throw new Error('queryExecutionId must be a non-empty string');\n    }\n\n    const input: GetQueryResultsCommandInput = {\n      QueryExecutionId: queryExecutionId,\n      NextToken: nextToken,\n      MaxResults: this.options.maxResults,\n      QueryResultType: this.options.queryResultType,\n    };\n\n    const response = await this.client.send(new GetQueryResultsCommand(input));\n\n    const rows = this.parser.parseResultSet(response.ResultSet);\n\n    return {\n      rows,\n      nextToken: response.NextToken,\n      rowCount: rows.length,\n    };\n  }\n\n  /**\n   * Retrieves one page and maps each {@link ParsedRow} through `rowParser`.\n   *\n   * @typeParam T - Output type produced by `rowParser`.\n   * @param queryExecutionId - Athena query execution identifier.\n   * @param rowParser - Converts each dictionary row into `T`.\n   * @param nextToken - Pass `undefined` first; subsequent calls use {@link PageResult.nextToken}.\n   * @returns Transformed rows plus pagination metadata from this response only.\n   * @throws {Error} When `queryExecutionId` is empty or whitespace only.\n   */\n  async fetchPageWith<T>(\n    queryExecutionId: string,\n    rowParser: RowParser<T>,\n    nextToken?: string,\n  ): Promise<PageResult<T>> {\n    if (queryExecutionId.trim() === '') {\n      throw new Error('queryExecutionId must be a non-empty string');\n    }\n\n    const input: GetQueryResultsCommandInput = {\n      QueryExecutionId: queryExecutionId,\n      NextToken: nextToken,\n      MaxResults: this.options.maxResults,\n      QueryResultType: this.options.queryResultType,\n    };\n\n    const response = await this.client.send(new GetQueryResultsCommand(input));\n\n    const rows = this.parser.parseResultSetWith(response.ResultSet, rowParser);\n\n    return {\n      rows,\n      nextToken: response.NextToken,\n      rowCount: rows.length,\n    };\n  }\n\n  /**\n   * Lazily walks all pages for an execution, yielding {@link PageResult} of {@link ParsedRow} each step.\n   *\n   * @param queryExecutionId - Athena query execution identifier.\n   * @yields One page at a time until AWS returns no `NextToken`.\n   */\n  async *iteratePages(\n    queryExecutionId: string,\n  ): AsyncGenerator<PageResult<ParsedRow>> {\n    let nextToken: string | undefined;\n\n    do {\n      const page = await this.fetchPage(queryExecutionId, nextToken);\n      yield page;\n      nextToken = page.nextToken;\n    } while (nextToken);\n  }\n\n  /**\n   * Same as {@link AthenaQueryResultPager.iteratePages} but applies `rowParser` per row on every page.\n   *\n   * @typeParam T - Output type emitted in {@link PageResult.rows}.\n   * @param queryExecutionId - Athena query execution identifier.\n   * @param rowParser - Converts each parsed row into `T`.\n   * @yields Successive {@link PageResult} values whose `rows` are typed as `T`.\n   */\n  async *iteratePagesWith<T>(\n    queryExecutionId: string,\n    rowParser: RowParser<T>,\n  ): AsyncGenerator<PageResult<T>> {\n    let nextToken: string | undefined;\n\n    do {\n      const page = await this.fetchPageWith(queryExecutionId, rowParser, nextToken);\n      yield page;\n      nextToken = page.nextToken;\n    } while (nextToken);\n  }\n\n  /**\n   * Flattens {@link AthenaQueryResultPager.iteratePagesWith} into individual `T` values (one row per `next()`).\n   *\n   * @typeParam T - Output type produced by `rowParser`.\n   * @param queryExecutionId - Athena query execution identifier.\n   * @param rowParser - Converts each parsed row into `T`.\n   * @yields Each data row in execution order without buffering the full result set in memory.\n   */\n  async *iterateRows<T>(\n    queryExecutionId: string,\n    rowParser: RowParser<T>,\n  ): AsyncGenerator<T> {\n    for await (const page of this.iteratePagesWith(queryExecutionId, rowParser)) {\n      for (const row of page.rows) {\n        yield row;\n      }\n    }\n  }\n\n  /**\n   * Instantiates a fresh {@link AthenaQueryResultParser} so header-row handling does not leak between queries.\n   *\n   * Call when reusing this pager for a different `queryExecutionId` than the previous parse sequence.\n   */\n  reset(): void {\n    this.parser = new AthenaQueryResultParser();\n  }\n}\n\n/** Re-exports `ParsedRow` and `RowParser` from the `athena-query-result-parser` package. */\nexport type { ParsedRow, RowParser };"]}

package/package.json

@@ -1,5 +1,6 @@
 {
   "name": "athena-query-result-pager",
+  "description": "Paginate AWS Athena GetQueryResults calls with AWS SDK v3. This library walks NextToken, parses tabular rows with athena-query-result-parser, and forwards MaxResults and QueryResultType from PagerOptions on every GetQueryResults request.",
   "repository": {
     "type": "git",
     "url": "https://github.com/gammarers-aws-sdk-extensions/athena-query-result-pager.git"
@@ -48,18 +49,33 @@
     "typescript": "5.9.x"
   },
   "dependencies": {
-    "@aws-sdk/client-athena": "^3",
-    "athena-query-result-parser": "^0.2"
+    "@aws-sdk/client-athena": "^3.983.0",
+    "athena-query-result-parser": "^0.3.1"
   },
+  "keywords": [
+    "athena",
+    "aws",
+    "aws-sdk",
+    "pager",
+    "query",
+    "result"
+  ],
   "engines": {
     "node": ">= 20.0.0"
   },
+  "devEngines": {
+    "packageManager": {
+      "name": "yarn",
+      "version": "1.22.22",
+      "onFail": "ignore"
+    }
+  },
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.8",
+  "version": "0.3.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [