@mshick/dyno 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Shick
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# @mshick/dyno
+
+A simple DynamoDB client, inspired by [dyno](https://github.com/mapbox/dyno).
+
+## Install
+
+```sh
+pnpm add @mshick/dyno
+```
+
+## Example
+
+```typescript
+import { Dyno } from '@mshick/dyno';
+
+const table = new Dyno({ table: 'my-table', region: 'us-east-1' });
+
+await table.ensureTable({
+  AttributeDefinitions: [{ AttributeName: 'id', AttributeType: 'S' }],
+  KeySchema: [{ AttributeName: 'id', KeyType: 'HASH' }],
+});
+
+await table.batchPutAll([{ id: 'a' }, { id: 'b' }]).sendAll();
+
+const { Items } = await table.scan({ Pages: Infinity });
+console.log(Items); // [{id: 'a'}, {id: 'b'}]
+```
+
+For supported methods and more examples, see the [`Dyno` tests](./src/__tests__/dyno.test.ts).
+
+## Development
+
+This project uses [pnpm](https://pnpm.io). Tests use a local DynamoDB via
+Docker (`docker-compose.yml`), so make sure Docker is running.
+
+```sh
+pnpm install
+pnpm test          # spins up DynamoDB, runs vitest
+pnpm check         # tsc --noEmit
+pnpm lint          # biome check
+pnpm build         # emits dist/
+```
+
+## Release
+
+Releases are driven by [release-please](https://github.com/googleapis/release-please)
+on the `main` branch. PR titles and the first commit on a branch must follow
+[Conventional Commits](https://www.conventionalcommits.org/) (e.g.
+`feat: add new method`, `fix: handle empty batch`). Subsequent commits on a
+branch can use plain descriptive messages.
+
+## License
+
+[MIT](./LICENSE)

package/dist/client.d.ts

@@ -0,0 +1,4 @@
+import type { DynamoDBClientConfig } from '@aws-sdk/client-dynamodb';
+import type { TranslateConfig } from '@aws-sdk/lib-dynamodb';
+export declare function getClientConfig(config: DynamoDBClientConfig): DynamoDBClientConfig;
+export declare function getClientTranslateConfig(config?: TranslateConfig): TranslateConfig;

package/dist/client.js

@@ -0,0 +1,31 @@
+import https from 'node:https';
+import { NodeHttpHandler } from '@smithy/node-http-handler';
+import { REGION } from "./constants.js";
+export function getClientConfig(config) {
+    return {
+        maxAttempts: 6,
+        requestHandler: new NodeHttpHandler({
+            // Disabled due to timeouts with SSG — effectively no connectionTimeout
+            // connectionTimeout: 1000,
+            requestTimeout: 5000,
+            httpsAgent: new https.Agent({
+                // Set this explicitly, since we provide an agent, we can't rely on defaults
+                keepAlive: true,
+                maxSockets: 400, // default is 50
+            }),
+        }),
+        region: REGION,
+        ...config,
+    };
+}
+export function getClientTranslateConfig(config) {
+    return {
+        marshallOptions: {
+            removeUndefinedValues: true,
+            ...config?.marshallOptions,
+        },
+        unmarshallOptions: {
+            ...config?.unmarshallOptions,
+        },
+    };
+}

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const REGION = "us-east-1";

package/dist/constants.js

@@ -0,0 +1 @@
+export const REGION = 'us-east-1';

package/dist/dyno.d.ts

@@ -0,0 +1,161 @@
+import { type CreateTableCommandInput, type DeleteTableCommandInput, type DescribeTableCommandInput, DynamoDB, type DynamoDBClientConfig, type ListTablesCommandInput } from '@aws-sdk/client-dynamodb';
+import { type BatchGetCommandInput, type BatchWriteCommandInput, type DeleteCommandInput, DynamoDBDocument, type GetCommandInput, type PutCommandInput, type TranslateConfig, type UpdateCommandInput } from '@aws-sdk/lib-dynamodb';
+import type { HttpHandlerOptions } from '@smithy/types';
+import type { SendAllOptions } from './requests/send-all.ts';
+import type { SendCompletelyOptions } from './requests/send-completely.ts';
+import { type ParseResponseOptions } from './responses.ts';
+import { type PutStreamInput, type PutStreamOptions, type QueryInput, type QueryOutput, type ReadStreamOptions, type ScanInput, type ScanOutput } from './stream.ts';
+import { type WaitForConnectionOptions, type WaitForIndexOperation, type WaitForIndexParams, type WaitForTableOperation, type WaitForTableParams } from './table.ts';
+import type { EnsureTableInput, NativeAttributeMap, OptionalTableName } from './types.ts';
+export type DynoConfig<T extends string | undefined = string> = DynamoDBClientConfig & {
+    table: T;
+} & SendCompletelyOptions & SendAllOptions & ParseResponseOptions & {
+    translateConfig?: TranslateConfig;
+};
+/**
+ * Extends an interface matching the `dynoExtensions` in `dyno`. Native methods
+ * can be
+ */
+export declare class Dyno<TableName extends string | undefined = undefined> {
+    /**
+     * Create a DynamoDB client with defaults
+     */
+    static createClient(config: DynamoDBClientConfig): DynamoDB;
+    /**
+     * Create a DynamoDBDocument client with defaults
+     */
+    static createDocumentClient(client: DynamoDB, translateConfig?: TranslateConfig): DynamoDBDocument;
+    /**
+     * Create a Dynamo instance from a client
+     *
+     * Note: Not in Dyno
+     */
+    static from(client: DynamoDB): Dyno<undefined>;
+    readonly config: DynoConfig<TableName>;
+    readonly tableName: TableName;
+    private readonly _client;
+    private readonly _docClient;
+    constructor(config: DynoConfig<TableName>, client?: DynamoDB);
+    /**
+     * Destroy the DynamoDB client
+     *
+     * Note: Not in Dyno
+     */
+    destroy(): void;
+    /**
+     * Get a sub-client, scoped to a single table. Similar to the behavior of the Dyno class constructor.
+     *
+     * Note: Not in Dyno
+     */
+    table(tableName: string): Dyno<string>;
+    ensureTable(params?: OptionalTableName<EnsureTableInput, TableName>): Promise<import("./table.ts").EnsureTableOutput>;
+    waitForConnection(options?: WaitForConnectionOptions): Promise<void>;
+    killConnection(): void;
+    waitForIndex(operation: WaitForIndexOperation, params: OptionalTableName<WaitForIndexParams, TableName>): Promise<void>;
+    waitForTable(operation: WaitForTableOperation, params?: OptionalTableName<WaitForTableParams, TableName>): Promise<void>;
+    /**
+     * List the tables available in a given region. Passthrough to [DynamoDB.listTables](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#listTables-property).
+     */
+    listTables(params?: ListTablesCommandInput): Promise<import("@aws-sdk/client-dynamodb").ListTablesCommandOutput>;
+    /**
+     * Get table information. Passthrough to [DynamoDB.describeTable](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#describTable-property).
+     */
+    describeTable(params?: OptionalTableName<DescribeTableCommandInput, TableName>): Promise<{
+        Table: import("@aws-sdk/client-dynamodb").TableDescription;
+    }>;
+    /**
+     * Perform a batch of get operations. Passthrough to [DocumentClient.batchGet](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#batchGet-property).
+     */
+    batchGetItem(params: TableName extends string ? NonNullable<BatchGetCommandInput['RequestItems']>[string] : BatchGetCommandInput, options?: HttpHandlerOptions): Promise<import("@aws-sdk/lib-dynamodb").BatchGetCommandOutput>;
+    /**
+     * Perform a batch of write operations. Passthrough to [DocumentClient.batchWrite](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#batchWrite-property).
+     */
+    batchWriteItem(params: TableName extends string ? NonNullable<BatchWriteCommandInput['RequestItems']>[string] : BatchWriteCommandInput, options?: HttpHandlerOptions): Promise<import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
+    /**
+     * Delete a single record. Passthrough to [DocumentClient.delete](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#delete-property).
+     */
+    deleteItem(params: OptionalTableName<DeleteCommandInput, TableName>): Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput>;
+    /**
+     * Get a single record. Passthrough to [DocumentClient.get](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#get-property).
+     */
+    getItem(params: OptionalTableName<GetCommandInput, TableName>): Promise<import("@aws-sdk/lib-dynamodb").GetCommandOutput>;
+    /**
+     * Put a single record. Passthrough to [DocumentClient.put](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#put-property).
+     */
+    putItem(params: OptionalTableName<PutCommandInput, TableName>): Promise<import("@aws-sdk/lib-dynamodb").PutCommandOutput>;
+    /**
+     * Update a single record. Passthrough to [DocumentClient.update](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#update-property).
+     */
+    updateItem(params: OptionalTableName<UpdateCommandInput, TableName>): Promise<import("@aws-sdk/lib-dynamodb").UpdateCommandOutput>;
+    /**
+     * Break a large batch of get operations into a set of requests that can be
+     * sent individually or concurrently.
+     */
+    batchGetItemRequests(params: TableName extends string ? NonNullable<BatchGetCommandInput['RequestItems']>[string] : BatchGetCommandInput, options?: HttpHandlerOptions & SendAllOptions): import("./requests/send-all.ts").SendAllBatch<BatchGetCommandInput, import("@aws-sdk/lib-dynamodb").BatchGetCommandOutput>;
+    /**
+     * Break a large batch of write operations into a set of requests that can be
+     * sent individually or concurrently.
+     */
+    batchWriteItemRequests(params: TableName extends string ? NonNullable<BatchWriteCommandInput['RequestItems']>[string] : BatchWriteCommandInput, options?: HttpHandlerOptions & SendAllOptions): import("./requests/send-all.ts").SendAllBatch<BatchWriteCommandInput, import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
+    /**
+     * Break a large batch of get operations into a set of requests that are intended
+     * to be sent concurrently.
+     */
+    batchGetAll(params: TableName extends string ? NonNullable<BatchGetCommandInput['RequestItems']>[string] : BatchGetCommandInput, options?: HttpHandlerOptions & SendCompletelyOptions): import("./requests/send-completely.ts").SendCompletelyBatch<BatchGetCommandInput, import("@aws-sdk/lib-dynamodb").BatchGetCommandOutput>;
+    /**
+     * Break a large batch of write operations into a set of requests that are intended
+     * to be sent concurrently.
+     */
+    batchWriteAll(params: TableName extends string ? NonNullable<BatchWriteCommandInput['RequestItems']>[string] : BatchWriteCommandInput, options?: HttpHandlerOptions & SendCompletelyOptions): import("./requests/send-completely.ts").SendCompletelyBatch<BatchWriteCommandInput, import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
+    /**
+     * Sugar on batchWriteAll, only for table clients
+     */
+    batchPutAll(items: TableName extends string ? NativeAttributeMap[] : never, options?: HttpHandlerOptions & SendCompletelyOptions): import("./requests/send-completely.ts").SendCompletelyBatch<BatchWriteCommandInput, import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
+    /**
+     * Sugar on batchWriteAll, only for table clients
+     */
+    batchDeleteAll(items: TableName extends string ? NativeAttributeMap[] : never, options?: HttpHandlerOptions & SendCompletelyOptions): import("./requests/send-completely.ts").SendCompletelyBatch<BatchWriteCommandInput, import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
+    /**
+     * Create a table. Passthrough to [DynamoDB.createTable](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#createTable-property),
+     * except the function polls DynamoDB until the table is ready to accept
+     * reads and writes, at which point the callback function is called.
+     */
+    createTable(params: OptionalTableName<CreateTableCommandInput, TableName>): Promise<{
+        TableDescription: import("@aws-sdk/client-dynamodb").TableDescription;
+    }>;
+    /**
+     * Delete a table. Passthrough to [DynamoDB.deleteTable](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#deleteTable-property),
+     * except the function polls DynamoDB until the table is ready to accept
+     * reads and writes, at which point the callback function is called.
+     */
+    deleteTable(params?: OptionalTableName<DeleteTableCommandInput, TableName>): Promise<void>;
+    /**
+     * Provide the results of a query as a [Readable Stream](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+     * This function will paginate through query responses, making HTTP requests
+     * as the caller reads from the stream.
+     */
+    queryStream(params: OptionalTableName<QueryInput, TableName>, options?: ReadStreamOptions): import("./index.ts").DynoReadableStream;
+    /**
+     * Provide the results of a scan as a [Readable Stream](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+     * This function will paginate through query responses, making HTTP requests
+     * as the caller reads from the stream.
+     */
+    scanStream(params?: OptionalTableName<ScanInput, TableName>, options?: ReadStreamOptions): import("./index.ts").DynoReadableStream;
+    /**
+     * Creates a [Writable stream](https://nodejs.org/api/stream.html#stream_class_stream_writable).
+     * Writing individual records to the stream will aggregate them into sets of
+     * 25 items and submit them as `BatchWriteItem` requests.
+     */
+    putStream(params?: OptionalTableName<PutStreamInput, TableName>, options?: PutStreamOptions): import("./index.ts").DynoWritableStream;
+    /**
+     * Query a table or secondary index. Passthrough to [DocumentClient.query](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#query-property).
+     */
+    query(params: OptionalTableName<QueryInput, TableName>, options?: ReadStreamOptions): Promise<QueryOutput>;
+    /**
+     * Scan a table or secondary index. Passthrough to [DocumentClient.scan](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#scan-property).
+     */
+    scan(params?: OptionalTableName<ScanInput, TableName>, options?: ReadStreamOptions): Promise<ScanOutput>;
+    private paramsWithTableName;
+    private batchParams;
+    private batchOptions;
+}

package/dist/dyno.js

@@ -0,0 +1,289 @@
+import { DynamoDB, } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocument, } from '@aws-sdk/lib-dynamodb';
+import { getClientConfig, getClientTranslateConfig } from "./client.js";
+import { TableNameError } from "./error.js";
+import { readPaginatedStream } from "./paginated.js";
+import { batchDeleteAll, batchGetAll, batchGetItemRequests, batchPutAll, batchWriteAll, batchWriteItemRequests, } from "./requests/requests.js";
+import { parseResponse } from "./responses.js";
+import { createPutStream, createReadStream, } from "./stream.js";
+import { createTable, deleteTable, ensureTable, killConnection, waitForConnection, waitForIndex, waitForTable, } from "./table.js";
+/**
+ * Extends an interface matching the `dynoExtensions` in `dyno`. Native methods
+ * can be
+ */
+export class Dyno {
+    /**
+     * Create a DynamoDB client with defaults
+     */
+    static createClient(config) {
+        return new DynamoDB(getClientConfig(config));
+    }
+    /**
+     * Create a DynamoDBDocument client with defaults
+     */
+    static createDocumentClient(client, translateConfig) {
+        return DynamoDBDocument.from(client, getClientTranslateConfig(translateConfig));
+    }
+    /**
+     * Create a Dynamo instance from a client
+     *
+     * Note: Not in Dyno
+     */
+    static from(client) {
+        return new Dyno({ table: undefined }, client);
+    }
+    config;
+    tableName;
+    _client;
+    _docClient;
+    constructor(config, client) {
+        let { table, maxRetries, concurrency, translateConfig, ...clientConfig } = config;
+        if (client) {
+            this._client = client;
+        }
+        else {
+            clientConfig = getClientConfig(clientConfig);
+            this._client = Dyno.createClient(clientConfig);
+        }
+        translateConfig = getClientTranslateConfig(translateConfig);
+        this._docClient = DynamoDBDocument.from(this._client, translateConfig);
+        this.tableName = table;
+        this.config = {
+            table,
+            maxRetries,
+            concurrency,
+            translateConfig,
+            ...clientConfig,
+        };
+    }
+    /**
+     * Destroy the DynamoDB client
+     *
+     * Note: Not in Dyno
+     */
+    destroy() {
+        this._client.destroy();
+    }
+    /**
+     * Get a sub-client, scoped to a single table. Similar to the behavior of the Dyno class constructor.
+     *
+     * Note: Not in Dyno
+     */
+    table(tableName) {
+        return new Dyno({ ...this.config, table: tableName }, this._client);
+    }
+    async ensureTable(params) {
+        return ensureTable(this._client, this.paramsWithTableName(params));
+    }
+    async waitForConnection(options) {
+        return waitForConnection(this._client, options);
+    }
+    killConnection() {
+        killConnection(this._client);
+    }
+    async waitForIndex(operation, params) {
+        return waitForIndex(this._client, this.paramsWithTableName(params), operation);
+    }
+    async waitForTable(operation, params) {
+        return waitForTable(this._client, this.paramsWithTableName(params), operation);
+    }
+    /**
+     * List the tables available in a given region. Passthrough to [DynamoDB.listTables](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#listTables-property).
+     */
+    async listTables(params) {
+        return this._client.listTables(params ?? {});
+    }
+    /**
+     * Get table information. Passthrough to [DynamoDB.describeTable](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#describTable-property).
+     */
+    async describeTable(params) {
+        const { Table } = await this._client.describeTable(this.paramsWithTableName(params));
+        if (!Table) {
+            throw new Error('Missing Table in response');
+        }
+        return { Table };
+    }
+    /**
+     * Perform a batch of get operations. Passthrough to [DocumentClient.batchGet](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#batchGet-property).
+     */
+    async batchGetItem(params, options) {
+        return parseResponse(await this._docClient.batchGet(this.batchParams(params), options), this.config);
+    }
+    /**
+     * Perform a batch of write operations. Passthrough to [DocumentClient.batchWrite](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#batchWrite-property).
+     */
+    async batchWriteItem(params, options) {
+        return this._docClient.batchWrite(this.batchParams(params), options);
+    }
+    /**
+     * Delete a single record. Passthrough to [DocumentClient.delete](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#delete-property).
+     */
+    async deleteItem(params) {
+        return this._docClient.delete(this.paramsWithTableName(params));
+    }
+    /**
+     * Get a single record. Passthrough to [DocumentClient.get](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#get-property).
+     */
+    async getItem(params) {
+        return parseResponse(await this._docClient.get(this.paramsWithTableName(params)), this.config);
+    }
+    /**
+     * Put a single record. Passthrough to [DocumentClient.put](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#put-property).
+     */
+    async putItem(params) {
+        return this._docClient.put(this.paramsWithTableName(params));
+    }
+    /**
+     * Update a single record. Passthrough to [DocumentClient.update](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#update-property).
+     */
+    async updateItem(params) {
+        return this._docClient.update(this.paramsWithTableName(params));
+    }
+    /**
+     * Break a large batch of get operations into a set of requests that can be
+     * sent individually or concurrently.
+     */
+    batchGetItemRequests(params, options) {
+        return batchGetItemRequests(this._docClient, this.batchParams(params), this.batchOptions(options));
+    }
+    /**
+     * Break a large batch of write operations into a set of requests that can be
+     * sent individually or concurrently.
+     */
+    batchWriteItemRequests(params, options) {
+        return batchWriteItemRequests(this._docClient, this.batchParams(params), this.batchOptions(options));
+    }
+    /**
+     * Break a large batch of get operations into a set of requests that are intended
+     * to be sent concurrently.
+     */
+    batchGetAll(params, options) {
+        return batchGetAll(this._docClient, this.batchParams(params), this.batchOptions(options));
+    }
+    /**
+     * Break a large batch of write operations into a set of requests that are intended
+     * to be sent concurrently.
+     */
+    batchWriteAll(params, options) {
+        return batchWriteAll(this._docClient, this.batchParams(params), this.batchOptions(options));
+    }
+    /**
+     * Sugar on batchWriteAll, only for table clients
+     */
+    batchPutAll(items, options) {
+        if (!this.tableName) {
+            throw new TableNameError();
+        }
+        return batchPutAll(this._docClient, this.tableName, items, this.batchOptions(options));
+    }
+    /**
+     * Sugar on batchWriteAll, only for table clients
+     */
+    batchDeleteAll(items, options) {
+        if (!this.tableName) {
+            throw new TableNameError();
+        }
+        return batchDeleteAll(this._docClient, this.tableName, items, this.batchOptions(options));
+    }
+    /**
+     * Create a table. Passthrough to [DynamoDB.createTable](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#createTable-property),
+     * except the function polls DynamoDB until the table is ready to accept
+     * reads and writes, at which point the callback function is called.
+     */
+    async createTable(params) {
+        return createTable(this._client, this.paramsWithTableName(params));
+    }
+    /**
+     * Delete a table. Passthrough to [DynamoDB.deleteTable](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#deleteTable-property),
+     * except the function polls DynamoDB until the table is ready to accept
+     * reads and writes, at which point the callback function is called.
+     */
+    async deleteTable(params) {
+        return deleteTable(this._client, this.paramsWithTableName(params));
+    }
+    /**
+     * Provide the results of a query as a [Readable Stream](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+     * This function will paginate through query responses, making HTTP requests
+     * as the caller reads from the stream.
+     */
+    queryStream(params, options) {
+        return createReadStream(this._docClient, this.paramsWithTableName(params), {
+            ...options,
+            mode: 'query',
+        });
+    }
+    /**
+     * Provide the results of a scan as a [Readable Stream](https://nodejs.org/api/stream.html#stream_class_stream_readable).
+     * This function will paginate through query responses, making HTTP requests
+     * as the caller reads from the stream.
+     */
+    scanStream(params, options) {
+        return createReadStream(this._docClient, this.paramsWithTableName(params), {
+            ...options,
+            mode: 'scan',
+        });
+    }
+    /**
+     * Creates a [Writable stream](https://nodejs.org/api/stream.html#stream_class_stream_writable).
+     * Writing individual records to the stream will aggregate them into sets of
+     * 25 items and submit them as `BatchWriteItem` requests.
+     */
+    putStream(params, options) {
+        const { concurrency, maxRetries } = this.config;
+        return createPutStream(this._docClient, this.paramsWithTableName(params), {
+            concurrency,
+            maxRetries,
+            ...options,
+        });
+    }
+    /**
+     * Query a table or secondary index. Passthrough to [DocumentClient.query](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#query-property).
+     */
+    async query(params, options) {
+        if (!params?.Pages) {
+            return this._docClient.query(this.paramsWithTableName(params));
+        }
+        return readPaginatedStream(this.queryStream(params, options));
+    }
+    /**
+     * Scan a table or secondary index. Passthrough to [DocumentClient.scan](http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html#scan-property).
+     */
+    async scan(params, options) {
+        if (!params?.Pages) {
+            return this._docClient.scan(this.paramsWithTableName(params));
+        }
+        return readPaginatedStream(this.scanStream(params, options));
+    }
+    paramsWithTableName(params) {
+        // Class-defined tableName takes precedence
+        const TableName = this.tableName ?? params?.TableName;
+        if (!TableName) {
+            throw new TableNameError();
+        }
+        return { TableName, ...params };
+    }
+    batchParams(requestOrItems) {
+        let params;
+        if ('RequestItems' in requestOrItems) {
+            params = requestOrItems;
+        }
+        else {
+            if (!this.tableName) {
+                throw new TableNameError();
+            }
+            params = {
+                RequestItems: { [this.tableName]: requestOrItems },
+            };
+        }
+        return params;
+    }
+    batchOptions(options) {
+        const { concurrency, maxRetries, noBuffers } = this.config;
+        return {
+            concurrency,
+            maxRetries,
+            noBuffers,
+            ...options,
+        };
+    }
+}

package/dist/error.d.ts

@@ -0,0 +1,3 @@
+export declare class TableNameError extends Error {
+    constructor(message?: string, options?: {});
+}

package/dist/error.js

@@ -0,0 +1,5 @@
+export class TableNameError extends Error {
+    constructor(message = 'TableName is required', options = {}) {
+        super(message, options);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './client.ts';
+export * from './dyno.ts';
+export * from './error.ts';
+export type * from './requests/requests.ts';
+export type * from './requests/send-all.ts';
+export type * from './requests/send-completely.ts';
+export type * from './stream.ts';
+export type * from './streams/dyno-readable-stream.ts';
+export type * from './streams/dyno-writable-stream.ts';
+export type * from './table.ts';
+export type * from './types.ts';
+export * from './util.ts';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./client.js";
+export * from "./dyno.js";
+export * from "./error.js";
+export * from "./util.js";

package/dist/paginated.d.ts

@@ -0,0 +1,3 @@
+import type { ScanCommandOutput } from '@aws-sdk/lib-dynamodb';
+import type { DynoReadableStream } from './streams/dyno-readable-stream.ts';
+export declare function readPaginatedStream(stream: DynoReadableStream): Promise<Omit<ScanCommandOutput, '$metadata'>>;

package/dist/paginated.js

@@ -0,0 +1,19 @@
+export async function readPaginatedStream(stream) {
+    return new Promise((resolve, reject) => {
+        const items = [];
+        stream
+            .on('error', reject)
+            .on('data', (item) => {
+            items.push(item);
+        })
+            .on('end', () => {
+            resolve({
+                Items: items,
+                Count: stream.Count,
+                ScannedCount: stream.ScannedCount,
+                LastEvaluatedKey: stream.LastEvaluatedKey,
+                ConsumedCapacity: stream.ConsumedCapacity,
+            });
+        });
+    });
+}

package/dist/requests/requests.d.ts

@@ -0,0 +1,16 @@
+import type { BatchGetCommandInput, BatchWriteCommandInput, DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+import type { HttpHandlerOptions } from '@smithy/types';
+import { type ParseResponseOptions } from '../responses.ts';
+import type { NativeAttributeMap } from '../types.ts';
+import { SendAllBatch, type SendAllOptions } from './send-all.ts';
+import { SendCompletelyBatch, type SendCompletelyOptions } from './send-completely.ts';
+export type BatchWriteItemRequestsOptions = {
+    maxLength?: number;
+    maxSize?: number;
+};
+export declare function batchWriteItemRequests(client: DynamoDBDocument, params: BatchWriteCommandInput, options?: HttpHandlerOptions & BatchWriteItemRequestsOptions & SendAllOptions): SendAllBatch<BatchWriteCommandInput, import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
+export declare function batchGetItemRequests(client: DynamoDBDocument, params: BatchGetCommandInput, options?: HttpHandlerOptions & SendAllOptions & ParseResponseOptions): SendAllBatch<BatchGetCommandInput, import("@aws-sdk/lib-dynamodb").BatchGetCommandOutput>;
+export declare function batchWriteAll(client: DynamoDBDocument, params: BatchWriteCommandInput, options?: HttpHandlerOptions & SendCompletelyOptions): SendCompletelyBatch<BatchWriteCommandInput, import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
+export declare function batchPutAll(client: DynamoDBDocument, tableName: string, items: NativeAttributeMap[], options?: HttpHandlerOptions & SendCompletelyOptions): SendCompletelyBatch<BatchWriteCommandInput, import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
+export declare function batchDeleteAll(client: DynamoDBDocument, tableName: string, items: NativeAttributeMap[], options?: HttpHandlerOptions & SendCompletelyOptions): SendCompletelyBatch<BatchWriteCommandInput, import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
+export declare function batchGetAll(client: DynamoDBDocument, params: BatchGetCommandInput, options?: HttpHandlerOptions & SendCompletelyOptions & ParseResponseOptions): SendCompletelyBatch<BatchGetCommandInput, import("@aws-sdk/lib-dynamodb").BatchGetCommandOutput>;