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

package/dist/shared/dynamodb/partition-delete.d.ts

@@ -1,39 +0,0 @@
-import type { DynamoDBDocument, QueryCommandInput } from '@aws-sdk/lib-dynamodb';
-import type { PayloadDescriptor } from '../codec/codec';
-import type { S3Offloader } from '../codec/s3/offloader';
-import type { Logger } from '../logging/logger';
-import type { RetryOptions } from './retry';
-import type { DocItem } from './types';
-/** Collaborators and per-adapter policy for one partition-wide delete. */
-export interface PartitionDeleteOptions {
-    client: DynamoDBDocument;
-    tableName: string;
-    params: QueryCommandInput;
-    logger: Logger;
-    /** The adapter's retry options for the page reads and batch deletes. */
-    retry?: RetryOptions;
-    /** Aborting it stops the read between pages and rejects with the library's AbortError. */
-    signal?: AbortSignal;
-    offloader?: S3Offloader;
-    /** Label for log lines and S3-cleanup diagnostics, e.g. `deleteThread`. */
-    operation: string;
-    /**
-     * True when a sort key belongs to the calling adapter. A partition query
-     * carries no sort-key condition, so without this a shared-table partition
-     * holding a foreign row would have that row deleted too.
-     */
-    ownsSortKey: (sortKey: string) => boolean;
-    /** The offloaded payload descriptors a row references, if any. */
-    descriptorsOf: (row: DocItem) => (PayloadDescriptor | undefined)[];
-    /** The partition's own leading S3 key parts; objects outside their path are never deleted. */
-    scope: readonly string[];
-}
-/**
- * Delete every row in a partition that belongs to the calling adapter,
- * best-effort deleting any offloaded S3 objects. Streams the partition with
- * unbounded pagination and flushes in batches, so a partition of any size is
- * deleted to completion with bounded memory — never silently truncated at the
- * in-memory page caps, and never discarding already-flushed progress if a
- * later batch fails. Returns the number of rows deleted.
- */
-export declare function deletePartitionRows(options: PartitionDeleteOptions): Promise<number>;

package/dist/shared/dynamodb/partition-delete.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deletePartitionRows = deletePartitionRows;
-const descriptor_keys_1 = require("../codec/descriptor-keys");
-const orphans_1 = require("../codec/s3/orphans");
-const constants_1 = require("../constants");
-const errors_1 = require("../errors/errors");
-const batch_write_1 = require("./batch-write");
-const paginate_1 = require("./paginate");
-/** Delete the buffered keys, best-effort clean their S3 objects, then clear it. */
-async function flushBuffer(options, buffer, progress) {
-    if (buffer.keys.length === 0)
-        return;
-    const chunks = Math.ceil(buffer.keys.length / constants_1.BATCH_WRITE_MAX);
-    try {
-        await (0, batch_write_1.batchWriteAll)(options.client, options.tableName, buffer.keys.map((Key) => ({ DeleteRequest: { Key } })), { retry: options.retry, signal: options.signal });
-    }
-    catch (error) {
-        /** batchWriteAll's only throw is a BatchWriteAllIncompleteError (see batch-write.ts). */
-        const failure = error;
-        throw new errors_1.BatchWriteAllIncompleteError(progress.succeededChunks + failure.succeededChunks, progress.totalChunks + failure.totalChunks, failure.failedChunks, progress.writes + failure.succeededCount);
-    }
-    progress.writes += buffer.keys.length;
-    progress.succeededChunks += chunks;
-    progress.totalChunks += chunks;
-    if (options.offloader) {
-        await (0, orphans_1.cleanUpS3Orphans)(options.offloader, (0, descriptor_keys_1.collectS3Keys)(buffer.descriptors), options.operation, options.logger, { scope: options.scope });
-    }
-    buffer.keys = [];
-    buffer.descriptors = [];
-}
-/**
- * Delete every row in a partition that belongs to the calling adapter,
- * best-effort deleting any offloaded S3 objects. Streams the partition with
- * unbounded pagination and flushes in batches, so a partition of any size is
- * deleted to completion with bounded memory — never silently truncated at the
- * in-memory page caps, and never discarding already-flushed progress if a
- * later batch fails. Returns the number of rows deleted.
- */
-async function deletePartitionRows(options) {
-    const buffer = { keys: [], descriptors: [] };
-    const progress = { writes: 0, succeededChunks: 0, totalChunks: 0 };
-    let skipped = 0;
-    const pages = (0, paginate_1.paginateQuery)({
-        client: options.client,
-        params: options.params,
-        retry: options.retry,
-        signal: options.signal,
-        maxItems: Number.POSITIVE_INFINITY,
-        maxIterations: Number.POSITIVE_INFINITY,
-    });
-    for await (const row of pages) {
-        if (!options.ownsSortKey(row.SK)) {
-            skipped += 1;
-            options.logger.warn(`${options.operation}: left a foreign row in place`, {
-                sortKey: row.SK,
-            });
-            continue;
-        }
-        buffer.keys.push({ PK: row.PK, SK: row.SK });
-        for (const descriptor of options.descriptorsOf(row)) {
-            if (descriptor)
-                buffer.descriptors.push(descriptor);
-        }
-        if (buffer.keys.length >= constants_1.BATCH_WRITE_MAX)
-            await flushBuffer(options, buffer, progress);
-    }
-    await flushBuffer(options, buffer, progress);
-    options.logger.info(`${options.operation}: deleted rows`, { deleted: progress.writes, skipped });
-    return progress.writes;
-}

