@farukada/aws-langgraph-dynamodb-ts 1.0.0-rc.1 → 1.0.0

package/dist/shared/dynamodb/abort.d.ts

@@ -1,9 +0,0 @@
-import { AbortError } from '../errors/errors';
-/**
- * The library's error for an aborted `signal`. A caller's own `AbortError`
- * used as the abort reason is returned unchanged; anything else — the
- * `DOMException` a bare `controller.abort()` produces, a string, a custom
- * error — becomes the `cause` of a fresh {@link AbortError}, so
- * `code === 'ABORTED'` holds however the signal was aborted.
- */
-export declare function abortErrorFrom(signal: AbortSignal): AbortError;

package/dist/shared/dynamodb/abort.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.abortErrorFrom = abortErrorFrom;
-const base_error_1 = require("../errors/base-error");
-const error_code_1 = require("../errors/error-code");
-const errors_1 = require("../errors/errors");
-const wrap_error_1 = require("../errors/wrap-error");
-/** True when the abort reason already is this library's `AbortError` (a string or DOMException is not). */
-function isLibraryAbort(reason) {
-    return (typeof reason === 'object' &&
-        reason !== null &&
-        (0, base_error_1.isDynamoDBLangGraphError)(reason) &&
-        reason.code === error_code_1.ErrorCode.ABORTED);
-}
-/**
- * The library's error for an aborted `signal`. A caller's own `AbortError`
- * used as the abort reason is returned unchanged; anything else — the
- * `DOMException` a bare `controller.abort()` produces, a string, a custom
- * error — becomes the `cause` of a fresh {@link AbortError}, so
- * `code === 'ABORTED'` holds however the signal was aborted.
- */
-function abortErrorFrom(signal) {
-    const reason = signal.reason;
-    if (isLibraryAbort(reason))
-        return reason;
-    return new errors_1.AbortError('Operation aborted', reason === undefined ? undefined : (0, wrap_error_1.toError)(reason));
-}

package/dist/shared/dynamodb/backoff.d.ts

@@ -1,15 +0,0 @@
-/**
- * Sleep for `ms` milliseconds, cancellable via `signal`. An already-aborted
- * signal rejects at once and an abort while pending rejects the moment it fires; both
- * reject with the library's `AbortError` (see `abortErrorFrom`), so a caller
- * branching on `code === 'ABORTED'` sees it however the signal was aborted.
- */
-export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
-/** Next exponential-backoff delay: double `currentMs`, capped at `maxMs`. */
-export declare function nextBackoffDelay(currentMs: number, maxMs?: number): number;
-/**
- * Apply AWS-recommended full jitter: a uniform random value in `[0, delayMs)`.
- *
- * @param rng - RNG seam returning `[0, 1)`. Defaults to `Math.random`.
- */
-export declare function fullJitter(delayMs: number, rng?: () => number): number;

package/dist/shared/dynamodb/backoff.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleep = sleep;
-exports.nextBackoffDelay = nextBackoffDelay;
-exports.fullJitter = fullJitter;
-const constants_1 = require("../constants");
-const abort_1 = require("./abort");
-/**
- * Sleep for `ms` milliseconds, cancellable via `signal`. An already-aborted
- * signal rejects at once and an abort while pending rejects the moment it fires; both
- * reject with the library's `AbortError` (see `abortErrorFrom`), so a caller
- * branching on `code === 'ABORTED'` sees it however the signal was aborted.
- */
-function sleep(ms, signal) {
-    if (signal?.aborted) {
-        return Promise.reject((0, abort_1.abortErrorFrom)(signal));
-    }
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const onAbort = () => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            reject((0, abort_1.abortErrorFrom)(signal));
-        };
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            signal?.removeEventListener('abort', onAbort);
-            resolve();
-        }, ms);
-        signal?.addEventListener('abort', onAbort, { once: true });
-    });
-}
-/** Next exponential-backoff delay: double `currentMs`, capped at `maxMs`. */
-function nextBackoffDelay(currentMs, maxMs = constants_1.MAX_BACKOFF_DELAY_MS) {
-    return Math.min(currentMs * 2, maxMs);
-}
-/**
- * Apply AWS-recommended full jitter: a uniform random value in `[0, delayMs)`.
- *
- * @param rng - RNG seam returning `[0, 1)`. Defaults to `Math.random`.
- */
-function fullJitter(delayMs, rng = Math.random) {
-    return rng() * delayMs;
-}

