Options
All
  • Public
  • Public/Protected
  • All
Menu

Module @aws-sdk/lib-dynamodb

@aws-sdk/lib-dynamodb

NPM version NPM downloads

Overview

The document client simplifies working with items in Amazon DynamoDB by abstracting away the notion of attribute values. This abstraction annotates native JavaScript types supplied as input parameters, as well as converts annotated response data to native JavaScript types.

Marshalling Input and Unmarshalling Response Data

The document client affords developers the use of native JavaScript types instead of AttributeValues to simplify the JavaScript development experience with Amazon DynamoDB. JavaScript objects passed in as parameters are marshalled into AttributeValue shapes required by Amazon DynamoDB. Responses from DynamoDB are unmarshalled into plain JavaScript objects by the DocumentClient. The DocumentClient does not accept AttributeValues in favor of native JavaScript types.

JavaScript Type DynamoDB AttributeValue
String S
Number / BigInt N
Boolean BOOL
null NULL
Array L
Object M
Set<Uint8Array, Blob, ...> BS
Set<Number, BigInt> NS
Set<String> SS
Uint8Array, Buffer, File, Blob... B

Example

Here is an example list which is sent to DynamoDB client in an operation:

{ "L": [{ "NULL": true }, { "BOOL": false }, { "N": 1 }, { "S": "two" }] }

The DynamoDB document client abstracts the attribute values as follows in both input and output:

[null, false, 1, "two"]

Usage

To create document client you need to create DynamoDB client first as follows:

import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; // ES6 import
// const { DynamoDBClient } = require("@aws-sdk/client-dynamodb"); // CommonJS import

// Bare-bones DynamoDB Client
const client = new DynamoDBClient({});
import { DynamoDB } from "@aws-sdk/client-dynamodb"; // ES6 import
// const { DynamoDB } = require("@aws-sdk/client-dynamodb"); // CommonJS import

// Full DynamoDB Client
const client = new DynamoDB({});

The bare-bones clients are more modular. They reduce bundle size and improve loading performance over full clients as explained in blog post on modular packages in AWS SDK for JavaScript.

Constructor

Once DynamoDB client is created, you can either create the bare-bones document client or full document client as follows:

import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb"; // ES6 import
// const { DynamoDBDocumentClient } = require("@aws-sdk/lib-dynamodb"); // CommonJS import

// Bare-bones document client
const ddbDocClient = DynamoDBDocumentClient.from(client); // client is DynamoDB client
import { DynamoDBDocument } from "@aws-sdk/lib-dynamodb"; // ES6 import
// const { DynamoDBDocument } = require("@aws-sdk/lib-dynamodb"); // CommonJS import

// Full document client
const ddbDocClient = DynamoDBDocument.from(client); // client is DynamoDB client

Configuration

The configuration for marshalling and unmarshalling can be sent as an optional second parameter during creation of document client as follows:

const marshallOptions = {
  // Whether to automatically convert empty strings, blobs, and sets to `null`.
  convertEmptyValues: false, // false, by default.
  // Whether to remove undefined values while marshalling.
  removeUndefinedValues: false, // false, by default.
  // Whether to convert typeof object to map attribute.
  convertClassInstanceToMap: false, // false, by default.
};

const unmarshallOptions = {
  // Whether to return numbers as a string instead of converting them to native JavaScript numbers.
  wrapNumbers: false, // false, by default.
};

const translateConfig = { marshallOptions, unmarshallOptions };

const client = new DynamoDBClient({});
const ddbDocClient = DynamoDBDocument.from(client, translateConfig);

Calling operations

You can call the document client operations using command objects on bare-bones client as follows:

import { DynamoDBDocumentClient, PutCommand } from "@aws-sdk/lib-dynamodb";

// ... DynamoDB client creation

const ddbDocClient = DynamoDBDocumentClient.from(client);
// Call using bare-bones client and Command object.
await ddbDocClient.send(
  new PutCommand({
    TableName,
    Item: {
      id: "1",
      content: "content from DynamoDBDocumentClient",
    },
  })
);