package/dist/shared/dynamodb/retry-classifier.d.ts

@@ -1,17 +0,0 @@
-/**
- * Default retryable transient signals. TransactionCanceledException is
- * intentionally absent (its reasons include permanent failures);
- * TransactionConflictException (transient row contention) IS retryable.
- */
-export declare const DEFAULT_RETRYABLE_ERRORS: readonly string[];
-/**
- * True when `error` (or any cause in its chain) is transient: a transaction
- * cancellation whose every reason is transient (that verdict takes precedence,
- * because a permanent reason arrives with the same statuses as a transient
- * one), an HTTP status in {@link TRANSIENT_HTTP_STATUSES}, the SDK's
- * `$retryable` trait, or an exact match of a `name`/`code`/`errno`/`syscall`
- * token against `retryableErrors`. Exact, not substring: the fields are
- * whole tokens, and a substring rule would let an unrelated name that merely
- * contains one ride along.
- */
-export declare function isRetryableError(error: Error, retryableErrors: readonly string[]): boolean;

package/dist/shared/dynamodb/retry-classifier.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_RETRYABLE_ERRORS = void 0;
-exports.isRetryableError = isRetryableError;
-const cancellation_1 = require("./cancellation");
-const MAX_CAUSE_DEPTH = 32;
-/**
- * Default retryable transient signals. TransactionCanceledException is
- * intentionally absent (its reasons include permanent failures);
- * TransactionConflictException (transient row contention) IS retryable.
- */
-exports.DEFAULT_RETRYABLE_ERRORS = [
-    'ProvisionedThroughputExceededException',
-    'ThrottlingException',
-    'RequestLimitExceeded',
-    'InternalServerError',
-    'ServiceUnavailable',
-    'TransactionConflictException',
-    'TransactionInProgressException',
-    'RequestTimeout',
-    'RequestTimeoutException',
-    'ECONNRESET',
-    'ECONNREFUSED',
-    'ETIMEDOUT',
-    'EPIPE',
-    'EAI_AGAIN',
-    'NetworkingError',
-    'TimeoutError',
-    'EHOSTUNREACH',
-    'ENETUNREACH',
-    'ENOTFOUND',
-];
-/**
- * HTTP statuses the AWS SDK retries regardless of the error name: throttling
- * (429) and the transient server statuses. They matter most for an error the
- * SDK could not map to a modeled exception (an intermediary's HTML 503, a
- * truncated body), which arrives as `name: 'Unknown'` with only its status.
- */
-const TRANSIENT_HTTP_STATUSES = [429, 500, 502, 503, 504];
-/**
- * Cancellation reason codes (from a `TransactionCanceledException`'s
- * `CancellationReasons`) that are transient and safe to retry. `None` marks an
- * item that was not the cause and is ignored.
- */
-const TRANSIENT_CANCELLATION_REASONS = [
-    'None',
-    'TransactionConflict',
-    'ThrottlingError',
-    'ProvisionedThroughputExceeded',
-];
-/**
- * When `error` is a transaction cancellation carrying reasons, return whether
- * every reason is transient; otherwise undefined so normal signal matching
- * applies. A bare cancellation with no reasons is treated as non-retryable.
- */
-function transactionCancellationRetryable(error) {
-    const reasons = (0, cancellation_1.getCancellationReasons)(error);
-    if (!reasons)
-        return undefined;
-    /**
-     * `length > 0` is load-bearing: `.every()` is vacuously true on an empty
-     * array, which would make a reason-less cancellation retryable — the exact
-     * opposite of what this function documents. AWS populates one reason per
-     * `TransactItems` entry, so an empty array should not occur; if it ever
-     * does, the conservative answer is not to retry.
-     */
-    return (reasons.length > 0 &&
-        reasons.every((reason) => reason.Code === undefined || TRANSIENT_CANCELLATION_REASONS.includes(reason.Code)));
-}
-/** Add one node's signal tokens, HTTP status and retryable trait to `evidence`. */
-function recordNode(fields, evidence) {
-    for (const value of [fields.name, fields.code, fields.errno, fields.syscall]) {
-        if (typeof value === 'string')
-            evidence.signals.push(value);
-    }
-    if (typeof fields.$metadata?.httpStatusCode === 'number') {
-        evidence.statuses.push(fields.$metadata.httpStatusCode);
-    }
-    if (fields.$retryable !== undefined && fields.$retryable !== null)
-        evidence.retryableByTrait = true;
-}
-function collectEvidence(error) {
-    const seen = new WeakSet();
-    const evidence = { signals: [], statuses: [], retryableByTrait: false };
-    const walk = (node, depth) => {
-        if (depth > MAX_CAUSE_DEPTH || node === null || typeof node !== 'object' || seen.has(node)) {
-            return;
-        }
-        seen.add(node);
-        const fields = node;
-        recordNode(fields, evidence);
-        if (fields.cause)
-            walk(fields.cause, depth + 1);
-    };
-    walk(error, 0);
-    return evidence;
-}
-/**
- * True when `error` (or any cause in its chain) is transient: a transaction
- * cancellation whose every reason is transient (that verdict takes precedence,
- * because a permanent reason arrives with the same statuses as a transient
- * one), an HTTP status in {@link TRANSIENT_HTTP_STATUSES}, the SDK's
- * `$retryable` trait, or an exact match of a `name`/`code`/`errno`/`syscall`
- * token against `retryableErrors`. Exact, not substring: the fields are
- * whole tokens, and a substring rule would let an unrelated name that merely
- * contains one ride along.
- */
-function isRetryableError(error, retryableErrors) {
-    const cancellation = transactionCancellationRetryable(error);
-    if (cancellation !== undefined)
-        return cancellation;
-    const evidence = collectEvidence(error);
-    if (evidence.retryableByTrait)
-        return true;
-    if (evidence.statuses.some((status) => TRANSIENT_HTTP_STATUSES.includes(status)))
-        return true;
-    return evidence.signals.some((signal) => retryableErrors.includes(signal));
-}

