graphddb 0.2.2 → 0.2.4

package/dist/{types-SKxZQbQO.d.ts → types-BEeQ_nSd.d.ts}

@@ -1,5 +1,131 @@
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 
+/**
+ * App-level throttle / transient-error retry for single-op sends (issue #111).
+ *
+ * GraphDDB's single-item ops (GetItem / Query / Put / Update / Delete) and the
+ * read fan-out (relation resolution) used to throw on throttling
+ * (`ProvisionedThroughputExceededException` / `ThrottlingException`) and rely
+ * solely on the AWS SDK v3 default retry, so the LIBRARY itself guaranteed no
+ * throttle-resilience. The batch ops already retry partial completion
+ * (`UnprocessedKeys` / `UnprocessedItems`, see `src/operations/batch-retry.ts`);
+ * this module is the SEPARATE, library-owned ERROR retry that wraps every
+ * `docClient.send()` for the single ops via {@link RetryingExecutor}.
+ *
+ * The two retry layers are DISTINCT and must not be merged:
+ *  - (A) partial-batch retry (`batch-retry.ts`) — DynamoDB accepted the request
+ *    but could not process every key/item; the request itself did NOT error.
+ *  - (B) error retry (this module) — `send()` REJECTED with a throttle / transient
+ *    error and is retried whole.
+ * They share {@link computeBackoffDelay} so backoff is consistent across both,
+ * but they are different mechanisms.
+ *
+ * The default policy is ENABLED out of the box (see {@link DEFAULT_RETRY_POLICY}):
+ * even with zero configuration a sensible exponential-backoff-with-jitter,
+ * bounded-attempts retry applies. Users tune it globally via
+ * `DDBModel.setRetryPolicy(...)` or per-call via the `retry?:` option on the
+ * operation option bags; `retry: false` disables retry for that one call.
+ *
+ * NOTE on the AWS SDK's OWN retry: now that the library owns retry, a
+ * `DynamoDBClient` left at the SDK default `maxAttempts: 3` retries
+ * MULTIPLICATIVELY underneath this layer. Users should construct their client
+ * with `maxAttempts: 1` so the library is the single source of truth for retry
+ * (documented at `DDBModel.setClient` and in the README). The library does NOT
+ * silently mutate a user-provided client.
+ */
+/** The single-op kind a retry is wrapping — surfaced to {@link RetryPolicy.onRetry}. */
+type RetryOperationKind = 'get' | 'query' | 'batchGet' | 'put' | 'update' | 'delete' | 'batchWrite' | 'transactWrite';
+/** The context handed to {@link RetryPolicy.onRetry} before each backoff sleep. */
+interface RetryInfo {
+    /** 1-based attempt number that just FAILED and is about to be retried. */
+    readonly attempt: number;
+    /** The throttle / transient error that triggered this retry. */
+    readonly error: unknown;
+    /** The backoff delay (ms) about to be slept before the next attempt. */
+    readonly delayMs: number;
+    /** Which single-op kind is being retried. */
+    readonly operation: RetryOperationKind;
+}
+/**
+ * A retry policy for the single-op error-retry layer (issue #111). Every field is
+ * optional and resolved INDEPENDENTLY, in layers (see {@link resolveRetryPolicy}):
+ * a per-call override field wins, else the globally-configured policy's field
+ * (from {@link import('../model/DDBModel.js').DDBModel.setRetryPolicy}), else
+ * {@link DEFAULT_RETRY_POLICY}. So a partial per-call override (e.g.
+ * `{ maxAttempts: 3 }`) overrides ONLY that field and INHERITS the rest from the
+ * global policy — a global `onRetry` / `jitter` is NOT dropped. A policy value of
+ * `false` on an option bag disables retry entirely for that call.
+ */
+interface RetryPolicy {
+    /**
+     * Maximum number of attempts (the FIRST try counts as attempt 1). `1` disables
+     * retry (a single try, no backoff). Default {@link DEFAULT_MAX_ATTEMPTS}.
+     */
+    readonly maxAttempts?: number;
+    /**
+     * Compute the base backoff delay (ms) for a 1-based retry attempt, BEFORE jitter.
+     * Defaults to {@link computeBackoffDelay} (`min(1000, 50*2^(attempt-1))`), the
+     * same ramp the batch partial-retry layer uses, so backoff is consistent across
+     * the two layers.
+     */
+    readonly computeDelay?: (attempt: number) => number;
+    /**
+     * Jitter strategy applied to the base delay:
+     *  - `'full'` (default) — uniform random in `[0, base]` (AWS "full jitter"),
+     *    the recommended strategy to de-correlate retries across clients.
+     *  - `'none'` — use the base delay verbatim (deterministic; handy in tests).
+     */
+    readonly jitter?: 'full' | 'none';
+    /**
+     * Classify whether an error is retryable. Defaults to {@link isRetryableError}
+     * (throttle + 5xx / transient). A custom classifier fully replaces the default —
+     * it should still avoid retrying validation / conditional-check failures.
+     */
+    readonly isRetryable?: (error: unknown) => boolean;
+    /**
+     * Observability hook (issue #111 §8): invoked BEFORE each backoff sleep with the
+     * attempt number, the triggering error, the computed (post-jitter) delay, and the
+     * operation kind. Never invoked on the terminal success or the terminal failure.
+     */
+    readonly onRetry?: (info: RetryInfo) => void;
+}
+/** Default cap on attempts: the first try plus up to 9 retries (mirrors the batch cap). */
+declare const DEFAULT_MAX_ATTEMPTS = 10;
+/**
+ * The default, always-on retry policy (issue #111 §3). Exponential backoff (the
+ * shared {@link computeBackoffDelay} ramp) + full jitter, capped at
+ * {@link DEFAULT_MAX_ATTEMPTS} attempts, retrying throttle / 5xx / transient
+ * errors only (never validation / conditional-check failures).
+ */
+declare const DEFAULT_RETRY_POLICY: Required<Pick<RetryPolicy, 'maxAttempts' | 'computeDelay' | 'jitter' | 'isRetryable'>>;
+/**
+ * Default error classifier (issue #111 §5). Retryable when the error is a known
+ * throttle / transient fault, an AWS SDK error flagged `$retryable`, or a 5xx /
+ * 429 status. NEVER retryable for validation / conditional-check / not-found /
+ * access-denied — those are deterministic and would just burn the attempt budget.
+ *
+ * NOTE: a {@link https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html
+ * TransactionCanceledException} is handled SEPARATELY by
+ * {@link isRetryableTransactionCancellation}; this function treats it as
+ * non-retryable so the transact path can inspect its `CancellationReasons` first.
+ */
+declare function isRetryableError(error: unknown): boolean;
+/**
+ * Classify a `TransactionCanceledException` (issue #111 §6). Inspects the
+ * `CancellationReasons`:
+ *  - ANY `ConditionalCheckFailed` reason ⇒ NOT retryable (a deterministic
+ *    condition failure; retrying would just fail again) — return `false`.
+ *  - Otherwise, when EVERY non-`None` reason is a throttle / conflict code
+ *    (`ThrottlingError` / `ProvisionedThroughputExceeded` / `TransactionConflict`)
+ *    ⇒ retryable — return `true`.
+ *  - A cancellation with no inspectable reasons, or any other reason code, is
+ *    treated conservatively as NOT retryable.
+ *
+ * Only meaningful for an error whose name is `TransactionCanceledException`; the
+ * caller checks that first.
+ */
+declare function isRetryableTransactionCancellation(error: unknown): boolean;
+
 interface RangeCondition {
     operator: 'begins_with';
     key: string;
@@ -859,41 +985,6 @@ interface ModelStatic<T extends DDBModel, C = unknown> {
     deleteItem(key: DeleteKey<C>, options?: WriteOptions<T>): Promise<void>;
 }
 
-interface PutOptions<T = unknown> {
-    condition?: WriteCondition<T>;
-}
-interface UpdateOptions<T = unknown> {
-    condition?: WriteCondition<T>;
-    /**
-     * How to re-derive a GSI key whose composing fields are changed but **not all**
-     * available from `{ ...key, ...changes }` (issue #115).
-     *
-     * - **unset (default)** — refuse with an explicit error rather than let the
-     *   index silently rot. The error names the index, the changed field, and the
-     *   missing field(s). The happy path (all composing fields available) re-derives
-     *   in the SAME `UpdateExpression` and is unaffected by this option.
-     * - `'read-modify-write'` — read the current item, merge `{ ...item, ...changes }`,
-     *   re-derive every affected GSI key from the merged image, and write back under
-     *   an optimistic condition (the item must still exist / be unchanged). This costs
-     *   one extra read and is NOT atomic with the original update, but always re-derives
-     *   correctly.
-     */
-    rederive?: 'read-modify-write';
-}
-interface DeleteOptions<T = unknown> {
-    condition?: WriteCondition<T>;
-}
-
-interface PutInput {
-    TableName: string;
-    Item: Record<string, unknown>;
-    ConditionExpression?: string;
-    ExpressionAttributeNames?: Record<string, string>;
-    ExpressionAttributeValues?: Record<string, unknown>;
-}
-declare function buildPutInput(modelClass: Function, item: Record<string, unknown>, options?: PutOptions): PutInput;
-declare function executePut(modelClass: Function, item: Record<string, unknown>, options?: PutOptions): Promise<void>;
-
 interface UpdateInput {
     TableName: string;
     Key: Record<string, unknown>;
@@ -930,10 +1021,34 @@ interface ExecutorResult {
 interface WriteResult {
     oldItem?: Record<string, unknown>;
 }
+/**
+ * A per-call retry override threaded down to {@link RetryingExecutor} (issue
+ * #111). `undefined` ⇒ use the globally-configured (or default) policy; a
+ * {@link RetryPolicy} ⇒ use that for this call; `false` ⇒ disable retry for this
+ * call. The default {@link DynamoExecutor} and the test `MemoryExecutor` ignore
+ * it — only {@link RetryingExecutor} acts on it.
+ */
+type RetryOverride = RetryPolicy | false;
+/**
+ * Per-call options for the READ path (issue #111). Carries the per-op retry
+ * override down to {@link RetryingExecutor}. Extended (rather than passing the
+ * override positionally) so future per-call read knobs have a home.
+ */
+interface ReadExecOptions {
+    /** Per-call retry override; see {@link RetryOverride}. */
+    retry?: RetryOverride;
+}
 /** Options shared by the single-item structured write methods. */
 interface WriteExecOptions {
     /** Request the pre-write image (DynamoDB `ReturnValues: ALL_OLD`). */
     returnOldImage?: boolean;
+    /** Per-call retry override (issue #111); see {@link RetryOverride}. */
+    retry?: RetryOverride;
+}
+/** Per-call options for the batch / transact paths (issue #111). */
+interface BatchExecOptions {
+    /** Per-call retry override; see {@link RetryOverride}. */
+    retry?: RetryOverride;
 }
 /**
  * One BatchGetItem sub-request: a single physical table plus its keys and an
@@ -997,13 +1112,18 @@ type TransactWriteExecItem = {
  * implement a fake.
  */
 interface Executor {
-    /** Read path: GetItem / Query / BatchGetItem. */
-    execute(operation: DynamoDBOperation): Promise<ExecutorResult>;
+    /**
+     * Read path: GetItem / Query / BatchGetItem. The optional {@link ReadExecOptions}
+     * carries a per-call retry override (issue #111); the default
+     * {@link DynamoExecutor} and `MemoryExecutor` ignore it, only `RetryingExecutor`
+     * acts on it.
+     */
+    execute(operation: DynamoDBOperation, options?: ReadExecOptions): Promise<ExecutorResult>;
     /**
      * BatchGetItem for a single table. The caller is responsible for chunking
      * keys ≤100 (the relation traversal and the planner-driven path both do).
      */
-    batchGet(input: BatchGetExecInput): Promise<ExecutorResult>;
+    batchGet(input: BatchGetExecInput, options?: ReadExecOptions): Promise<ExecutorResult>;
     /** Put one item. */
     put(input: PutInput, options?: WriteExecOptions): Promise<WriteResult>;
     /** Update one item (applies its structured UpdateExpression). */
@@ -1014,10 +1134,63 @@ interface Executor {
      * BatchWriteItem for a single table (non-atomic). Keys/items are chunked ≤25
      * with UnprocessedItems retry by the implementation.
      */
-    batchWrite(tableName: string, items: BatchWriteExecItem[]): Promise<void>;
+    batchWrite(tableName: string, items: BatchWriteExecItem[], options?: BatchExecOptions): Promise<void>;
     /** TransactWriteItems — all-or-nothing atomic. */
-    transactWrite(items: TransactWriteExecItem[]): Promise<void>;
+    transactWrite(items: TransactWriteExecItem[], options?: BatchExecOptions): Promise<void>;
+}
+
+interface PutOptions<T = unknown> {
+    condition?: WriteCondition<T>;
+    /**
+     * Per-call throttle / transient-error retry override (issue #111). A
+     * {@link RetryPolicy} replaces the global policy for this call; `false` disables
+     * retry for this call. Omit to use the configured (or built-in default) policy.
+     */
+    retry?: RetryOverride;
+}
+interface UpdateOptions<T = unknown> {
+    condition?: WriteCondition<T>;
+    /**
+     * Per-call throttle / transient-error retry override (issue #111). A
+     * {@link RetryPolicy} replaces the global policy for this call; `false` disables
+     * retry for this call.
+     */
+    retry?: RetryOverride;
+    /**
+     * How to re-derive a GSI key whose composing fields are changed but **not all**
+     * available from `{ ...key, ...changes }` (issue #115).
+     *
+     * - **unset (default)** — refuse with an explicit error rather than let the
+     *   index silently rot. The error names the index, the changed field, and the
+     *   missing field(s). The happy path (all composing fields available) re-derives
+     *   in the SAME `UpdateExpression` and is unaffected by this option.
+     * - `'read-modify-write'` — read the current item, merge `{ ...item, ...changes }`,
+     *   re-derive every affected GSI key from the merged image, and write back under
+     *   an optimistic condition (the item must still exist / be unchanged). This costs
+     *   one extra read and is NOT atomic with the original update, but always re-derives
+     *   correctly.
+     */
+    rederive?: 'read-modify-write';
+}
+interface DeleteOptions<T = unknown> {
+    condition?: WriteCondition<T>;
+    /**
+     * Per-call throttle / transient-error retry override (issue #111). A
+     * {@link RetryPolicy} replaces the global policy for this call; `false` disables
+     * retry for this call.
+     */
+    retry?: RetryOverride;
+}
+
+interface PutInput {
+    TableName: string;
+    Item: Record<string, unknown>;
+    ConditionExpression?: string;
+    ExpressionAttributeNames?: Record<string, string>;
+    ExpressionAttributeValues?: Record<string, unknown>;
 }
+declare function buildPutInput(modelClass: Function, item: Record<string, unknown>, options?: PutOptions): PutInput;
+declare function executePut(modelClass: Function, item: Record<string, unknown>, options?: PutOptions): Promise<void>;
 
 type TransactWriteItemInput = {
     Put: PutInput;
@@ -4266,6 +4439,14 @@ type WriteEnvelope = Record<string, InProcessWriteDescriptor>;
 /** Options for {@link executeWriteEnvelope}. */
 interface MutateOptions {
     readonly mode?: MutateMode;
+    /**
+     * Per-call throttle / transient-error retry override (issue #111), applied to
+     * every write this envelope composes (the atomic `TransactWriteItems` in
+     * `transaction` mode, or each op's send in `parallel` mode). A {@link RetryPolicy}
+     * overrides the global policy; `false` disables retry. Omit ⇒ the configured /
+     * built-in default policy.
+     */
+    readonly retry?: RetryOverride;
 }
 /** A per-alias result in `parallel` mode: success carries the read-back, else error. */
 type ParallelOpResult = {
@@ -4345,8 +4526,28 @@ type MutateParallelResult<E extends WriteEnvelope> = {
 declare abstract class DDBModel {
     /** @internal Type brand — prevents primitives from structurally matching DDBModel. */
     private readonly __brand;
+    /**
+     * Register the `DynamoDBClient` GraphDDB sends through.
+     *
+     * IMPORTANT (issue #111): GraphDDB now owns single-op throttle / transient-error
+     * retry (see {@link setRetryPolicy}), so a client left at the AWS SDK default
+     * `maxAttempts: 3` retries MULTIPLICATIVELY underneath the library. Construct the
+     * client with `maxAttempts: 1` so the library is the single source of truth for
+     * retry — e.g. `new DynamoDBClient({ maxAttempts: 1 })`. GraphDDB does NOT mutate
+     * a client you pass in.
+     */
     static setClient(client: DynamoDBClient): void;
     static setTableMapping(mapping: Record<string, string>): void;
+    /**
+     * Configure the global single-op retry policy (issue #111) — exponential backoff
+     * + jitter with a bounded attempt cap, applied to every GetItem / Query / Put /
+     * Update / Delete / relation-fan-out send and to `TransactWriteItems`. Mirrors
+     * {@link setClient} / {@link setTableMapping}. A sensible default is ALWAYS on; call
+     * this only to tune it (or pass `null` to restore the default). A per-call
+     * `retry?: RetryPolicy | false` on an operation's options overrides this globally
+     * for that call (`false` disables retry).
+     */
+    static setRetryPolicy(policy: RetryPolicy | null): void;
     static transaction(fn: (tx: TransactionContext) => void | Promise<void>): Promise<void>;
     /**
      * In-process multi-route READ (issue #101 — the unified envelope). Each alias
@@ -4619,4 +4820,4 @@ interface CdcEmulatorOptions {
 }
 type ShardId = string;
 
-export { type AnyOperationDefinition as $, type StrictSelectSpec as A, type BatchGetExecInput as B, type ChangeEvent as C, type DynamoDBOperation as D, type Executor as E, type FaultSpec as F, type EntityInput as G, type UniqueQueryKeyOf as H, type EntityRef as I, type ConditionInput as J, type QueryMethodSpec as K, type CommandModelContract as L, type ModelStatic as M, type CommandMethodSpec as N, type OperationDefinition as O, type PutInput as P, type QueryModelContract as Q, type RawCondition as R, type SelectableOf as S, type TransactWriteExecItem as T, type UpdateInput as U, type ContractSpec as V, type WriteExecOptions as W, type QuerySpec as X, type CommandSpec as Y, type ContextSpec as Z, type OperationsDocument as _, type ExecutorResult as a, type InProcessWriteDescriptor as a$, type BridgeBundle as a0, type ConditionSpec as a1, type BatchDeleteRequest as a2, type BatchGetRequest as a3, BatchGetResult as a4, type BatchPutRequest as a5, type BatchResult as a6, type BatchWriteRequest as a7, CONTRACT_RANGE_FANOUT_CONCURRENCY as a8, type CdcMode as a9, type ContractKeyInput as aA, type ContractKeyRef as aB, type ContractKeySpec as aC, type ContractKind as aD, type ContractMethodOp as aE, type ContractParamRef as aF, type ContractQueryParams as aG, type ContractResolution as aH, type DeleteOptions as aI, type DeriveEffect as aJ, type DerivedEdgeWrite as aK, type DerivedUpdate as aL, type DescriptorBinding as aM, ENTITY_WRITES_MARKER as aN, type EdgeEffect as aO, type EffectPath as aP, type EmitEffect as aQ, type EntityWritesDefinition as aR, type EntityWritesShape as aS, type ExecutableCommandContract as aT, type ExecutableQueryContract as aU, type FilterInput as aV, type FilterSpec as aW, type FragmentInput as aX, type GsiDefinitionMarker as aY, type GsiOptions as aZ, type IdempotencyEffect as a_, type ChangeBatch as aa, type ChangeEventName as ab, type ClockMode as ac, type Column as ad, type ColumnMap as ae, type CommandContractMethodSpec as af, type CommandInputShape as ag, type CommandMethod as ah, type CommandPlan as ai, type CommandResolutionTarget as aj, type CommandResultKind as ak, type CommandSelectShape as al, type CompiledFragment as am, type ComposeSpec as an, type CondSlot as ao, type ConditionCheckInput as ap, type Connection as aq, type ContractCallSignature as ar, type ContractCardinality as as, type ContractCommandParams as at, type ContractCommandResult as au, type ContractComposeNode as av, type ContractFromRef as aw, type ContractInputArity as ax, type ContractItem as ay, type ContractKeyFieldRef as az, type WriteResult as b, type UniqueEffect as b$, type InputArity as b0, type KeyDefinitionMarker as b1, type KeySegment as b2, type KeySlot as b3, type KeyStructure as b4, type KeyedResult as b5, LIFECYCLE_CONTRACT_MARKER as b6, type LifecycleContract as b7, type LifecycleEffects as b8, type LiteralParam as b9, type PutOptions as bA, type QueryContractMethodSpec as bB, type QueryEnvelopeResult as bC, type QueryKeyOf as bD, type QueryMethod as bE, type QueryResult as bF, type RangeConditionSpec as bG, type ReadEnvelope as bH, type ReadOperationType as bI, type ReadRouteDescriptor as bJ, type ReadRouteOptions as bK, type ReadRouteResult as bL, type RecordedCompose as bM, type RelationBuilder as bN, type RelationSelect as bO, type RelationSpec as bP, type RequiresEffect as bQ, type Resolution as bR, SPEC_VERSION as bS, type SegmentSpec as bT, type SelectBuilder as bU, type SelectOf as bV, type StartingPosition as bW, type StreamViewType as bX, type StringParam as bY, TransactionContext as bZ, type TransactionItemType as b_, type ManifestEntity as ba, type ManifestField as bb, type ManifestFieldType as bc, type ManifestGsi as bd, type ManifestKey as be, type ManifestRelation as bf, type ManifestTable as bg, type ModelRef as bh, type MutateMode as bi, type MutateOptions as bj, type MutateParallelResult as bk, type MutateTransactionResult as bl, type MutationBody as bm, type MutationDescriptorMap as bn, type MutationFragment as bo, type MutationInputProxy as bp, type MutationInputRef as bq, type MutationIntent as br, type NumberParam as bs, type OperationKind as bt, type OperationSpec as bu, type ParallelOpResult as bv, type ParamKind as bw, type ParamSpec as bx, type ParamStructure as by, type PlannedCommandMethod as bz, type DeleteInput as c, type Updatable as c0, type UpdateOptions as c1, type WhenSpec as c2, type WriteDescriptor as c3, type WriteEnvelope as c4, type WriteLifecyclePhase as c5, type WriteOperationType as c6, type WriteRecorder as c7, type WriteResultProjection as c8, attachModelClass as c9, isContractComposeNode as cA, isContractFromRef as cB, isContractKeyFieldRef as cC, isContractKeyRef as cD, isContractParamRef as cE, isEntityWritesDefinition as cF, isKeySegment as cG, isLifecycleContract as cH, isMutationFragment as cI, isMutationInputRef as cJ, isParam as cK, isPlannedCommandMethod as cL, isQueryModelContract as cM, k as cN, key as cO, lifecyclePhaseForIntent as cP, mintContractKeyFieldRef as cQ, mintContractParamRef as cR, mutation as cS, param as cT, publicCommandModel as cU, publicQueryModel as cV, query as cW, resolveLifecycle as cX, wholeKeysSentinel as cY, buildDeleteInput as ca, buildPutInput as cb, buildUpdateInput as cc, compileFragment as cd, compileMutationPlan as ce, compileSingleFragmentPlan as cf, cond as cg, contractOfMethodSpec as ch, definePlan as ci, entityWrites as cj, executeBatchGet as ck, executeBatchWrite as cl, executeCommandMethod as cm, executeDelete as cn, executeKeyedBatchGet as co, executePut as cp, executeQueryMethod as cq, executeRangeFanout as cr, executeTransaction as cs, executeUpdate as ct, from as cu, getEntityWrites as cv, gsi as cw, isColumn as cx, isCommandModelContract as cy, isCommandPlan as cz, type BatchWriteExecItem as d, DDBModel as e, type PrimaryKeyOf as f, type ExecutionPlanSpec as g, type SegmentedKey as h, type SelectBuilderSpec as i, type TransactionSpec as j, type Manifest as k, type ExecutionPlan as l, type ResolvedKey as m, type CdcEmulatorOptions as n, type ChangeHandler as o, type Unsubscribe as p, type ConcurrentRecomputeRef as q, type EventLog as r, type ReplayOptions as s, type ShardId as t, type TransactionItemSpec as u, type Param as v, type ParamDescriptor as w, type DefinitionMap as x, type WriteDefinitionOptions as y, type PartialQueryKeyOf as z };
+export { type QuerySpec as $, type ParamDescriptor as A, type BatchGetExecInput as B, type ChangeEvent as C, type DynamoDBOperation as D, type Executor as E, type FaultSpec as F, type DefinitionMap as G, type WriteDefinitionOptions as H, type PartialQueryKeyOf as I, type StrictSelectSpec as J, type EntityInput as K, type UniqueQueryKeyOf as L, type ModelStatic as M, type EntityRef as N, type OperationDefinition as O, type PutInput as P, type ConditionInput as Q, type ReadExecOptions as R, type SelectableOf as S, type TransactWriteExecItem as T, type UpdateInput as U, type QueryModelContract as V, type WriteExecOptions as W, type QueryMethodSpec as X, type CommandModelContract as Y, type CommandMethodSpec as Z, type ContractSpec as _, type ExecutorResult as a, type FilterInput as a$, type CommandSpec as a0, type ContextSpec as a1, type OperationsDocument as a2, type AnyOperationDefinition as a3, type BridgeBundle as a4, type ConditionSpec as a5, type BatchDeleteRequest as a6, type BatchGetRequest as a7, BatchGetResult as a8, type BatchPutRequest as a9, type ContractFromRef as aA, type ContractInputArity as aB, type ContractItem as aC, type ContractKeyFieldRef as aD, type ContractKeyInput as aE, type ContractKeyRef as aF, type ContractKeySpec as aG, type ContractKind as aH, type ContractMethodOp as aI, type ContractParamRef as aJ, type ContractQueryParams as aK, type ContractResolution as aL, DEFAULT_MAX_ATTEMPTS as aM, DEFAULT_RETRY_POLICY as aN, type DeleteOptions as aO, type DeriveEffect as aP, type DerivedEdgeWrite as aQ, type DerivedUpdate as aR, type DescriptorBinding as aS, ENTITY_WRITES_MARKER as aT, type EdgeEffect as aU, type EffectPath as aV, type EmitEffect as aW, type EntityWritesDefinition as aX, type EntityWritesShape as aY, type ExecutableCommandContract as aZ, type ExecutableQueryContract as a_, type BatchResult as aa, type BatchWriteRequest as ab, CONTRACT_RANGE_FANOUT_CONCURRENCY as ac, type CdcMode as ad, type ChangeBatch as ae, type ChangeEventName as af, type ClockMode as ag, type Column as ah, type ColumnMap as ai, type CommandContractMethodSpec as aj, type CommandInputShape as ak, type CommandMethod as al, type CommandPlan as am, type CommandResolutionTarget as an, type CommandResultKind as ao, type CommandSelectShape as ap, type CompiledFragment as aq, type ComposeSpec as ar, type CondSlot as as, type ConditionCheckInput as at, type Connection as au, type ContractCallSignature as av, type ContractCardinality as aw, type ContractCommandParams as ax, type ContractCommandResult as ay, type ContractComposeNode as az, type WriteResult as b, type SegmentSpec as b$, type FilterSpec as b0, type FragmentInput as b1, type GsiDefinitionMarker as b2, type GsiOptions as b3, type IdempotencyEffect as b4, type InProcessWriteDescriptor as b5, type InputArity as b6, type KeyDefinitionMarker as b7, type KeySegment as b8, type KeySlot as b9, type OperationSpec as bA, type ParallelOpResult as bB, type ParamKind as bC, type ParamSpec as bD, type ParamStructure as bE, type PlannedCommandMethod as bF, type PutOptions as bG, type QueryContractMethodSpec as bH, type QueryEnvelopeResult as bI, type QueryKeyOf as bJ, type QueryMethod as bK, type QueryResult as bL, type RangeConditionSpec as bM, type ReadEnvelope as bN, type ReadOperationType as bO, type ReadRouteDescriptor as bP, type ReadRouteOptions as bQ, type ReadRouteResult as bR, type RecordedCompose as bS, type RelationBuilder as bT, type RelationSelect as bU, type RelationSpec as bV, type RequiresEffect as bW, type Resolution as bX, type RetryInfo as bY, type RetryOperationKind as bZ, SPEC_VERSION as b_, type KeyStructure as ba, type KeyedResult as bb, LIFECYCLE_CONTRACT_MARKER as bc, type LifecycleContract as bd, type LifecycleEffects as be, type LiteralParam as bf, type ManifestEntity as bg, type ManifestField as bh, type ManifestFieldType as bi, type ManifestGsi as bj, type ManifestKey as bk, type ManifestRelation as bl, type ManifestTable as bm, type ModelRef as bn, type MutateMode as bo, type MutateOptions as bp, type MutateParallelResult as bq, type MutateTransactionResult as br, type MutationBody as bs, type MutationDescriptorMap as bt, type MutationFragment as bu, type MutationInputProxy as bv, type MutationInputRef as bw, type MutationIntent as bx, type NumberParam as by, type OperationKind as bz, type DeleteInput as c, mintContractParamRef as c$, type SelectBuilder as c0, type SelectOf as c1, type StartingPosition as c2, type StreamViewType as c3, type StringParam as c4, TransactionContext as c5, type TransactionItemType as c6, type UniqueEffect as c7, type Updatable as c8, type UpdateOptions as c9, executeTransaction as cA, executeUpdate as cB, from as cC, getEntityWrites as cD, gsi as cE, isColumn as cF, isCommandModelContract as cG, isCommandPlan as cH, isContractComposeNode as cI, isContractFromRef as cJ, isContractKeyFieldRef as cK, isContractKeyRef as cL, isContractParamRef as cM, isEntityWritesDefinition as cN, isKeySegment as cO, isLifecycleContract as cP, isMutationFragment as cQ, isMutationInputRef as cR, isParam as cS, isPlannedCommandMethod as cT, isQueryModelContract as cU, isRetryableError as cV, isRetryableTransactionCancellation as cW, k as cX, key as cY, lifecyclePhaseForIntent as cZ, mintContractKeyFieldRef as c_, type WhenSpec as ca, type WriteDescriptor as cb, type WriteEnvelope as cc, type WriteLifecyclePhase as cd, type WriteOperationType as ce, type WriteRecorder as cf, type WriteResultProjection as cg, attachModelClass as ch, buildDeleteInput as ci, buildPutInput as cj, buildUpdateInput as ck, compileFragment as cl, compileMutationPlan as cm, compileSingleFragmentPlan as cn, cond as co, contractOfMethodSpec as cp, definePlan as cq, entityWrites as cr, executeBatchGet as cs, executeBatchWrite as ct, executeCommandMethod as cu, executeDelete as cv, executeKeyedBatchGet as cw, executePut as cx, executeQueryMethod as cy, executeRangeFanout as cz, type BatchWriteExecItem as d, mutation as d0, param as d1, publicCommandModel as d2, publicQueryModel as d3, query as d4, resolveLifecycle as d5, wholeKeysSentinel as d6, type BatchExecOptions as e, DDBModel as f, type PrimaryKeyOf as g, type RetryPolicy as h, type ExecutionPlanSpec as i, type SegmentedKey as j, type SelectBuilderSpec as k, type RawCondition as l, type TransactionSpec as m, type Manifest as n, type RetryOverride as o, type ExecutionPlan as p, type ResolvedKey as q, type CdcEmulatorOptions as r, type ChangeHandler as s, type Unsubscribe as t, type ConcurrentRecomputeRef as u, type EventLog as v, type ReplayOptions as w, type ShardId as x, type TransactionItemSpec as y, type Param as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphddb",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Graph data modeling on DynamoDB with adjacency list pattern",
   "type": "module",
   "main": "dist/index.js",