You can also call operations on full client as follows:

import { DynamoDBDocument } from "@aws-sdk/lib-dynamodb";

// ... DynamoDB client creation

const ddbDocClient = DynamoDBDocument.from(client);
// Call using full client.
await ddbDocClient.put({
  TableName,
  Item: {
    id: "2",
    content: "content from DynamoDBDocument",
  },
});

Destroying document client

The destroy() call on document client is a no-op as document client does not create a new DynamoDB client. You need to call destroy() on DynamoDB client to clean resources used by it as shown below.

const client = new DynamoDBClient({});
const ddbDocClient = DynamoDBDocumentClient.from(client);

// Perform operations on document client.

ddbDocClient.destroy(); // no-op
client.destroy(); // destroys DynamoDBClient

Index

References

Classes

Type aliases

Functions

References

BatchExecuteStatementCommand

Re-exports BatchExecuteStatementCommand

BatchExecuteStatementCommandInput

Re-exports BatchExecuteStatementCommandInput

BatchExecuteStatementCommandOutput

Re-exports BatchExecuteStatementCommandOutput

BatchGetCommand

Re-exports BatchGetCommand

BatchGetCommandInput

Re-exports BatchGetCommandInput

BatchGetCommandOutput

Re-exports BatchGetCommandOutput

BatchWriteCommand

Re-exports BatchWriteCommand

BatchWriteCommandInput

Re-exports BatchWriteCommandInput

BatchWriteCommandOutput

Re-exports BatchWriteCommandOutput

DeleteCommand

Re-exports DeleteCommand

DeleteCommandInput

Re-exports DeleteCommandInput

DeleteCommandOutput

Re-exports DeleteCommandOutput

DynamoDBDocument

Re-exports DynamoDBDocument

DynamoDBDocumentClient

Re-exports DynamoDBDocumentClient

DynamoDBDocumentClientResolvedConfig

Re-exports DynamoDBDocumentClientResolvedConfig

ExecuteStatementCommand

Re-exports ExecuteStatementCommand

ExecuteStatementCommandInput

Re-exports ExecuteStatementCommandInput

ExecuteStatementCommandOutput

Re-exports ExecuteStatementCommandOutput

ExecuteTransactionCommand

Re-exports ExecuteTransactionCommand

ExecuteTransactionCommandInput

Re-exports ExecuteTransactionCommandInput

ExecuteTransactionCommandOutput

Re-exports ExecuteTransactionCommandOutput

GetCommand

Re-exports GetCommand

GetCommandInput

Re-exports GetCommandInput

GetCommandOutput

Re-exports GetCommandOutput

PutCommand

Re-exports PutCommand

PutCommandInput

Re-exports PutCommandInput

PutCommandOutput

Re-exports PutCommandOutput

QueryCommand

Re-exports QueryCommand

QueryCommandInput

Re-exports QueryCommandInput

QueryCommandOutput

Re-exports QueryCommandOutput

ScanCommand

Re-exports ScanCommand

ScanCommandInput

Re-exports ScanCommandInput

ScanCommandOutput

Re-exports ScanCommandOutput

ServiceInputTypes

Re-exports ServiceInputTypes

ServiceOutputTypes

Re-exports ServiceOutputTypes

TransactGetCommand

Re-exports TransactGetCommand

TransactGetCommandInput

Re-exports TransactGetCommandInput

TransactGetCommandOutput

Re-exports TransactGetCommandOutput

TransactWriteCommand

Re-exports TransactWriteCommand

TransactWriteCommandInput

Re-exports TransactWriteCommandInput

TransactWriteCommandOutput

Re-exports TransactWriteCommandOutput

TranslateConfig

Re-exports TranslateConfig

UpdateCommand

Re-exports UpdateCommand

UpdateCommandInput

Re-exports UpdateCommandInput

UpdateCommandOutput

Re-exports UpdateCommandOutput

Type aliases

AllNodes

AllNodes: { children?: KeyNode[] | AllNodes }