package/dist/shared/dynamodb/retry-policy.d.ts

@@ -1,26 +0,0 @@
-import type { Logger } from '../logging/logger';
-import type { RetryOptions } from './retry';
-/**
- * Caller-facing retry tunables for every DynamoDB call an adapter makes. The
- * schedule is full-jitter exponential backoff: `baseDelayMs` doubling per
- * attempt, capped at `maxDelayMs`, for `maxAttempts` attempts. The
- * message-append path never goes below its own contention floor.
- */
-export interface RetryPolicy {
-    /** Attempts per call before `RetryExhaustedError` (default 5). */
-    maxAttempts?: number;
-    /** First backoff delay in milliseconds (default 100). */
-    baseDelayMs?: number;
-    /** Cap on a single backoff delay in milliseconds (default 5000). */
-    maxDelayMs?: number;
-}
-/**
- * Resolve an adapter's retry policy once, attaching the context logger so
- * every retry is visible at `debug` (attempt, the delay about to be slept, the
- * error name) instead of only surfacing once the budget is exhausted.
- */
-export declare function resolveRetryPolicy(policy: RetryPolicy | undefined, logger: Logger): RetryOptions;
-/** The context's retry options plus a per-call cancellation signal, when one is given. */
-export declare function retryFor(context: {
-    retry?: RetryOptions;
-}, signal?: AbortSignal): RetryOptions | undefined;

