@mshick/dyno 0.1.0

package/dist/requests/send-completely.js

@@ -0,0 +1,231 @@
+import createDebug from 'debug';
+import fastq from 'fastq';
+import { calculateDelay, delay, ensureError, reduceCapacity } from "../util.js";
+const log = createDebug('dyno-requests');
+/**
+ * Compacts results, removing the often redundant table name key
+ */
+function compactSendCompletely(data) {
+    if ('Responses' in data) {
+        const responses = data.Responses;
+        data.Responses = responses
+            ? Object.values(responses)[0]
+            : responses;
+    }
+    if ('UnprocessedKeys' in data) {
+        const unprocessed = data.UnprocessedKeys;
+        data.UnprocessedKeys = unprocessed
+            ? Object.values(unprocessed)[0]
+            : unprocessed;
+    }
+    if ('UnprocessedItems' in data) {
+        const unprocessed = data.UnprocessedItems;
+        data.UnprocessedItems = unprocessed
+            ? Object.values(unprocessed)[0]
+            : unprocessed;
+    }
+    return data;
+}
+function _sendCompletely(requests, requestFactory, options, callback) {
+    const l = log.extend('sendCompletely');
+    const { concurrency = 1, maxRetries = 5 } = options;
+    l('requests:', requests.length, 'concurrency:', concurrency, 'maxRetries:', maxRetries);
+    const worker = (request, done) => {
+        const result = { error: null, data: {} };
+        let retryCount = 0;
+        const send = async (req) => {
+            const res = await req.send();
+            if (!res.data) {
+                l('send:error', res.error);
+                result.error = res.error;
+                return result;
+            }
+            if ('Responses' in res.data) {
+                if (res.data.Responses) {
+                    result.data.Responses ??= {};
+                    const responses = result.data.Responses;
+                    for (const [table, item] of Object.entries(res.data.Responses)) {
+                        responses[table] ??= [];
+                        const bucket = responses[table];
+                        for (const r of item) {
+                            bucket.push(r);
+                        }
+                    }
+                }
+            }
+            if (res.data.ConsumedCapacity) {
+                result.data.ConsumedCapacity = reduceCapacity(result.data.ConsumedCapacity ?? {}, res.data.ConsumedCapacity);
+            }
+            let retry;
+            if ('UnprocessedItems' in res.data) {
+                if (res.data.UnprocessedItems && Object.keys(res.data.UnprocessedItems).length) {
+                    retry = requestFactory({
+                        RequestItems: res.data.UnprocessedItems,
+                        ReturnConsumedCapacity: req.params.ReturnConsumedCapacity,
+                    });
+                }
+            }
+            if ('UnprocessedKeys' in res.data) {
+                if (res.data.UnprocessedKeys && Object.keys(res.data.UnprocessedKeys).length) {
+                    retry = requestFactory({
+                        RequestItems: res.data.UnprocessedKeys,
+                        ReturnConsumedCapacity: req.params.ReturnConsumedCapacity,
+                    });
+                }
+            }
+            if (retry && retryCount < maxRetries) {
+                l('send:retry', retryCount);
+                await delay(calculateDelay(retryCount));
+                retryCount += 1;
+                return send(retry);
+            }
+            if ('UnprocessedKeys' in res.data) {
+                if (res.data.UnprocessedKeys) {
+                    result.data.UnprocessedKeys ??= {};
+                    const unprocessedKeys = result.data.UnprocessedKeys;
+                    for (const [table, item] of Object.entries(res.data.UnprocessedKeys)) {
+                        unprocessedKeys[table] ??= { Keys: [] };
+                        const bucket = unprocessedKeys[table];
+                        bucket.Keys ??= [];
+                        for (const r of item.Keys ?? []) {
+                            bucket.Keys.push(r);
+                        }
+                    }
+                }
+            }
+            if ('UnprocessedItems' in res.data) {
+                if (res.data.UnprocessedItems) {
+                    result.data.UnprocessedItems ??= {};
+                    const unprocessedItems = result.data.UnprocessedItems;
+                    for (const [table, items] of Object.entries(res.data.UnprocessedItems)) {
+                        unprocessedItems[table] ??= [];
+                        const bucket = unprocessedItems[table];
+                        for (const r of items) {
+                            bucket.push(r);
+                        }
+                    }
+                }
+            }
+            return result;
+        };
+        void send(request)
+            .then((res) => {
+            done(null, res);
+        })
+            .catch((err) => {
+            result.error = ensureError(err);
+            done(null, result);
+        });
+    };
+    const drain = (results) => {
+        return () => {
+            l('drain:results', results.length);
+            const errors = [];
+            const data = {};
+            if (results.length) {
+                for (const res of results) {
+                    if (res.error) {
+                        errors.push(res.error);
+                    }
+                    if (!res.data) {
+                        continue;
+                    }
+                    if ('Responses' in res.data) {
+                        if (res.data.Responses) {
+                            data.Responses ??= {};
+                            const responses = data.Responses;
+                            for (const [table, response] of Object.entries(res.data.Responses)) {
+                                responses[table] ??= [];
+                                const bucket = responses[table];
+                                for (const r of response) {
+                                    bucket.push(r);
+                                }
+                            }
+                        }
+                    }
+                    if ('UnprocessedItems' in res.data) {
+                        if (res.data.UnprocessedItems && Object.keys(res.data.UnprocessedItems ?? {}).length) {
+                            data.UnprocessedItems ??= {};
+                            const unprocessedItems = data.UnprocessedItems;
+                            for (const [table, items] of Object.entries(res.data.UnprocessedItems)) {
+                                unprocessedItems[table] ??= [];
+                                const bucket = unprocessedItems[table];
+                                for (const r of items) {
+                                    bucket.push(r);
+                                }
+                            }
+                        }
+                    }
+                    if ('UnprocessedKeys' in res.data) {
+                        if (res.data.UnprocessedKeys && Object.keys(res.data.UnprocessedKeys ?? {}).length) {
+                            data.UnprocessedKeys ??= {};
+                            const unprocessedKeys = data.UnprocessedKeys;
+                            for (const [table, items] of Object.entries(res.data.UnprocessedKeys)) {
+                                unprocessedKeys[table] ??= { Keys: [] };
+                                const bucket = unprocessedKeys[table];
+                                bucket.Keys ??= [];
+                                for (const r of items.Keys ?? []) {
+                                    bucket.Keys.push(r);
+                                }
+                            }
+                        }
+                    }
+                    if (res.data.ConsumedCapacity) {
+                        data.ConsumedCapacity = reduceCapacity(data.ConsumedCapacity ?? {}, res.data.ConsumedCapacity);
+                    }
+                }
+            }
+            if (options.compact === true) {
+                callback(errors.length ? new AggregateError(errors, 'SendCompletely batch error') : undefined, compactSendCompletely(data));
+                return;
+            }
+            callback(errors.length ? new AggregateError(errors, 'SendCompletely batch error') : undefined, data);
+        };
+    };
+    const q = fastq(worker, concurrency);
+    const results = [];
+    q.drain = drain(results);
+    for (const req of requests) {
+        q.push(req, (_err, res) => {
+            if (res) {
+                results.push(res);
+            }
+        });
+    }
+}
+async function _sendCompletelyAsync(requests, requestFactory, options) {
+    return new Promise((resolve) => {
+        _sendCompletely(requests, requestFactory, options, (error, data) => {
+            resolve({ error, data });
+        });
+    });
+}
+export class SendCompletelyBatch {
+    requestFactory;
+    items;
+    options;
+    requests;
+    constructor(requestFactory, items, options) {
+        this.requestFactory = requestFactory;
+        this.items = items;
+        this.options = options;
+        this.requests = items.map((params) => requestFactory(params));
+    }
+    load(items) {
+        return new SendCompletelyBatch(this.requestFactory, items, this.options);
+    }
+    sendAll(optionsOrCb, cb) {
+        if (typeof optionsOrCb === 'function') {
+            _sendCompletely(this.requests, this.requestFactory, this.options, optionsOrCb);
+        }
+        else if (typeof cb === 'function') {
+            _sendCompletely(this.requests, this.requestFactory, { ...this.options, ...optionsOrCb }, cb);
+        }
+        else {
+            return _sendCompletelyAsync(this.requests, this.requestFactory, {
+                ...this.options,
+                ...optionsOrCb,
+            });
+        }
+    }
+}

