dynamodb-refresh-token-provider 0.4.6 → 0.5.1

package/README.md

@@ -4,7 +4,7 @@
 [![License](https://img.shields.io/npm/l/dynamodb-refresh-token-provider.svg)](https://github.com/gammarers-aws-sdk-modules/dynamodb-refresh-token-provider/blob/main/LICENSE)
 [![build](https://github.com/gammarers-aws-sdk-modules/dynamodb-refresh-token-provider/actions/workflows/build.yml/badge.svg)](https://github.com/gammarers-aws-sdk-modules/dynamodb-refresh-token-provider/actions/workflows/build.yml)
 
-TypeScript library that stores **opaque refresh tokens** in **Amazon DynamoDB** using AWS SDK for JavaScript v3. Tokens are persisted under a hash of the plaintext value; **issue**, **rotate** (with reuse detection via a transactional write), **revoke** (idempotent), and **revokeSession** (session-wide family revocation) are supported.
+TypeScript library that stores **opaque refresh tokens** in **Amazon DynamoDB** using AWS SDK for JavaScript v3. Tokens are persisted under a hash of the plaintext value; **issue**, **rotate** (with reuse detection via a transactional write), **revoke** (idempotent), **revokeSession** (session-wide family revocation), and **revokeSubject** (subject-wide revocation across all sessions) are supported.
 
 ## Features
 
@@ -14,6 +14,7 @@ TypeScript library that stores **opaque refresh tokens** in **Amazon DynamoDB**
 - **Logical expiration** — `expiresAt` drives validation; `ttl` is for storage cleanup only.
 - **Rotation safety** — marks the old row as rotated and inserts the successor in one transaction; detects reuse and conflicting updates.
 - **Session revocation (OAuth 2.0 BCP)** — `revokeSession({ sessionId })` revokes all tokens for a session via a `sessionId` GSI; optional `revokeSessionOnReuse` cascades on reuse detection.
+- **Subject revocation** — `revokeSubject({ subjectId })` revokes every token for a user across all sessions via a `subjectId` GSI (logout all devices, password change, account suspension).
 - **Structured errors** — `RefreshTokenError`, `RefreshTokenInvalidError`, `RefreshTokenExpiredError`, `RefreshTokenRevokedError`, `RefreshTokenReusedError` (with optional `subjectId` / `sessionId`), and `RefreshTokenRotateFailedError` for `instanceof` handling.
 - **Utilities** — `sha256hex` and `randomtoken` for hashing and token generation aligned with the store.
 
@@ -29,7 +30,7 @@ yarn add dynamodb-refresh-token-provider
 
 ## Usage
 
-Create a store with your table name, AWS region, and optional `StoreOptions`. Your DynamoDB table needs a **string partition key** named `pk`, **TTL enabled** on attribute `ttl` (see [DynamoDB TTL](#dynamodb-ttl)), and a **GSI** on `sessionId` for session revocation (see [Session GSI](#session-gsi)).
+Create a store with your table name, AWS region, and optional `StoreOptions`. Your DynamoDB table needs a **string partition key** named `pk`, **TTL enabled** on attribute `ttl` (see [DynamoDB TTL](#dynamodb-ttl)), a **GSI** on `sessionId` for session revocation (see [Session GSI](#session-gsi)), and a **GSI** on `subjectId` for subject-wide revocation (see [Subject GSI](#subject-gsi)).
 
 ```typescript
 import {
@@ -42,10 +43,14 @@ import {
 
 const store = new DynamodbRefreshTokenProvider('your-refresh-token-table', 'us-east-1', {
   ttlDays: 60,
+  // ttlSeconds: 3600, // alternative to ttlDays; takes precedence when both are set
+  // tokenBytes: 32,
   pkPrefix: 'rt#',
+  // translateConfig: { marshallOptions: { removeUndefinedValues: true } },
   // Optional: revoke every token in the session when reuse is detected (OAuth 2.0 BCP)
   // revokeSessionOnReuse: true,
   // sessionIdIndexName: 'sessionId-index',
+  // subjectIdIndexName: 'subjectId-index',
 });
 
 // Issue a new refresh token for a subject/session
@@ -85,6 +90,9 @@ await store.revoke({ refreshToken: issued.refreshToken });
 
 // Revoke all tokens for a session (requires sessionId GSI)
 await store.revokeSession({ sessionId: 'session-456', subjectId: 'user-123' });
+
+// Revoke all tokens for a subject across every session (requires subjectId GSI)
+await store.revokeSubject({ subjectId: 'user-123' });
 ```
 
 ### DynamoDB TTL
@@ -96,7 +104,7 @@ Each item includes:
 | `expiresAt` | Logical expiration (Unix seconds); used by the library for validation. |
 | `ttl` | DynamoDB TTL attribute (Unix seconds); enable table TTL on this name for automatic deletion. |
 
-On **issue**, both are set to the same value. On **rotate**, the successor `Put` sets both to the new expiration; the previous row’s `ttl` is updated to its existing `expiresAt`. **Revoke** / **revokeSession** do not change `ttl` (the value from issue/rotate still applies).
+On **issue**, both are set to the same value. On **rotate**, the successor `Put` sets both to the new expiration; the previous row’s `ttl` is updated to its existing `expiresAt`. **Revoke**, **revokeSession**, and **revokeSubject** do not change `ttl` (the value from issue/rotate still applies).
 
 Enable TTL on your table once (per table/region). The TTL attribute name must be **`ttl`**.
 
@@ -140,25 +148,54 @@ aws dynamodb update-table \
   }]'
 ```
 
+### Subject GSI
+
+`revokeSubject` queries token rows by `subjectId` to revoke every refresh token for a user (e.g. logout all devices, password change, account suspension). Create a GSI whose **partition key** is the attribute **`subjectId`** (String). `KEYS_ONLY` projection is enough (base-table `pk` is always projected).
+
+| Setting | Value |
+|---------|--------|
+| Index name | `subjectId-index` (override with `subjectIdIndexName`) |
+| Partition key | `subjectId` (S) |
+| Projection | `KEYS_ONLY` (or `ALL`) |
+
+**AWS CLI** (example; adjust billing mode / capacity as needed)
+
+```bash
+aws dynamodb update-table \
+  --table-name your-refresh-token-table \
+  --attribute-definitions AttributeName=subjectId,AttributeType=S \
+  --global-secondary-index-updates '[{
+    "Create": {
+      "IndexName": "subjectId-index",
+      "KeySchema": [{"AttributeName": "subjectId", "KeyType": "HASH"}],
+      "Projection": {"ProjectionType": "KEYS_ONLY"}
+    }
+  }]'
+```
+
 ## Options
 
 Constructor: `new DynamodbRefreshTokenProvider(tableName, region, options?)`.
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `ttlDays` | `number` | `60` | Token lifetime in days; added to `now` when computing `expiresAt` and `ttl` (Unix seconds). |
+| `ttlDays` | `number` | `60` | Token lifetime in days; added to `now` when computing `expiresAt` and `ttl` (Unix seconds). Ignored when `ttlSeconds` is set. |
+| `ttlSeconds` | `number` | (none) | Token lifetime in seconds; takes precedence over `ttlDays` when both are set. |
+| `tokenBytes` | `number` | `32` | Random byte length for generated refresh tokens (e.g. `32` → 256-bit). |
+| `translateConfig` | `DocumentClientTranslateConfig` | (none) | Pass-through to `DynamoDBDocumentClient.from` (e.g. `marshallOptions.removeUndefinedValues`). |
 | `pkPrefix` | `string` | `'rt#'` | Partition key prefix; full `pk` is `prefix` + SHA-256 hex of the plaintext token. |
 | `consistentRead` | `boolean` | `true` | Use strongly consistent reads on `GetItem` when loading a token row. |
 | `endpoint` | `string` | (none) | Custom DynamoDB API endpoint (e.g. LocalStack or DynamoDB Local). |
 | `sessionIdIndexName` | `string` | `'sessionId-index'` | GSI name whose partition key is `sessionId` (required for `revokeSession`). |
+| `subjectIdIndexName` | `string` | `'subjectId-index'` | GSI name whose partition key is `subjectId` (required for `revokeSubject`). |
 | `revokeSessionOnReuse` | `boolean` | `false` | When true, `rotate` calls `revokeSession` for the token’s session before throwing `RefreshTokenReusedError`. |
 
-`issue`, `rotate`, `revoke`, and `revokeSession` accept an optional `now?: Date` for testing or clock injection.
+`issue`, `rotate`, `revoke`, `revokeSession`, and `revokeSubject` accept an optional `now?: Date` for testing or clock injection.
 
 ## Requirements
 
 - **Node.js** 20.0.0 or later.
-- A **DynamoDB table** with a string partition key **`pk`**, **TTL enabled** on attribute **`ttl`** (see [DynamoDB TTL](#dynamodb-ttl)), and a **GSI** on **`sessionId`** for session revocation (see [Session GSI](#session-gsi)).
+- A **DynamoDB table** with a string partition key **`pk`**, **TTL enabled** on attribute **`ttl`** (see [DynamoDB TTL](#dynamodb-ttl)), a **GSI** on **`sessionId`** for session revocation (see [Session GSI](#session-gsi)), and a **GSI** on **`subjectId`** for subject-wide revocation (see [Subject GSI](#subject-gsi)).
 - **AWS credentials** and permissions for `PutItem`, `GetItem`, `UpdateItem`, `Query`, and `TransactWriteItems` on that table (and the configured `endpoint` if used).
 
 ## License

package/lib/index.d.ts

@@ -1,13 +1,14 @@
 /**
  * Public API: refresh token store types, DynamoDB-backed implementation, structured errors, and crypto helpers.
  *
- * Enable DynamoDB TTL on attribute `ttl`, and a `sessionId` GSI for session revocation, when using
- * {@link DynamodbRefreshTokenProvider}.
+ * Enable DynamoDB TTL on attribute `ttl`, and GSIs on `sessionId` and `subjectId` for bulk
+ * revocation, when using {@link DynamodbRefreshTokenProvider}.
  */
-export type { RefreshTokenStore, IssueParams, IssueResult, RotateParams, RotateResult, RevokeParams, RevokeSessionParams, RevokeSessionResult, StoreOptions, TokenRecord, EpochSec, } from './types/index';
+export type { RefreshTokenStore, IssueParams, IssueResult, RotateParams, RotateResult, RevokeParams, RevokeSessionParams, RevokeSessionResult, RevokeSubjectParams, RevokeSubjectResult, DocumentClientTranslateConfig, StoreOptions, TokenRecord, EpochSec, } from './types/index';
 /**
  * DynamoDB-backed {@link RefreshTokenStore} with rotation reuse detection and optional
- * session-wide revocation (`revokeSession` / `revokeSessionOnReuse`).
+ * session-wide revocation (`revokeSession` / `revokeSessionOnReuse`) and subject-wide
+ * revocation (`revokeSubject`).
  */
 export { DynamodbRefreshTokenProvider } from './stores/dynamodb';
 /**

package/lib/index.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomtoken = exports.sha256hex = exports.RefreshTokenRotateFailedError = exports.RefreshTokenRevokedError = exports.RefreshTokenReusedError = exports.RefreshTokenInvalidError = exports.RefreshTokenExpiredError = exports.RefreshTokenError = exports.DynamodbRefreshTokenProvider = void 0;
 /**
  * DynamoDB-backed {@link RefreshTokenStore} with rotation reuse detection and optional
- * session-wide revocation (`revokeSession` / `revokeSessionOnReuse`).
+ * session-wide revocation (`revokeSession` / `revokeSessionOnReuse`) and subject-wide
+ * revocation (`revokeSubject`).
  */
 var dynamodb_1 = require("./stores/dynamodb");
 Object.defineProperty(exports, "DynamodbRefreshTokenProvider", { enumerable: true, get: function () { return dynamodb_1.DynamodbRefreshTokenProvider; } });
@@ -22,4 +23,4 @@ Object.defineProperty(exports, "RefreshTokenRotateFailedError", { enumerable: tr
 var hash_1 = require("./utils/hash");
 Object.defineProperty(exports, "sha256hex", { enumerable: true, get: function () { return hash_1.sha256hex; } });
 Object.defineProperty(exports, "randomtoken", { enumerable: true, get: function () { return hash_1.randomtoken; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBb0JBOzs7R0FHRztBQUNILDhDQUFpRTtBQUF4RCx3SEFBQSw0QkFBNEIsT0FBQTtBQUVyQzs7O0dBR0c7QUFDSCxzRUFPdUM7QUFOckMseUhBQUEsaUJBQWlCLE9BQUE7QUFDakIsZ0lBQUEsd0JBQXdCLE9BQUE7QUFDeEIsZ0lBQUEsd0JBQXdCLE9BQUE7QUFDeEIsK0hBQUEsdUJBQXVCLE9BQUE7QUFDdkIsZ0lBQUEsd0JBQXdCLE9BQUE7QUFDeEIscUlBQUEsNkJBQTZCLE9BQUE7QUFHL0IseUVBQXlFO0FBQ3pFLHFDQUFzRDtBQUE3QyxpR0FBQSxTQUFTLE9BQUE7QUFBRSxtR0FBQSxXQUFXLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFB1YmxpYyBBUEk6IHJlZnJlc2ggdG9rZW4gc3RvcmUgdHlwZXMsIER5bmFtb0RCLWJhY2tlZCBpbXBsZW1lbnRhdGlvbiwgc3RydWN0dXJlZCBlcnJvcnMsIGFuZCBjcnlwdG8gaGVscGVycy5cbiAqXG4gKiBFbmFibGUgRHluYW1vREIgVFRMIG9uIGF0dHJpYnV0ZSBgdHRsYCwgYW5kIGEgYHNlc3Npb25JZGAgR1NJIGZvciBzZXNzaW9uIHJldm9jYXRpb24sIHdoZW4gdXNpbmdcbiAqIHtAbGluayBEeW5hbW9kYlJlZnJlc2hUb2tlblByb3ZpZGVyfS5cbiAqL1xuZXhwb3J0IHR5cGUge1xuICBSZWZyZXNoVG9rZW5TdG9yZSxcbiAgSXNzdWVQYXJhbXMsXG4gIElzc3VlUmVzdWx0LFxuICBSb3RhdGVQYXJhbXMsXG4gIFJvdGF0ZVJlc3VsdCxcbiAgUmV2b2tlUGFyYW1zLFxuICBSZXZva2VTZXNzaW9uUGFyYW1zLFxuICBSZXZva2VTZXNzaW9uUmVzdWx0LFxuICBTdG9yZU9wdGlvbnMsXG4gIFRva2VuUmVjb3JkLFxuICBFcG9jaFNlYyxcbn0gZnJvbSAnLi90eXBlcy9pbmRleCc7XG5cbi8qKlxuICogRHluYW1vREItYmFja2VkIHtAbGluayBSZWZyZXNoVG9rZW5TdG9yZX0gd2l0aCByb3RhdGlvbiByZXVzZSBkZXRlY3Rpb24gYW5kIG9wdGlvbmFsXG4gKiBzZXNzaW9uLXdpZGUgcmV2b2NhdGlvbiAoYHJldm9rZVNlc3Npb25gIC8gYHJldm9rZVNlc3Npb25PblJldXNlYCkuXG4gKi9cbmV4cG9ydCB7IER5bmFtb2RiUmVmcmVzaFRva2VuUHJvdmlkZXIgfSBmcm9tICcuL3N0b3Jlcy9keW5hbW9kYic7XG5cbi8qKlxuICogU3RydWN0dXJlZCBlcnJvcnMgZm9yIGBpbnN0YW5jZW9mYCBoYW5kbGluZyBpbiBhdXRoIGZsb3dzLlxuICoge0BsaW5rIFJlZnJlc2hUb2tlblJldXNlZEVycm9yfSBtYXkgY2FycnkgYHN1YmplY3RJZGAgLyBgc2Vzc2lvbklkYCBmb3Igc2Vzc2lvbiByZXZva2UuXG4gKi9cbmV4cG9ydCB7XG4gIFJlZnJlc2hUb2tlbkVycm9yLFxuICBSZWZyZXNoVG9rZW5FeHBpcmVkRXJyb3IsXG4gIFJlZnJlc2hUb2tlbkludmFsaWRFcnJvcixcbiAgUmVmcmVzaFRva2VuUmV1c2VkRXJyb3IsXG4gIFJlZnJlc2hUb2tlblJldm9rZWRFcnJvcixcbiAgUmVmcmVzaFRva2VuUm90YXRlRmFpbGVkRXJyb3IsXG59IGZyb20gJy4vc3RvcmVzL3JlZnJlc2gtdG9rZW4tZXJyb3JzJztcblxuLyoqIFNIQS0yNTYgaGV4IGhhc2hpbmcgYW5kIGNyeXB0b2dyYXBoaWNhbGx5IHNlY3VyZSB0b2tlbiBnZW5lcmF0aW9uLiAqL1xuZXhwb3J0IHsgc2hhMjU2aGV4LCByYW5kb210b2tlbiB9IGZyb20gJy4vdXRpbHMvaGFzaCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/stores/dynamodb.d.ts

@@ -1,6 +1,6 @@
-import type { RefreshTokenStore, StoreOptions, TokenRecord, IssueParams, RotateParams, RevokeParams, RevokeSessionParams, RevokeSessionResult, IssueResult, RotateResult } from '../types/index';
+import type { RefreshTokenStore, StoreOptions, DocumentClientTranslateConfig, TokenRecord, IssueParams, RotateParams, RevokeParams, RevokeSessionParams, RevokeSessionResult, RevokeSubjectParams, RevokeSubjectResult, IssueResult, RotateResult } from '../types/index';
 /** Re-exported types for consumers that import the DynamoDB store module. */
-export { RefreshTokenStore, StoreOptions, TokenRecord, IssueParams, RotateParams, RevokeParams, RevokeSessionParams, RevokeSessionResult, IssueResult, RotateResult, };
+export { RefreshTokenStore, StoreOptions, DocumentClientTranslateConfig, TokenRecord, IssueParams, RotateParams, RevokeParams, RevokeSessionParams, RevokeSessionResult, RevokeSubjectParams, RevokeSubjectResult, IssueResult, RotateResult, };
 /**
  * {@link RefreshTokenStore} implementation backed by a single DynamoDB table.
  *
@@ -16,7 +16,7 @@ export declare class DynamodbRefreshTokenProvider implements RefreshTokenStore {
     private readonly options?;
     /** Lazily initialized and cached document client. */
     private ddb;
-    /** Random byte length for generated refresh tokens (default 32 → 256-bit). */
+    /** Random byte length for generated refresh tokens. */
     private readonly tokenBytes;
     /**
      * @param tableName - DynamoDB table name for refresh token items.
@@ -71,6 +71,23 @@ export declare class DynamodbRefreshTokenProvider implements RefreshTokenStore {
      * @returns Count of rows updated with `revokedAt` in this call.
      */
     revokeSession: (params: RevokeSessionParams) => Promise<RevokeSessionResult>;
+    /**
+     * Sets `revokedAt` on every refresh token row for the given `subjectId` across all sessions.
+     *
+     * Queries the subject GSI (partition key `subjectId`; `KEYS_ONLY` is enough), then updates each
+     * base-table item. Missing items are skipped (idempotent). Paginate with `LastEvaluatedKey`.
+     *
+     * @param params - Subject id and optional clock.
+     * @returns Count of rows updated with `revokedAt` in this call.
+     */
+    revokeSubject: (params: RevokeSubjectParams) => Promise<RevokeSubjectResult>;
+    /**
+     * Queries a GSI and sets `revokedAt` on each matching base-table row.
+     *
+     * @param params - GSI query parameters and per-row update conditions.
+     * @returns Count of rows updated with `revokedAt` in this call.
+     */
+    private revokeTokenRowsByIndexQuery;
     /**
      * Handles refresh-token reuse detection: optionally cascades {@link DynamodbRefreshTokenProvider.revokeSession}
      * when {@link StoreOptions.revokeSessionOnReuse} is true, then throws {@link RefreshTokenReusedError}
@@ -108,12 +125,27 @@ export declare class DynamodbRefreshTokenProvider implements RefreshTokenStore {
      */
     private getPrimaryKey;
     /**
-     * Computes logical expiration (`expiresAt` / `ttl`) as `nowSec` plus {@link StoreOptions.ttlDays}.
+     * Computes logical expiration (`expiresAt` / `ttl`) as `nowSec` plus configured lifetime.
      *
      * @param nowSec - Current time as Unix seconds.
-     * @returns Expiration timestamp in Unix seconds (default lifetime: 60 days).
+     * @returns Expiration timestamp in Unix seconds.
      */
     private makeExpiresAt;
+    /**
+     * Resolves and validates {@link StoreOptions.tokenBytes}.
+     *
+     * @param tokenBytes - Optional byte length from store options.
+     * @returns Positive integer byte length.
+     * @throws {RangeError} When `tokenBytes` is not a positive integer.
+     */
+    private resolveTokenBytes;
+    /**
+     * Validates TTL-related store options at construction time.
+     *
+     * @param options - Store options from the constructor.
+     * @throws {RangeError} When `ttlSeconds` or `ttlDays` is not a positive number.
+     */
+    private validateTtlOptions;
     /**
      * Ensures the token is non-empty and matches the expected base64url length for `tokenBytes`.
      *

package/lib/stores/dynamodb.js

@@ -10,6 +10,12 @@ const time_1 = require("../utils/time");
 const DEFAULT_PRIMARY_KEY_PREFIX = 'rt#';
 /** Default GSI name for querying token rows by `sessionId`. */
 const DEFAULT_SESSION_ID_INDEX_NAME = 'sessionId-index';
+/** Default GSI name for querying token rows by `subjectId`. */
+const DEFAULT_SUBJECT_ID_INDEX_NAME = 'subjectId-index';
+/** Default random byte length for generated refresh tokens (32 → 256-bit). */
+const DEFAULT_TOKEN_BYTES = 32;
+/** Default token lifetime in days when neither ttlSeconds nor ttlDays is set. */
+const DEFAULT_TTL_DAYS = 60;
 /**
  * {@link RefreshTokenStore} implementation backed by a single DynamoDB table.
  *
@@ -31,8 +37,6 @@ class DynamodbRefreshTokenProvider {
         this.options = options;
         /** Lazily initialized and cached document client. */
         this.ddb = null;
-        /** Random byte length for generated refresh tokens (default 32 → 256-bit). */
-        this.tokenBytes = 32;
         /**
          * Inserts a new token record with `expiresAt` and matching `ttl`. Fails the put if `pk` already exists.
          *
@@ -205,10 +209,57 @@ class DynamodbRefreshTokenProvider {
          * @returns Count of rows updated with `revokedAt` in this call.
          */
         this.revokeSession = async (params) => {
-            const ddb = this.getddb();
             const now = params.now ?? new Date();
             const nowSec = (0, time_1.epochsec)(now);
             const indexName = this.options?.sessionIdIndexName ?? DEFAULT_SESSION_ID_INDEX_NAME;
+            const revokedCount = await this.revokeTokenRowsByIndexQuery({
+                indexName,
+                keyConditionExpression: 'sessionId = :sessionId',
+                queryExpressionAttributeValues: {
+                    ':sessionId': params.sessionId,
+                },
+                nowSec,
+                updateConditionExpression: params.subjectId
+                    ? 'attribute_exists(pk) AND subjectId = :subjectId'
+                    : 'attribute_exists(pk)',
+                updateExpressionAttributeValues: params.subjectId
+                    ? { ':subjectId': params.subjectId }
+                    : undefined,
+            });
+            return { revokedCount };
+        };
+        /**
+         * Sets `revokedAt` on every refresh token row for the given `subjectId` across all sessions.
+         *
+         * Queries the subject GSI (partition key `subjectId`; `KEYS_ONLY` is enough), then updates each
+         * base-table item. Missing items are skipped (idempotent). Paginate with `LastEvaluatedKey`.
+         *
+         * @param params - Subject id and optional clock.
+         * @returns Count of rows updated with `revokedAt` in this call.
+         */
+        this.revokeSubject = async (params) => {
+            const now = params.now ?? new Date();
+            const nowSec = (0, time_1.epochsec)(now);
+            const indexName = this.options?.subjectIdIndexName ?? DEFAULT_SUBJECT_ID_INDEX_NAME;
+            const revokedCount = await this.revokeTokenRowsByIndexQuery({
+                indexName,
+                keyConditionExpression: 'subjectId = :subjectId',
+                queryExpressionAttributeValues: {
+                    ':subjectId': params.subjectId,
+                },
+                nowSec,
+                updateConditionExpression: 'attribute_exists(pk)',
+            });
+            return { revokedCount };
+        };
+        /**
+         * Queries a GSI and sets `revokedAt` on each matching base-table row.
+         *
+         * @param params - GSI query parameters and per-row update conditions.
+         * @returns Count of rows updated with `revokedAt` in this call.
+         */
+        this.revokeTokenRowsByIndexQuery = async (params) => {
+            const ddb = this.getddb();
             let revokedCount = 0;
             let exclusiveStartKey;
             /** Whether another Query page is available after the previous response. */
@@ -216,11 +267,9 @@ class DynamodbRefreshTokenProvider {
             do {
                 const res = await ddb.send(new lib_dynamodb_1.QueryCommand({
                     TableName: this.tableName,
-                    IndexName: indexName,
-                    KeyConditionExpression: 'sessionId = :sessionId',
-                    ExpressionAttributeValues: {
-                        ':sessionId': params.sessionId,
-                    },
+                    IndexName: params.indexName,
+                    KeyConditionExpression: params.keyConditionExpression,
+                    ExpressionAttributeValues: params.queryExpressionAttributeValues,
                     ProjectionExpression: 'pk',
                     ExclusiveStartKey: exclusiveStartKey,
                 }));
@@ -231,19 +280,15 @@ class DynamodbRefreshTokenProvider {
                         continue;
                     }
                     const expressionAttributeValues = {
-                        ':now': nowSec,
+                        ':now': params.nowSec,
+                        ...params.updateExpressionAttributeValues,
                     };
-                    let conditionExpression = 'attribute_exists(pk)';
-                    if (params.subjectId) {
-                        conditionExpression = 'attribute_exists(pk) AND subjectId = :subjectId';
-                        expressionAttributeValues[':subjectId'] = params.subjectId;
-                    }
                     try {
                         await ddb.send(new lib_dynamodb_1.UpdateCommand({
                             TableName: this.tableName,
                             Key: { pk },
                             UpdateExpression: 'SET revokedAt = :now',
-                            ConditionExpression: conditionExpression,
+                            ConditionExpression: params.updateConditionExpression,
                             ExpressionAttributeValues: expressionAttributeValues,
                         }));
                         revokedCount += 1;
@@ -257,7 +302,7 @@ class DynamodbRefreshTokenProvider {
                 }
                 exclusiveStartKey = res.LastEvaluatedKey;
             } while (shouldContinuePaging());
-            return { revokedCount };
+            return revokedCount;
         };
         /**
          * Handles refresh-token reuse detection: optionally cascades {@link DynamodbRefreshTokenProvider.revokeSession}
@@ -297,7 +342,7 @@ class DynamodbRefreshTokenProvider {
                         return `https://dynamodb.${this.region}.amazonaws.com`;
                     })(),
                 });