package/dist/shared/dynamodb/retry-policy.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveRetryPolicy = resolveRetryPolicy;
-exports.retryFor = retryFor;
-const constants_1 = require("../constants");
-/**
- * Resolve an adapter's retry policy once, attaching the context logger so
- * every retry is visible at `debug` (attempt, the delay about to be slept, the
- * error name) instead of only surfacing once the budget is exhausted.
- */
-function resolveRetryPolicy(policy, logger) {
-    return {
-        maxAttempts: policy?.maxAttempts ?? constants_1.DEFAULT_RETRY_MAX_ATTEMPTS,
-        baseDelayMs: policy?.baseDelayMs ?? constants_1.INITIAL_BACKOFF_DELAY_MS,
-        maxDelayMs: policy?.maxDelayMs ?? constants_1.MAX_BACKOFF_DELAY_MS,
-        onRetry: ({ attempt, delayMs, error }) => logger.debug('retrying after a transient error', { attempt, delayMs, error: error.name }),
-    };
-}
-/** The context's retry options plus a per-call cancellation signal, when one is given. */
-function retryFor(context, signal) {
-    return signal === undefined ? context.retry : { ...context.retry, signal };
-}

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

@@ -1,31 +0,0 @@
-/** What {@link RetryOptions.onRetry} learns before each backoff sleep. */
-export interface RetryAttemptInfo {
-    attempt: number;
-    delayMs: number;
-    error: Error;
-}
-/** Options controlling {@link withRetry}. */
-export interface RetryOptions {
-    maxAttempts?: number;
-    baseDelayMs?: number;
-    maxDelayMs?: number;
-    retryableErrors?: readonly string[];
-    /**
-     * Decides retryability instead of `retryableErrors`, so a call site can
-     * share one classifier (see `isTransientS3Error`) with paths that do not
-     * go through `withRetry`.
-     */
-    isRetryable?: (error: Error) => boolean;
-    /** Called before every backoff sleep, so retries are visible before the budget is exhausted. */
-    onRetry?: (info: RetryAttemptInfo) => void;
-    signal?: AbortSignal;
-    rng?: () => number;
-}
-/**
- * Run `fn`, retrying retryable transient errors with full-jitter exponential
- * backoff. Non-retryable errors are re-thrown unchanged; exhaustion throws
- * {@link RetryExhaustedError}; an aborted signal throws {@link AbortError}.
- */
-export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-/** {@link withRetry} preset for DynamoDB operations. */
-export declare function withDynamoDBRetry<T>(fn: () => Promise<T>, overrides?: Partial<RetryOptions>): Promise<T>;

package/dist/shared/dynamodb/retry.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withRetry = withRetry;
-exports.withDynamoDBRetry = withDynamoDBRetry;
-const constants_1 = require("../constants");
-const errors_1 = require("../errors/errors");
-const wrap_error_1 = require("../errors/wrap-error");
-const secret_patterns_1 = require("../logging/secret-patterns");
-const abort_1 = require("./abort");
-const backoff_1 = require("./backoff");
-const retry_classifier_1 = require("./retry-classifier");
-function delayForAttempt(attempt, base, max, rng) {
-    const exponential = base * 2 ** (attempt - 1);
-    return (0, backoff_1.fullJitter)(Math.min(exponential, max), rng);
-}
-/** Apply defaults to {@link RetryOptions}. */
-function resolveRetryOptions(options) {
-    return {
-        maxAttempts: options.maxAttempts ?? constants_1.DEFAULT_RETRY_MAX_ATTEMPTS,
-        baseDelayMs: options.baseDelayMs ?? constants_1.INITIAL_BACKOFF_DELAY_MS,
-        maxDelayMs: options.maxDelayMs ?? constants_1.MAX_BACKOFF_DELAY_MS,
-        isRetryable: options.isRetryable ??
-            ((error) => (0, retry_classifier_1.isRetryableError)(error, options.retryableErrors ?? retry_classifier_1.DEFAULT_RETRYABLE_ERRORS)),
-        rng: options.rng ?? Math.random,
-    };
-}
-/**
- * Run `fn`, retrying retryable transient errors with full-jitter exponential
- * backoff. Non-retryable errors are re-thrown unchanged; exhaustion throws
- * {@link RetryExhaustedError}; an aborted signal throws {@link AbortError}.
- */
-async function withRetry(fn, options = {}) {
-    const { maxAttempts, baseDelayMs, maxDelayMs, isRetryable, rng } = resolveRetryOptions(options);
-    if (options.signal?.aborted)
-        throw (0, abort_1.abortErrorFrom)(options.signal);
-    let lastError = new Error('Retry failed without error');
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            lastError = (0, wrap_error_1.toError)(error);
-            if (!isRetryable(lastError))
-                throw lastError;
-            if (attempt === maxAttempts)
-                break;
-            const delayMs = delayForAttempt(attempt, baseDelayMs, maxDelayMs, rng);
-            options.onRetry?.({ attempt, delayMs, error: lastError });
-            await (0, backoff_1.sleep)(delayMs, options.signal);
-        }
-    }
-    throw new errors_1.RetryExhaustedError(`Operation failed after ${maxAttempts} attempts: ${(0, secret_patterns_1.redactedMessage)(lastError)}`, maxAttempts, lastError);
-}
-/** {@link withRetry} preset for DynamoDB operations. */
-async function withDynamoDBRetry(fn, overrides) {
-    return withRetry(fn, { maxAttempts: constants_1.DEFAULT_RETRY_MAX_ATTEMPTS, ...overrides });
-}

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

