DEV Community

Tochukwu Adams
Tochukwu Adams

Posted on • Updated on

Redis OM: Developer Experience using Node.Js

Using Redis database just for cache is like using a modern mobile phone just for phone calls! You are missing out on a ton of cool things it can do! Give it a try! - Raja Rao, (VP of Growth Marketing at Redis)

I couldn't agree more with Raja. There is a whole lot one can do with Redis, why limit yourself. Since I started using the Redis database to manage my data, first it improved my application speed, and I have learned a lot about Redis Stacks and Redis Cloud. In this tutorial, I will share my experience with you. We will go over how to create records in JSON format using the RedisJSON, index and search records using the RediSearch stacks. You can read my other blog How To Store And Retrieve RedisJSON on Redis Cloud using Node.js where I threw some light about the gains of using Redis and Redis Cloud.

Redis OM

Redis OM is the magic stick developers can use to create data model on our applications and map it to the Redis database. Just like Mongoose, with Redis OM we can create models that interact with the database. This tool makes us (Software Developers) have a better experience while using Redis on our application.

Goal

The aim of this tutorial is to learn how to use the Redis technologies to store our data on the Redis cloud while utilizing its high throughput and low latency. We will be creating a Digital Book Library API using NodeJs. The library database will contain a book entity.

Prerequisite
  • Node Engine
  • Yarn or NPM installer
  • IDE (E.g: Visual Studio Code)
Setup Redis Cloud Account

You can use this link Redis Cloud to create a free account. After registration click on the New subscription button to set up a plan. If you're new to Redis you can start with a free subscription to get yourself familiarised with the platform or you can pick a paid plan. For this tutorial, I am using the AWS vendor but you can choose other vendor you're more comfortable with. After creating a subscription you can go ahead and create a database. When creating a database, there is a type with three options for you to select from. For this tutorial we will be using the Redis Stack Modules.

Redis Stack gives you a software development experience by enabling you to create data models and map them to your database. With RedisJSON module you can create records in JSON format and use the RediSearch to query them.

Let's go create our API!

Project Setup

Create a project folder redis-book-libray (you can name your project differently) and CD into the project folder.
$ mkdir redis-book-libray

$ cd redis-book-libray

$ yarn init -y (You can use NPM)

$ yarn add express redis-om nodemon

In your project root folder, create a src folder that will hold most of your program logic. I like to separate concerns for code clarity, easy debugging and reusability. Let's set up our database connection. Create a connection.js file inside your src folder. On the client.open() method paste your database credentials there. You can get your database details from the configuration tab after logging.

import { createClient } from 'redis';
import { Client } from 'redis-om';

// Database connection
const client = new Client()
// E.g URL = 'redis://default:WyfL..WH...AtUS3...jW...nf@redis-1...1.c73.us-...t-1-2.ec2.c..d.redislabs.com:1...1'
const DBConnection = await client.open('redis://username:password@Public-endpoint:port');

export default DBConnection;

Enter fullscreen mode Exit fullscreen mode
Database Credentials

After registration, on your side bar click on Databases go to your Configuration tab, under General you will see your public endpoint which is your host and the digits after the colon is your port number, scroll down to security you will see your username and password. If you are using the free subscription your username is default.

Inside your src folder, create an app.js file that will serve as the gateway to your application. Don't pay attention to the imported route function for now. That will be sorted out later.

import express from 'express';
import routes from './routes.js';

const app = express()


app.use(express.json());


const PORT = process.env.PORT || 3000

app.use('/api/v1', routes);

app.listen(PORT, async () => {
    console.log(`app is running on port ${PORT}`)
})
Enter fullscreen mode Exit fullscreen mode

Go to your package.json file and set up your scripts.

{
  "name": "redis-book-libray",
  "version": "1.0.0",
  "main": "./src/app.js",
  "license": "MIT",
  "scripts": {
    "start": "nodemon ./src/app.js"
  },
  "type": "module",
  "dependencies": {
    "express": "^4.18.1",
    "nodemon": "^2.0.19",
    "redis-om": "^0.3.6"
  },
  "devDependencies": {
    "nodemon": "^2.0.19"
  }
}
Enter fullscreen mode Exit fullscreen mode

Go to your terminal or CMD, cd into your project and run yarn start or npm start.

The Next step is to define the Entity, Schema and Repository.

An Entity is a class for wrapping the objects that will be stored in the database. The Book Entity will extend to Redis OM Entity that will hold your data.

Schema is what we use to describe how the data will look. It defines the field and their types on the entity.

Repository is the interface that gives you access to create, read, update and delete methods that you can use to manipulate your records from the Entity class.

Inside the src folder create an BookEntity.js file that contains your Book Entity and Repository.

import { Entity, Schema } from 'redis-om';
import DBConnection  from './connection.js'

export class Book extends Entity {}

const BookSchema = new Schema(Book, {
    title: { type: 'string' },
    author: { type: 'string' },
    pages: { type: 'number' },
    publisher: { type: 'string' },
    publishedDate: { type: 'date' },
},{
    dataStructure: 'JSON'
});