package/dist/requests/types.d.ts

@@ -0,0 +1,32 @@
+import type { ConsumedCapacity } from '@aws-sdk/client-dynamodb';
+import type { BatchGetCommandInput, BatchGetCommandOutput, BatchWriteCommandInput, BatchWriteCommandOutput } from '@aws-sdk/lib-dynamodb';
+import type { NativeAttributeValue } from '@aws-sdk/util-dynamodb';
+import type { NativeAttributeMap } from '../types.ts';
+export type BatchCommandInput = BatchGetCommandInput | BatchWriteCommandInput;
+export type BatchCommandOutput = BatchGetCommandOutput | BatchWriteCommandOutput;
+export type FetcherResponse<T extends BatchCommandOutput> = {
+    data: T;
+    error?: undefined;
+} | {
+    error: unknown;
+    data?: undefined;
+};
+export type Fetcher<T extends BatchCommandInput> = {
+    params: T;
+    send: () => Promise<FetcherResponse<T extends BatchGetCommandInput ? BatchGetCommandOutput : BatchWriteCommandOutput>>;
+};
+export type BatchResult = {
+    error?: unknown;
+    data: {
+        Responses?: Record<string, Array<Record<string, NativeAttributeValue>>>;
+        ConsumedCapacity?: ConsumedCapacity;
+        UnprocessedKeys?: Record<string, {
+            Keys: NativeAttributeMap[];
+        }>;
+        UnprocessedItems?: Record<string, NativeAttributeMap[]>;
+    };
+};
+export type RequestFactory<U extends BatchCommandInput> = (params: U) => Fetcher<U>;
+export type CompactOptions = {
+    compact?: boolean;
+};