@@ -1,14 +0,0 @@
-import type { DynamoDBDocument, ScanCommandInput } from '@aws-sdk/lib-dynamodb';
-import { type PaginateCoreOptions } from './paginate-core';
-import type { DocItem } from './types';
-/** Options for {@link paginateScan}. */
-export interface ScanOptions extends PaginateCoreOptions {
-    client: DynamoDBDocument;
-    params: ScanCommandInput;
-}
-/**
- * Drive a DynamoDB Scan across all pages, yielding each item. Shares the
- * pagination core with {@link paginateQuery}: abort handling, retry per page,
- * and runaway guards.
- */
-export declare function paginateScan(options: ScanOptions): AsyncGenerator<DocItem>;

package/dist/shared/dynamodb/scan.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.paginateScan = paginateScan;
-const paginate_core_1 = require("./paginate-core");
-const retry_1 = require("./retry");
-/**
- * Drive a DynamoDB Scan across all pages, yielding each item. Shares the
- * pagination core with {@link paginateQuery}: abort handling, retry per page,
- * and runaway guards.
- */
-function paginateScan(options) {
-    return (0, paginate_core_1.paginatePages)(async (startKey) => {
-        const page = await (0, retry_1.withDynamoDBRetry)(() => options.client.scan({ ...options.params, ExclusiveStartKey: startKey }), { ...options.retry, signal: options.signal });
-        return {
-            items: page.Items ?? [],
-            lastKey: page.LastEvaluatedKey,
-        };
-    }, options);
-}

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

@@ -1,23 +0,0 @@
-import type { NativeAttributeValue } from '@aws-sdk/lib-dynamodb';
-/**
- * A DynamoDB item as returned/accepted by the DocumentClient. Reads that we
- * wrote ourselves are narrowed with a single structural `as` at the mapper
- * boundary (never `as any`/`as unknown`); untrusted shared-table scans go
- * through `narrowStoreRecord`.
- */
-export type DocItem = Record<string, NativeAttributeValue>;
-/** A BatchWriteItem PutRequest. */
-interface PutWriteRequest {
-    PutRequest: {
-        Item: DocItem;
-    };
-}
-/** A BatchWriteItem DeleteRequest. */
-interface DeleteWriteRequest {
-    DeleteRequest: {
-        Key: DocItem;
-    };
-}
-/** A single BatchWriteItem write request. */
-export type WriteRequest = PutWriteRequest | DeleteWriteRequest;
-export {};

package/dist/shared/errors/base-error.d.ts

@@ -1,30 +0,0 @@
-import { ErrorCode } from './error-code';
-/**
- * Structured, log-safe context attached to every library error. Identifiers
- * and counts only — never a payload or a credential.
- */
-export interface ErrorContext {
-    /** The DynamoDB table the operation targeted, when known. */
-    tableName?: string;
-    /** The public operation (`saver.put`, `store.batch`, …) or internal step that failed. */
-    operation?: string;
-    /** The option, argument or cap that failed validation or was exceeded. */
-    field?: string;
-    /** The S3 object key involved, for offload failures. */
-    key?: string;
-    /** Attempts made before a retry budget was exhausted. */
-    attempts?: number;
-}
-/**
- * Base class for every error this library throws. Carries a branchable
- * {@link ErrorCode}, structured {@link ErrorContext}, and a native `cause`
- * chain. Detected via {@link isDynamoDBLangGraphError} (a symbol brand) rather
- * than `instanceof`, which is banned repo-wide.
- */
-export declare class DynamoDBLangGraphError extends Error {
-    readonly code: ErrorCode;
-    readonly context: ErrorContext;
-    constructor(message: string, code: ErrorCode, context?: ErrorContext, cause?: Error);
-}
-/** True when `value` is a {@link DynamoDBLangGraphError}, detected by brand. */
-export declare function isDynamoDBLangGraphError(value: Error): value is DynamoDBLangGraphError;