export const BookRepository = DBConnection.fetchRepository(BookSchema)
await BookRepository.createIndex()
Enter fullscreen mode Exit fullscreen mode

Lets create our Controller and Routes file. Inside the src folder create a BookController.js file. This file will be a class that will contain your CRUD methods.

import { BookRepository } from './BookEntity.js';

export default class BookController {

    // store book
    static store = async (req, res, next) => {
        try {
            const book = await BookRepository.createAndSave(req.body);

            return res.send({
                status: "successful",
                data: book
            }, 201)
        } catch (error) {
            return next(error)
        }
    }

    // fetch specified book
    static getBook = async (req, res, next) => {
        try {
            const book = await BookRepository.fetch(req.params.id)
            return res.send({
                status: "successful",
                data: book
            })
        }catch (error) {
            return next(error)
        }
    }

    // update book
    static update = async (req, res, next) => {
        try {
            const book = await BookRepository.fetch(req.params.id);
            book.title = req.body.title;
            book.author = req.body.author;
            book.pages = req.body.pages;
            book.publisher = req.body.publisher;
            book.publishedDate = req.body.publishedDate;
            await BookRepository.save(book);

            return res.send({
                status: "successful",
                data: book
            })
        } catch (error) {
            return next(error)
        }
    }

    // delete book
    static delete = async (req, res, next) => {
        try {
            const id = req.params.id
            const result = await BookRepository.remove(id);

            return res.send({
                status: "successful",
            }, 200)
        } catch (error) {
            return next(error)
        } 
    }
}
Enter fullscreen mode Exit fullscreen mode

Let's set up our router with the necessary endpoints. Inside the src folder create a routes.js file. Remember your route file has been imported on the app.js file and it is bind to your Express app.

import express from 'express';
import BookController from './BookController.js';
import BookSearchController from './BookSearchController.js';

const router = express.Router();

router.post('/create', BookController.store)
router.get('/:id/book', BookController.getBook)
router.post('/:id/book', BookController.update)
router.delete('/:id/book', BookController.delete)

export default router;
Enter fullscreen mode Exit fullscreen mode

Go to your terminal on the root folder of your project and enter this command yarn start or npm start to start your app. Open your Postman (or whatever tool you use to test or consume RESTful APIs) and test your endpoint.

image

RediSearch

Is time to carry out some search on your Book records including full-text search. The Search class contains five methods.

import { BookRepository } from './BookEntity.js';

export default class BookSearchController {
    // find all book records
    static findAll = async (req, res) => {
        const result = await BookRepository.search().return.all()
        return res.json(result)
    }

    // find all albums where the artist is 'Charles Dickens'
    static findByAuthor = async (req, res) => {
        const result = await BookRepository.search().where('author').equals('Charles Dickens').return.all()
        return res.json(result);
    }

    // find all books where publishedDate year is equal to 2022
    static findByYear = async (req, res) => {
        const result = await BookRepository.search().where('publishedDate').eq(2022).return.all()
        return res.json(result)
    }

    // find first record
    static findFirstRecord = async (req, res) => {
        const result  = await BookRepository.search().return.first()
        return res.json(result)
    }

    // count all book records
    static countAll = async (req, res) => {
        const result = await BookRepository.search().return.count()
        return res.json(result)
    }
}
Enter fullscreen mode Exit fullscreen mode

Go to your routes.js file and bind your search methods to your Express router.

import express, { Router } from 'express';
import BookController from './BookController.js';
import BookSearchController from './BookSearchController.js';

const router = express.Router();

router.post('/create', BookController.store)
router.get('/:id/book', BookController.getBook)
router.post('/:id/book', BookController.update)
router.delete('/:id/book', BookController.delete)

// search routes
router.get('/search/count', BookSearchController.countAll)
router.get('/search/all', BookSearchController.findAll)
router.get('/search/:author', BookSearchController.findByAuthor)
router.get('/search/:year', BookSearchController.findByYear)
router.get('/search', BookSearchController.findFirstRecord)


export default router;
Enter fullscreen mode Exit fullscreen mode

Your file structure should look like the one below if you followed my tutorial.

📦redis-book-libray
 ┣ 📂node_modules
 ┣ 📂src
 ┃ ┣ 📜BookController.js
 ┃ ┣ 📜BookEntity.js
 ┃ ┣ 📜BookSearchController.js
 ┃ ┣ 📜app.js
 ┃ ┣ 📜connection.js
 ┃ ┗ 📜routes.js
 ┣ 📜package.json
 ┗ 📜yarn.lock
Enter fullscreen mode Exit fullscreen mode
Conclusion

You have learned how to use the Redis OM, NodeJs and Express framework to develop RESTful APIs

RESTful APIs using the Redis OM and NodeJs with Express framework. You can go ahead and create more Entities (E.g Publisher) to get acquainted with the Redis technologies. GitHub repository to the project.

This post is in collaboration with Redis

Related

Try Redis Cloud for free

Redis Developer Hub - tools, guides, and tutorials about Redis

RedisInsight Desktop GUI

Watch this video on the benefits of Redis Cloud over other Redis providers

Top comments (1)

Collapse
 
benwazzy profile image
Benwaz78

Wow!! This is Awesome