Type declaration

BatchExecuteStatementCommandInput

BatchExecuteStatementCommandInput: Omit<__BatchExecuteStatementCommandInput, "Statements"> & { Statements: (Omit<BatchStatementRequest, "Parameters"> & { Parameters?: NativeAttributeValue[] })[] | undefined }

BatchExecuteStatementCommandOutput

BatchExecuteStatementCommandOutput: Omit<__BatchExecuteStatementCommandOutput, "Responses"> & { Responses?: (Omit<BatchStatementResponse, "Item"> & { Item?: {} })[] }

BatchGetCommandInput

BatchGetCommandInput: Omit<__BatchGetItemCommandInput, "RequestItems"> & { RequestItems: {} | undefined }

BatchGetCommandOutput

BatchGetCommandOutput: Omit<__BatchGetItemCommandOutput, "Responses" | "UnprocessedKeys"> & { Responses?: {}; UnprocessedKeys?: {} }

BatchWriteCommandInput

BatchWriteCommandInput: Omit<__BatchWriteItemCommandInput, "RequestItems"> & { RequestItems: {} | undefined }

BatchWriteCommandOutput

BatchWriteCommandOutput: Omit<__BatchWriteItemCommandOutput, "UnprocessedItems" | "ItemCollectionMetrics"> & { ItemCollectionMetrics?: {}; UnprocessedItems?: {} }

DeleteCommandInput

DeleteCommandInput: Omit<__DeleteItemCommandInput, "Key" | "Expected" | "ExpressionAttributeValues"> & { Expected?: {}; ExpressionAttributeValues?: {}; Key: {} | undefined }

DeleteCommandOutput

DeleteCommandOutput: Omit<__DeleteItemCommandOutput, "Attributes" | "ItemCollectionMetrics"> & { Attributes?: {}; ItemCollectionMetrics?: Omit<ItemCollectionMetrics, "ItemCollectionKey"> & { ItemCollectionKey?: {} } }

DynamoDBDocumentClientResolvedConfig

DynamoDBDocumentClientResolvedConfig: DynamoDBClientResolvedConfig & { translateConfig?: TranslateConfig }

ExecuteStatementCommandInput

ExecuteStatementCommandInput: Omit<__ExecuteStatementCommandInput, "Parameters"> & { Parameters?: NativeAttributeValue[] }

ExecuteStatementCommandOutput

ExecuteStatementCommandOutput: Omit<__ExecuteStatementCommandOutput, "Items"> & { Items?: {}[] }

ExecuteTransactionCommandInput

ExecuteTransactionCommandInput: Omit<__ExecuteTransactionCommandInput, "TransactStatements"> & { TransactStatements: (Omit<ParameterizedStatement, "Parameters"> & { Parameters?: NativeAttributeValue[] })[] | undefined }

ExecuteTransactionCommandOutput

ExecuteTransactionCommandOutput: Omit<__ExecuteTransactionCommandOutput, "Responses"> & { Responses?: (Omit<ItemResponse, "Item"> & { Item?: {} })[] }

GetCommandInput

GetCommandInput: Omit<__GetItemCommandInput, "Key"> & { Key: {} | undefined }

GetCommandOutput

GetCommandOutput: Omit<__GetItemCommandOutput, "Item"> & { Item?: {} }

KeyNode

KeyNode: { children?: KeyNode[] | AllNodes; key: string }

Type declaration

PutCommandInput

PutCommandInput: Omit<__PutItemCommandInput, "Item" | "Expected" | "ExpressionAttributeValues"> & { Expected?: {}; ExpressionAttributeValues?: {}; Item: {} | undefined }

PutCommandOutput

PutCommandOutput: Omit<__PutItemCommandOutput, "Attributes" | "ItemCollectionMetrics"> & { Attributes?: {}; ItemCollectionMetrics?: Omit<ItemCollectionMetrics, "ItemCollectionKey"> & { ItemCollectionKey?: {} } }

QueryCommandInput

QueryCommandInput: Omit<__QueryCommandInput, "KeyConditions" | "QueryFilter" | "ExclusiveStartKey" | "ExpressionAttributeValues"> & { ExclusiveStartKey?: {}; ExpressionAttributeValues?: {}; KeyConditions?: {}; QueryFilter?: {} }

QueryCommandOutput

QueryCommandOutput: Omit<__QueryCommandOutput, "Items" | "LastEvaluatedKey"> & { Items?: {}[]; LastEvaluatedKey?: {} }

ScanCommandInput

ScanCommandInput: Omit<__ScanCommandInput, "ScanFilter" | "ExclusiveStartKey" | "ExpressionAttributeValues"> & { ExclusiveStartKey?: {}; ExpressionAttributeValues?: {}; ScanFilter?: {} }

ScanCommandOutput

ScanCommandOutput: Omit<__ScanCommandOutput, "Items" | "LastEvaluatedKey"> & { Items?: {}[]; LastEvaluatedKey?: {} }

ServiceInputTypes

ServiceOutputTypes

TransactGetCommandInput

TransactGetCommandInput: Omit<__TransactGetItemsCommandInput, "TransactItems"> & { TransactItems: (Omit<TransactGetItem, "Get"> & { Get: (Omit<Get, "Key"> & { Key: {} | undefined }) | undefined })[] | undefined }

TransactGetCommandOutput

TransactGetCommandOutput: Omit<__TransactGetItemsCommandOutput, "Responses"> & { Responses?: (Omit<ItemResponse, "Item"> & { Item?: {} })[] }

TransactWriteCommandInput

TransactWriteCommandInput: Omit<__TransactWriteItemsCommandInput, "TransactItems"> & { TransactItems: (Omit<TransactWriteItem, "ConditionCheck" | "Put" | "Delete" | "Update"> & { ConditionCheck?: Omit<ConditionCheck, "Key" | "ExpressionAttributeValues"> & { ExpressionAttributeValues?: {}; Key: {} | undefined }; Delete?: Omit<Delete, "Key" | "ExpressionAttributeValues"> & { ExpressionAttributeValues?: {}; Key: {} | undefined }; Put?: Omit<Put, "Item" | "ExpressionAttributeValues"> & { ExpressionAttributeValues?: {}; Item: {} | undefined }; Update?: Omit<Update, "Key" | "ExpressionAttributeValues"> & { ExpressionAttributeValues?: {}; Key: {} | undefined } })[] | undefined }

TransactWriteCommandOutput

TransactWriteCommandOutput: Omit<__TransactWriteItemsCommandOutput, "ItemCollectionMetrics"> & { ItemCollectionMetrics?: {} }

TranslateConfig

TranslateConfig: { marshallOptions?: marshallOptions; unmarshallOptions?: unmarshallOptions }

Type declaration

UpdateCommandInput

UpdateCommandInput: Omit<__UpdateItemCommandInput, "Key" | "AttributeUpdates" | "Expected" | "ExpressionAttributeValues"> & { AttributeUpdates?: {}; Expected?: {}; ExpressionAttributeValues?: {}; Key: {} | undefined }

UpdateCommandOutput

UpdateCommandOutput: Omit<__UpdateItemCommandOutput, "Attributes" | "ItemCollectionMetrics"> & { Attributes?: {}; ItemCollectionMetrics?: Omit<ItemCollectionMetrics, "ItemCollectionKey"> & { ItemCollectionKey?: {} } }

Functions

Const marshallInput

Const processAllKeysInObj

  • processAllKeysInObj(obj: any, processFunc: Function, children?: KeyNode[] | AllNodes): any

Const processKeyInObj

  • processKeyInObj(obj: any, processFunc: Function, children?: KeyNode[] | AllNodes): any

Const processKeysInObj

  • processKeysInObj(obj: any, processFunc: Function, keyNodes: KeyNode[]): any

Const processObj

  • processObj(obj: any, processFunc: Function, children?: KeyNode[] | AllNodes): any

Const unmarshallOutput