package/dist/shared/errors/base-error.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamoDBLangGraphError = void 0;
-exports.isDynamoDBLangGraphError = isDynamoDBLangGraphError;
-const ERROR_BRAND = Symbol.for('@farukada/aws-langgraph-dynamodb-ts/error');
-/**
- * Base class for every error this library throws. Carries a branchable
- * {@link ErrorCode}, structured {@link ErrorContext}, and a native `cause`
- * chain. Detected via {@link isDynamoDBLangGraphError} (a symbol brand) rather
- * than `instanceof`, which is banned repo-wide.
- */
-class DynamoDBLangGraphError extends Error {
-    code;
-    context;
-    constructor(message, code, context = {}, cause) {
-        super(message, cause === undefined ? undefined : { cause });
-        this.name = 'DynamoDBLangGraphError';
-        this.code = code;
-        this.context = context;
-        Object.defineProperty(this, ERROR_BRAND, { value: true, enumerable: false });
-    }
-}
-exports.DynamoDBLangGraphError = DynamoDBLangGraphError;
-/** True when `value` is a {@link DynamoDBLangGraphError}, detected by brand. */
-function isDynamoDBLangGraphError(value) {
-    return ERROR_BRAND in value;
-}

package/dist/shared/errors/boundary.d.ts

@@ -1,18 +0,0 @@
-/**
- * Normalise anything escaping a public method into the library's error model:
- * a branded library error is returned unchanged (its code was assigned closer
- * to the failure and wins), anything else becomes an {@link UpstreamError}.
- */
-export declare function toPublicError(error: Error, operation: string): Error;
-/**
- * Run a public operation so that every rejection is a library error. Applied
- * once, at each adapter class method, so internal code can keep rethrowing SDK
- * errors verbatim (the retry classifier depends on their shape).
- */
-export declare function guardPublic<T>(operation: string, fn: () => Promise<T>): Promise<T>;
-/**
- * The same guard for a streaming result: items pass through, a failure raised
- * mid-iteration is wrapped, and a consumer that stops early still closes the
- * source generator.
- */
-export declare function guardPublicIterable<T>(operation: string, source: AsyncGenerator<T>): AsyncGenerator<T>;

package/dist/shared/errors/boundary.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toPublicError = toPublicError;
-exports.guardPublic = guardPublic;
-exports.guardPublicIterable = guardPublicIterable;
-const base_error_1 = require("./base-error");
-const upstream_error_1 = require("./upstream-error");
-const wrap_error_1 = require("./wrap-error");
-/**
- * Normalise anything escaping a public method into the library's error model:
- * a branded library error is returned unchanged (its code was assigned closer
- * to the failure and wins), anything else becomes an {@link UpstreamError}.
- */
-function toPublicError(error, operation) {
-    const normalized = (0, wrap_error_1.toError)(error);
-    return (0, base_error_1.isDynamoDBLangGraphError)(normalized)
-        ? normalized
-        : new upstream_error_1.UpstreamError(normalized, operation);
-}
-/**
- * Run a public operation so that every rejection is a library error. Applied
- * once, at each adapter class method, so internal code can keep rethrowing SDK
- * errors verbatim (the retry classifier depends on their shape).
- */
-async function guardPublic(operation, fn) {
-    try {
-        return await fn();
-    }
-    catch (error) {
-        throw toPublicError(error, operation);
-    }
-}
-/**
- * The same guard for a streaming result: items pass through, a failure raised
- * mid-iteration is wrapped, and a consumer that stops early still closes the
- * source generator.
- */
-async function* guardPublicIterable(operation, source) {
-    try {
-        for await (const item of source)
-            yield item;
-    }
-    catch (error) {
-        throw toPublicError(error, operation);
-    }
-}

package/dist/shared/errors/error-code.d.ts