package/dist/requests/types.js

@@ -0,0 +1 @@
+export {};

package/dist/responses.d.ts

@@ -0,0 +1,11 @@
+import type { BatchGetCommandOutput, GetCommandOutput, QueryCommandOutput, ScanCommandOutput } from '@aws-sdk/lib-dynamodb';
+export type ParseResponseOptions = {
+    /**
+     * Set to true to _not_ upgrade Uint8Arrays in responses to Buffers.
+     */
+    noBuffers?: boolean;
+};
+/**
+ * Parse the items in a variety of responses. Converts Uint8Arrays to Buffers. Mutates response items.
+ */
+export declare function parseResponse<T extends Pick<GetCommandOutput, 'Item'> | Pick<ScanCommandOutput, 'Items'> | Pick<QueryCommandOutput, 'Items'> | Pick<BatchGetCommandOutput, 'Responses'>>(response: T, options: ParseResponseOptions): T;

package/dist/responses.js

@@ -0,0 +1,47 @@
+import isPlainObject from 'lodash/isPlainObject.js';
+function restoreItemBuffers(item) {
+    for (const [k, v] of Object.entries(item)) {
+        if (isPlainObject(v)) {
+            restoreItemBuffers(v);
+            continue;
+        }
+        if (Array.isArray(v)) {
+            for (const vv of v) {
+                if (isPlainObject(vv)) {
+                    restoreItemBuffers(vv);
+                }
+            }
+            continue;
+        }
+        if (v instanceof Uint8Array) {
+            item[k] = Buffer.from(v);
+        }
+    }
+    return item;
+}
+/**
+ * Parse the items in a variety of responses. Converts Uint8Arrays to Buffers. Mutates response items.
+ */
+export function parseResponse(response, options) {
+    if (options.noBuffers) {
+        return response;
+    }
+    if ('Item' in response) {
+        if (response.Item) {
+            restoreItemBuffers(response.Item);
+        }
+    }
+    if ('Items' in response) {
+        if (response.Items) {
+            response.Items.forEach(restoreItemBuffers);
+        }
+    }
+    if ('Responses' in response) {
+        if (response.Responses) {
+            for (const items of Object.values(response.Responses)) {
+                items.forEach(restoreItemBuffers);
+            }
+        }
+    }
+    return response;
+}

package/dist/stream.d.ts