package/dist/shared/dynamodb/batch-write.d.ts

@@ -1,22 +0,0 @@
-import type { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
-import { DrainOptions } from './drain-unprocessed';
-import type { WriteRequest } from './types';
-/**
- * Write an arbitrary number of requests, chunked into batches of 25 (the
- * BatchWriteItem limit). Every chunk is attempted regardless of an earlier
- * chunk's failure — order-independent writes (deletes/puts) should never
- * lose "later" chunks just because an earlier one failed. If any chunk fails,
- * throws {@link BatchWriteAllIncompleteError} reporting exactly how many
- * chunks succeeded vs. failed, and exactly how many individual writes
- * persisted, once every chunk has been attempted.
- *
- * This is this function's ONLY throw site. Two callers —
- * checkpointer/internal/special-write-cleanup.ts and
- * history/internal/append-saga.ts — type-assert a caught error straight to
- * {@link BatchWriteAllIncompleteError} on that guarantee (not `instanceof`,
- * banned repo-wide) instead of narrowing it, since this project enforces
- * 100% branch coverage and a defensive else-branch here would be
- * unreachable, hence untestable. Adding another throw path to this function
- * requires updating both call sites.
- */
-export declare function batchWriteAll(client: DynamoDBDocument, tableName: string, requests: WriteRequest[], options?: DrainOptions): Promise<void>;

package/dist/shared/dynamodb/batch-write.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.batchWriteAll = batchWriteAll;
-const constants_1 = require("../constants");
-const errors_1 = require("../errors/errors");
-const drain_unprocessed_1 = require("./drain-unprocessed");
-/**
- * Write an arbitrary number of requests, chunked into batches of 25 (the
- * BatchWriteItem limit). Every chunk is attempted regardless of an earlier
- * chunk's failure — order-independent writes (deletes/puts) should never
- * lose "later" chunks just because an earlier one failed. If any chunk fails,
- * throws {@link BatchWriteAllIncompleteError} reporting exactly how many
- * chunks succeeded vs. failed, and exactly how many individual writes
- * persisted, once every chunk has been attempted.
- *
- * This is this function's ONLY throw site. Two callers —
- * checkpointer/internal/special-write-cleanup.ts and
- * history/internal/append-saga.ts — type-assert a caught error straight to
- * {@link BatchWriteAllIncompleteError} on that guarantee (not `instanceof`,
- * banned repo-wide) instead of narrowing it, since this project enforces
- * 100% branch coverage and a defensive else-branch here would be
- * unreachable, hence untestable. Adding another throw path to this function
- * requires updating both call sites.
- */
-async function batchWriteAll(client, tableName, requests, options = {}) {
-    const totalChunks = Math.ceil(requests.length / constants_1.BATCH_WRITE_MAX);
-    let succeededChunks = 0;
-    let succeededCount = 0;
-    const failedChunks = [];
-    for (let offset = 0; offset < requests.length; offset += constants_1.BATCH_WRITE_MAX) {
-        const chunk = requests.slice(offset, offset + constants_1.BATCH_WRITE_MAX);
-        try {
-            await (0, drain_unprocessed_1.drainUnprocessedWrites)(client, tableName, chunk, options);
-            succeededChunks += 1;
-            succeededCount += chunk.length;
-        }
-        catch (error) {
-            /**
-             * drainUnprocessedWrites has exactly three throw sites and every one
-             * constructs a BatchWriteIncompleteError with an accurate
-             * succeededCount — asserted, not name-checked, since the false case is
-             * unreachable and this project enforces 100% branch coverage with no
-             * exceptions (see drain-unprocessed.ts).
-             */
-            const err = error;
-            failedChunks.push(err);
-            succeededCount += err.succeededCount;
-        }
-    }
-    if (failedChunks.length > 0) {
-        throw new errors_1.BatchWriteAllIncompleteError(succeededChunks, totalChunks, failedChunks, succeededCount);
-    }
-}

package/dist/shared/dynamodb/cancellation.d.ts

@@ -1,6 +0,0 @@
-/** One entry of a TransactWriteItems/TransactionCanceledException's CancellationReasons. */
-export interface CancellationReason {
-    Code?: string;
-}
-/** Extract `CancellationReasons` from a transaction-cancellation error, if present. */
-export declare function getCancellationReasons(error: Error): CancellationReason[] | undefined;

package/dist/shared/dynamodb/cancellation.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCancellationReasons = getCancellationReasons;
-/** Extract `CancellationReasons` from a transaction-cancellation error, if present. */
-function getCancellationReasons(error) {
-    return error.CancellationReasons;
-}

package/dist/shared/dynamodb/client.d.ts

@@ -1,28 +0,0 @@
-import { DynamoDBClient, type DynamoDBClientConfig } from '@aws-sdk/client-dynamodb';
-import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
-import type { Logger } from '../logging/logger';
-/** A resolved DynamoDB client plus its ownership flag. */
-export interface ResolvedDynamoDBClient {
-    ddbClient: DynamoDBClient | undefined;
-    client: DynamoDBDocument;
-    ownsClient: boolean;
-}
-/** Options for {@link resolveDynamoDBClient}. */
-export interface ResolveClientOptions {
-    client?: DynamoDBDocument;
-    clientConfig?: DynamoDBClientConfig;
-}
-/**
- * Resolve the DocumentClient for an adapter. An injected `client` is used as-is
- * and not owned; otherwise a client is built from `clientConfig` (via the
- * `createClient` seam) and owned, so the adapter destroys it on `destroy()`.
- */
-export declare function resolveDynamoDBClient(options: ResolveClientOptions): ResolvedDynamoDBClient;
-/**
- * Warn once when an injected client keeps the SDK's own retries. They run
- * inside every attempt of this library's retry layer, so the budget the
- * constants and README describe multiplies (5 × 3 requests per operation with
- * the SDK default) and a throttling event turns into a retry storm. A client
- * that cannot report its setting is left alone; the check never throws.
- */
-export declare function warnOnStackedRetries(client: DynamoDBDocument, logger: Logger): Promise<void>;

package/dist/shared/dynamodb/conditional-put.d.ts

@@ -1,67 +0,0 @@
-import type { DocItem } from './types';
-/**
- * Attribute holding a row's revision token on adapters that need one. The
- * checkpointer's special writes reuse their existing per-call `writeGroup`
- * instead, so `revisionGuard` takes the attribute name rather than assuming it.
- */
-export declare const REVISION_ATTRIBUTE = "rev";
-/**
- * Compare-and-swap attempts before a caller gives up and overwrites
- * unconditionally. Kept small on purpose: DynamoDB charges write capacity for a
- * *failed* conditional write too, sized on the existing item, so an aggressive
- * loop turns contention into cost. Three attempts settle every realistic race,
- * and the fallback is exactly the pre-0.9.0 behaviour rather than an error.
- */
-export declare const OVERWRITE_CAS_MAX_ATTEMPTS = 3;
-/** What a caller saw at the row before it tried to overwrite it. */
-export interface ObservedRow {
-    exists: boolean;
-    revision?: string;
-}
-/**
- * Condition fragments to spread into a `PutCommand` input. Every guard asks
- * DynamoDB to attach the existing row to a rejection, so a compare-and-swap
- * that loses can re-pin from the exception (see {@link rejectedItem}) instead
- * of spending a second strongly-consistent read.
- */
-export interface RevisionGuard {
-    ConditionExpression: string;
-    ExpressionAttributeNames?: Record<string, string>;
-    ExpressionAttributeValues?: Record<string, string>;
-    ReturnValuesOnConditionCheckFailure: 'ALL_OLD';
-}
-/**
- * Build the condition admitting a write only while the row still holds the
- * revision this caller observed.
- *
- * Without it, two concurrent overwrites both read the same previous payload
- * descriptor, both commit their own nonced upload, and both delete that same
- * previous object — leaving the loser's upload orphaned with nothing left
- * recording that it ever existed. A post-commit read-back cannot repair that,
- * because neither writer can learn of an object it never saw; only refusing the
- * second write until it re-reads can.
- *
- * A row with no revision attribute was written before 0.9.0. Pinning its
- * *absence* is what makes the swap correct across an upgrade: the first writer
- * to touch such a row stamps one, and any racer still holding the pre-upgrade
- * observation is turned away.
- */
-export declare function revisionGuard(attribute: string, observed: ObservedRow): RevisionGuard;
-/**
- * True when the guard rejected a write — NOT evidence a competitor won: a
- * `PutCommand` retried after its response was lost can re-hit its own
- * committed row and fail identically; the two cases are indistinguishable.
- */
-export declare function isConditionalCheckFailed(error: {
-    name?: string;
-}): boolean;
-/**
- * The row that turned a conditional write away, when DynamoDB attached it
- * (`ReturnValuesOnConditionCheckFailure: 'ALL_OLD'`). Verified against real
- * DynamoDB: the document client does not unmarshall an *error* payload the way
- * it unmarshalls a response, so the item arrives in raw AttributeValue form and
- * is unmarshalled here. Undefined when the rejection carries no item — the row
- * was deleted between the observation and the write — in which case the caller
- * falls back to a read.
- */
-export declare function rejectedItem(error: Error): DocItem | undefined;

package/dist/shared/dynamodb/conditional-put.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OVERWRITE_CAS_MAX_ATTEMPTS = exports.REVISION_ATTRIBUTE = void 0;
-exports.revisionGuard = revisionGuard;
-exports.isConditionalCheckFailed = isConditionalCheckFailed;
-exports.rejectedItem = rejectedItem;
-const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
-/**
- * Attribute holding a row's revision token on adapters that need one. The
- * checkpointer's special writes reuse their existing per-call `writeGroup`
- * instead, so `revisionGuard` takes the attribute name rather than assuming it.
- */
-exports.REVISION_ATTRIBUTE = 'rev';
-/**
- * Compare-and-swap attempts before a caller gives up and overwrites
- * unconditionally. Kept small on purpose: DynamoDB charges write capacity for a
- * *failed* conditional write too, sized on the existing item, so an aggressive
- * loop turns contention into cost. Three attempts settle every realistic race,
- * and the fallback is exactly the pre-0.9.0 behaviour rather than an error.
- */
-exports.OVERWRITE_CAS_MAX_ATTEMPTS = 3;
-const RETURN_REJECTED_ROW = { ReturnValuesOnConditionCheckFailure: 'ALL_OLD' };
-/**
- * Build the condition admitting a write only while the row still holds the
- * revision this caller observed.
- *
- * Without it, two concurrent overwrites both read the same previous payload
- * descriptor, both commit their own nonced upload, and both delete that same
- * previous object — leaving the loser's upload orphaned with nothing left
- * recording that it ever existed. A post-commit read-back cannot repair that,
- * because neither writer can learn of an object it never saw; only refusing the
- * second write until it re-reads can.
- *
- * A row with no revision attribute was written before 0.9.0. Pinning its
- * *absence* is what makes the swap correct across an upgrade: the first writer
- * to touch such a row stamps one, and any racer still holding the pre-upgrade
- * observation is turned away.
- */
-function revisionGuard(attribute, observed) {
-    if (!observed.exists)
-        return { ...RETURN_REJECTED_ROW, ConditionExpression: 'attribute_not_exists(PK)' };
-    if (observed.revision === undefined) {
-        return {
-            ...RETURN_REJECTED_ROW,
-            ConditionExpression: 'attribute_not_exists(#rev)',
-            ExpressionAttributeNames: { '#rev': attribute },
-        };
-    }
-    return {
-        ...RETURN_REJECTED_ROW,
-        ConditionExpression: '#rev = :rev',
-        ExpressionAttributeNames: { '#rev': attribute },
-        ExpressionAttributeValues: { ':rev': observed.revision },
-    };
-}
-/**
- * True when the guard rejected a write — NOT evidence a competitor won: a
- * `PutCommand` retried after its response was lost can re-hit its own
- * committed row and fail identically; the two cases are indistinguishable.
- */
-function isConditionalCheckFailed(error) {
-    return error.name === 'ConditionalCheckFailedException';
-}
-/**
- * The row that turned a conditional write away, when DynamoDB attached it
- * (`ReturnValuesOnConditionCheckFailure: 'ALL_OLD'`). Verified against real
- * DynamoDB: the document client does not unmarshall an *error* payload the way
- * it unmarshalls a response, so the item arrives in raw AttributeValue form and
- * is unmarshalled here. Undefined when the rejection carries no item — the row
- * was deleted between the observation and the write — in which case the caller
- * falls back to a read.
- */
-function rejectedItem(error) {
-    const raw = error.Item;
-    return raw === undefined ? undefined : (0, util_dynamodb_1.unmarshall)(raw);
-}

package/dist/shared/dynamodb/drain-unprocessed.d.ts

@@ -1,21 +0,0 @@
-import type { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
-import { type RetryOptions } from './retry';
-import type { WriteRequest } from './types';
-/** Backoff/abort options shared by the drain helpers. */
-export interface DrainOptions {
-    /** The adapter's retry options, applied to every BatchWriteItem round. */
-    retry?: RetryOptions;
-    signal?: AbortSignal;
-    rng?: () => number;
-    maxRetries?: number;
-}
-/**
- * Submit `requests` via BatchWriteItem and re-submit UnprocessedItems with
- * full-jitter backoff until the batch drains. Throws
- * {@link BatchWriteIncompleteError} if it cannot drain within the retry budget,
- * or if a round's write call or backoff wait throws outright (SDK failure, or
- * the caller's signal aborting) — in every case `succeededCount` reflects
- * every earlier round's confirmed persists, and the triggering error is
- * attached as `cause`.
- */
-export declare function drainUnprocessedWrites(client: DynamoDBDocument, tableName: string, requests: WriteRequest[], options?: DrainOptions): Promise<void>;

package/dist/shared/dynamodb/drain-unprocessed.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.drainUnprocessedWrites = drainUnprocessedWrites;
-const constants_1 = require("../constants");
-const errors_1 = require("../errors/errors");
-const backoff_1 = require("./backoff");
-const retry_1 = require("./retry");
-/**
- * Submit `requests` via BatchWriteItem and re-submit UnprocessedItems with
- * full-jitter backoff until the batch drains. Throws
- * {@link BatchWriteIncompleteError} if it cannot drain within the retry budget,
- * or if a round's write call or backoff wait throws outright (SDK failure, or
- * the caller's signal aborting) — in every case `succeededCount` reflects
- * every earlier round's confirmed persists, and the triggering error is
- * attached as `cause`.
- */
-async function drainUnprocessedWrites(client, tableName, requests, options = {}) {
-    if (requests.length === 0)
-        return;
-    const maxRetries = options.maxRetries ?? constants_1.MAX_UNPROCESSED_RETRIES;
-    const initialCount = requests.length;
-    let pending = requests;
-    let delay = constants_1.INITIAL_BACKOFF_DELAY_MS;
-    let retries = 0;
-    while (pending.length > 0) {
-        try {
-            const result = await (0, retry_1.withDynamoDBRetry)(() => client.batchWrite({ RequestItems: { [tableName]: pending } }), { ...options.retry, signal: options.signal });
-            const leftover = result.UnprocessedItems?.[tableName] ?? [];
-            if (leftover.length === 0)
-                return;
-            pending = leftover;
-            retries += 1;
-            if (retries > maxRetries)
-                break;
-            await (0, backoff_1.sleep)((0, backoff_1.fullJitter)(delay, options.rng), options.signal);
-            delay = (0, backoff_1.nextBackoffDelay)(delay);
-        }
-        catch (error) {
-            throw new errors_1.BatchWriteIncompleteError(initialCount - pending.length, pending, retries, error);
-        }
-    }
-    throw new errors_1.BatchWriteIncompleteError(initialCount - pending.length, pending, maxRetries);
-}

package/dist/shared/dynamodb/expiry.d.ts

@@ -1,16 +0,0 @@
-import type { QueryCommandInput, ScanCommandInput } from '@aws-sdk/lib-dynamodb';
-/**
- * True when a row carrying a DynamoDB TTL is at or past it. DynamoDB's sweep
- * can lag up to ~48 h, so every read path applies this itself; the value is
- * epoch seconds, the unit the `ttl` attribute uses.
- */
-export declare function isExpiredRow(row: {
-    ttl?: number;
-}, nowSeconds: number): boolean;
-/**
- * Exclude expired rows server-side, ANDing any filter the query already has.
- * A filter never replaces the in-process {@link isExpiredRow} check — it only
- * trims transfer — because the two clocks (query build, row iteration) are
- * not the same instant and DynamoDB applies filters after `Limit`.
- */
-export declare function withoutExpired<T extends QueryCommandInput | ScanCommandInput>(params: T, nowSeconds: number): T;

package/dist/shared/dynamodb/expiry.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExpiredRow = isExpiredRow;
-exports.withoutExpired = withoutExpired;
-/**
- * True when a row carrying a DynamoDB TTL is at or past it. DynamoDB's sweep
- * can lag up to ~48 h, so every read path applies this itself; the value is
- * epoch seconds, the unit the `ttl` attribute uses.
- */
-function isExpiredRow(row, nowSeconds) {
-    return row.ttl !== undefined && row.ttl <= nowSeconds;
-}
-const TTL_FILTER = 'attribute_not_exists(#ttl) OR #ttl > :now';
-/**
- * Exclude expired rows server-side, ANDing any filter the query already has.
- * A filter never replaces the in-process {@link isExpiredRow} check — it only
- * trims transfer — because the two clocks (query build, row iteration) are
- * not the same instant and DynamoDB applies filters after `Limit`.
- */
-function withoutExpired(params, nowSeconds) {
-    return {
-        ...params,
-        FilterExpression: params.FilterExpression
-            ? `(${params.FilterExpression}) AND (${TTL_FILTER})`
-            : TTL_FILTER,
-        ExpressionAttributeNames: { ...params.ExpressionAttributeNames, '#ttl': 'ttl' },
-        ExpressionAttributeValues: { ...params.ExpressionAttributeValues, ':now': nowSeconds },
-    };
-}

package/dist/shared/dynamodb/paginate-core.d.ts

@@ -1,24 +0,0 @@
-import type { RetryOptions } from './retry';
-import type { DocItem } from './types';
-/** One page of results plus the key to resume from (undefined when exhausted). */
-export interface PageResult {
-    items: DocItem[];
-    lastKey: DocItem | undefined;
-}
-/** Options shared by the paginators built on {@link paginatePages}. */
-export interface PaginateCoreOptions {
-    /** The adapter's retry options, applied to every page read. */
-    retry?: RetryOptions;
-    signal?: AbortSignal;
-    maxItems?: number;
-    maxIterations?: number;
-}
-/**
- * Drive a paged DynamoDB read to completion, yielding each item. Continues past
- * empty pages, honors the abort signal before each fetch, and enforces iteration
- * + in-memory item caps. `fetchPage` performs one page read. When a cap is hit
- * while more data actually remains, throws {@link ResultTruncatedError} rather
- * than silently returning a partial result; pass `Infinity` caps to read to true
- * completion (e.g. for deletes).
- */
-export declare function paginatePages(fetchPage: (startKey: DocItem | undefined) => Promise<PageResult>, options?: PaginateCoreOptions): AsyncGenerator<DocItem>;

package/dist/shared/dynamodb/paginate-core.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.paginatePages = paginatePages;
-const constants_1 = require("../constants");
-const errors_1 = require("../errors/errors");
-const abort_1 = require("./abort");
-/** Read the next page, honouring the abort signal and the iteration cap first. */
-async function readPage(reader, startKey) {
-    if (reader.iterations >= reader.maxIterations) {
-        throw new errors_1.ResultTruncatedError('maxIterations', reader.maxIterations);
-    }
-    if (reader.signal?.aborted)
-        throw (0, abort_1.abortErrorFrom)(reader.signal);
-    reader.iterations += 1;
-    return reader.fetchPage(startKey);
-}
-/**
- * Yield one page's items, counting toward the shared `state.yielded` budget.
- * Reaching the cap with unyielded items still on the page is a truncation;
- * reaching it on the last item is reported as `capped` for the caller to settle.
- */
-async function* yieldPageItems(page, state, maxItems) {
-    for (let index = 0; index < page.items.length; index++) {
-        yield page.items[index];
-        state.yielded += 1;
-        if (state.yielded >= maxItems) {
-            if (index < page.items.length - 1)
-                throw new errors_1.ResultTruncatedError('maxItems', maxItems);
-            return 'capped';
-        }
-    }
-    return 'exhausted';
-}
-/**
- * Whether anything remains past `startKey`. DynamoDB returns a
- * `LastEvaluatedKey` whenever it stopped *evaluating* at the 1 MB boundary,
- * whether or not a later item passes the filter, so a trailing key alone proves
- * nothing: the keys are followed until a page carries an item (truncated) or
- * they run out (the result was complete). The probe is charged against the same
- * iteration budget and honours the same signal as the read itself.
- */
-async function dataRemains(reader, startKey) {
-    let key = startKey;
-    while (key !== undefined) {
-        const page = await readPage(reader, key);
-        if (page.items.length > 0)
-            return true;
-        key = page.lastKey;
-    }
-    return false;
-}
-/**
- * Drive a paged DynamoDB read to completion, yielding each item. Continues past
- * empty pages, honors the abort signal before each fetch, and enforces iteration
- * + in-memory item caps. `fetchPage` performs one page read. When a cap is hit
- * while more data actually remains, throws {@link ResultTruncatedError} rather
- * than silently returning a partial result; pass `Infinity` caps to read to true
- * completion (e.g. for deletes).
- */
-async function* paginatePages(fetchPage, options = {}) {
-    const maxItems = options.maxItems ?? constants_1.MAX_TOTAL_ITEMS_IN_MEMORY;
-    const reader = {
-        fetchPage,
-        maxIterations: options.maxIterations ?? constants_1.MAX_LOOP_ITERATIONS,
-        iterations: 0,
-        signal: options.signal,
-    };
-    const state = { yielded: 0 };
-    let startKey;
-    for (;;) {
-        const page = await readPage(reader, startKey);
-        const outcome = yield* yieldPageItems(page, state, maxItems);
-        if (outcome === 'capped') {
-            if (await dataRemains(reader, page.lastKey))
-                throw new errors_1.ResultTruncatedError('maxItems', maxItems);
-            return;
-        }
-        startKey = page.lastKey;
-        if (startKey === undefined)
-            return;
-    }
-}

package/dist/shared/dynamodb/paginate.d.ts

@@ -1,14 +0,0 @@
-import type { DynamoDBDocument, QueryCommandInput } from '@aws-sdk/lib-dynamodb';
-import { type PaginateCoreOptions } from './paginate-core';
-import type { DocItem } from './types';
-/** Options for {@link paginateQuery}. */
-export interface PaginateOptions extends PaginateCoreOptions {
-    client: DynamoDBDocument;
-    params: QueryCommandInput;
-}
-/**
- * Drive a DynamoDB Query across all pages, yielding each item. Follows
- * `LastEvaluatedKey`, honors the abort signal, wraps each page in
- * {@link withDynamoDBRetry}, and enforces runaway guards via the shared core.
- */
-export declare function paginateQuery(options: PaginateOptions): AsyncGenerator<DocItem>;

package/dist/shared/dynamodb/paginate.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.paginateQuery = paginateQuery;
-const paginate_core_1 = require("./paginate-core");
-const retry_1 = require("./retry");
-/**
- * Drive a DynamoDB Query across all pages, yielding each item. Follows
- * `LastEvaluatedKey`, honors the abort signal, wraps each page in
- * {@link withDynamoDBRetry}, and enforces runaway guards via the shared core.
- */
-function paginateQuery(options) {
-    return (0, paginate_core_1.paginatePages)(async (startKey) => {
-        const page = await (0, retry_1.withDynamoDBRetry)(() => options.client.query({ ...options.params, ExclusiveStartKey: startKey }), { ...options.retry, signal: options.signal });
-        return {
-            items: page.Items ?? [],
-            lastKey: page.LastEvaluatedKey,
-        };
-    }, options);
-}