@@ -1,13 +0,0 @@
-/** Stable, branchable classification for every error this library throws. */
-export declare enum ErrorCode {
-    VALIDATION = "VALIDATION",
-    CONDITION_CONFLICT = "CONDITION_CONFLICT",
-    RETRY_EXHAUSTED = "RETRY_EXHAUSTED",
-    BATCH_WRITE_INCOMPLETE = "BATCH_WRITE_INCOMPLETE",
-    COMPRESSION_LIMIT = "COMPRESSION_LIMIT",
-    S3_OFFLOAD_FAILED = "S3_OFFLOAD_FAILED",
-    RESULT_TRUNCATED = "RESULT_TRUNCATED",
-    ABORTED = "ABORTED",
-    COMPENSATION_FAILED = "COMPENSATION_FAILED",
-    UPSTREAM = "UPSTREAM"
-}

package/dist/shared/errors/errors.d.ts

@@ -1,68 +0,0 @@
-import type { WriteRequest } from '../dynamodb/types';
-import { DynamoDBLangGraphError } from './base-error';
-/** Input failed a validation rule before any AWS call was made; `context.field` names the input. */
-export declare class ValidationError extends DynamoDBLangGraphError {
-    constructor(message: string, field?: string, cause?: Error);
-}
-/** A conditional write failed because the precondition no longer holds. */
-export declare class ConflictError extends DynamoDBLangGraphError {
-    constructor(message: string, cause?: Error);
-}
-/** A retried operation exhausted its attempt budget. */
-export declare class RetryExhaustedError extends DynamoDBLangGraphError {
-    constructor(message: string, attempts?: number, cause?: Error);
-}
-/**
- * A paginated read hit its runaway guard (item or iteration cap) while more
- * data remained, so the result would have been silently truncated. Narrow the
- * query (filter/prefix) or raise the cap rather than trusting a partial result.
- * `context.field` names the cap that was hit.
- */
-export declare class ResultTruncatedError extends DynamoDBLangGraphError {
-    constructor(cap: string, limit: number);
-}
-/** An operation was cancelled via its AbortSignal. */
-export declare class AbortError extends DynamoDBLangGraphError {
-    constructor(message?: string, cause?: Error);
-}
-/**
- * A BatchWriteItem sequence could not drain its UnprocessedItems. Items NOT
- * listed in {@link unprocessed} were acked by DynamoDB and persist — there is
- * no rollback (drive reconciliation from `unprocessed`). `cause`, when given,
- * is the underlying failure that interrupted the drain (e.g. a thrown,
- * non-UnprocessedItems error from a retry round) rather than a clean exhaustion
- * of the UnprocessedItems retry budget.
- */
-export declare class BatchWriteIncompleteError extends DynamoDBLangGraphError {
-    readonly succeededCount: number;
-    readonly unprocessed: WriteRequest[];
-    constructor(succeededCount: number, unprocessed: WriteRequest[], retries: number, cause?: Error);
-}
-/**
- * batchWriteAll attempts every chunk rather than stopping at the first
- * failure — a mid-sequence chunk failing does not abandon the chunks after
- * it. `failedChunks` holds each failing chunk's own error (commonly a
- * {@link BatchWriteIncompleteError}); every chunk not represented there
- * drained successfully and its writes persist — there is no rollback.
- * `succeededCount` is the exact number of individual write requests
- * confirmed persisted across every chunk (full chunks plus any failed
- * chunk's own partial drain), more precise than `succeededChunks` alone
- * when a chunk partially drains before exhausting its retries.
- */
-export declare class BatchWriteAllIncompleteError extends DynamoDBLangGraphError {
-    readonly succeededChunks: number;
-    readonly totalChunks: number;
-    readonly failedChunks: Error[];
-    readonly succeededCount: number;
-    constructor(succeededChunks: number, totalChunks: number, failedChunks: Error[], succeededCount?: number);
-}
-/**
- * A compensating rollback failed after an append-saga chunk error, so the
- * trigger error could not be cleanly undone. Carries the original trigger as
- * `cause` and the rollback failure as {@link rollbackError}; the session's
- * `messageCount` may have drifted — repair it with `reconcileMessageCount`.
- */
-export declare class CompensationFailedError extends DynamoDBLangGraphError {
-    readonly rollbackError: Error;
-    constructor(cause: Error, rollbackError: Error);
-}