@@ -0,0 +1,44 @@
+import type { ReadableOptions } from 'node:stream';
+import { type BatchWriteCommandInput, type DynamoDBDocument, type QueryCommandInput, type QueryCommandOutput, type ScanCommandInput, type ScanCommandOutput } from '@aws-sdk/lib-dynamodb';
+import { type ParseResponseOptions } from './responses.ts';
+import { DynoReadableStream } from './streams/dyno-readable-stream.ts';
+import { DynoWritableStream } from './streams/dyno-writable-stream.ts';
+import type { ParallelWritableOptions } from './streams/parallel-writable.ts';
+export type ScanInput = Omit<ScanCommandInput, 'TableName'> & {
+    TableName: string;
+    /**
+     * Maximum number of pages of scan results to request. Set to `Infinity` to return all available data.
+     */
+    Pages?: number;
+};
+export type ScanOutput = Omit<ScanCommandOutput, '$metadata'>;
+export type QueryInput = Omit<QueryCommandInput, 'TableName'> & {
+    TableName: string;
+    /**
+     * Maximum number of pages of scan results to request. Set to `Infinity` to return all available data.
+     */
+    Pages?: number;
+};
+export type QueryOutput = Omit<QueryCommandOutput, '$metadata'>;
+export type ReadStreamOptions = ReadableOptions & ParseResponseOptions & {
+    mode?: 'scan' | 'query';
+    pageSize?: number;
+};
+/**
+ * Create a scan stream, reading the whole table unless limited.
+ */
+export declare function createReadStream(client: DynamoDBDocument, { TableName, Pages, Limit, ExclusiveStartKey, ...commandInput }: ScanInput | QueryInput, { mode, pageSize, noBuffers, ...readableOptions }?: ReadStreamOptions): DynoReadableStream;
+export type PutStreamInput = Omit<BatchWriteCommandInput, 'TableName' | 'RequestItems'> & {
+    TableName: string;
+};
+export type PutStreamOptions = ParallelWritableOptions & {
+    pageSize?: number;
+    maxRetries?: number;
+    maxBatchSize?: number;
+    docMode?: boolean;
+};
+/**
+ * Create a put stream, writing batches to DynamoDB with support for valid
+ * request size checking. Supports parallel writes and delayed retry of unprocessed items.
+ */
+export declare function createPutStream(client: DynamoDBDocument, commandInput: PutStreamInput, { concurrency, pageSize, maxRetries, maxBatchSize, ...writableOptions }?: PutStreamOptions): DynoWritableStream;

package/dist/stream.js