-                this.ddb = lib_dynamodb_1.DynamoDBDocumentClient.from(client);
+                this.ddb = lib_dynamodb_1.DynamoDBDocumentClient.from(client, this.options?.translateConfig);
             }
             return this.ddb;
         };
@@ -334,14 +379,48 @@ class DynamodbRefreshTokenProvider {
             return `${this.getPrimaryKeyPrefix()}${hash}`;
         };
         /**
-         * Computes logical expiration (`expiresAt` / `ttl`) as `nowSec` plus {@link StoreOptions.ttlDays}.
+         * Computes logical expiration (`expiresAt` / `ttl`) as `nowSec` plus configured lifetime.
          *
          * @param nowSec - Current time as Unix seconds.
-         * @returns Expiration timestamp in Unix seconds (default lifetime: 60 days).
+         * @returns Expiration timestamp in Unix seconds.
          */
         this.makeExpiresAt = (nowSec) => {
-            return nowSec + (this.options?.ttlDays ?? 60) * 24 * 60 * 60;
+            const ttlSeconds = this.options?.ttlSeconds;
+            if (ttlSeconds !== undefined) {
+                return nowSec + ttlSeconds;
+            }
+            return nowSec + (this.options?.ttlDays ?? DEFAULT_TTL_DAYS) * 24 * 60 * 60;
+        };
+        /**
+         * Resolves and validates {@link StoreOptions.tokenBytes}.
+         *
+         * @param tokenBytes - Optional byte length from store options.
+         * @returns Positive integer byte length.
+         * @throws {RangeError} When `tokenBytes` is not a positive integer.
+         */
+        this.resolveTokenBytes = (tokenBytes) => {
+            const bytes = tokenBytes ?? DEFAULT_TOKEN_BYTES;
+            if (!Number.isInteger(bytes) || bytes < 1) {
+                throw new RangeError('tokenBytes must be a positive integer');
+            }
+            return bytes;
+        };
+        /**
+         * Validates TTL-related store options at construction time.
+         *
+         * @param options - Store options from the constructor.
+         * @throws {RangeError} When `ttlSeconds` or `ttlDays` is not a positive number.
+         */
+        this.validateTtlOptions = (options) => {
+            if (options?.ttlSeconds !== undefined && options.ttlSeconds <= 0) {
+                throw new RangeError('ttlSeconds must be a positive number');
+            }
+            if (options?.ttlDays !== undefined && options.ttlDays <= 0) {
+                throw new RangeError('ttlDays must be a positive number');
+            }
         };
