DynamoDB is a well-known NoSQL database from Amazon Web Services(AWS). It offers a wide variety of features for free in its free tier program.
One can get started with DynamoDB in just a few minutes.&nbsp;But before that, you need to signup for an AWS account. Signing up for an AWS account can be done in a few simple steps, directly from the aws.com site.
Note you need to provide a credit or debit card to complete the signup. You will not be charged any amount until you cross their free tier service, so nothing to worry about 😊.&nbsp;
In the AWS free tier, you will get tonnes of features to use, of which some are limited for the first year and some are free even rest of the years until a certain threshold.
DynamoDB comes under always free service with&nbsp;
<ul>
<li>25 GB&nbsp;of Storage</li>
<li>25&nbsp;provisioned Write Capacity Units (WCU)</li>
<li>25&nbsp;provisioned Read Capacity Units (RCU)</li>
</ul>
and is said to handle up to 200M requests per month. If you go beyond that you will be charged the amount as per the extra usage.&nbsp;
<blockquote>
1 WCU = 1 write of up to 1 KB/s.
2 WCUs = 1 transactional write request (one write per second) for items up to 1 KB.
</blockquote>
<blockquote>
1 RCU =&nbsp; 1&nbsp; read of up to 4 KB/s&nbsp;
2 RCUs = 1 transactional read request (one read per second) for items up to 4 KB.
</blockquote>
To understand more about the read and write capacities check these <a href="https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.html" target="_blank" rel="noopener">aws docs</a>.
Once the AWS account is ready, you can set up the credentials locally for using the AWS services. Linux and Windows users can create <code>.aws</code> directory in the user folder and add the credentials file without any extension with the following details.
<pre class="language-markup"><code>[default]
aws_access_key_id = &lt;YOUR_ACCESS_KEY_ID&gt;
aws_secret_access_key = &lt;YOUR_SECRET_ACCESS_KEY&gt;</code></pre>
If you need more details for setting up the AWS credentials, follow up <a href="https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/loading-node-credentials-shared.html" target="_blank" rel="noopener">this doc</a>.
Now let's get started with the DynamoDB NodeJS crud operations.&nbsp;
<h2 style="text-align: center;">DynamoDB NodeJS CRUD</h2>
Let's create a new directory <code>dynamo-crud</code> and initialize node project(you need to have node installed already).&nbsp;
<pre class="language-bash"><code>mkdir dynamo-crud
cd dynamo-crud
npm init -y</code></pre>
To get started with using AWS services we need <code>aws-sdk</code> package and we can install it using <code>npm</code>. You can learn the <a href="https://devapt.com/npm-commands-list" target="_blank" rel="noopener">npm commands from here</a>.
<pre class="language-bash"><code>npm i aws-sdk</code></pre>
For having unique IDs for our records or items, we can use <code>nanoid</code> package.
<pre class="language-bash"><code>npm i nanoid</code></pre>
Next create the <code>index.js</code>&nbsp;file in the root project directory.
After that configure AWS with your desired region and create DynamoDB instance. Keep in mind that we have already configured our credentials through a local file inside <code>.aws</code> directory.
<pre class="language-javascript"><code>// Inside index.js
import AWS from 'aws-sdk';
import { nanoid } from 'nanoid';

AWS.config.update({ region: 'ap-south-1' }); // you can change region as per your preference

const DynamoDB = new AWS.DynamoDB(); // instance of DynamoDB</code></pre>
<h3>Creating table in DynamoDB NodeJS</h3>
Now let's create a table named <code>Posts</code>. While creating the table we need to mention the unique key for querying the data.
In DynamoDB there are two key parameters, one is partition key and the other is sort key.
The primary key can be created using only the partition key or the combination of partition and sort key, known as composite primary key.
Having a sort key helps in sorting the data based on that sort key.
<blockquote>
In DynamoDB, tables, items, and attributes are the core components to work with. A table&nbsp;is a collection of&nbsp;items, and each item is a collection of&nbsp;attributes. DynamoDB uses primary keys to uniquely identify each item in a table and secondary indexes to provide more querying flexibility.
</blockquote>
We'll make a function for each operation so that it will be easier to use or reuse it and keep all related lines of code together.&nbsp;
<pre class="language-javascript"><code>// Creating the table with parition key as the primary key
const createTable = () =&gt; {
 const params = {
 TableName: 'Posts',
 KeySchema: [{ AttributeName: 'postId', KeyType: 'HASH' }], // using partition key only
 AttributeDefinitions: [{ AttributeName: 'postId', AttributeType: 'S' }], // S for string
 ProvisionedThroughput: {
 ReadCapacityUnits: 5,
 WriteCapacityUnits: 5,
 },
 };

 DynamoDB.createTable(params, function (err, data) {
 if (err) {
 console.error('Unable to create table', err);
 } else {
 console.log('Created table', data);
 }
 });
};</code></pre>
In the above code, we have created a table with name <code>Posts</code> and primary key <code>postId</code>. We have provisioned the capacity units 5 each RCU and WCU.&nbsp;
In <code>DynamoDB</code> instance by using <code>createTable</code> method we can pass the <code>params</code> and a callback with <code>err</code> and <code>data</code> arguments to create the table.
Calling the <code>creatTable()</code> function will run all the code inside it and will create the <code>Posts</code> table in the AWS DynamoDB space.
<h3>Creating items/records in DynamoDB</h3>
We'll create a function named <code>insertPost</code> that takes <code>postId</code>, <code>title</code> and <code>content</code> as arguments for creating the item with three key-value pairs.
We need <code>documentClient</code> instance for doing CRUD operations in the Dynamo database. With the following code snippet, we can create the instance of the <code>documentClient</code>.
<pre class="language-javascript"><code>const documentClient = new AWS.DynamoDB.DocumentClient();</code></pre>
Now initialize the function <code>insertPost</code> for inserting the items. We are going to use <code>put</code> method of <code>documentClient</code> for inserting the items.
<pre class="language-javascript"><code>// Function to insert the post into Posts table/document
const insertPost = async (postId, title, content) =&gt; {
 const params = {
 TableName: 'Posts',
 Item: {
 postId,
 title,
 content,
 },
 };
 try {
 const data = await documentClient.put(params).promise();
 console.log('Post inserted', data);
 } catch (err) {
 console.log(err);
 }
};</code></pre>
So we can now insert posts by calling the <code>insertPost</code> function with the data.&nbsp;
<pre class="language-javascript"><code>// Inserting two posts
insertPost(
 nanoid(),
 'How to do CRUD operations in Dynamo?',
 'It is not that hard to do CRUD operations in DynamoDB.'
);
insertPost(
 nanoid(),
 'Sample title that can be deleted',
 'Sample description for the sample post'
);</code></pre>
<h3>Reading items/records in DynamoDB</h3>
For reading the items we're going to create two functions, <code>getAllPosts</code> and <code>getSinglePost</code> functions.
<code>scan</code> method of <code>documentClient</code> is used to get all the items in the table. <code>get</code> method is used to get a single item by using the primary key, nothing but the <code>postId</code> here.
<pre class="language-javascript"><code>// Function to get all the posts
const getAllPosts = async (table) =&gt; {
 const params = {
 TableName: table,
 };
 try {
 const data = await documentClient.scan(params).promise();
 console.log(data);
 return data;
 } catch (err) {
 console.log(err);
 }
};

getAllPosts('Posts');

// Output:
// {
// Items: [
// {
// content: 'Sample description for the sample post',
// postId: 'FPbCFAvNoKWinPadsNBoW',
// title: 'Sample title that can be deleted'
// },
// {
// content: 'Follow this to learn about DyanamoDB',
// postId: 'j6uv_RKuZg5XZll1AkAWx',
// title: 'Learn to use DyanamoDB'
// }
// ],
// Count: 2,
// ScannedCount: 2
// }
</code></pre>
By calling <code>getAllPosts('Posts')</code> with the table name we get all the posts.&nbsp;
<pre class="language-javascript"><code>// Function to get single post from the table/document
const getSinglePost = async (table, keyObj) =&gt; {
 const params = {
 TableName: table,
 Key: keyObj,
 };
 try {
 const data = await documentClient.get(params).promise();
 console.log(data);
 return data;
 } catch (err) {
 console.log(err);
 }
};

getSinglePost('Posts', { postId: 'FPbCFAvNoKWinPadsNBoW' }); // gets single post</code></pre>
By calling <code>getSinglePost(...)</code> with the table name and keyObj gets the single post.&nbsp;
<h3>Updating items in DynamoDB&nbsp;</h3>
For updating the items we're going to create <code>updatePost</code> function.
<code>put</code> method of <code>documentClient</code> is used for inserting and updating the item based on the primary key. If there's an item already existing then it will update else insert the item into the table.
<pre class="language-javascript"><code>// Function to update the post based on postId
const updatePost = async (postId, title, content) =&gt; {
 const params = {
 TableName: 'Posts',
 Item: {
 postId,
 title,
 content,
 }
 };
 try {
 const data = await documentClient.put(params).promise();
 console.log('Post updated', data);
 } catch (err) {
 console.log(err);
 }
};
updatePost(
 'FPbCFAvNoKWinPadsNBoW',
 'Update sample post title',
 'Updated content'
);</code></pre>
By calling <code>updatePost(...)</code> with <code>postId</code>, <code>title</code> and <code>content</code> will update that particular post.&nbsp;
<h3>Deleting item in DynamoDB</h3>
For deleting the item we're going to create <code>deletePost</code> function.
<code>delete</code> method of <code>documentClient</code> is used for deleting the item based on the primary key.&nbsp;
<pre class="language-javascript"><code>// Function to delete the post from posts table/document by postId
const deletePost = async (postId) =&gt; {
 const params = {
 TableName: 'Posts',
 Key: {
 postId,
 }
 };
 try {
 const data = await documentClient.delete(params).promise();
 console.log('Post deleted', data);
 } catch (err) {
 console.log(err);
 }
};
deletePost('FPbCFAvNoKWinPadsNBoW');</code></pre>
By calling <code>deletePost(...)</code> function with <code>postId</code>, deletes the item from the <code>Posts</code> table.
That's the basic CRUD(Create, Read, Update, Delete) in DynamoDB using NodeJS. There are other methods and ways for querying data based on different conditions in AWS dynamodb. You can find the detailed documentation in these <a href="https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html" target="_blank" rel="noopener">docs</a>.
You can find all the above-discussed codes in this <a href="https://github.com/Basharath/dynamodb-crud" target="_blank" rel="noopener">dynamodb-crud git repository</a>.

AWS DynamoDB is a well-known NoSQL database. Here are the DynamoDB NodeJS CRUD operations with examples to help you get started using this NoSQL database.

Posts tagged with DynamoDB

Getting started with AWS DynamoDB NodeJS CRUD operations