@@ -0,0 +1,205 @@
+import assert from 'node:assert';
+import { BatchWriteCommand, QueryCommand, ScanCommand, } from '@aws-sdk/lib-dynamodb';
+import { isThrottlingError } from '@smithy/service-error-classification';
+import createDebug from 'debug';
+import { parseResponse } from "./responses.js";
+import { DynoReadableStream } from "./streams/dyno-readable-stream.js";
+import { DynoWritableStream } from "./streams/dyno-writable-stream.js";
+import { calculateDelay, getItemSize } from "./util.js";
+const log = createDebug('dyno-stream');
+const logRead = log.extend('read');
+const logPut = log.extend('put');
+function getLimit(limit, pageSize) {
+    if (limit !== undefined && pageSize !== undefined) {
+        return Math.min(limit, pageSize);
+    }
+    return limit ?? pageSize;
+}
+/**
+ * Create a scan stream, reading the whole table unless limited.
+ */
+export function createReadStream(client, { TableName, Pages = Number.POSITIVE_INFINITY, Limit, ExclusiveStartKey, ...commandInput }, { mode = 'scan', pageSize, noBuffers, ...readableOptions } = {}) {
+    logRead('createReadStream');
+    assert(Pages > 0, 'Pages must be an integer greater than 0');
+    let pending = false;
+    let items = [];
+    function push() {
+        logRead('push', 'items:', items.length);
+        let status = true;
+        while (status && items.length) {
+            status = readable.push(items.shift());
+        }
+        return status;
+    }
+    function finish() {
+        logRead('finish', 'count:', readable.Count, 'scanned:', readable.ScannedCount, 'readableLength:', readable.readableLength, 'highWater:', readable.readableHighWaterMark);
+        readable.push(null);
+    }
+    function request(nextLimit) {
+        logRead('request', 'limit:', nextLimit);
+        pending = true;
+        let command;
+        if (mode === 'scan') {
+            command = new ScanCommand({
+                ...commandInput,
+                TableName,
+                ExclusiveStartKey: readable.LastEvaluatedKey,
+                Limit: getLimit(pageSize, nextLimit),
+            });
+        }
+        else {
+            command = new QueryCommand({
+                ...commandInput,
+                TableName,
+                ExclusiveStartKey: readable.LastEvaluatedKey,
+                Limit: getLimit(pageSize, nextLimit),
+            });
+        }
+        logRead('sending command input:', command.input);
+        client.send(command, (error, response) => {
+            logRead('got response');
+            pending = false;
+            if (error) {
+                logRead('error', { error, response });
+                readable.emit('error', error);
+                return;
+            }
+            if (!response) {
+                logRead('empty');
+                readable.update();
+                read();
+                return;
+            }
+            parseResponse(response, { noBuffers });
+            if (response.Items) {
+                items = [...response.Items];
+            }
+            readable.update(response);
+            if (readable.hasNextPage()) {
+                logRead('has another page');
+                read();
+                return;
+            }
+            read();
+        });
+    }
+    function read() {
+        logRead('read', 'pending:', pending, 'items:', items.length);
+        /**
+         * If status is false, highwater mark has been reached and we should not
+         * push more data until `read` is called again.
+         */
+        const status = push();
+        if (items.length) {
+            return;
+        }
+        const nextLimit = readable.getNextLimit();
+        if (readable.isLastPage() || (nextLimit !== undefined && nextLimit <= 0)) {
+            finish();
+            return;
+        }
+        if (status && !pending) {
+            request(nextLimit);
+        }
+    }
+    const readable = new DynoReadableStream({ objectMode: true, read, ...readableOptions }, { TableName, LastEvaluatedKey: ExclusiveStartKey, Limit, Pages });
+    return readable;
+}
+/**
+ * Create a put stream, writing batches to DynamoDB with support for valid
+ * request size checking. Supports parallel writes and delayed retry of unprocessed items.
+ */
+export function createPutStream(client, commandInput, { concurrency = 5, pageSize = 25, maxRetries = 5, maxBatchSize = 16 * 1024 * 1024, ...writableOptions } = {}) {
+    const { TableName } = commandInput;
+    let pageItems = [];
+    let pageItemsSize = 0;
+    const resetPageItems = () => {
+        pageItemsSize = 0;
+        pageItems = [];
+    };
+    const pushPageItem = (item, itemSize) => {
+        pageItemsSize += itemSize;
+        pageItems.push({ PutRequest: { Item: item } });
+    };
+    function write(item, _encoding, callback) {
+        const nextItemSize = getItemSize(item);
+        const nextPageItemsSize = pageItemsSize + nextItemSize;
+        // If adding the next item pushes the batch over the limit, write and push onto the next page
+        if (nextPageItemsSize > maxBatchSize) {
+            logPut('write - writing page', { maxBatchSize, nextPageItemsSize });
+            writePage(pageItems, 0, callback);
+            resetPageItems();
+            pushPageItem(item, nextItemSize);
+            return;
+        }
+        pushPageItem(item, nextItemSize);
+        // If the page size is hit, write
+        if (pageItems.length === pageSize) {
+            logPut('write - writing page', {
+                pageSize,
+                pageItemsLength: pageItems.length,
+            });
+            writePage(pageItems, 0, callback);
+            resetPageItems();
+            return;
+        }
+        callback();
+    }
+    function _done(callback) {
+        return (error) => {
+            writable.done();
+            callback(error);
+        };
+    }
+    function final(callback) {
+        const done = _done(callback);
+        if (!pageItems.length) {
+            done();
+            return;
+        }
+        logPut('final - writing page', { pageItemsLength: pageItems.length });
+        writePage(pageItems, 0, done);
+        pageItems = [];
+    }
+    function writePage(items, retryCount, callback) {
+        const command = new BatchWriteCommand({
+            RequestItems: {
+                [TableName]: items,
+            },
+            ...commandInput,
+        });
+        logPut('sending command', { retryCount });
+        client.send(command, (error, response) => {
+            if (error) {
+                logPut({ error, response });
+            }
+            // In these cases the items were not processed, so retry the items originally provided
+            if (error && isThrottlingError(error) && !response) {
+                setTimeout(() => {
+                    writePage(items, retryCount + 1, callback);
+                }, calculateDelay(retryCount));
+                return;
+            }
+            writable.update(response, items);
+            const writableUnprocessedItems = writable.UnprocessedItems;
+            // If there are any dangling items and retries are left, attempt to process them
+            if (writableUnprocessedItems?.length && retryCount < maxRetries) {
+                const page = writableUnprocessedItems.splice(0, pageSize);
+                setTimeout(() => {
+                    writePage(page, retryCount + 1, callback);
+                }, calculateDelay(retryCount));
+                return;
+            }
+            callback(error);
+        });
+    }
+    const writable = new DynoWritableStream({
+        TableName,
+        concurrency,
+        write,
+        final,
+        objectMode: true,
+        ...writableOptions,
+    });
+    return writable;
+}