+        this.tokenBytes = this.resolveTokenBytes(this.options?.tokenBytes);
+        this.validateTtlOptions(this.options);
     }
     /**
      * Ensures the token is non-empty and matches the expected base64url length for `tokenBytes`.
@@ -356,4 +435,4 @@ class DynamodbRefreshTokenProvider {
     }
 }
 exports.DynamodbRefreshTokenProvider = DynamodbRefreshTokenProvider;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamodb.js","sourceRoot":"","sources":["../../src/stores/dynamodb.ts"],"names":[],"mappings":"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","sourcesContent":["import { DynamoDBClient } from '@aws-sdk/client-dynamodb';\nimport { DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, UpdateCommand, TransactWriteCommand } from '@aws-sdk/lib-dynamodb';\n\nimport {\n  RefreshTokenExpiredError,\n  RefreshTokenInvalidError,\n  RefreshTokenReusedError,\n  RefreshTokenRevokedError,\n} from './refresh-token-errors';\nimport type {\n  RefreshTokenStore,\n  StoreOptions,\n  TokenRecord,\n  IssueParams,\n  RotateParams,\n  RevokeParams,\n  RevokeSessionParams,\n  RevokeSessionResult,\n  IssueResult,\n  RotateResult,\n} from '../types/index';\nimport { randomtoken, sha256hex } from '../utils/hash';\nimport { epochsec } from '../utils/time';\n\n/** Re-exported types for consumers that import the DynamoDB store module. */\nexport {\n  RefreshTokenStore,\n  StoreOptions,\n  TokenRecord,\n  IssueParams,\n  RotateParams,\n  RevokeParams,\n  RevokeSessionParams,\n  RevokeSessionResult,\n  IssueResult,\n  RotateResult,\n};\n\n/** Default partition key prefix for refresh token items. */\nconst DEFAULT_PRIMARY_KEY_PREFIX = 'rt#';\n\n/** Default GSI name for querying token rows by `sessionId`. */\nconst DEFAULT_SESSION_ID_INDEX_NAME = 'sessionId-index';\n\n/**\n * {@link RefreshTokenStore} implementation backed by a single DynamoDB table.\n *\n * Items use partition key `pk`, logical expiration `expiresAt`, and DynamoDB TTL attribute `ttl`\n * (Unix seconds). Enable table TTL on attribute `ttl` so expired and rotated rows are removed\n * asynchronously. Session-wide revocation requires a GSI whose partition key is `sessionId`\n * (see {@link StoreOptions.sessionIdIndexName}). This class owns the DynamoDB client; callers\n * supply `tableName`, `region`, and optional {@link StoreOptions}.\n */\nexport class DynamodbRefreshTokenProvider implements RefreshTokenStore {\n  /** Lazily initialized and cached document client. */\n  private ddb: DynamoDBDocumentClient | null = null;\n\n  /** Random byte length for generated refresh tokens (default 32 → 256-bit). */\n  private readonly tokenBytes = 32;\n\n  /**\n   * @param tableName - DynamoDB table name for refresh token items.\n   * @param region - AWS region for the DynamoDB client.\n   * @param options - Token lifetime, PK prefix, GSI name, reuse revocation, or custom endpoint.\n   */\n  constructor(\n    private readonly tableName: string,\n    private readonly region: string,\n    private readonly options?: StoreOptions,\n  ) {}\n\n  /**\n   * Inserts a new token record with `expiresAt` and matching `ttl`. Fails the put if `pk` already exists.\n   *\n   * @param params - Subject, session, and optional clock (`now`).\n   * @returns Plaintext refresh token and expiration as Unix seconds.\n   */\n  public issue = async (params: IssueParams): Promise<IssueResult> => {\n    const ddb = this.getddb();\n\n    const now = params.now ?? new Date();\n    const nowSec = epochsec(now);\n    const expiresAt = this.makeExpiresAt(nowSec);\n\n    const refreshToken = randomtoken(this.tokenBytes);\n    const hash = sha256hex(refreshToken);\n    const pk = this.getPrimaryKey(hash);\n\n    await ddb.send(\n      new PutCommand({\n        TableName: this.tableName,\n        Item: {\n          pk,\n          subjectId: params.subjectId,\n          sessionId: params.sessionId,\n          createdAt: nowSec,\n          expiresAt,\n          ttl: expiresAt,\n        },\n        ConditionExpression: 'attribute_not_exists(pk)',\n      }),\n    );\n\n    return {\n      refreshToken,\n      refreshTokenExpiresAt: expiresAt,\n    };\n  };\n\n  /**\n   * Marks the current token as rotated and creates the successor row in one transaction.\n   *\n   * Updates the previous row’s `ttl` to its `expiresAt` and sets `ttl` on the new Put to the\n   * successor’s expiration so DynamoDB can delete both when appropriate.\n   *\n   * When reuse is detected and {@link StoreOptions.revokeSessionOnReuse} is true, all tokens for\n   * the same `sessionId` and `subjectId` are revoked via {@link DynamodbRefreshTokenProvider.revokeSession}\n   * before throwing.\n   *\n   * @param params - Client refresh token and optional clock (`now`).\n   * @returns Subject, session, new plaintext token, and new expiration.\n   * @throws {@link RefreshTokenInvalidError} When the token format is invalid or no row exists.\n   * @throws {@link RefreshTokenExpiredError} When `expiresAt` is not after `now`.\n   * @throws {@link RefreshTokenRevokedError} When the token row has `revokedAt` set.\n   * @throws {@link RefreshTokenReusedError} When the token was already rotated or the transaction\n   *   indicates reuse. Includes `subjectId` and `sessionId` from the loaded row.\n   */\n  public rotate = async (params: RotateParams): Promise<RotateResult> => {\n    // validate refresh token\n    this.validateRefreshToken(params.refreshToken);\n\n    const ddb = this.getddb();\n\n    const now = params.now ?? new Date();\n    const nowSec = epochsec(now);\n\n    const currentHash = sha256hex(params.refreshToken);\n    const currentPk = this.getPrimaryKey(currentHash);\n\n    const current = await this.getTokenRecord(currentPk);\n    if (!current) {\n      throw new RefreshTokenInvalidError();\n    }\n    if (current.expiresAt <= nowSec) {\n      throw new RefreshTokenExpiredError();\n    }\n    if (current.revokedAt) {\n      throw new RefreshTokenRevokedError();\n    }\n    if (current.rotatedAt) {\n      await this.handleRefreshTokenReuse(current, now);\n    }\n\n    const nextRefreshTokenExpiresAt = this.makeExpiresAt(nowSec);\n    const nextRefreshToken = randomtoken(this.tokenBytes);\n    const nextHash = sha256hex(nextRefreshToken);\n    const nextPk = this.getPrimaryKey(nextHash);\n\n    try {\n      await ddb.send(new TransactWriteCommand({\n        TransactItems: [\n          {\n            Update: {\n              TableName: this.tableName,\n              Key: { pk: currentPk },\n              UpdateExpression: 'SET rotatedAt = :now, replacedByPk = :nextPk, #ttl = :ttl',\n              ConditionExpression: 'attribute_exists(pk) AND attribute_not_exists(rotatedAt) AND attribute_not_exists(revokedAt)',\n              ExpressionAttributeNames: {\n                '#ttl': 'ttl',\n              },\n              ExpressionAttributeValues: {\n                ':now': nowSec,\n                ':nextPk': nextPk,\n                ':ttl': current.expiresAt,\n              },\n            },\n          },\n          {\n            Put: {\n              TableName: this.tableName,\n              Item: {\n                pk: nextPk,\n                subjectId: current.subjectId,\n                sessionId: current.sessionId,\n                createdAt: nowSec,\n                expiresAt: nextRefreshTokenExpiresAt,\n                ttl: nextRefreshTokenExpiresAt,\n              },\n              ConditionExpression: 'attribute_not_exists(pk)',\n            },\n          },\n        ],\n      }));\n\n    } catch (error: unknown) {\n      if (error instanceof Error && error.name === 'TransactionCanceledException') {\n        // Treat conditional transaction failure as token reuse.\n        await this.handleRefreshTokenReuse(current, now);\n      }\n      throw error;\n    }\n\n    return {\n      subjectId: current.subjectId,\n      sessionId: current.sessionId,\n      refreshToken: nextRefreshToken,\n      refreshTokenExpiresAt: nextRefreshTokenExpiresAt,\n    };\n  };\n\n  /**\n   * Sets `revokedAt` on the token row. Missing items succeed (idempotent revoke).\n   *\n   * Does not update `ttl`; existing `ttl` from issue/rotate still applies for DynamoDB cleanup.\n   *\n   * @param params - Refresh token and optional clock (`now`).\n   * @returns `true` after a successful update or no-op when the item is absent.\n   * @throws {@link RefreshTokenInvalidError} When the token string format is invalid.\n   */\n  public revoke = async (params: RevokeParams): Promise<true> => {\n    // validate refresh token\n    this.validateRefreshToken(params.refreshToken);\n\n    const ddb = this.getddb();\n\n    const now = params.now ?? new Date();\n    const nowSec = epochsec(now);\n\n    const hash = sha256hex(params.refreshToken);\n    const pk = this.getPrimaryKey(hash);\n\n    try {\n      await ddb.send(\n        new UpdateCommand({\n          TableName: this.tableName,\n          Key: { pk },\n          UpdateExpression: 'SET revokedAt = :now',\n          ConditionExpression: 'attribute_exists(pk)',\n          ExpressionAttributeValues: {\n            ':now': nowSec,\n          },\n        }),\n      );\n    } catch (error: unknown) {\n      // Missing item: treat as success (idempotent revoke).\n      if (error instanceof Error && error.name === 'ConditionalCheckFailedException') {\n        return true;\n      }\n      throw error;\n    }\n    return true;\n  };\n\n  /**\n   * Sets `revokedAt` on every token row for the given `sessionId` (optionally filtered by `subjectId`).\n   *\n   * Queries the session GSI (partition key `sessionId`; `KEYS_ONLY` is enough), then updates each\n   * base-table item. When `subjectId` is set, it is required in the `UpdateItem` condition.\n   * Missing or non-matching items are skipped (idempotent). Paginate with `LastEvaluatedKey`.\n   *\n   * @param params - Session id, optional subject filter, and optional clock.\n   * @returns Count of rows updated with `revokedAt` in this call.\n   */\n  public revokeSession = async (params: RevokeSessionParams): Promise<RevokeSessionResult> => {\n    const ddb = this.getddb();\n\n    const now = params.now ?? new Date();\n    const nowSec = epochsec(now);\n    const indexName = this.options?.sessionIdIndexName ?? DEFAULT_SESSION_ID_INDEX_NAME;\n\n    let revokedCount = 0;\n    let exclusiveStartKey: Record<string, unknown> | undefined;\n\n    /** Whether another Query page is available after the previous response. */\n    const shouldContinuePaging = (): boolean => exclusiveStartKey !== undefined;\n\n    do {\n      const res = await ddb.send(\n        new QueryCommand({\n          TableName: this.tableName,\n          IndexName: indexName,\n          KeyConditionExpression: 'sessionId = :sessionId',\n          ExpressionAttributeValues: {\n            ':sessionId': params.sessionId,\n          },\n          ProjectionExpression: 'pk',\n          ExclusiveStartKey: exclusiveStartKey,\n        }),\n      );\n\n      const items = res.Items ?? [];\n      for (const item of items) {\n        const pk = item.pk;\n        if (typeof pk !== 'string') {\n          continue;\n        }\n\n        const expressionAttributeValues: Record<string, string | number> = {\n          ':now': nowSec,\n        };\n        let conditionExpression = 'attribute_exists(pk)';\n        if (params.subjectId) {\n          conditionExpression = 'attribute_exists(pk) AND subjectId = :subjectId';\n          expressionAttributeValues[':subjectId'] = params.subjectId;\n        }\n\n        try {\n          await ddb.send(\n            new UpdateCommand({\n              TableName: this.tableName,\n              Key: { pk },\n              UpdateExpression: 'SET revokedAt = :now',\n              ConditionExpression: conditionExpression,\n              ExpressionAttributeValues: expressionAttributeValues,\n            }),\n          );\n          revokedCount += 1;\n        } catch (error: unknown) {\n          if (error instanceof Error && error.name === 'ConditionalCheckFailedException') {\n            continue;\n          }\n          throw error;\n        }\n      }\n\n      exclusiveStartKey = res.LastEvaluatedKey as Record<string, unknown> | undefined;\n    } while (shouldContinuePaging());\n\n    return { revokedCount };\n  };\n\n  /**\n   * Handles refresh-token reuse detection: optionally cascades {@link DynamodbRefreshTokenProvider.revokeSession}\n   * when {@link StoreOptions.revokeSessionOnReuse} is true, then throws {@link RefreshTokenReusedError}\n   * populated with `subjectId` / `sessionId` from `current`.\n   *\n   * @param current - Token row that indicated reuse (`rotatedAt` set or transaction canceled).\n   * @param now - Clock used for `revokedAt` when cascading revoke is enabled.\n   * @throws {@link RefreshTokenReusedError} Always (return type is `never`).\n   */\n  private handleRefreshTokenReuse = async (current: TokenRecord, now: Date): Promise<never> => {\n    if (this.options?.revokeSessionOnReuse) {\n      await this.revokeSession({\n        sessionId: current.sessionId,\n        subjectId: current.subjectId,\n        now,\n      });\n    }\n\n    throw new RefreshTokenReusedError(undefined, {\n      subjectId: current.subjectId,\n      sessionId: current.sessionId,\n    });\n  };\n\n  /**\n   * Returns the cached {@link DynamoDBDocumentClient}, creating it on first use.\n   *\n   * @returns Document client configured for `region` and optional `endpoint`.\n   */\n  private getddb = (): DynamoDBDocumentClient => {\n    if (!this.ddb) {\n      const client = new DynamoDBClient({\n        region: this.region,\n        endpoint: (() => {\n          if (this.options?.endpoint) {\n            return this.options.endpoint;\n          }\n          return `https://dynamodb.${this.region}.amazonaws.com`;\n        })(),\n      });\n      this.ddb = DynamoDBDocumentClient.from(client);\n    }\n    return this.ddb;\n  };\n\n  /**\n   * Loads a token row by partition key.\n   *\n   * @param pk - Full partition key (`prefix` + hash).\n   * @returns Parsed {@link TokenRecord}, or `null` if the item does not exist.\n   */\n  private getTokenRecord = async (pk: string): Promise<TokenRecord | null> => {\n    const ddb = this.getddb();\n\n    const res = await ddb.send(\n      new GetCommand({\n        TableName: this.tableName,\n        Key: { pk },\n        ConsistentRead: this.options?.consistentRead ?? true,\n      }),\n    );\n    return (res.Item as TokenRecord) ?? null;\n  };\n\n  /**\n   * Effective partition key prefix from {@link StoreOptions} or {@link DEFAULT_PRIMARY_KEY_PREFIX}.\n   *\n   * @returns Prefix string (e.g. `rt#`).\n   */\n  private getPrimaryKeyPrefix = (): string => {\n    return `${this.options?.pkPrefix ?? DEFAULT_PRIMARY_KEY_PREFIX}`;\n  };\n\n  /**\n   * Builds the full partition key for a token hash.\n   *\n   * @param hash - SHA-256 hex digest of the plaintext token.\n   * @returns `prefix` + `hash`.\n   */\n  private getPrimaryKey = (hash: string): string => {\n    return `${this.getPrimaryKeyPrefix()}${hash}`;\n  };\n\n  /**\n   * Computes logical expiration (`expiresAt` / `ttl`) as `nowSec` plus {@link StoreOptions.ttlDays}.\n   *\n   * @param nowSec - Current time as Unix seconds.\n   * @returns Expiration timestamp in Unix seconds (default lifetime: 60 days).\n   */\n  private makeExpiresAt = (nowSec: number): number => {\n    return nowSec + (this.options?.ttlDays ?? 60) * 24 * 60 * 60;\n  };\n\n  /**\n   * Ensures the token is non-empty and matches the expected base64url length for `tokenBytes`.\n   *\n   * @param token - Plaintext refresh token from the client.\n   * @throws {@link RefreshTokenInvalidError} When validation fails.\n   */\n  private validateRefreshToken(token: string): void {\n    if (!token || token.length !== Math.ceil(this.tokenBytes * 8 / 6)) {\n      throw new RefreshTokenInvalidError();\n    }\n  }\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamodb.js","sourceRoot":"","sources":["../../src/stores/dynamodb.ts"],"names":[],"mappings":";;;AAAA,8DAA0D;AAC1D,wDAA0I;AAE1I,iEAKgC;AAgBhC,wCAAuD;AACvD,wCAAyC;AAmBzC,4DAA4D;AAC5D,MAAM,0BAA0B,GAAG,KAAK,CAAC;AAEzC,+DAA+D;AAC/D,MAAM,6BAA6B,GAAG,iBAAiB,CAAC;AAExD,+DAA+D;AAC/D,MAAM,6BAA6B,GAAG,iBAAiB,CAAC;AAExD,8EAA8E;AAC9E,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAE/B,iFAAiF;AACjF,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAE5B;;;;;;;;GAQG;AACH,MAAa,4BAA4B;IAOvC;;;;OAIG;IACH,YACmB,SAAiB,EACjB,MAAc,EACd,OAAsB;QAFtB,cAAS,GAAT,SAAS,CAAQ;QACjB,WAAM,GAAN,MAAM,CAAQ;QACd,YAAO,GAAP,OAAO,CAAe;QAdzC,qDAAqD;QAC7C,QAAG,GAAkC,IAAI,CAAC;QAmBlD;;;;;WAKG;QACI,UAAK,GAAG,KAAK,EAAE,MAAmB,EAAwB,EAAE;YACjE,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAE1B,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;YACrC,MAAM,MAAM,GAAG,IAAA,eAAQ,EAAC,GAAG,CAAC,CAAC;YAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YAE7C,MAAM,YAAY,GAAG,IAAA,kBAAW,EAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAClD,MAAM,IAAI,GAAG,IAAA,gBAAS,EAAC,YAAY,CAAC,CAAC;YACrC,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAEpC,MAAM,GAAG,CAAC,IAAI,CACZ,IAAI,yBAAU,CAAC;gBACb,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,IAAI,EAAE;oBACJ,EAAE;oBACF,SAAS,EAAE,MAAM,CAAC,SAAS;oBAC3B,SAAS,EAAE,MAAM,CAAC,SAAS;oBAC3B,SAAS,EAAE,MAAM;oBACjB,SAAS;oBACT,GAAG,EAAE,SAAS;iBACf;gBACD,mBAAmB,EAAE,0BAA0B;aAChD,CAAC,CACH,CAAC;YAEF,OAAO;gBACL,YAAY;gBACZ,qBAAqB,EAAE,SAAS;aACjC,CAAC;QACJ,CAAC,CAAC;QAEF;;;;;;;;;;;;;;;;;WAiBG;QACI,WAAM,GAAG,KAAK,EAAE,MAAoB,EAAyB,EAAE;YACpE,yBAAyB;YACzB,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAE/C,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAE1B,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;YACrC,MAAM,MAAM,GAAG,IAAA,eAAQ,EAAC,GAAG,CAAC,CAAC;YAE7B,MAAM,WAAW,GAAG,IAAA,gBAAS,EAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YACnD,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;YAElD,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;YACrD,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,+CAAwB,EAAE,CAAC;YACvC,CAAC;YACD,IAAI,OAAO,CAAC,SAAS,IAAI,MAAM,EAAE,CAAC;gBAChC,MAAM,IAAI,+CAAwB,EAAE,CAAC;YACvC,CAAC;YACD,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;gBACtB,MAAM,IAAI,+CAAwB,EAAE,CAAC;YACvC,CAAC;YACD,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;gBACtB,MAAM,IAAI,CAAC,uBAAuB,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;YACnD,CAAC;YAED,MAAM,yBAAyB,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YAC7D,MAAM,gBAAgB,GAAG,IAAA,kBAAW,EAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACtD,MAAM,QAAQ,GAAG,IAAA,gBAAS,EAAC,gBAAgB,CAAC,CAAC;YAC7C,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAE5C,IAAI,CAAC;gBACH,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,mCAAoB,CAAC;oBACtC,aAAa,EAAE;wBACb;4BACE,MAAM,EAAE;gCACN,SAAS,EAAE,IAAI,CAAC,SAAS;gCACzB,GAAG,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE;gCACtB,gBAAgB,EAAE,2DAA2D;gCAC7E,mBAAmB,EAAE,8FAA8F;gCACnH,wBAAwB,EAAE;oCACxB,MAAM,EAAE,KAAK;iCACd;gCACD,yBAAyB,EAAE;oCACzB,MAAM,EAAE,MAAM;oCACd,SAAS,EAAE,MAAM;oCACjB,MAAM,EAAE,OAAO,CAAC,SAAS;iCAC1B;6BACF;yBACF;wBACD;4BACE,GAAG,EAAE;gCACH,SAAS,EAAE,IAAI,CAAC,SAAS;gCACzB,IAAI,EAAE;oCACJ,EAAE,EAAE,MAAM;oCACV,SAAS,EAAE,OAAO,CAAC,SAAS;oCAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;oCAC5B,SAAS,EAAE,MAAM;oCACjB,SAAS,EAAE,yBAAyB;oCACpC,GAAG,EAAE,yBAAyB;iCAC/B;gCACD,mBAAmB,EAAE,0BAA0B;6BAChD;yBACF;qBACF;iBACF,CAAC,CAAC,CAAC;YAEN,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,8BAA8B,EAAE,CAAC;oBAC5E,wDAAwD;oBACxD,MAAM,IAAI,CAAC,uBAAuB,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;gBACnD,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;YAED,OAAO;gBACL,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,YAAY,EAAE,gBAAgB;gBAC9B,qBAAqB,EAAE,yBAAyB;aACjD,CAAC;QACJ,CAAC,CAAC;QAEF;;;;;;;;WAQG;QACI,WAAM,GAAG,KAAK,EAAE,MAAoB,EAAiB,EAAE;YAC5D,yBAAyB;YACzB,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAE/C,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAE1B,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;YACrC,MAAM,MAAM,GAAG,IAAA,eAAQ,EAAC,GAAG,CAAC,CAAC;YAE7B,MAAM,IAAI,GAAG,IAAA,gBAAS,EAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAC5C,MAAM,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YAEpC,IAAI,CAAC;gBACH,MAAM,GAAG,CAAC,IAAI,CACZ,IAAI,4BAAa,CAAC;oBAChB,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,GAAG,EAAE,EAAE,EAAE,EAAE;oBACX,gBAAgB,EAAE,sBAAsB;oBACxC,mBAAmB,EAAE,sBAAsB;oBAC3C,yBAAyB,EAAE;wBACzB,MAAM,EAAE,MAAM;qBACf;iBACF,CAAC,CACH,CAAC;YACJ,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,sDAAsD;gBACtD,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,iCAAiC,EAAE,CAAC;oBAC/E,OAAO,IAAI,CAAC;gBACd,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC,CAAC;QAEF;;;;;;;;;WASG;QACI,kBAAa,GAAG,KAAK,EAAE,MAA2B,EAAgC,EAAE;YACzF,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;YACrC,MAAM,MAAM,GAAG,IAAA,eAAQ,EAAC,GAAG,CAAC,CAAC;YAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,EAAE,kBAAkB,IAAI,6BAA6B,CAAC;YAEpF,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,2BAA2B,CAAC;gBAC1D,SAAS;gBACT,sBAAsB,EAAE,wBAAwB;gBAChD,8BAA8B,EAAE;oBAC9B,YAAY,EAAE,MAAM,CAAC,SAAS;iBAC/B;gBACD,MAAM;gBACN,yBAAyB,EAAE,MAAM,CAAC,SAAS;oBACzC,CAAC,CAAC,iDAAiD;oBACnD,CAAC,CAAC,sBAAsB;gBAC1B,+BAA+B,EAAE,MAAM,CAAC,SAAS;oBAC/C,CAAC,CAAC,EAAE,YAAY,EAAE,MAAM,CAAC,SAAS,EAAE;oBACpC,CAAC,CAAC,SAAS;aACd,CAAC,CAAC;YAEH,OAAO,EAAE,YAAY,EAAE,CAAC;QAC1B,CAAC,CAAC;QAEF;;;;;;;;WAQG;QACI,kBAAa,GAAG,KAAK,EAAE,MAA2B,EAAgC,EAAE;YACzF,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;YACrC,MAAM,MAAM,GAAG,IAAA,eAAQ,EAAC,GAAG,CAAC,CAAC;YAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,EAAE,kBAAkB,IAAI,6BAA6B,CAAC;YAEpF,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,2BAA2B,CAAC;gBAC1D,SAAS;gBACT,sBAAsB,EAAE,wBAAwB;gBAChD,8BAA8B,EAAE;oBAC9B,YAAY,EAAE,MAAM,CAAC,SAAS;iBAC/B;gBACD,MAAM;gBACN,yBAAyB,EAAE,sBAAsB;aAClD,CAAC,CAAC;YAEH,OAAO,EAAE,YAAY,EAAE,CAAC;QAC1B,CAAC,CAAC;QAEF;;;;;WAKG;QACK,gCAA2B,GAAG,KAAK,EAAE,MAO5C,EAAmB,EAAE;YACpB,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAE1B,IAAI,YAAY,GAAG,CAAC,CAAC;YACrB,IAAI,iBAAsD,CAAC;YAE3D,2EAA2E;YAC3E,MAAM,oBAAoB,GAAG,GAAY,EAAE,CAAC,iBAAiB,KAAK,SAAS,CAAC;YAE5E,GAAG,CAAC;gBACF,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC,IAAI,CACxB,IAAI,2BAAY,CAAC;oBACf,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,SAAS,EAAE,MAAM,CAAC,SAAS;oBAC3B,sBAAsB,EAAE,MAAM,CAAC,sBAAsB;oBACrD,yBAAyB,EAAE,MAAM,CAAC,8BAA8B;oBAChE,oBAAoB,EAAE,IAAI;oBAC1B,iBAAiB,EAAE,iBAAiB;iBACrC,CAAC,CACH,CAAC;gBAEF,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC;gBAC9B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;oBACzB,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;oBACnB,IAAI,OAAO,EAAE,KAAK,QAAQ,EAAE,CAAC;wBAC3B,SAAS;oBACX,CAAC;oBAED,MAAM,yBAAyB,GAAoC;wBACjE,MAAM,EAAE,MAAM,CAAC,MAAM;wBACrB,GAAG,MAAM,CAAC,+BAA+B;qBAC1C,CAAC;oBAEF,IAAI,CAAC;wBACH,MAAM,GAAG,CAAC,IAAI,CACZ,IAAI,4BAAa,CAAC;4BAChB,SAAS,EAAE,IAAI,CAAC,SAAS;4BACzB,GAAG,EAAE,EAAE,EAAE,EAAE;4BACX,gBAAgB,EAAE,sBAAsB;4BACxC,mBAAmB,EAAE,MAAM,CAAC,yBAAyB;4BACrD,yBAAyB,EAAE,yBAAyB;yBACrD,CAAC,CACH,CAAC;wBACF,YAAY,IAAI,CAAC,CAAC;oBACpB,CAAC;oBAAC,OAAO,KAAc,EAAE,CAAC;wBACxB,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,iCAAiC,EAAE,CAAC;4BAC/E,SAAS;wBACX,CAAC;wBACD,MAAM,KAAK,CAAC;oBACd,CAAC;gBACH,CAAC;gBAED,iBAAiB,GAAG,GAAG,CAAC,gBAAuD,CAAC;YAClF,CAAC,QAAQ,oBAAoB,EAAE,EAAE;YAEjC,OAAO,YAAY,CAAC;QACtB,CAAC,CAAC;QAEF;;;;;;;;WAQG;QACK,4BAAuB,GAAG,KAAK,EAAE,OAAoB,EAAE,GAAS,EAAkB,EAAE;YAC1F,IAAI,IAAI,CAAC,OAAO,EAAE,oBAAoB,EAAE,CAAC;gBACvC,MAAM,IAAI,CAAC,aAAa,CAAC;oBACvB,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,GAAG;iBACJ,CAAC,CAAC;YACL,CAAC;YAED,MAAM,IAAI,8CAAuB,CAAC,SAAS,EAAE;gBAC3C,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,SAAS,EAAE,OAAO,CAAC,SAAS;aAC7B,CAAC,CAAC;QACL,CAAC,CAAC;QAEF;;;;WAIG;QACK,WAAM,GAAG,GAA2B,EAAE;YAC5C,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;gBACd,MAAM,MAAM,GAAG,IAAI,gCAAc,CAAC;oBAChC,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,QAAQ,EAAE,CAAC,GAAG,EAAE;wBACd,IAAI,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,CAAC;4BAC3B,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;wBAC/B,CAAC;wBACD,OAAO,oBAAoB,IAAI,CAAC,MAAM,gBAAgB,CAAC;oBACzD,CAAC,CAAC,EAAE;iBACL,CAAC,CAAC;gBACH,IAAI,CAAC,GAAG,GAAG,qCAAsB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;YAChF,CAAC;YACD,OAAO,IAAI,CAAC,GAAG,CAAC;QAClB,CAAC,CAAC;QAEF;;;;;WAKG;QACK,mBAAc,GAAG,KAAK,EAAE,EAAU,EAA+B,EAAE;YACzE,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAE1B,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC,IAAI,CACxB,IAAI,yBAAU,CAAC;gBACb,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,GAAG,EAAE,EAAE,EAAE,EAAE;gBACX,cAAc,EAAE,IAAI,CAAC,OAAO,EAAE,cAAc,IAAI,IAAI;aACrD,CAAC,CACH,CAAC;YACF,OAAQ,GAAG,CAAC,IAAoB,IAAI,IAAI,CAAC;QAC3C,CAAC,CAAC;QAEF;;;;WAIG;QACK,wBAAmB,GAAG,GAAW,EAAE;YACzC,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,QAAQ,IAAI,0BAA0B,EAAE,CAAC;QACnE,CAAC,CAAC;QAEF;;;;;WAKG;QACK,kBAAa,GAAG,CAAC,IAAY,EAAU,EAAE;YAC/C,OAAO,GAAG,IAAI,CAAC,mBAAmB,EAAE,GAAG,IAAI,EAAE,CAAC;QAChD,CAAC,CAAC;QAEF;;;;;WAKG;QACK,kBAAa,GAAG,CAAC,MAAc,EAAU,EAAE;YACjD,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC;YAC5C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;gBAC7B,OAAO,MAAM,GAAG,UAAU,CAAC;YAC7B,CAAC;YACD,OAAO,MAAM,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;QAC7E,CAAC,CAAC;QAEF;;;;;;WAMG;QACK,sBAAiB,GAAG,CAAC,UAAmB,EAAU,EAAE;YAC1D,MAAM,KAAK,GAAG,UAAU,IAAI,mBAAmB,CAAC;YAChD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;gBAC1C,MAAM,IAAI,UAAU,CAAC,uCAAuC,CAAC,CAAC;YAChE,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC,CAAC;QAEF;;;;;WAKG;QACK,uBAAkB,GAAG,CAAC,OAAsB,EAAQ,EAAE;YAC5D,IAAI,OAAO,EAAE,UAAU,KAAK,SAAS,IAAI,OAAO,CAAC,UAAU,IAAI,CAAC,EAAE,CAAC;gBACjE,MAAM,IAAI,UAAU,CAAC,sCAAsC,CAAC,CAAC;YAC/D,CAAC;YACD,IAAI,OAAO,EAAE,OAAO,KAAK,SAAS,IAAI,OAAO,CAAC,OAAO,IAAI,CAAC,EAAE,CAAC;gBAC3D,MAAM,IAAI,UAAU,CAAC,mCAAmC,CAAC,CAAC;YAC5D,CAAC;QACH,CAAC,CAAC;QA1bA,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QACnE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IA0bD;;;;;OAKG;IACK,oBAAoB,CAAC,KAAa;QACxC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YAClE,MAAM,IAAI,+CAAwB,EAAE,CAAC;QACvC,CAAC;IACH,CAAC;CAEF;AAzdD,oEAydC","sourcesContent":["import { DynamoDBClient } from '@aws-sdk/client-dynamodb';\nimport { DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, UpdateCommand, TransactWriteCommand } from '@aws-sdk/lib-dynamodb';\n\nimport {\n  RefreshTokenExpiredError,\n  RefreshTokenInvalidError,\n  RefreshTokenReusedError,\n  RefreshTokenRevokedError,\n} from './refresh-token-errors';\nimport type {\n  RefreshTokenStore,\n  StoreOptions,\n  DocumentClientTranslateConfig,\n  TokenRecord,\n  IssueParams,\n  RotateParams,\n  RevokeParams,\n  RevokeSessionParams,\n  RevokeSessionResult,\n  RevokeSubjectParams,\n  RevokeSubjectResult,\n  IssueResult,\n  RotateResult,\n} from '../types/index';\nimport { randomtoken, sha256hex } from '../utils/hash';\nimport { epochsec } from '../utils/time';\n\n/** Re-exported types for consumers that import the DynamoDB store module. */\nexport {\n  RefreshTokenStore,\n  StoreOptions,\n  DocumentClientTranslateConfig,\n  TokenRecord,\n  IssueParams,\n  RotateParams,\n  RevokeParams,\n  RevokeSessionParams,\n  RevokeSessionResult,\n  RevokeSubjectParams,\n  RevokeSubjectResult,\n  IssueResult,\n  RotateResult,\n};\n\n/** Default partition key prefix for refresh token items. */\nconst DEFAULT_PRIMARY_KEY_PREFIX = 'rt#';\n\n/** Default GSI name for querying token rows by `sessionId`. */\nconst DEFAULT_SESSION_ID_INDEX_NAME = 'sessionId-index';\n\n/** Default GSI name for querying token rows by `subjectId`. */\nconst DEFAULT_SUBJECT_ID_INDEX_NAME = 'subjectId-index';\n\n/** Default random byte length for generated refresh tokens (32 → 256-bit). */\nconst DEFAULT_TOKEN_BYTES = 32;\n\n/** Default token lifetime in days when neither ttlSeconds nor ttlDays is set. */\nconst DEFAULT_TTL_DAYS = 60;\n\n/**\n * {@link RefreshTokenStore} implementation backed by a single DynamoDB table.\n *\n * Items use partition key `pk`, logical expiration `expiresAt`, and DynamoDB TTL attribute `ttl`\n * (Unix seconds). Enable table TTL on attribute `ttl` so expired and rotated rows are removed\n * asynchronously. Session-wide revocation requires a GSI whose partition key is `sessionId`\n * (see {@link StoreOptions.sessionIdIndexName}). This class owns the DynamoDB client; callers\n * supply `tableName`, `region`, and optional {@link StoreOptions}.\n */\nexport class DynamodbRefreshTokenProvider implements RefreshTokenStore {\n  /** Lazily initialized and cached document client. */\n  private ddb: DynamoDBDocumentClient | null = null;\n\n  /** Random byte length for generated refresh tokens. */\n  private readonly tokenBytes: number;\n\n  /**\n   * @param tableName - DynamoDB table name for refresh token items.\n   * @param region - AWS region for the DynamoDB client.\n   * @param options - Token lifetime, PK prefix, GSI name, reuse revocation, or custom endpoint.\n   */\n  constructor(\n    private readonly tableName: string,\n    private readonly region: string,\n    private readonly options?: StoreOptions,\n  ) {\n    this.tokenBytes = this.resolveTokenBytes(this.options?.tokenBytes);\n    this.validateTtlOptions(this.options);\n  }\n\n  /**\n   * Inserts a new token record with `expiresAt` and matching `ttl`. Fails the put if `pk` already exists.\n   *\n   * @param params - Subject, session, and optional clock (`now`).\n   * @returns Plaintext refresh token and expiration as Unix seconds.\n   */\n  public issue = async (params: IssueParams): Promise<IssueResult> => {\n    const ddb = this.getddb();\n\n    const now = params.now ?? new Date();\n    const nowSec = epochsec(now);\n    const expiresAt = this.makeExpiresAt(nowSec);\n\n    const refreshToken = randomtoken(this.tokenBytes);\n    const hash = sha256hex(refreshToken);\n    const pk = this.getPrimaryKey(hash);\n\n    await ddb.send(\n      new PutCommand({\n        TableName: this.tableName,\n        Item: {\n          pk,\n          subjectId: params.subjectId,\n          sessionId: params.sessionId,\n          createdAt: nowSec,\n          expiresAt,\n          ttl: expiresAt,\n        },\n        ConditionExpression: 'attribute_not_exists(pk)',\n      }),\n    );\n\n    return {\n      refreshToken,\n      refreshTokenExpiresAt: expiresAt,\n    };\n  };\n\n  /**\n   * Marks the current token as rotated and creates the successor row in one transaction.\n   *\n   * Updates the previous row’s `ttl` to its `expiresAt` and sets `ttl` on the new Put to the\n   * successor’s expiration so DynamoDB can delete both when appropriate.\n   *\n   * When reuse is detected and {@link StoreOptions.revokeSessionOnReuse} is true, all tokens for\n   * the same `sessionId` and `subjectId` are revoked via {@link DynamodbRefreshTokenProvider.revokeSession}\n   * before throwing.\n   *\n   * @param params - Client refresh token and optional clock (`now`).\n   * @returns Subject, session, new plaintext token, and new expiration.\n   * @throws {@link RefreshTokenInvalidError} When the token format is invalid or no row exists.\n   * @throws {@link RefreshTokenExpiredError} When `expiresAt` is not after `now`.\n   * @throws {@link RefreshTokenRevokedError} When the token row has `revokedAt` set.\n   * @throws {@link RefreshTokenReusedError} When the token was already rotated or the transaction\n   *   indicates reuse. Includes `subjectId` and `sessionId` from the loaded row.\n   */\n  public rotate = async (params: RotateParams): Promise<RotateResult> => {\n    // validate refresh token\n    this.validateRefreshToken(params.refreshToken);\n\n    const ddb = this.getddb();\n\n    const now = params.now ?? new Date();\n    const nowSec = epochsec(now);\n\n    const currentHash = sha256hex(params.refreshToken);\n    const currentPk = this.getPrimaryKey(currentHash);\n\n    const current = await this.getTokenRecord(currentPk);\n    if (!current) {\n      throw new RefreshTokenInvalidError();\n    }\n    if (current.expiresAt <= nowSec) {\n      throw new RefreshTokenExpiredError();\n    }\n    if (current.revokedAt) {\n      throw new RefreshTokenRevokedError();\n    }\n    if (current.rotatedAt) {\n      await this.handleRefreshTokenReuse(current, now);\n    }\n\n    const nextRefreshTokenExpiresAt = this.makeExpiresAt(nowSec);\n    const nextRefreshToken = randomtoken(this.tokenBytes);\n    const nextHash = sha256hex(nextRefreshToken);\n    const nextPk = this.getPrimaryKey(nextHash);\n\n    try {\n      await ddb.send(new TransactWriteCommand({\n        TransactItems: [\n          {\n            Update: {\n              TableName: this.tableName,\n              Key: { pk: currentPk },\n              UpdateExpression: 'SET rotatedAt = :now, replacedByPk = :nextPk, #ttl = :ttl',\n              ConditionExpression: 'attribute_exists(pk) AND attribute_not_exists(rotatedAt) AND attribute_not_exists(revokedAt)',\n              ExpressionAttributeNames: {\n                '#ttl': 'ttl',\n              },\n              ExpressionAttributeValues: {\n                ':now': nowSec,\n                ':nextPk': nextPk,\n                ':ttl': current.expiresAt,\n              },\n            },\n          },\n          {\n            Put: {\n              TableName: this.tableName,\n              Item: {\n                pk: nextPk,\n                subjectId: current.subjectId,\n                sessionId: current.sessionId,\n                createdAt: nowSec,\n                expiresAt: nextRefreshTokenExpiresAt,\n                ttl: nextRefreshTokenExpiresAt,\n              },\n              ConditionExpression: 'attribute_not_exists(pk)',\n            },\n          },\n        ],\n      }));\n\n    } catch (error: unknown) {\n      if (error instanceof Error && error.name === 'TransactionCanceledException') {\n        // Treat conditional transaction failure as token reuse.\n        await this.handleRefreshTokenReuse(current, now);\n      }\n      throw error;\n    }\n\n    return {\n      subjectId: current.subjectId,\n      sessionId: current.sessionId,\n      refreshToken: nextRefreshToken,\n      refreshTokenExpiresAt: nextRefreshTokenExpiresAt,\n    };\n  };\n\n  /**\n   * Sets `revokedAt` on the token row. Missing items succeed (idempotent revoke).\n   *\n   * Does not update `ttl`; existing `ttl` from issue/rotate still applies for DynamoDB cleanup.\n   *\n   * @param params - Refresh token and optional clock (`now`).\n   * @returns `true` after a successful update or no-op when the item is absent.\n   * @throws {@link RefreshTokenInvalidError} When the token string format is invalid.\n   */\n  public revoke = async (params: RevokeParams): Promise<true> => {\n    // validate refresh token\n    this.validateRefreshToken(params.refreshToken);\n\n    const ddb = this.getddb();\n\n    const now = params.now ?? new Date();\n    const nowSec = epochsec(now);\n\n    const hash = sha256hex(params.refreshToken);\n    const pk = this.getPrimaryKey(hash);\n\n    try {\n      await ddb.send(\n        new UpdateCommand({\n          TableName: this.tableName,\n          Key: { pk },\n          UpdateExpression: 'SET revokedAt = :now',\n          ConditionExpression: 'attribute_exists(pk)',\n          ExpressionAttributeValues: {\n            ':now': nowSec,\n          },\n        }),\n      );\n    } catch (error: unknown) {\n      // Missing item: treat as success (idempotent revoke).\n      if (error instanceof Error && error.name === 'ConditionalCheckFailedException') {\n        return true;\n      }\n      throw error;\n    }\n    return true;\n  };\n\n  /**\n   * Sets `revokedAt` on every token row for the given `sessionId` (optionally filtered by `subjectId`).\n   *\n   * Queries the session GSI (partition key `sessionId`; `KEYS_ONLY` is enough), then updates each\n   * base-table item. When `subjectId` is set, it is required in the `UpdateItem` condition.\n   * Missing or non-matching items are skipped (idempotent). Paginate with `LastEvaluatedKey`.\n   *\n   * @param params - Session id, optional subject filter, and optional clock.\n   * @returns Count of rows updated with `revokedAt` in this call.\n   */\n  public revokeSession = async (params: RevokeSessionParams): Promise<RevokeSessionResult> => {\n    const now = params.now ?? new Date();\n    const nowSec = epochsec(now);\n    const indexName = this.options?.sessionIdIndexName ?? DEFAULT_SESSION_ID_INDEX_NAME;\n\n    const revokedCount = await this.revokeTokenRowsByIndexQuery({\n      indexName,\n      keyConditionExpression: 'sessionId = :sessionId',\n      queryExpressionAttributeValues: {\n        ':sessionId': params.sessionId,\n      },\n      nowSec,\n      updateConditionExpression: params.subjectId\n        ? 'attribute_exists(pk) AND subjectId = :subjectId'\n        : 'attribute_exists(pk)',\n      updateExpressionAttributeValues: params.subjectId\n        ? { ':subjectId': params.subjectId }\n        : undefined,\n    });\n\n    return { revokedCount };\n  };\n\n  /**\n   * Sets `revokedAt` on every refresh token row for the given `subjectId` across all sessions.\n   *\n   * Queries the subject GSI (partition key `subjectId`; `KEYS_ONLY` is enough), then updates each\n   * base-table item. Missing items are skipped (idempotent). Paginate with `LastEvaluatedKey`.\n   *\n   * @param params - Subject id and optional clock.\n   * @returns Count of rows updated with `revokedAt` in this call.\n   */\n  public revokeSubject = async (params: RevokeSubjectParams): Promise<RevokeSubjectResult> => {\n    const now = params.now ?? new Date();\n    const nowSec = epochsec(now);\n    const indexName = this.options?.subjectIdIndexName ?? DEFAULT_SUBJECT_ID_INDEX_NAME;\n\n    const revokedCount = await this.revokeTokenRowsByIndexQuery({\n      indexName,\n      keyConditionExpression: 'subjectId = :subjectId',\n      queryExpressionAttributeValues: {\n        ':subjectId': params.subjectId,\n      },\n      nowSec,\n      updateConditionExpression: 'attribute_exists(pk)',\n    });\n\n    return { revokedCount };\n  };\n\n  /**\n   * Queries a GSI and sets `revokedAt` on each matching base-table row.\n   *\n   * @param params - GSI query parameters and per-row update conditions.\n   * @returns Count of rows updated with `revokedAt` in this call.\n   */\n  private revokeTokenRowsByIndexQuery = async (params: {\n    indexName: string;\n    keyConditionExpression: string;\n    queryExpressionAttributeValues: Record<string, string>;\n    nowSec: number;\n    updateConditionExpression: string;\n    updateExpressionAttributeValues?: Record<string, string>;\n  }): Promise<number> => {\n    const ddb = this.getddb();\n\n    let revokedCount = 0;\n    let exclusiveStartKey: Record<string, unknown> | undefined;\n\n    /** Whether another Query page is available after the previous response. */\n    const shouldContinuePaging = (): boolean => exclusiveStartKey !== undefined;\n\n    do {\n      const res = await ddb.send(\n        new QueryCommand({\n          TableName: this.tableName,\n          IndexName: params.indexName,\n          KeyConditionExpression: params.keyConditionExpression,\n          ExpressionAttributeValues: params.queryExpressionAttributeValues,\n          ProjectionExpression: 'pk',\n          ExclusiveStartKey: exclusiveStartKey,\n        }),\n      );\n\n      const items = res.Items ?? [];\n      for (const item of items) {\n        const pk = item.pk;\n        if (typeof pk !== 'string') {\n          continue;\n        }\n\n        const expressionAttributeValues: Record<string, string | number> = {\n          ':now': params.nowSec,\n          ...params.updateExpressionAttributeValues,\n        };\n\n        try {\n          await ddb.send(\n            new UpdateCommand({\n              TableName: this.tableName,\n              Key: { pk },\n              UpdateExpression: 'SET revokedAt = :now',\n              ConditionExpression: params.updateConditionExpression,\n              ExpressionAttributeValues: expressionAttributeValues,\n            }),\n          );\n          revokedCount += 1;\n        } catch (error: unknown) {\n          if (error instanceof Error && error.name === 'ConditionalCheckFailedException') {\n            continue;\n          }\n          throw error;\n        }\n      }\n\n      exclusiveStartKey = res.LastEvaluatedKey as Record<string, unknown> | undefined;\n    } while (shouldContinuePaging());\n\n    return revokedCount;\n  };\n\n  /**\n   * Handles refresh-token reuse detection: optionally cascades {@link DynamodbRefreshTokenProvider.revokeSession}\n   * when {@link StoreOptions.revokeSessionOnReuse} is true, then throws {@link RefreshTokenReusedError}\n   * populated with `subjectId` / `sessionId` from `current`.\n   *\n   * @param current - Token row that indicated reuse (`rotatedAt` set or transaction canceled).\n   * @param now - Clock used for `revokedAt` when cascading revoke is enabled.\n   * @throws {@link RefreshTokenReusedError} Always (return type is `never`).\n   */\n  private handleRefreshTokenReuse = async (current: TokenRecord, now: Date): Promise<never> => {\n    if (this.options?.revokeSessionOnReuse) {\n      await this.revokeSession({\n        sessionId: current.sessionId,\n        subjectId: current.subjectId,\n        now,\n      });\n    }\n\n    throw new RefreshTokenReusedError(undefined, {\n      subjectId: current.subjectId,\n      sessionId: current.sessionId,\n    });\n  };\n\n  /**\n   * Returns the cached {@link DynamoDBDocumentClient}, creating it on first use.\n   *\n   * @returns Document client configured for `region` and optional `endpoint`.\n   */\n  private getddb = (): DynamoDBDocumentClient => {\n    if (!this.ddb) {\n      const client = new DynamoDBClient({\n        region: this.region,\n        endpoint: (() => {\n          if (this.options?.endpoint) {\n            return this.options.endpoint;\n          }\n          return `https://dynamodb.${this.region}.amazonaws.com`;\n        })(),\n      });\n      this.ddb = DynamoDBDocumentClient.from(client, this.options?.translateConfig);\n    }\n    return this.ddb;\n  };\n\n  /**\n   * Loads a token row by partition key.\n   *\n   * @param pk - Full partition key (`prefix` + hash).\n   * @returns Parsed {@link TokenRecord}, or `null` if the item does not exist.\n   */\n  private getTokenRecord = async (pk: string): Promise<TokenRecord | null> => {\n    const ddb = this.getddb();\n\n    const res = await ddb.send(\n      new GetCommand({\n        TableName: this.tableName,\n        Key: { pk },\n        ConsistentRead: this.options?.consistentRead ?? true,\n      }),\n    );\n    return (res.Item as TokenRecord) ?? null;\n  };\n\n  /**\n   * Effective partition key prefix from {@link StoreOptions} or {@link DEFAULT_PRIMARY_KEY_PREFIX}.\n   *\n   * @returns Prefix string (e.g. `rt#`).\n   */\n  private getPrimaryKeyPrefix = (): string => {\n    return `${this.options?.pkPrefix ?? DEFAULT_PRIMARY_KEY_PREFIX}`;\n  };\n\n  /**\n   * Builds the full partition key for a token hash.\n   *\n   * @param hash - SHA-256 hex digest of the plaintext token.\n   * @returns `prefix` + `hash`.\n   */\n  private getPrimaryKey = (hash: string): string => {\n    return `${this.getPrimaryKeyPrefix()}${hash}`;\n  };\n\n  /**\n   * Computes logical expiration (`expiresAt` / `ttl`) as `nowSec` plus configured lifetime.\n   *\n   * @param nowSec - Current time as Unix seconds.\n   * @returns Expiration timestamp in Unix seconds.\n   */\n  private makeExpiresAt = (nowSec: number): number => {\n    const ttlSeconds = this.options?.ttlSeconds;\n    if (ttlSeconds !== undefined) {\n      return nowSec + ttlSeconds;\n    }\n    return nowSec + (this.options?.ttlDays ?? DEFAULT_TTL_DAYS) * 24 * 60 * 60;\n  };\n\n  /**\n   * Resolves and validates {@link StoreOptions.tokenBytes}.\n   *\n   * @param tokenBytes - Optional byte length from store options.\n   * @returns Positive integer byte length.\n   * @throws {RangeError} When `tokenBytes` is not a positive integer.\n   */\n  private resolveTokenBytes = (tokenBytes?: number): number => {\n    const bytes = tokenBytes ?? DEFAULT_TOKEN_BYTES;\n    if (!Number.isInteger(bytes) || bytes < 1) {\n      throw new RangeError('tokenBytes must be a positive integer');\n    }\n    return bytes;\n  };\n\n  /**\n   * Validates TTL-related store options at construction time.\n   *\n   * @param options - Store options from the constructor.\n   * @throws {RangeError} When `ttlSeconds` or `ttlDays` is not a positive number.\n   */\n  private validateTtlOptions = (options?: StoreOptions): void => {\n    if (options?.ttlSeconds !== undefined && options.ttlSeconds <= 0) {\n      throw new RangeError('ttlSeconds must be a positive number');\n    }\n    if (options?.ttlDays !== undefined && options.ttlDays <= 0) {\n      throw new RangeError('ttlDays must be a positive number');\n    }\n  };\n\n  /**\n   * Ensures the token is non-empty and matches the expected base64url length for `tokenBytes`.\n   *\n   * @param token - Plaintext refresh token from the client.\n   * @throws {@link RefreshTokenInvalidError} When validation fails.\n   */\n  private validateRefreshToken(token: string): void {\n    if (!token || token.length !== Math.ceil(this.tokenBytes * 8 / 6)) {\n      throw new RefreshTokenInvalidError();\n    }\n  }\n\n}\n"]}

package/lib/types/index.d.ts

@@ -1,19 +1,45 @@
+import type { marshallOptions, unmarshallOptions } from '@aws-sdk/lib-dynamodb';
 /** Unix timestamp in whole seconds. */
 export type EpochSec = number;
+/**
+ * Pass-through to {@link DynamoDBDocumentClient.from} `translateConfig` (marshall / unmarshall options).
+ */
+export type DocumentClientTranslateConfig = {
+    /** Options for marshalling JavaScript values to DynamoDB attribute values. */
+    marshallOptions?: marshallOptions;
+    /** Options for unmarshalling DynamoDB attribute values to JavaScript values. */
+    unmarshallOptions?: unmarshallOptions;
+};
 /**
  * Configuration for the DynamoDB refresh token provider constructor.
  *
- * Token lifetime (`ttlDays`) drives both logical expiration (`expiresAt`) and the
- * DynamoDB TTL attribute (`ttl`) written on Put / Transact. Session revocation options
- * (`sessionIdIndexName`, `revokeSessionOnReuse`) require a GSI whose partition key is
- * `sessionId`.
+ * Token lifetime (`ttlDays` or `ttlSeconds`) drives both logical expiration (`expiresAt`) and the
+ * DynamoDB TTL attribute (`ttl`) written on Put / Transact. When both are set, `ttlSeconds` takes
+ * precedence. Session revocation options (`sessionIdIndexName`, `revokeSessionOnReuse`) require a
+ * GSI whose partition key is `sessionId`. Subject-wide revocation (`subjectIdIndexName`,
+ * {@link RefreshTokenStore.revokeSubject}) requires a GSI whose partition key is `subjectId`.
  */
 export type StoreOptions = {
     /**
      * Refresh token lifetime in days (added to `now` when computing `expiresAt` / `ttl`).
+     * Ignored when {@link StoreOptions.ttlSeconds} is set.
      * @defaultValue 60
      */
     ttlDays?: number;
+    /**
+     * Refresh token lifetime in seconds (added to `now` when computing `expiresAt` / `ttl`).
+     * Takes precedence over {@link StoreOptions.ttlDays} when both are set.
+     */
+    ttlSeconds?: number;
+    /**
+     * Number of random bytes used when generating opaque refresh tokens.
+     * @defaultValue 32
+     */
+    tokenBytes?: number;
+    /**
+     * Pass-through to {@link DynamoDBDocumentClient.from} `translateConfig` (e.g. `removeUndefinedValues`).
+     */
+    translateConfig?: DocumentClientTranslateConfig;
     /**
      * Partition key prefix for DynamoDB items; full `pk` is `prefix` + SHA-256 hex of the token.
      * @defaultValue `'rt#'`
@@ -35,6 +61,13 @@ export type StoreOptions = {
      * @defaultValue `'sessionId-index'`
      */
     sessionIdIndexName?: string;
+    /**
+     * DynamoDB GSI name whose partition key attribute is `subjectId` (String).
+     * Required for {@link RefreshTokenStore.revokeSubject} (e.g. logout all devices, password change).
+     * `KEYS_ONLY` projection is sufficient.
+     * @defaultValue `'subjectId-index'`
+     */
+    subjectIdIndexName?: string;
     /**
      * When true, {@link RefreshTokenStore.rotate} calls {@link RefreshTokenStore.revokeSession}
      * for the token’s `sessionId` and `subjectId` before throwing {@link RefreshTokenReusedError}.
@@ -102,6 +135,18 @@ export type RevokeSessionResult = {
     /** Number of token rows successfully updated with `revokedAt` in this call. */
     revokedCount: number;
 };
+/** Parameters for {@link RefreshTokenStore.revokeSubject}. */
+export type RevokeSubjectParams = {
+    /** Subject (user) whose refresh token rows should all be revoked across every session. */
+    subjectId: string;
+    /** Clock override for tests; defaults to `new Date()`. */
+    now?: Date;
+};
+/** Result of {@link RefreshTokenStore.revokeSubject}. */
+export type RevokeSubjectResult = {
+    /** Number of token rows successfully updated with `revokedAt` in this call. */
+    revokedCount: number;
+};
 /**
  * DynamoDB item shape for a stored refresh token (hash-keyed by `pk`).
  *
@@ -111,7 +156,7 @@ export type RevokeSessionResult = {
 export type TokenRecord = {
     /** Partition key: prefix + SHA-256 hex of the plaintext token. */
     pk: string;
-    /** Subject (user) identifier; also used when cascading session revoke on reuse. */
+    /** Subject (user) identifier; partition key of the subject GSI used by {@link RefreshTokenStore.revokeSubject}. */
     subjectId: string;
     /**
      * Session identifier. Partition key of the session GSI used by
@@ -179,4 +224,13 @@ export interface RefreshTokenStore {
      * @returns Count of rows updated with `revokedAt`.
      */
     revokeSession(params: RevokeSessionParams): Promise<RevokeSessionResult>;
+    /**
+     * Sets `revokedAt` on every refresh token row for the given subject (logout all devices, password change, account suspension).
+     *
+     * Requires a DynamoDB GSI whose partition key is `subjectId` (see {@link StoreOptions.subjectIdIndexName}).
+     *
+     * @param params - Subject id and optional clock.
+     * @returns Count of rows updated with `revokedAt`.
+     */
+    revokeSubject(params: RevokeSubjectParams): Promise<RevokeSubjectResult>;
 }

package/lib/types/index.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"","sourcesContent":["/** Unix timestamp in whole seconds. */\nexport type EpochSec = number;\n\n/**\n * Configuration for the DynamoDB refresh token provider constructor.\n *\n * Token lifetime (`ttlDays`) drives both logical expiration (`expiresAt`) and the\n * DynamoDB TTL attribute (`ttl`) written on Put / Transact. Session revocation options\n * (`sessionIdIndexName`, `revokeSessionOnReuse`) require a GSI whose partition key is\n * `sessionId`.\n */\nexport type StoreOptions = {\n  /**\n   * Refresh token lifetime in days (added to `now` when computing `expiresAt` / `ttl`).\n   * @defaultValue 60\n   */\n  ttlDays?: number;\n\n  /**\n   * Partition key prefix for DynamoDB items; full `pk` is `prefix` + SHA-256 hex of the token.\n   * @defaultValue `'rt#'`\n   */\n  pkPrefix?: string;\n\n  /**\n   * Whether to use strongly consistent reads on `GetItem`.\n   * @defaultValue true\n   */\n  consistentRead?: boolean;\n\n  /**\n   * Custom DynamoDB API endpoint (e.g. LocalStack or DynamoDB Local).\n   */\n  endpoint?: string;\n\n  /**\n   * DynamoDB GSI name whose partition key attribute is `sessionId` (String).\n   * Required for {@link RefreshTokenStore.revokeSession} and for `revokeSessionOnReuse`.\n   * `KEYS_ONLY` projection is sufficient.\n   * @defaultValue `'sessionId-index'`\n   */\n  sessionIdIndexName?: string;\n\n  /**\n   * When true, {@link RefreshTokenStore.rotate} calls {@link RefreshTokenStore.revokeSession}\n   * for the token’s `sessionId` and `subjectId` before throwing {@link RefreshTokenReusedError}.\n   * Aligns with OAuth 2.0 BCP refresh-token family revocation on reuse detection.\n   * @defaultValue false\n   */\n  revokeSessionOnReuse?: boolean;\n};\n\n/** Parameters for {@link RefreshTokenStore.issue}. */\nexport type IssueParams = {\n  /** Subject (user) identifier to associate with the token. */\n  subjectId: string;\n  /** Session identifier to associate with the token. */\n  sessionId: string;\n  /** Clock override for tests; defaults to `new Date()`. */\n  now?: Date;\n};\n\n/** Result of {@link RefreshTokenStore.issue}. */\nexport type IssueResult = {\n  /** Opaque refresh token string (plaintext; only a hash is stored at rest). */\n  refreshToken: string;\n  /** Logical expiration time as Unix seconds (same value written to `expiresAt` / `ttl`). */\n  refreshTokenExpiresAt: EpochSec;\n};\n\n/** Parameters for {@link RefreshTokenStore.rotate}. */\nexport type RotateParams = {\n  /** Current refresh token from the client. */\n  refreshToken: string;\n  /** Clock override for tests; defaults to `new Date()`. */\n  now?: Date;\n};\n\n/** Result of {@link RefreshTokenStore.rotate}. */\nexport type RotateResult = {\n  /** Subject identifier from the rotated token row. */\n  subjectId: string;\n  /** Session identifier from the rotated token row. */\n  sessionId: string;\n  /** New opaque refresh token after rotation. */\n  refreshToken: string;\n  /** Logical expiration of the new token as Unix seconds. */\n  refreshTokenExpiresAt: EpochSec;\n};\n\n/** Parameters for {@link RefreshTokenStore.revoke}. */\nexport type RevokeParams = {\n  /** Refresh token to revoke. */\n  refreshToken: string;\n  /** Clock override for tests; defaults to `new Date()`. */\n  now?: Date;\n};\n\n/** Parameters for {@link RefreshTokenStore.revokeSession}. */\nexport type RevokeSessionParams = {\n  /** Session whose refresh token rows should all be revoked. */\n  sessionId: string;\n  /**\n   * When set, only rows matching this subject are revoked.\n   * Applied as an `UpdateItem` condition on the base table (not a GSI filter), so a\n   * `KEYS_ONLY` session GSI is sufficient.\n   */\n  subjectId?: string;\n  /** Clock override for tests; defaults to `new Date()`. */\n  now?: Date;\n};\n\n/** Result of {@link RefreshTokenStore.revokeSession}. */\nexport type RevokeSessionResult = {\n  /** Number of token rows successfully updated with `revokedAt` in this call. */\n  revokedCount: number;\n};\n\n/**\n * DynamoDB item shape for a stored refresh token (hash-keyed by `pk`).\n *\n * `expiresAt` is used for application-level validation; `ttl` is the DynamoDB TTL\n * attribute for asynchronous item deletion (enable TTL on the table for attribute `ttl`).\n */\nexport type TokenRecord = {\n  /** Partition key: prefix + SHA-256 hex of the plaintext token. */\n  pk: string;\n  /** Subject (user) identifier; also used when cascading session revoke on reuse. */\n  subjectId: string;\n  /**\n   * Session identifier. Partition key of the session GSI used by\n   * {@link RefreshTokenStore.revokeSession}.\n   */\n  sessionId: string;\n  /** Row creation time as Unix seconds. */\n  createdAt: EpochSec;\n  /** Logical expiration time as Unix seconds. */\n  expiresAt: EpochSec;\n  /**\n   * DynamoDB TTL attribute (Unix seconds). Set on write; table TTL must target this attribute name.\n   */\n  ttl: EpochSec;\n  /** Time the token was rotated, if applicable. */\n  rotatedAt?: EpochSec | null;\n  /** Partition key of the successor token after rotation. */\n  replacedByPk?: string | null;\n  /** Time the token was revoked, if applicable. */\n  revokedAt?: EpochSec | null;\n};\n\n/**\n * Persistence abstraction for opaque refresh tokens: issue, rotate, revoke, and session revoke.\n */\nexport interface RefreshTokenStore {\n  /**\n   * Creates a new refresh token row and returns the plaintext token.\n   *\n   * @param params - Subject, session, and optional clock.\n   * @returns Plaintext token and expiration as Unix seconds.\n   */\n  issue(params: IssueParams): Promise<IssueResult>;\n\n  /**\n   * Validates the current token, marks it rotated, inserts the successor row, and returns the new token.\n   *\n   * When reuse is detected and {@link StoreOptions.revokeSessionOnReuse} is enabled, the\n   * implementation may revoke the whole session before throwing.\n   *\n   * @param params - Current token and optional clock.\n   * @returns Subject, session, new token, and new expiration.\n   * @throws {@link RefreshTokenInvalidError} When the token is invalid or no row exists.\n   * @throws {@link RefreshTokenExpiredError} When `expiresAt` is not after `now`.\n   * @throws {@link RefreshTokenRevokedError} When the row has `revokedAt` set.\n   * @throws {@link RefreshTokenReusedError} When the token was already rotated or the transaction\n   *   failed conditionally. May include `subjectId` / `sessionId` from the store row.\n   */\n  rotate(params: RotateParams): Promise<RotateResult>;\n\n  /**\n   * Sets `revokedAt` on the token row. Idempotent if the row does not exist.\n   *\n   * Does not change DynamoDB TTL (`ttl`); cleanup still follows the value from issue/rotate.\n   *\n   * @param params - Token to revoke and optional clock.\n   * @returns `true` after a successful update or no-op when the item is absent.\n   * @throws {@link RefreshTokenInvalidError} When the token string format is invalid.\n   */\n  revoke(params: RevokeParams): Promise<true>;\n\n  /**\n   * Sets `revokedAt` on every refresh token row for the given session (OAuth 2.0 BCP family revocation).\n   *\n   * Requires a DynamoDB GSI whose partition key is `sessionId` (see {@link StoreOptions.sessionIdIndexName}).\n   * Optional `subjectId` is enforced on each base-table update condition.\n   *\n   * @param params - Session id, optional subject filter, and optional clock.\n   * @returns Count of rows updated with `revokedAt`.\n   */\n  revokeSession(params: RevokeSessionParams): Promise<RevokeSessionResult>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"","sourcesContent":["import type { marshallOptions, unmarshallOptions } from '@aws-sdk/lib-dynamodb';\n\n/** Unix timestamp in whole seconds. */\nexport type EpochSec = number;\n\n/**\n * Pass-through to {@link DynamoDBDocumentClient.from} `translateConfig` (marshall / unmarshall options).\n */\nexport type DocumentClientTranslateConfig = {\n  /** Options for marshalling JavaScript values to DynamoDB attribute values. */\n  marshallOptions?: marshallOptions;\n  /** Options for unmarshalling DynamoDB attribute values to JavaScript values. */\n  unmarshallOptions?: unmarshallOptions;\n};\n\n/**\n * Configuration for the DynamoDB refresh token provider constructor.\n *\n * Token lifetime (`ttlDays` or `ttlSeconds`) drives both logical expiration (`expiresAt`) and the\n * DynamoDB TTL attribute (`ttl`) written on Put / Transact. When both are set, `ttlSeconds` takes\n * precedence. Session revocation options (`sessionIdIndexName`, `revokeSessionOnReuse`) require a\n * GSI whose partition key is `sessionId`. Subject-wide revocation (`subjectIdIndexName`,\n * {@link RefreshTokenStore.revokeSubject}) requires a GSI whose partition key is `subjectId`.\n */\nexport type StoreOptions = {\n  /**\n   * Refresh token lifetime in days (added to `now` when computing `expiresAt` / `ttl`).\n   * Ignored when {@link StoreOptions.ttlSeconds} is set.\n   * @defaultValue 60\n   */\n  ttlDays?: number;\n\n  /**\n   * Refresh token lifetime in seconds (added to `now` when computing `expiresAt` / `ttl`).\n   * Takes precedence over {@link StoreOptions.ttlDays} when both are set.\n   */\n  ttlSeconds?: number;\n\n  /**\n   * Number of random bytes used when generating opaque refresh tokens.\n   * @defaultValue 32\n   */\n  tokenBytes?: number;\n\n  /**\n   * Pass-through to {@link DynamoDBDocumentClient.from} `translateConfig` (e.g. `removeUndefinedValues`).\n   */\n  translateConfig?: DocumentClientTranslateConfig;\n\n  /**\n   * Partition key prefix for DynamoDB items; full `pk` is `prefix` + SHA-256 hex of the token.\n   * @defaultValue `'rt#'`\n   */\n  pkPrefix?: string;\n\n  /**\n   * Whether to use strongly consistent reads on `GetItem`.\n   * @defaultValue true\n   */\n  consistentRead?: boolean;\n\n  /**\n   * Custom DynamoDB API endpoint (e.g. LocalStack or DynamoDB Local).\n   */\n  endpoint?: string;\n\n  /**\n   * DynamoDB GSI name whose partition key attribute is `sessionId` (String).\n   * Required for {@link RefreshTokenStore.revokeSession} and for `revokeSessionOnReuse`.\n   * `KEYS_ONLY` projection is sufficient.\n   * @defaultValue `'sessionId-index'`\n   */\n  sessionIdIndexName?: string;\n\n  /**\n   * DynamoDB GSI name whose partition key attribute is `subjectId` (String).\n   * Required for {@link RefreshTokenStore.revokeSubject} (e.g. logout all devices, password change).\n   * `KEYS_ONLY` projection is sufficient.\n   * @defaultValue `'subjectId-index'`\n   */\n  subjectIdIndexName?: string;\n\n  /**\n   * When true, {@link RefreshTokenStore.rotate} calls {@link RefreshTokenStore.revokeSession}\n   * for the token’s `sessionId` and `subjectId` before throwing {@link RefreshTokenReusedError}.\n   * Aligns with OAuth 2.0 BCP refresh-token family revocation on reuse detection.\n   * @defaultValue false\n   */\n  revokeSessionOnReuse?: boolean;\n};\n\n/** Parameters for {@link RefreshTokenStore.issue}. */\nexport type IssueParams = {\n  /** Subject (user) identifier to associate with the token. */\n  subjectId: string;\n  /** Session identifier to associate with the token. */\n  sessionId: string;\n  /** Clock override for tests; defaults to `new Date()`. */\n  now?: Date;\n};\n\n/** Result of {@link RefreshTokenStore.issue}. */\nexport type IssueResult = {\n  /** Opaque refresh token string (plaintext; only a hash is stored at rest). */\n  refreshToken: string;\n  /** Logical expiration time as Unix seconds (same value written to `expiresAt` / `ttl`). */\n  refreshTokenExpiresAt: EpochSec;\n};\n\n/** Parameters for {@link RefreshTokenStore.rotate}. */\nexport type RotateParams = {\n  /** Current refresh token from the client. */\n  refreshToken: string;\n  /** Clock override for tests; defaults to `new Date()`. */\n  now?: Date;\n};\n\n/** Result of {@link RefreshTokenStore.rotate}. */\nexport type RotateResult = {\n  /** Subject identifier from the rotated token row. */\n  subjectId: string;\n  /** Session identifier from the rotated token row. */\n  sessionId: string;\n  /** New opaque refresh token after rotation. */\n  refreshToken: string;\n  /** Logical expiration of the new token as Unix seconds. */\n  refreshTokenExpiresAt: EpochSec;\n};\n\n/** Parameters for {@link RefreshTokenStore.revoke}. */\nexport type RevokeParams = {\n  /** Refresh token to revoke. */\n  refreshToken: string;\n  /** Clock override for tests; defaults to `new Date()`. */\n  now?: Date;\n};\n\n/** Parameters for {@link RefreshTokenStore.revokeSession}. */\nexport type RevokeSessionParams = {\n  /** Session whose refresh token rows should all be revoked. */\n  sessionId: string;\n  /**\n   * When set, only rows matching this subject are revoked.\n   * Applied as an `UpdateItem` condition on the base table (not a GSI filter), so a\n   * `KEYS_ONLY` session GSI is sufficient.\n   */\n  subjectId?: string;\n  /** Clock override for tests; defaults to `new Date()`. */\n  now?: Date;\n};\n\n/** Result of {@link RefreshTokenStore.revokeSession}. */\nexport type RevokeSessionResult = {\n  /** Number of token rows successfully updated with `revokedAt` in this call. */\n  revokedCount: number;\n};\n\n/** Parameters for {@link RefreshTokenStore.revokeSubject}. */\nexport type RevokeSubjectParams = {\n  /** Subject (user) whose refresh token rows should all be revoked across every session. */\n  subjectId: string;\n  /** Clock override for tests; defaults to `new Date()`. */\n  now?: Date;\n};\n\n/** Result of {@link RefreshTokenStore.revokeSubject}. */\nexport type RevokeSubjectResult = {\n  /** Number of token rows successfully updated with `revokedAt` in this call. */\n  revokedCount: number;\n};\n\n/**\n * DynamoDB item shape for a stored refresh token (hash-keyed by `pk`).\n *\n * `expiresAt` is used for application-level validation; `ttl` is the DynamoDB TTL\n * attribute for asynchronous item deletion (enable TTL on the table for attribute `ttl`).\n */\nexport type TokenRecord = {\n  /** Partition key: prefix + SHA-256 hex of the plaintext token. */\n  pk: string;\n  /** Subject (user) identifier; partition key of the subject GSI used by {@link RefreshTokenStore.revokeSubject}. */\n  subjectId: string;\n  /**\n   * Session identifier. Partition key of the session GSI used by\n   * {@link RefreshTokenStore.revokeSession}.\n   */\n  sessionId: string;\n  /** Row creation time as Unix seconds. */\n  createdAt: EpochSec;\n  /** Logical expiration time as Unix seconds. */\n  expiresAt: EpochSec;\n  /**\n   * DynamoDB TTL attribute (Unix seconds). Set on write; table TTL must target this attribute name.\n   */\n  ttl: EpochSec;\n  /** Time the token was rotated, if applicable. */\n  rotatedAt?: EpochSec | null;\n  /** Partition key of the successor token after rotation. */\n  replacedByPk?: string | null;\n  /** Time the token was revoked, if applicable. */\n  revokedAt?: EpochSec | null;\n};\n\n/**\n * Persistence abstraction for opaque refresh tokens: issue, rotate, revoke, and session revoke.\n */\nexport interface RefreshTokenStore {\n  /**\n   * Creates a new refresh token row and returns the plaintext token.\n   *\n   * @param params - Subject, session, and optional clock.\n   * @returns Plaintext token and expiration as Unix seconds.\n   */\n  issue(params: IssueParams): Promise<IssueResult>;\n\n  /**\n   * Validates the current token, marks it rotated, inserts the successor row, and returns the new token.\n   *\n   * When reuse is detected and {@link StoreOptions.revokeSessionOnReuse} is enabled, the\n   * implementation may revoke the whole session before throwing.\n   *\n   * @param params - Current token and optional clock.\n   * @returns Subject, session, new token, and new expiration.\n   * @throws {@link RefreshTokenInvalidError} When the token is invalid or no row exists.\n   * @throws {@link RefreshTokenExpiredError} When `expiresAt` is not after `now`.\n   * @throws {@link RefreshTokenRevokedError} When the row has `revokedAt` set.\n   * @throws {@link RefreshTokenReusedError} When the token was already rotated or the transaction\n   *   failed conditionally. May include `subjectId` / `sessionId` from the store row.\n   */\n  rotate(params: RotateParams): Promise<RotateResult>;\n\n  /**\n   * Sets `revokedAt` on the token row. Idempotent if the row does not exist.\n   *\n   * Does not change DynamoDB TTL (`ttl`); cleanup still follows the value from issue/rotate.\n   *\n   * @param params - Token to revoke and optional clock.\n   * @returns `true` after a successful update or no-op when the item is absent.\n   * @throws {@link RefreshTokenInvalidError} When the token string format is invalid.\n   */\n  revoke(params: RevokeParams): Promise<true>;\n\n  /**\n   * Sets `revokedAt` on every refresh token row for the given session (OAuth 2.0 BCP family revocation).\n   *\n   * Requires a DynamoDB GSI whose partition key is `sessionId` (see {@link StoreOptions.sessionIdIndexName}).\n   * Optional `subjectId` is enforced on each base-table update condition.\n   *\n   * @param params - Session id, optional subject filter, and optional clock.\n   * @returns Count of rows updated with `revokedAt`.\n   */\n  revokeSession(params: RevokeSessionParams): Promise<RevokeSessionResult>;\n\n  /**\n   * Sets `revokedAt` on every refresh token row for the given subject (logout all devices, password change, account suspension).\n   *\n   * Requires a DynamoDB GSI whose partition key is `subjectId` (see {@link StoreOptions.subjectIdIndexName}).\n   *\n   * @param params - Subject id and optional clock.\n   * @returns Count of rows updated with `revokedAt`.\n   */\n  revokeSubject(params: RevokeSubjectParams): Promise<RevokeSubjectResult>;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynamodb-refresh-token-provider",
-  "description": "TypeScript library that stores **opaque refresh tokens** in **Amazon DynamoDB** using AWS SDK for JavaScript v3. Tokens are persisted under a hash of the plaintext value; **issue**, **rotate** (with reuse detection via a transactional write), **revoke** (idempotent), and **revokeSession** (OAuth 2.0 BCP family revocation) are supported.",
+  "description": "TypeScript library that stores **opaque refresh tokens** in **Amazon DynamoDB** using AWS SDK for JavaScript v3. Tokens are persisted under a hash of the plaintext value; **issue**, **rotate** (with reuse detection via a transactional write), **revoke** (idempotent), **revokeSession** (OAuth 2.0 BCP family revocation), and **revokeSubject** (subject-wide revocation across all sessions) are supported.",
   "repository": {
     "type": "git",
     "url": "https://github.com/gammarers-aws-sdk-modules/dynamodb-refresh-token-provider.git"
@@ -42,9 +42,9 @@
     "eslint": "^9",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import": "^2.32.0",
-    "jest": "^30.4.2",
+    "jest": "^30.5.0",
     "jest-junit": "^17",
-    "projen": "^0.103.1",
+    "projen": "^0.103.11",
     "ts-jest": "^29.4.12",
     "ts-node": "^10.9.2",
     "typescript": "6.0.x"
@@ -67,7 +67,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.4.6",
+  "version": "0.5.1",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [