To help you get started, we've collected the most common ways that @mapbox/dyno is being used within popular public projects.

mapbox / dynamodb-replicator / lib / replicate.js View on Github

params.RequestItems[process.env.ReplicaTable] = Object.keys(allRecords).map(function(key) {
    var change = allRecords[key].pop();
    if (change.eventName === 'INSERT' || change.eventName === 'MODIFY') {
      return {
        PutRequest: { Item: Dyno.deserialize(JSON.stringify(change.dynamodb.NewImage)) }
      };
    } else if (change.eventName === 'REMOVE') {
      return {
        DeleteRequest: { Key: Dyno.deserialize(JSON.stringify(change.dynamodb.Keys)) }
      };
    }
  });

View more ways to use @mapbox/dyno

Dyno

• Dyno
  • Overview
    • Native JavaScript objects
    • Streaming query and scan results
    • Chunked batch getItem and writeItem requests
    • Multi-table client
    • De/serialization
    • Command-line interface
  • Documentation

Dyno provides a DynamoDB client that adds additional functionality beyond what is provided by the aws-sdk-js.

Overview

Native JavaScript objects

Dyno operates as an extension to the aws-sdk's DocumentClient. This means that instead of interacting with typed JavaScript objects representing your DynamoDB records, you can use more "native" objects. For example, the following represents a typed object that could be stored in DynamoDB:

{
  id: { S: 'my-record' },
  numbers: { L: [{ N: '1' }, { N: '2' }, { N: '3' }] },
  data: { B: new Buffer.from('Hello World!') },
  version: { N: '5' },
}

Using Dyno, you can represent the same data in a "native" object:

{
  id: 'my-record',
  numbers: [1, 2, 3],
  data: new Buffer.from('Hello World!'),
  version: 5
}

Streaming query and scan results

A large query or scan operation may require multiple HTTP requests in order to retrieve all the desired data. Dyno provides functions that allow you to read those data from a native Node.js Readable Stream. Behind-the-scenes, Dyno manages making paginated requests to DynamoDB for you, and emits objects representing each of the records in the aggregated response.

Chunked batch getItem and writeItem requests

BatchGetItem and BatchWriteItem requests come with limits as to how much data you can ask for in a single HTTP request. Dyno functions allow you to present the entire set of batch requests that you wish to make. Dyno breaks your set up into an array of request objects each of which is within the limits of a single acceptable request. You can then send each of these requests and handle each of their responses individually.

Multi-table client

For situations where you may wish to write to one database and read from another. Dyno allows you to configure a client with parameters for two different tables, then routes your individual requests to the appropriate one.

De/serialization

Dyno exposes functions capable of serializing and deserializing native JavaScript objects representing DynamoDB records to and from wire-formatted strings acceptable as the body of any DynamoDB HTTP request.

Command-line interface

Dyno provides a CLI tool capable of reading and writing individual records, scanning, exporting and importing data into a DynamoDB table.

Documentation

See API.md for documentation of the JavaScript client, and use dyno --help for details on CLI usage.