dynamodb-refresh-token-provider 0.3.6 → 0.4.0

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), and **revoke** (idempotent) 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), and **revokeSession** (session-wide family revocation) are supported.
 
 ## Features
 
@@ -13,7 +13,8 @@ TypeScript library that stores **opaque refresh tokens** in **Amazon DynamoDB**
 - **DynamoDB TTL** — writes `ttl` (Unix seconds) on `Put` and `TransactWriteItems` so expired and rotated rows can be removed automatically when table TTL is enabled.
 - **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.
-- **Structured errors** — `RefreshTokenError`, `RefreshTokenInvalidError`, `RefreshTokenExpiredError`, `RefreshTokenRevokedError`, `RefreshTokenReusedError`, and `RefreshTokenRotateFailedError` for `instanceof` handling.
+- **Session revocation (OAuth 2.0 BCP)** — `revokeSession({ sessionId })` revokes all tokens for a session via a `sessionId` GSI; optional `revokeSessionOnReuse` cascades on reuse detection.
+- **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.
 
 ## Installation
@@ -28,7 +29,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`, and **TTL enabled** on attribute `ttl` (see [DynamoDB TTL](#dynamodb-ttl)).
+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)).
 
 ```typescript
 import {
@@ -42,6 +43,9 @@ import {
 const store = new DynamodbRefreshTokenProvider('your-refresh-token-table', 'us-east-1', {
   ttlDays: 60,
   pkPrefix: 'rt#',
+  // Optional: revoke every token in the session when reuse is detected (OAuth 2.0 BCP)
+  // revokeSessionOnReuse: true,
+  // sessionIdIndexName: 'sessionId-index',
 });
 
 // Issue a new refresh token for a subject/session
@@ -59,6 +63,10 @@ try {
 } catch (e) {
   if (e instanceof RefreshTokenReusedError) {
     // already rotated or lost a transactional race
+    // e.sessionId / e.subjectId are set when the store row was loaded
+    if (e.sessionId) {
+      await store.revokeSession({ sessionId: e.sessionId, subjectId: e.subjectId });
+    }
   }
   if (e instanceof RefreshTokenInvalidError) {
     // unknown or malformed token
@@ -72,8 +80,11 @@ try {
   throw e;
 }
 
-// Revoke: idempotent; succeeds even if the row does not exist
+// Revoke one token: idempotent; succeeds even if the row does not exist
 await store.revoke({ refreshToken: issued.refreshToken });
+
+// Revoke all tokens for a session (requires sessionId GSI)
+await store.revokeSession({ sessionId: 'session-456', subjectId: 'user-123' });
 ```
 
 ### DynamoDB TTL
@@ -85,7 +96,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** does 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** 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`**.
 
@@ -104,6 +115,31 @@ aws dynamodb update-time-to-live \
 
 DynamoDB deletes items asynchronously, typically within 48 hours after `ttl` is in the past.
 
+### Session GSI
+
+`revokeSession` (and `revokeSessionOnReuse`) query token rows by `sessionId`. Create a GSI whose **partition key** is the attribute **`sessionId`** (String). `KEYS_ONLY` projection is enough (base-table `pk` is always projected).
+
+| Setting | Value |
+|---------|--------|
+| Index name | `sessionId-index` (override with `sessionIdIndexName`) |
+| Partition key | `sessionId` (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=sessionId,AttributeType=S \
+  --global-secondary-index-updates '[{
+    "Create": {
+      "IndexName": "sessionId-index",
+      "KeySchema": [{"AttributeName": "sessionId", "KeyType": "HASH"}],
+      "Projection": {"ProjectionType": "KEYS_ONLY"}
+    }
+  }]'
+```
+
 ## Options
 
 Constructor: `new DynamodbRefreshTokenProvider(tableName, region, options?)`.
@@ -114,14 +150,16 @@ Constructor: `new DynamodbRefreshTokenProvider(tableName, region, options?)`.
 | `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`). |
+| `revokeSessionOnReuse` | `boolean` | `false` | When true, `rotate` calls `revokeSession` for the token’s session before throwing `RefreshTokenReusedError`. |
 
-`issue`, `rotate`, and `revoke` accept an optional `now?: Date` for testing or clock injection.
+`issue`, `rotate`, `revoke`, and `revokeSession` 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`** and **TTL enabled** on attribute **`ttl`** (see [DynamoDB TTL](#dynamodb-ttl)).
-- **AWS credentials** and permissions for `PutItem`, `GetItem`, `UpdateItem`, and `TransactWriteItems` on that table (and the configured `endpoint` if used).
+- 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)).
+- **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,12 +1,19 @@
 /**
  * Public API: refresh token store types, DynamoDB-backed implementation, structured errors, and crypto helpers.
  *
- * Enable DynamoDB TTL on attribute `ttl` when using {@link DynamodbRefreshTokenProvider}.
+ * Enable DynamoDB TTL on attribute `ttl`, and a `sessionId` GSI for session revocation, when using
+ * {@link DynamodbRefreshTokenProvider}.
+ */
+export type { RefreshTokenStore, IssueParams, IssueResult, RotateParams, RotateResult, RevokeParams, RevokeSessionParams, RevokeSessionResult, StoreOptions, TokenRecord, EpochSec, } from './types/index';
+/**
+ * DynamoDB-backed {@link RefreshTokenStore} with rotation reuse detection and optional
+ * session-wide revocation (`revokeSession` / `revokeSessionOnReuse`).
  */
-export type { RefreshTokenStore, IssueParams, IssueResult, RotateParams, RotateResult, RevokeParams, StoreOptions, TokenRecord, EpochSec, } from './types/index';
-/** DynamoDB-backed {@link RefreshTokenStore} with rotation reuse detection. */
 export { DynamodbRefreshTokenProvider } from './stores/dynamodb';
-/** Structured errors for `instanceof` handling in auth flows. */
+/**
+ * Structured errors for `instanceof` handling in auth flows.
+ * {@link RefreshTokenReusedError} may carry `subjectId` / `sessionId` for session revoke.
+ */
 export { RefreshTokenError, RefreshTokenExpiredError, RefreshTokenInvalidError, RefreshTokenReusedError, RefreshTokenRevokedError, RefreshTokenRotateFailedError, } from './stores/refresh-token-errors';
 /** SHA-256 hex hashing and cryptographically secure token generation. */
 export { sha256hex, randomtoken } from './utils/hash';

package/lib/index.js

@@ -1,10 +1,16 @@
 "use strict";
 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. */
+/**
+ * DynamoDB-backed {@link RefreshTokenStore} with rotation reuse detection and optional
+ * session-wide revocation (`revokeSession` / `revokeSessionOnReuse`).
+ */
 var dynamodb_1 = require("./stores/dynamodb");
 Object.defineProperty(exports, "DynamodbRefreshTokenProvider", { enumerable: true, get: function () { return dynamodb_1.DynamodbRefreshTokenProvider; } });
-/** Structured errors for `instanceof` handling in auth flows. */
+/**
+ * Structured errors for `instanceof` handling in auth flows.
+ * {@link RefreshTokenReusedError} may carry `subjectId` / `sessionId` for session revoke.
+ */
 var refresh_token_errors_1 = require("./stores/refresh-token-errors");
 Object.defineProperty(exports, "RefreshTokenError", { enumerable: true, get: function () { return refresh_token_errors_1.RefreshTokenError; } });
 Object.defineProperty(exports, "RefreshTokenExpiredError", { enumerable: true, get: function () { return refresh_token_errors_1.RefreshTokenExpiredError; } });
@@ -16,4 +22,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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBaUJBLCtFQUErRTtBQUMvRSw4Q0FBaUU7QUFBeEQsd0hBQUEsNEJBQTRCLE9BQUE7QUFFckMsaUVBQWlFO0FBQ2pFLHNFQU91QztBQU5yQyx5SEFBQSxpQkFBaUIsT0FBQTtBQUNqQixnSUFBQSx3QkFBd0IsT0FBQTtBQUN4QixnSUFBQSx3QkFBd0IsT0FBQTtBQUN4QiwrSEFBQSx1QkFBdUIsT0FBQTtBQUN2QixnSUFBQSx3QkFBd0IsT0FBQTtBQUN4QixxSUFBQSw2QkFBNkIsT0FBQTtBQUcvQix5RUFBeUU7QUFDekUscUNBQXNEO0FBQTdDLGlHQUFBLFNBQVMsT0FBQTtBQUFFLG1HQUFBLFdBQVcsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIEFQSTogcmVmcmVzaCB0b2tlbiBzdG9yZSB0eXBlcywgRHluYW1vREItYmFja2VkIGltcGxlbWVudGF0aW9uLCBzdHJ1Y3R1cmVkIGVycm9ycywgYW5kIGNyeXB0byBoZWxwZXJzLlxuICpcbiAqIEVuYWJsZSBEeW5hbW9EQiBUVEwgb24gYXR0cmlidXRlIGB0dGxgIHdoZW4gdXNpbmcge0BsaW5rIER5bmFtb2RiUmVmcmVzaFRva2VuUHJvdmlkZXJ9LlxuICovXG5leHBvcnQgdHlwZSB7XG4gIFJlZnJlc2hUb2tlblN0b3JlLFxuICBJc3N1ZVBhcmFtcyxcbiAgSXNzdWVSZXN1bHQsXG4gIFJvdGF0ZVBhcmFtcyxcbiAgUm90YXRlUmVzdWx0LFxuICBSZXZva2VQYXJhbXMsXG4gIFN0b3JlT3B0aW9ucyxcbiAgVG9rZW5SZWNvcmQsXG4gIEVwb2NoU2VjLFxufSBmcm9tICcuL3R5cGVzL2luZGV4JztcblxuLyoqIER5bmFtb0RCLWJhY2tlZCB7QGxpbmsgUmVmcmVzaFRva2VuU3RvcmV9IHdpdGggcm90YXRpb24gcmV1c2UgZGV0ZWN0aW9uLiAqL1xuZXhwb3J0IHsgRHluYW1vZGJSZWZyZXNoVG9rZW5Qcm92aWRlciB9IGZyb20gJy4vc3RvcmVzL2R5bmFtb2RiJztcblxuLyoqIFN0cnVjdHVyZWQgZXJyb3JzIGZvciBgaW5zdGFuY2VvZmAgaGFuZGxpbmcgaW4gYXV0aCBmbG93cy4gKi9cbmV4cG9ydCB7XG4gIFJlZnJlc2hUb2tlbkVycm9yLFxuICBSZWZyZXNoVG9rZW5FeHBpcmVkRXJyb3IsXG4gIFJlZnJlc2hUb2tlbkludmFsaWRFcnJvcixcbiAgUmVmcmVzaFRva2VuUmV1c2VkRXJyb3IsXG4gIFJlZnJlc2hUb2tlblJldm9rZWRFcnJvcixcbiAgUmVmcmVzaFRva2VuUm90YXRlRmFpbGVkRXJyb3IsXG59IGZyb20gJy4vc3RvcmVzL3JlZnJlc2gtdG9rZW4tZXJyb3JzJztcblxuLyoqIFNIQS0yNTYgaGV4IGhhc2hpbmcgYW5kIGNyeXB0b2dyYXBoaWNhbGx5IHNlY3VyZSB0b2tlbiBnZW5lcmF0aW9uLiAqL1xuZXhwb3J0IHsgc2hhMjU2aGV4LCByYW5kb210b2tlbiB9IGZyb20gJy4vdXRpbHMvaGFzaCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/stores/dynamodb.d.ts

@@ -1,13 +1,14 @@
-import type { RefreshTokenStore, StoreOptions, TokenRecord, IssueParams, RotateParams, RevokeParams, IssueResult, RotateResult } from '../types/index';
+import type { RefreshTokenStore, StoreOptions, TokenRecord, IssueParams, RotateParams, RevokeParams, RevokeSessionParams, RevokeSessionResult, IssueResult, RotateResult } from '../types/index';
 /** Re-exported types for consumers that import the DynamoDB store module. */
-export { RefreshTokenStore, StoreOptions, TokenRecord, IssueParams, RotateParams, RevokeParams, IssueResult, RotateResult };
+export { RefreshTokenStore, StoreOptions, TokenRecord, IssueParams, RotateParams, RevokeParams, RevokeSessionParams, RevokeSessionResult, IssueResult, RotateResult, };
 /**
  * {@link RefreshTokenStore} implementation backed by a single DynamoDB table.
  *
  * Items use partition key `pk`, logical expiration `expiresAt`, and DynamoDB TTL attribute `ttl`
  * (Unix seconds). Enable table TTL on attribute `ttl` so expired and rotated rows are removed
- * asynchronously. This class owns the DynamoDB client; callers supply `tableName`, `region`, and
- * optional {@link StoreOptions}.
+ * asynchronously. Session-wide revocation requires a GSI whose partition key is `sessionId`
+ * (see {@link StoreOptions.sessionIdIndexName}). This class owns the DynamoDB client; callers
+ * supply `tableName`, `region`, and optional {@link StoreOptions}.
  */
 export declare class DynamodbRefreshTokenProvider implements RefreshTokenStore {
     private readonly tableName;
@@ -20,7 +21,7 @@ export declare class DynamodbRefreshTokenProvider implements RefreshTokenStore {
     /**
      * @param tableName - DynamoDB table name for refresh token items.
      * @param region - AWS region for the DynamoDB client.
-     * @param options - Token lifetime, PK prefix, consistent reads, or custom endpoint.
+     * @param options - Token lifetime, PK prefix, GSI name, reuse revocation, or custom endpoint.
      */
     constructor(tableName: string, region: string, options?: StoreOptions | undefined);
     /**
@@ -36,12 +37,17 @@ export declare class DynamodbRefreshTokenProvider implements RefreshTokenStore {
      * Updates the previous row’s `ttl` to its `expiresAt` and sets `ttl` on the new Put to the
      * successor’s expiration so DynamoDB can delete both when appropriate.
      *
+     * When reuse is detected and {@link StoreOptions.revokeSessionOnReuse} is true, all tokens for
+     * the same `sessionId` and `subjectId` are revoked via {@link DynamodbRefreshTokenProvider.revokeSession}
+     * before throwing.
+     *
      * @param params - Client refresh token and optional clock (`now`).
      * @returns Subject, session, new plaintext token, and new expiration.
      * @throws {@link RefreshTokenInvalidError} When the token format is invalid or no row exists.
      * @throws {@link RefreshTokenExpiredError} When `expiresAt` is not after `now`.
      * @throws {@link RefreshTokenRevokedError} When the token row has `revokedAt` set.
-     * @throws {@link RefreshTokenReusedError} When the token was already rotated or the transaction indicates reuse.
+     * @throws {@link RefreshTokenReusedError} When the token was already rotated or the transaction
+     *   indicates reuse. Includes `subjectId` and `sessionId` from the loaded row.
      */
     rotate: (params: RotateParams) => Promise<RotateResult>;
     /**
@@ -54,6 +60,27 @@ export declare class DynamodbRefreshTokenProvider implements RefreshTokenStore {
      * @throws {@link RefreshTokenInvalidError} When the token string format is invalid.
      */
     revoke: (params: RevokeParams) => Promise<true>;
+    /**
+     * Sets `revokedAt` on every token row for the given `sessionId` (optionally filtered by `subjectId`).
+     *
+     * Queries the session GSI (partition key `sessionId`; `KEYS_ONLY` is enough), then updates each
+     * base-table item. When `subjectId` is set, it is required in the `UpdateItem` condition.
+     * Missing or non-matching items are skipped (idempotent). Paginate with `LastEvaluatedKey`.
+     *
+     * @param params - Session id, optional subject filter, and optional clock.
+     * @returns Count of rows updated with `revokedAt` in this call.
+     */
+    revokeSession: (params: RevokeSessionParams) => Promise<RevokeSessionResult>;
+    /**
+     * Handles refresh-token reuse detection: optionally cascades {@link DynamodbRefreshTokenProvider.revokeSession}
+     * when {@link StoreOptions.revokeSessionOnReuse} is true, then throws {@link RefreshTokenReusedError}
+     * populated with `subjectId` / `sessionId` from `current`.
+     *
+     * @param current - Token row that indicated reuse (`rotatedAt` set or transaction canceled).
+     * @param now - Clock used for `revokedAt` when cascading revoke is enabled.
+     * @throws {@link RefreshTokenReusedError} Always (return type is `never`).
+     */
+    private handleRefreshTokenReuse;
     /**
      * Returns the cached {@link DynamoDBDocumentClient}, creating it on first use.
      *

package/lib/stores/dynamodb.js

@@ -8,19 +8,22 @@ const hash_1 = require("../utils/hash");
 const time_1 = require("../utils/time");
 /** Default partition key prefix for refresh token items. */
 const DEFAULT_PRIMARY_KEY_PREFIX = 'rt#';
+/** Default GSI name for querying token rows by `sessionId`. */
+const DEFAULT_SESSION_ID_INDEX_NAME = 'sessionId-index';
 /**
  * {@link RefreshTokenStore} implementation backed by a single DynamoDB table.
  *
  * Items use partition key `pk`, logical expiration `expiresAt`, and DynamoDB TTL attribute `ttl`
  * (Unix seconds). Enable table TTL on attribute `ttl` so expired and rotated rows are removed
- * asynchronously. This class owns the DynamoDB client; callers supply `tableName`, `region`, and
- * optional {@link StoreOptions}.
+ * asynchronously. Session-wide revocation requires a GSI whose partition key is `sessionId`
+ * (see {@link StoreOptions.sessionIdIndexName}). This class owns the DynamoDB client; callers
+ * supply `tableName`, `region`, and optional {@link StoreOptions}.
  */
 class DynamodbRefreshTokenProvider {
     /**
      * @param tableName - DynamoDB table name for refresh token items.
      * @param region - AWS region for the DynamoDB client.
-     * @param options - Token lifetime, PK prefix, consistent reads, or custom endpoint.
+     * @param options - Token lifetime, PK prefix, GSI name, reuse revocation, or custom endpoint.
      */
     constructor(tableName, region, options) {
         this.tableName = tableName;
@@ -67,12 +70,17 @@ class DynamodbRefreshTokenProvider {
          * Updates the previous row’s `ttl` to its `expiresAt` and sets `ttl` on the new Put to the
          * successor’s expiration so DynamoDB can delete both when appropriate.
          *
+         * When reuse is detected and {@link StoreOptions.revokeSessionOnReuse} is true, all tokens for
+         * the same `sessionId` and `subjectId` are revoked via {@link DynamodbRefreshTokenProvider.revokeSession}
+         * before throwing.
+         *
          * @param params - Client refresh token and optional clock (`now`).
          * @returns Subject, session, new plaintext token, and new expiration.
          * @throws {@link RefreshTokenInvalidError} When the token format is invalid or no row exists.
          * @throws {@link RefreshTokenExpiredError} When `expiresAt` is not after `now`.
          * @throws {@link RefreshTokenRevokedError} When the token row has `revokedAt` set.
-         * @throws {@link RefreshTokenReusedError} When the token was already rotated or the transaction indicates reuse.
+         * @throws {@link RefreshTokenReusedError} When the token was already rotated or the transaction
+         *   indicates reuse. Includes `subjectId` and `sessionId` from the loaded row.
          */
         this.rotate = async (params) => {
             // validate refresh token
@@ -93,7 +101,7 @@ class DynamodbRefreshTokenProvider {
                 throw new refresh_token_errors_1.RefreshTokenRevokedError();
             }
             if (current.rotatedAt) {
-                throw new refresh_token_errors_1.RefreshTokenReusedError();
+                await this.handleRefreshTokenReuse(current, now);
             }
             const nextRefreshTokenExpiresAt = this.makeExpiresAt(nowSec);
             const nextRefreshToken = (0, hash_1.randomtoken)(this.tokenBytes);
@@ -138,7 +146,7 @@ class DynamodbRefreshTokenProvider {
             catch (error) {
                 if (error instanceof Error && error.name === 'TransactionCanceledException') {
                     // Treat conditional transaction failure as token reuse.
-                    throw new refresh_token_errors_1.RefreshTokenReusedError();
+                    await this.handleRefreshTokenReuse(current, now);
                 }
                 throw error;
             }
@@ -186,6 +194,93 @@ class DynamodbRefreshTokenProvider {
             }
             return true;
         };
+        /**
+         * Sets `revokedAt` on every token row for the given `sessionId` (optionally filtered by `subjectId`).
+         *
+         * Queries the session GSI (partition key `sessionId`; `KEYS_ONLY` is enough), then updates each
+         * base-table item. When `subjectId` is set, it is required in the `UpdateItem` condition.
+         * Missing or non-matching items are skipped (idempotent). Paginate with `LastEvaluatedKey`.
+         *
+         * @param params - Session id, optional subject filter, and optional clock.
+         * @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;
+            let revokedCount = 0;
+            let exclusiveStartKey;
+            /** Whether another Query page is available after the previous response. */
+            const shouldContinuePaging = () => exclusiveStartKey !== undefined;
+            do {
+                const res = await ddb.send(new lib_dynamodb_1.QueryCommand({
+                    TableName: this.tableName,
+                    IndexName: indexName,
+                    KeyConditionExpression: 'sessionId = :sessionId',
+                    ExpressionAttributeValues: {
+                        ':sessionId': params.sessionId,
+                    },
+                    ProjectionExpression: 'pk',
+                    ExclusiveStartKey: exclusiveStartKey,
+                }));
+                const items = res.Items ?? [];
+                for (const item of items) {
+                    const pk = item.pk;
+                    if (typeof pk !== 'string') {
+                        continue;
+                    }
+                    const expressionAttributeValues = {
+                        ':now': nowSec,
+                    };
+                    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,
+                            ExpressionAttributeValues: expressionAttributeValues,
+                        }));
+                        revokedCount += 1;
+                    }
+                    catch (error) {
+                        if (error instanceof Error && error.name === 'ConditionalCheckFailedException') {
+                            continue;
+                        }
+                        throw error;
+                    }
+                }
+                exclusiveStartKey = res.LastEvaluatedKey;
+            } while (shouldContinuePaging());
+            return { revokedCount };
+        };
+        /**
+         * Handles refresh-token reuse detection: optionally cascades {@link DynamodbRefreshTokenProvider.revokeSession}
+         * when {@link StoreOptions.revokeSessionOnReuse} is true, then throws {@link RefreshTokenReusedError}
+         * populated with `subjectId` / `sessionId` from `current`.
+         *
+         * @param current - Token row that indicated reuse (`rotatedAt` set or transaction canceled).
+         * @param now - Clock used for `revokedAt` when cascading revoke is enabled.
+         * @throws {@link RefreshTokenReusedError} Always (return type is `never`).
+         */
+        this.handleRefreshTokenReuse = async (current, now) => {
+            if (this.options?.revokeSessionOnReuse) {
+                await this.revokeSession({
+                    sessionId: current.sessionId,
+                    subjectId: current.subjectId,
+                    now,
+                });
+            }
+            throw new refresh_token_errors_1.RefreshTokenReusedError(undefined, {
+                subjectId: current.subjectId,
+                sessionId: current.sessionId,
+            });
+        };
         /**
          * Returns the cached {@link DynamoDBDocumentClient}, creating it on first use.
          *
@@ -261,4 +356,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, UpdateCommand, TransactWriteCommand } from '@aws-sdk/lib-dynamodb';\n\nimport {\n  RefreshTokenExpiredError,\n  RefreshTokenInvalidError,\n  RefreshTokenReusedError,\n  RefreshTokenRevokedError,\n} from './refresh-token-errors';\nimport type { RefreshTokenStore, StoreOptions, TokenRecord, IssueParams, RotateParams, RevokeParams, IssueResult, RotateResult } 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 { RefreshTokenStore, StoreOptions, TokenRecord, IssueParams, RotateParams, RevokeParams, IssueResult, RotateResult };\n\n/** Default partition key prefix for refresh token items. */\nconst DEFAULT_PRIMARY_KEY_PREFIX = 'rt#';\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. This class owns the DynamoDB client; callers supply `tableName`, `region`, and\n * 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, consistent reads, 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   * @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 indicates reuse.\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      throw new RefreshTokenReusedError();\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        throw new RefreshTokenReusedError();\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   * 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":"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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"]}

package/lib/stores/refresh-token-errors.d.ts

@@ -36,13 +36,34 @@ export declare class RefreshTokenRevokedError extends RefreshTokenError {
     constructor(message?: string);
 }
 /**
- * Thrown when a refresh token is presented after it has already been rotated (reuse detection).
+ * Optional identifiers attached when refresh token reuse is detected, so callers can
+ * revoke the whole session (e.g. via {@link RefreshTokenStore.revokeSession}).
+ */
+export type RefreshTokenReusedErrorContext = {
+    /** Subject identifier from the reused token row, when known. */
+    subjectId?: string;
+    /** Session identifier from the reused token row, when known. */
+    sessionId?: string;
+};
+/**
+ * Thrown when a refresh token is presented after it has already been rotated (reuse detection),
+ * or when a rotate transaction is canceled under reuse-safe conditions.
+ *
+ * When `subjectId` / `sessionId` are present, callers can revoke the whole session
+ * (e.g. via {@link RefreshTokenStore.revokeSession}) per OAuth 2.0 BCP family revocation.
+ * If the store was constructed with `revokeSessionOnReuse: true`, the session may already
+ * have been revoked before this error is thrown.
  */
 export declare class RefreshTokenReusedError extends RefreshTokenError {
+    /** Subject identifier from the reused token row, when known. */
+    readonly subjectId?: string;
+    /** Session identifier from the reused token row, when known. */
+    readonly sessionId?: string;
     /**
      * @param message - Human-readable error description.
+     * @param context - Subject/session from the store row to support session-wide revocation.
      */
-    constructor(message?: string);
+    constructor(message?: string, context?: RefreshTokenReusedErrorContext);
 }
 /**
  * Thrown when rotation fails for a reason other than reuse (e.g. transient store failure).

package/lib/stores/refresh-token-errors.js

@@ -52,14 +52,23 @@ class RefreshTokenRevokedError extends RefreshTokenError {
 }
 exports.RefreshTokenRevokedError = RefreshTokenRevokedError;
 /**
- * Thrown when a refresh token is presented after it has already been rotated (reuse detection).
+ * Thrown when a refresh token is presented after it has already been rotated (reuse detection),
+ * or when a rotate transaction is canceled under reuse-safe conditions.
+ *
+ * When `subjectId` / `sessionId` are present, callers can revoke the whole session
+ * (e.g. via {@link RefreshTokenStore.revokeSession}) per OAuth 2.0 BCP family revocation.
+ * If the store was constructed with `revokeSessionOnReuse: true`, the session may already
+ * have been revoked before this error is thrown.
  */
 class RefreshTokenReusedError extends RefreshTokenError {
     /**
      * @param message - Human-readable error description.
+     * @param context - Subject/session from the store row to support session-wide revocation.
      */
-    constructor(message = 'This refresh token has already been rotated and cannot be used again.') {
+    constructor(message = 'This refresh token has already been rotated and cannot be used again.', context) {
         super(message);
+        this.subjectId = context?.subjectId;
+        this.sessionId = context?.sessionId;
     }
 }
 exports.RefreshTokenReusedError = RefreshTokenReusedError;
@@ -75,4 +84,4 @@ class RefreshTokenRotateFailedError extends RefreshTokenError {
     }
 }
 exports.RefreshTokenRotateFailedError = RefreshTokenRotateFailedError;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/index.d.ts

@@ -4,7 +4,9 @@ export type EpochSec = number;
  * 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.
+ * DynamoDB TTL attribute (`ttl`) written on Put / Transact. Session revocation options
+ * (`sessionIdIndexName`, `revokeSessionOnReuse`) require a GSI whose partition key is
+ * `sessionId`.
  */
 export type StoreOptions = {
     /**
@@ -26,6 +28,20 @@ export type StoreOptions = {
      * Custom DynamoDB API endpoint (e.g. LocalStack or DynamoDB Local).
      */
     endpoint?: string;
+    /**
+     * DynamoDB GSI name whose partition key attribute is `sessionId` (String).
+     * Required for {@link RefreshTokenStore.revokeSession} and for `revokeSessionOnReuse`.
+     * `KEYS_ONLY` projection is sufficient.
+     * @defaultValue `'sessionId-index'`
+     */
+    sessionIdIndexName?: string;
+    /**
+     * When true, {@link RefreshTokenStore.rotate} calls {@link RefreshTokenStore.revokeSession}
+     * for the token’s `sessionId` and `subjectId` before throwing {@link RefreshTokenReusedError}.
+     * Aligns with OAuth 2.0 BCP refresh-token family revocation on reuse detection.
+     * @defaultValue false
+     */
+    revokeSessionOnReuse?: boolean;
 };
 /** Parameters for {@link RefreshTokenStore.issue}. */
 export type IssueParams = {
@@ -68,6 +84,24 @@ export type RevokeParams = {
     /** Clock override for tests; defaults to `new Date()`. */
     now?: Date;
 };
+/** Parameters for {@link RefreshTokenStore.revokeSession}. */
+export type RevokeSessionParams = {
+    /** Session whose refresh token rows should all be revoked. */
+    sessionId: string;
+    /**
+     * When set, only rows matching this subject are revoked.
+     * Applied as an `UpdateItem` condition on the base table (not a GSI filter), so a
+     * `KEYS_ONLY` session GSI is sufficient.
+     */
+    subjectId?: string;
+    /** Clock override for tests; defaults to `new Date()`. */
+    now?: Date;
+};
+/** Result of {@link RefreshTokenStore.revokeSession}. */
+export type RevokeSessionResult = {
+    /** 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`).
  *
@@ -77,9 +111,12 @@ export type RevokeParams = {
 export type TokenRecord = {
     /** Partition key: prefix + SHA-256 hex of the plaintext token. */
     pk: string;
-    /** Subject (user) identifier. */
+    /** Subject (user) identifier; also used when cascading session revoke on reuse. */
     subjectId: string;
-    /** Session identifier. */
+    /**
+     * Session identifier. Partition key of the session GSI used by
+     * {@link RefreshTokenStore.revokeSession}.
+     */
     sessionId: string;
     /** Row creation time as Unix seconds. */
     createdAt: EpochSec;
@@ -97,7 +134,7 @@ export type TokenRecord = {
     revokedAt?: EpochSec | null;
 };
 /**
- * Persistence abstraction for opaque refresh tokens: issue, rotate, and revoke.
+ * Persistence abstraction for opaque refresh tokens: issue, rotate, revoke, and session revoke.
  */
 export interface RefreshTokenStore {
     /**
@@ -110,20 +147,36 @@ export interface RefreshTokenStore {
     /**
      * Validates the current token, marks it rotated, inserts the successor row, and returns the new token.
      *
+     * When reuse is detected and {@link StoreOptions.revokeSessionOnReuse} is enabled, the
+     * implementation may revoke the whole session before throwing.
+     *
      * @param params - Current token and optional clock.
      * @returns Subject, session, new token, and new expiration.
      * @throws {@link RefreshTokenInvalidError} When the token is invalid or no row exists.
      * @throws {@link RefreshTokenExpiredError} When `expiresAt` is not after `now`.
      * @throws {@link RefreshTokenRevokedError} When the row has `revokedAt` set.
-     * @throws {@link RefreshTokenReusedError} When the token was already rotated or the transaction failed conditionally.
+     * @throws {@link RefreshTokenReusedError} When the token was already rotated or the transaction
+     *   failed conditionally. May include `subjectId` / `sessionId` from the store row.
      */
     rotate(params: RotateParams): Promise<RotateResult>;
     /**
      * Sets `revokedAt` on the token row. Idempotent if the row does not exist.
      *
+     * Does not change DynamoDB TTL (`ttl`); cleanup still follows the value from issue/rotate.
+     *
      * @param params - Token to revoke and optional clock.
      * @returns `true` after a successful update or no-op when the item is absent.
      * @throws {@link RefreshTokenInvalidError} When the token string format is invalid.
      */
     revoke(params: RevokeParams): Promise<true>;
+    /**
+     * Sets `revokedAt` on every refresh token row for the given session (OAuth 2.0 BCP family revocation).
+     *
+     * Requires a DynamoDB GSI whose partition key is `sessionId` (see {@link StoreOptions.sessionIdIndexName}).
+     * Optional `subjectId` is enforced on each base-table update condition.
+     *
+     * @param params - Session id, optional subject filter, and optional clock.
+     * @returns Count of rows updated with `revokedAt`.
+     */
+    revokeSession(params: RevokeSessionParams): Promise<RevokeSessionResult>;
 }

package/lib/types/index.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# 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"]}

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), and **revoke** (idempotent) 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), and **revokeSession** (OAuth 2.0 BCP family revocation) are supported.",
   "repository": {
     "type": "git",
     "url": "https://github.com/gammarers-aws-sdk-modules/dynamodb-refresh-token-provider.git"
@@ -46,7 +46,7 @@
     "projen": "^0.101.11",
     "ts-jest": "^29.4.11",
     "ts-node": "^10.9.2",
-    "typescript": "5.9.x"
+    "typescript": "6.0.x"
   },
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.777.0",
@@ -57,8 +57,7 @@
   },
   "devEngines": {
     "packageManager": {
-      "name": "yarn",
-      "version": "1.22.22",
+      "name": "npm",
       "onFail": "ignore"
     }
   },
@@ -67,7 +66,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.6",
+  "version": "0.4.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [
@@ -114,6 +113,5 @@
     }
   },
   "types": "lib/index.d.ts",
-  "packageManager": "yarn@1.22.22",
   "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
 }