package/dist/streams/dyno-readable-stream.d.ts

@@ -0,0 +1,24 @@
+import { Readable, type ReadableOptions } from 'node:stream';
+import type { ConsumedCapacity } from '@aws-sdk/client-dynamodb';
+import type { QueryCommandOutput, ScanCommandOutput } from '@aws-sdk/lib-dynamodb';
+export type DynoReadableStreamOptions = {
+    TableName: string;
+    LastEvaluatedKey?: ScanCommandOutput['LastEvaluatedKey'];
+    Limit?: number;
+    Pages?: number;
+};
+export declare class DynoReadableStream extends Readable {
+    Count: number;
+    ScannedCount: number;
+    LastEvaluatedKey: ScanCommandOutput['LastEvaluatedKey'];
+    ConsumedCapacity?: ConsumedCapacity;
+    Limit: number | undefined;
+    Pages: number;
+    TableName: string;
+    private _updated;
+    constructor(opts: ReadableOptions, dynoOpts: DynoReadableStreamOptions);
+    update(response?: ScanCommandOutput | QueryCommandOutput): void;
+    hasNextPage(): boolean;
+    isLastPage(): boolean;
+    getNextLimit(): number | undefined;
+}

package/dist/streams/dyno-readable-stream.js

@@ -0,0 +1,41 @@
+import { Readable } from 'node:stream';
+import { reduceCapacity } from "../util.js";
+export class DynoReadableStream extends Readable {
+    Count = 0;
+    ScannedCount = 0;
+    LastEvaluatedKey;
+    ConsumedCapacity;
+    Limit;
+    Pages;
+    TableName;
+    _updated = false;
+    constructor(opts, dynoOpts) {
+        super(opts);
+        this.TableName = dynoOpts.TableName;
+        this.Limit = dynoOpts.Limit;
+        this.Pages = dynoOpts.Pages ?? Number.POSITIVE_INFINITY;
+        this.LastEvaluatedKey = dynoOpts.LastEvaluatedKey;
+    }
+    update(response) {
+        this.Count += response?.Count ?? 0;
+        this.ScannedCount += response?.ScannedCount ?? 0;
+        this.LastEvaluatedKey = response?.LastEvaluatedKey;
+        this.ConsumedCapacity = response?.ConsumedCapacity
+            ? reduceCapacity(this.ConsumedCapacity ?? {}, response.ConsumedCapacity)
+            : this.ConsumedCapacity;
+        this.Pages -= 1;
+        this._updated = true;
+    }
+    hasNextPage() {
+        return this._updated ? Boolean(this.LastEvaluatedKey) : true;
+    }
+    isLastPage() {
+        return this._updated && (!this.LastEvaluatedKey || this.Pages <= 0);
+    }
+    getNextLimit() {
+        if (this.Limit === undefined) {
+            return;
+        }
+        return this.Limit - this.Count;
+    }
+}

package/dist/streams/dyno-writable-stream.d.ts

@@ -0,0 +1,18 @@
+import type { ConsumedCapacity } from '@aws-sdk/client-dynamodb';
+import type { BatchWriteCommandInput, BatchWriteCommandOutput } from '@aws-sdk/lib-dynamodb';
+import { ParallelWritable, type ParallelWritableOptions } from './parallel-writable.ts';
+export type BatchWriteRequestItem = NonNullable<BatchWriteCommandInput['RequestItems']>[string][number];
+export type BatchWriteUnprocessedItem = NonNullable<BatchWriteCommandOutput['UnprocessedItems']>[string][number];
+export type DynoWritableStreamOptions = ParallelWritableOptions & {
+    TableName: string;
+};
+export declare class DynoWritableStream extends ParallelWritable {
+    Count: number;
+    UnprocessedItems: BatchWriteUnprocessedItem[] | undefined;
+    ConsumedCapacity?: ConsumedCapacity;
+    TableName: string;
+    private readonly _consumedCapacity;
+    constructor(opts: DynoWritableStreamOptions);
+    update(response: BatchWriteCommandOutput | undefined, items: BatchWriteRequestItem[]): void;
+    done(): void;
+}