DEV Community: Osamuyi

How to Cache Database Results with Redis in Node.js

Osamuyi — Sun, 19 Nov 2023 05:00:09 +0000

The speed with which an application responds to user queries is an important performance metric that the application can be rated by. A major factor that has been proven to improve the response speed of an application is caching. Caching helps to enhance the performance of distributed systems.

When dealing with data that does not change too often, it is recommended that the results of the request be cached; this helps to reduce the number of API calls made to the database.

There are several tools for caching; however, in this article, we will be using Redis, an in-memory database that stores data in the server memory.

This article will be focused on caching and how to perform caching on database results with Redis in Node.

Why should you perform caching?
There are several reasons why developers should employ caching in their applications, amongst which are

To reduce latency, thus reducing response time.
To save or reduce costs. This is possible because caching reduces the load on the backend database(s), especially if the database charges per throughput.
Caching can greatly improve the performance of your application and, in the long run, lead to user satisfaction.
By implementing caching, developers can anticipate the performance of their applications, particularly during periods of high network requests.
When data is stored in the cache, users can still access this data even when there is a network outage.

Prerequisite

To follow through with this tutorial, a basic understanding of Node.js and how to build REST APIs' is required. You should have the following installed on your computer;

Node.js.
Redis: You can either have a local instance of Redis running on your local machine or use the Redis cloud service. For the purpose of this tutorial, we will be using a local instance of Redis.
For Windows users, you can follow through on how to download and install Redis on your local computer. For other operating systems, check out install Redis.
RedisInsight: is a Redis Graphical User Interface (GUI) tool that helps with visualizing data stored in the Redis database. It also helps in monitoring real-time changes in the database. Download and install RedisInsight.

Getting Started

Step 1: Project Setup

We will start with installing all the dependencies needed for this project and start an express server
i. create the directory for the project using the mkdir command

$ mkdir node_cache

ii. Navigate into the project directory using the cd command

$ cd node_cache

iii. Initialize your project and create a package.json file in the root folder of the project directory using the npm init command

$ npm init -y

The -y flag accepts all default suggestions automatically.
iv. Install the following dependencies from:

express,
ioredis: a Redis client for Node.js which can be used to connect your application to the Redis server
fetch If you are using the latest version of Node (> version 17.5), then you don't need to install the fetch API, as it comes inbuilt with the latest Node version. You can also use the axios API instead of the node fetch API, but to use axios you will need to install the package from the npm store. For the purpose of this project, we will be using the inbuilt node fetch API. To install the required packages all at once

$ npm i express ioredis

v. Now that the dependencies have all been installed, create an app.js file in the root directory of your project.

touch app.js

For Windows OS users, you can achieve the same method of file creation through Windows Powershell, using the command new-item. Thus to create an app.js file in windows

new-item app.js

You can also create the app.js file in your preferred text editor.
vi. Open the file in your preferred text editor. I will be using VS Code as my preferred text editor. In the app.js file, we are going to create a simple Express server

const express = require('express');

const app = express();
const PORT = 3300;

app.listen(PORT, () => {
  console.log(`App listening on port ${PORT}`);
});

Step 2: Retrieve data from an API without caching

We will make an API call to a third-party service, which, in turn, fetches data from a database, in order to retrieve the data we need. We will be making the API call from the Express server we built in step 1 above. Just so you know, the API call will be made without caching.
To begin, still, inside your app.js file, we will be making an API call to the REST COUNTRIES API to retrieve some data.

In your app.js, create a GET route. The GET method accepts two parameters, which are:

route parameter: It defines what should happen when a request is made to that specific route, in this case, '/country/:countryName'
callback function app.get('/country/:countryName', async (req, res) => {})

Note: The usage of the async keyword in the callback function of the GET route above is necessary due to the asynchronous nature of the fetch API. As the fetch function is asynchronous, we use async to declare the callback function as asynchronous. This allows us to use the await keyword within the function to wait for the result of the fetch API, ensuring that the data is fully retrieved before proceeding with further logic.

In the body of the callback function for our GET route, we will include a try{} catch{} block to effectively manage and handle any runtime errors that may occur

app.get('/country/:countryName', async (req, res) => {  
  try {

  } catch (error) {

  }
});

In the try{} catch{} block, we will call the node fetch API, which we will use to make an API call to REST COUNTRIES.

try {
   const data = await fetch(`https://restcountries.com/v3.1/name/${countryName}`)
  } catch (error) {
    console.log(error)
  }

When making a fetch request, it's necessary to invoke the .json() method on the response object to obtain the returned JSON data. Remember to include the await keyword, as you might get unparsed JSON data without it.

let result = await data.json();
    return res.status(200).send(result);

Our final code output will look like this:

const express = require('express');

const app = express();
const PORT = 3300;

app.get('/country/:countryName', async (req, res) => {
  const {countryName} = req.params;

  try {
    const data = await fetch(`https://restcountries.com/v3.1/name/${countryName}`);

let result = await data.json();
    return res.status(200).send(result);
  } catch (error) {
    console.log(error);
  }
});

app.listen(PORT, () => {
  console.log(`App listening on port ${PORT}`);
});

Now we can start our server by running $ node app.js and then open any API test tool of your choice. I will be using Postman for this. You can also download the Postman VS code extension.
The REST COUNTRIES API accepts many country's name initials, but we will use only the eest as a route parameter on the endpoint we will be testing throughout this tutorial.
In your postman, make a request to the country endpoint.
http://localhost:3300/country/eest

In the image displayed above, you'll notice that there's a highlighted section indicating that it takes approximately 1281 milliseconds for the request to be completed. This delay can be better optimized using caching, considering that the data being requested doesn't change frequently. Additionally, as your user base expands, the number of requests to this particular endpoint will increase, potentially leading to excessive strain on the database. But this issue can be resolved with caching

Step 3: Implementing Caching using Redis

Here, we will begin by starting our Redis server. In your terminal (wsl for windows users or redis-cli), type redis-server; this script will start the local redis server.
PS: You must have Redis installed in your computer.
To confirm if your local redis instance is up and running, open another terminal window and type redis-cli ping, and you will get back a response PONG.

Now that our redis server is up, we are going to connect our Express application to the local Redis server.

Firstly, inside your app.js file, import the ioredis module that was installed as a depency in step 1
const Redis = require('ioredis');

At the top of your GET route in the app.js file, create a function that connects to the Redis server.

let client;
(() => {  
    client = new Redis({
      port: 6379,
      host: '127.0.0.1',
    });

    client.on('connect', () => {
      console.log('Connected to Redis yo!');
    });

    client.on('error', (error) => {
      console.error(error);
    });
})();

In the above code, we declared a variable and then created an anonymous IIFE (Immediately Invoked Function Expression) function to connect our Express application to redis using ioredis. The variable client is declared outside of the IIFE function, so that it can be globally accessible outside of the function.

Inside the function, we called the new Redis() class to create a Redis instance and passed the connection parameters into the object. This method will come in handy if you are also trying to connect to the Redis cloud service. The new Redis instance is assigned to the client variable.

Also, call on the Node.js on() method which registers events on whichever object it is called on (in this case, the ioredis object). The on() method accepts two arguments; the name of the event and a callback function.

The client.on('connect', () => {}) function checks if the new Redis instance has successfully connected.

The client.on('error', () => {}) function checks if there is an error while trying to connect to the Redis server.

Next, we are going to implement cache hit logic. A cache hit is when data is successfully served from the cache memory. This code will look like:

let cachedData = await client.get(countryName);
    if (cachedData ) {
      return res.status(200).send(JSON.parse(cachedData));
    }

The ioredis get() method is used to get data from the redis server. We pass the countryName as an argument into the get() method.

The if(cachedData){} conditional statement checks if the cachedData variable has data, if it returns true, this is known as a cache hit. The cacheData variable is then converted to a JavaScript object using the JSON.parse() method, and the result is returned to the user.

After implementing the cache hit logic, next we will implement the cache miss logic. This is what happens when the cache hit fails, meaning there is no data with that key name in the redis server. The code logic for the cache miss would look like:

client.set(countryName, JSON.stringify(result));

The ioredis set() method plays a crucial role in storing data on our Redis cache server. This method requires two arguments: the key and data (in this case, countryName and result).

To elaborate further, the first argument, countryName, serves as the key under which the data is stored on the Redis server. It's essential to recall that countryName is a dynamic value, initially parsed in our endpoint '/country/:countryName'. Therefore, when users access the endpoint '/country/eest', the countryName dynamically becomes and is stored as eest on the Redis server.

The second argument holds the result retrieved either directly from the database or through a third-party API call. To ensure compatibility, we employ the JSON.stringify() method on the result. This step converts the obtained data into a JSON string. Also, recall that in our cache hit logic, when we retrieve data using the get() method, we subsequently use JSON.parse() on the cachedData. This action converts the data back into a JavaScript object, ensuring seamless integration into our application's logic.

Your updated code should look like:

const express = require('express');
const Redis = require('ioredis');

const app = express();
const PORT = 3300;

// Connect to the redis server
let client;
(() => {
  client = new Redis({
    port: 6379,
    host: '127.0.0.1',
  });

  client.on('connect', () => {
    console.log('Connected to Redis yo!!');
  });

  client.on('error', (error) => {
    console.error(error);
  });
})();


app.get('/country/:countryName', async (req, res) => {
  const {countryName} = req.params;

  try {
    //cache hit
    let cachedData = await client.get(countryName);

    if (cachedData) {
      return res.status(200).send(JSON.parse(cachedData));
    }

const data = await fetch(`https://restcountries.com/v3.1/name/${countryName}`);

    let result = await data.json();

    //cache miss
    client.set(countryName, JSON.stringify(result));

    return res.status(200).send(result);
  } catch (error) {
    console.log(error);
  }
});

app.listen(PORT, () => {
  console.log(`App listening on port ${PORT}`);
});

Save your code and navigate to Postman to test the endpoint

From the above image, we can see that the response time was high (1789ms). When we requested the data from the endpoint, the API call was made directly to the Rest Countries API, the cachedData variable returns null because there is no data with the key countryName stored in our Redis cache server yet. Thus there is a cache miss, then the rest codes after the if(cachedData){} condition would run, and eventually, the data is saved to the Redis cache server.

If you make the same request to the same API endpoint as shown below, you will see that the response time would significantly reduce, as shown below:

From the image above, we can see that it took 311ms to return data to the user, this is because, the data was already saved in the Redis server, thus faster retrieval.

Conclusion

The significance of caching in software development cannot be overstated. Its impact extends beyond just enhancing our application; it also plays a crucial role in cost savings, particularly when our service/application relies on data from paid API services or databases.

The complete code can be found Here

Count Number of Times an Item Appears in an Array

Osamuyi — Sat, 15 Apr 2023 11:32:23 +0000

JavaScript array methods are very powerful functions(methods) that have abstracted a lot of their functionalities. These methods help developers ease the manipulation of arrays to achieve the desired result.
check array methods for a list of some array methods in JavaScript.

For example; imagine you are working with the array below and are required to count the number of times each element in the array appears.

const data = [
  'car',
  'car',
  'truck',
  'truck',
  'bike', 'SUV', 'van','car',
  'walk',
  'car',
  'van',
  'bike',
  'walk',
  'car',
  'van',
  'car',
  'truck',
];

A couple of array methods can be used to get the desired result.

Count the number of items using `reduce()` method

//set the result to a variable
let itemsObject = data.reduce((accumulator, item) => {
  if (accumulator[item]) {
    ++accumulator[item];
} else {
    accumulator[item] = 1;
}
return accumulator;
}, {})


//USING TENARY OPERATOR
let itemsObject = data.reduce((accumulator, item) => {
 return accumulator[item] ? ++accumulator[item] : (accumulator[item] = 1), accumulator
}, {})


console.log(itemsObject)
/*
 {
  bike: 2,
  car: 6,
  SUV: 1,
  truck: 3,
  van: 3,
  walk: 2
}
*/

reduce() is a method that helps in getting the number of occurrences of each item in an array.

Count the number of items using `for of` loop

The for of loop is a modification of the for loop. It makes it easier to iterate through iterables such as arrays, maps, strings etc. It functions operates just like the forEach() method. The major difference between the for of loop and forEach() method is that, the for of loop is more compatible with async functions.

//initialize an empty object to store the items
let countVal = {};
for (val of data) {
  if (countVal[val]) {
    countVal[val] += 1;
  } else {
    countVal[val] = 1;
  }
}

console.log(countVal)
/*
 {
  bike: 2,
  car: 6,
  SUV: 1,
  truck: 3,
  van: 3,
  walk: 2
 }
*/

Conclusion

Several other array methods can also be used to accomplish this task, however, if you need to count the number of items present in an array, using the for of loop is preferable because of its compatibility with async functions. The reduce() method is also a good option to use.

Solving Leetcode's "Richest Customer Wealth" Challange with Javascript

Osamuyi — Tue, 21 Feb 2023 12:54:07 +0000

This problem was quite challenging for me at the beginning, cos one needs to have a fairly good understanding of how multi-dimensional arrays work. Eventually, I was able to figure it out, and I will walk you through my solution.

The question states thus;

You are given an m x n integer grid accounts where accounts[i][j] is the amount of money the Ith customer has in the jth bank. Return the wealth that the richest customer has.

A customer's wealth is the amount of money they have in all their bank accounts. The richest customer is the customer that has the maximum wealth.

Example

Input: accounts = [[1,5],[7,3],[3,5]]
Output: 10
Explanation: 
1st customer has wealth = 6
2nd customer has wealth = 10 
3rd customer has wealth = 8
The 2nd customer is the richest with a wealth of 10.

Solution
Firstly as with all programming challenges, we first need to understand the problem here, so we can come up with an algorithm for the solution.

We are expected to iterate through each embedded array.
Since it's a multi-dimensional array, we would need a nested loop
Get the sum of elements in each array
Push these sums into a new array
Return the highest number in the new array

function richestCus(accounts) {
    let newArr = [];
    for(let i = 0; i < accounts.length; i++) {
        let sum = 0;
        for(let j = 0; j < accounts[i].length; j++) {
            sum += accounts[i][j]
        }
        newArr.push(sum)
    }
    return Math.max.apply(null, newArr)

}

Explanation
What we did above was

We initialized a new array variable let newArr = []; inside the function. So that we can push our results into the array
Iterate through the outer array. If we log/print the result of the outer array we will see that the outer array has been broken down into single arrays. for example if;

accounts = [[1,2,3],[1,2,3],[6, 8, 10]]
console.log(accounts)// [1,2,3][1,2,3][6, 8, 10]

Inside the outer loop, initialize a variable let sum = 0, so that we can use it to add up elements in each array
Create a nested loop inside the initial loop, so that we can have access to the elements in each sub-array.
Add the elements in each sub-array inside the nested loop and assign the result to the sum variable.
At the end of each iteration of the nested loop, the sum result is pushed unto the new array variable that was created.
newArr.push(sum)
Finally, to get the highest number in our new array, we call the Math.max() function on our array.
The Math.max() function returns the largest of zero or more numbers, and we can pass any number of arguments.

console.log(Math.max(5,9,7,3)); // logs 9

But you can't pass an array of numbers on the Math.max() function like this

var num = [5,9,7,3];
console.log(Math.max(num)); // logs NaN

Thus we introduce the apply() method which accepts arguments in an array, like
Math.max.apply(null, newArr)

N:B => The first argument to the apply() method, sets the value to this, and since we don't have a need for it, hence we passed null as our first argument.

With the above explanation, I hope you've learned a thing or two from this article.

PS: I'm open to more efficient solutions

Cheers!!!

A step-by-step Guide to Creating a Blogging API/App with Nodejs/Express and MongoDb

Osamuyi — Tue, 10 Jan 2023 15:22:33 +0000

A blog is a web page that is frequently updated, and which can be used for personal personal commentary or business content.

The features of the Api will include

Users (logged in or not) will be able able to access the homepage which displays a list of all published blog articles
Users will provide their email and password to login
Emails used for registering to the application will be unique
Users will have the option to register/sign-up so they can have the right to update and publish blog articles
Before anyone can login to the blog, an authentication will first be carried out to ensure that the user's credentials are available in the database, before access can be granted to such user.

To get started, in your terminal initialize an empty Node.js project with default settings:

npm init -y

installation
Then, let's install the Express framework, and some other depencies for the project:

npm install express body-parser dotenv jsonwebtoken bcrypt mongoose validator  --save

Body-parser middleware helps parse incoming requests from the body of the request before it gets to the handler.
dotenv package serves as a file that helps save sensitive information such as passwords, API keys; out of the main code
bcrypt: is a function hashing function, that helps in hashing a password before it is saved in the database. This will make it difficult for malicious hackers to be able to decrypt the passwords if they get access to the database.
jsonwebtoken: is used for both authentication and authorization. We would get into it eventually in this article.
mongoose; is an ORM used to query and manipulate data in the database. For the purpose of this project, we'll be working with MongoDb.

index.js
This is going to be the entry point for our blog api. So create a file called index.js in the root folder, and type in the following code

const express = require('express')
const bodyParser = require('body-parser')

const app = express()
const PORT = 3333;

app.get('/api', function (req, res) {
  return res
    .status(201)
    .json({ test_page: 'A step further to becoming a worldclass developer' });
});


app.listen(PORT, () => {
  console.log(`Server listening on port: ${PORT}`)
})

In the code above, we required the express function, and then created an express server. After which, a custom route handler was created with the app.get() function. Now if you restart your server and go to http://localhost:3333/api, you will get a custom message displayed in the response header.

Database configuration
Create a *config * folder in the root directory of your project. Then create a dbconfig.js file. It should contain the following code

const moogoose = require('mongoose');
require('dotenv').config();

const MONGODB_URI = process.env.MONGODB_URI;

// connect to mongodb
function connectToMongoDB() {
    moogoose.connect(MONGODB_URI);

    moogoose.connection.on('connected', () => {
        console.log('Connected to MongoDB successfully');
    });

    moogoose.connection.on('error', (err) => {
        console.log('Error connecting to MongoDB', err);
    })
}

module.exports = { connectToMongoDB };

Ensure to provide a url for the MONGODB_URI variable in the dotenv file, and also a JWT_SECRET of your choice
Also, require the connectToMongoDB function in the index.js folder like this

require('./config/dbconfig').connectToMongoDB()

Next, we create a model folder in the root directory of our project.
models
In here, we will be having two services/models. One for the user, and the other for the blog.
user_Model.js

const mongoose = require('mongoose');
const bcrypt = require('bcrypt');
const validator = require('validator');
const saltRounds = 10;

const Schema = mongoose.Schema;

const userSchema = new Schema(
  {
    firstname: {
      type: String,
      required: [true, 'Your First name is required'],
    },
    lastname: {
      type: String,
      required: [true, 'Your last name is required'],
    },
    email: {
      type: String,
      required: [true, 'Your email address is required'],
      unique: [true, 'This email already exists'],
      lowercase: true,
      validate: [validator.isEmail, 'Provide a valid email address'],
    },
    password: {
      type: String,
      required: true,
      minlength: [8, 'Password must be at least 8 characters long'],
      select: false,
    },
    articles: [
      {
        type: Schema.Types.ObjectId,
        ref: 'Blog',
      },
    ],
  },
  { timestamps: true }
);

// Using bcrypt to hash user password before saving into database
userSchema.pre('save', function (next) {
  const user = this;

  bcrypt.hash(user.password, saltRounds, (err, hash) => {
    user.password = hash;
    next();
  });
});

const User = mongoose.model('user', userSchema);
module.exports = User;

In the above code, firstly we created a mongoose user schema, to help us define the structure of our document. Note that we referenced the blog in the article property. This is to makesure there is a link between a blog article and the user that posted the blog.
Also note the pre('save') function at the bottom of the schema, it ensures that the password given by the user when registering is hashed before is can be saved into the database. We achieved this using the external library which was installed earlier in the project "bcrypt".
blog_Model.js

const mongoose = require('mongoose');
const user = require('./users_model');

const Schema = mongoose.Schema;

//BlogPost schema
const BlogPostSchema = new Schema(
  {
    title: {
      type: String,
      required: [true, 'Title missing, provide a title'],
      unique: [true, 'Title name already exists'],
    },
    description: {
      type: String,
      required: [true, 'Description missing, provide a description'],
    },
    author: {
      type: Schema.Types.ObjectId,
      ref: 'User',
      required: true,
    },
    state: {
      type: String,
      enum: ['Draft', 'Published'],
      default: 'Draft',
    },
    read_count: {
      type: Number,
      default: 0,
    },
    reading_time: {
      type: String,
      required: [true, 'Provide a reading_time'],
    },
    tags: {
      type: String,
      required: [true, 'Specify tags'],
    },
    body: {
      type: String,
      required: [true, 'Body is needed'],
    }
  },
  {
    timestamps: true,
  }
);

const Blog = mongoose.model('BlogPost', BlogPostSchema);
module.exports = Blog;

Controller
The controller will contain the logic for our project. We will created three files in our controller folder: userController, BlogpostController and ErrorController

const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');

const util = require('util');

const userModel = require('../models/users_model');
const tryCatchErr = require('../utilities/catchErrors');
const serverErr = require('../utilities/serverError');
const CONFIG = require('../config/config');

const JWT_SECRET = CONFIG.JWT_SECRET;

//Create token function and set expiration to 1hr
const signInToken = (id) => {
  return jwt.sign({ id }, JWT_SECRET, { expiresIn: '1h' });
};

////////////////////////////////////////////////////////////////
/*
 * SIGN IN NEW USER
 */
/////////////////////////////////////////////////////////////////

exports.createUser = tryCatchErr(async (req, res, next) => {
  const user = await userModel.create({
    firstname: req.body.firstname,
    lastname: req.body.lastname,
    email: req.body.email,
    password: req.body.password,
  });

  const token = signInToken(user._id);
  res.status(200).json({
    status: 'success',
    token,
    data: {
      user: user,
    },
  });
});

////////////////////////////////////////////////////////////////
/*
 * LOGIN IN USER
 */
/////////////////////////////////////////////////////////////////

exports.login = tryCatchErr(async (req, res, next) => {
  const { email, password } = req.body;


  const user = await userModel.findOne({ email })
  if (!user) {
    return next(new serverErr('User not found', 401));
  }
  bcrypt.compare(password, user.password, (error, result) => {
  if (error) return next (error)
  if (!result) {
     return next(new serverErr('Wrong email and/or password', 401));
}
};

  const token = signInToken(user._id);
  res.status(201).json({
    status: 'success',
    token,
  });
});

////////////////////////////////////////////////////////////////////////
/*
 * Authenticating routes
 */
///////////////////////////////////////////////////////////////////////

exports.authenticate = tryCatchErr(async (req, res, next) => {
  let bearerToken;
  if (
    req.headers.authorization &&
    req.headers.authorization.startsWith('Bearer')
  ) {
    bearerToken = req.headers.authorization.split(' ')[1];
  }
  if (!bearerToken) {
    return next(new serverErr('Unauthirized, Login to continue', 401));
  }

  //Verify token
  const user = await util.promisify(jwt.verify)(bearerToken, JWT_SECRET);

  //Confirm if user still exists
  const currentUser = await userModel.findById(user.id);
  if (!currentUser) {
    return next(new serverErr('User does not exist', 401));
  }
  req.user = currentUser;
  next();
});

blog_controller.js

const blogModel = require('../models/blog_model');
const userModel = require('../models/users_model');
//const userService = require('../Services/UserServices');

const tryCatchErr = require('../utilities/catchErrors');
const serverError = require('../utilities/serverError');

require('dotenv').config();

///////////////////////////////////////////////////////////////
/*
 * Get all blog posts
 *
 */

///////////////////////////////////////////////////////////////

exports.getAllBlogs = tryCatchErr(async (req, res, next) => {
  const objectQuerry = { ...req.query };

  /// Filteration
  const removedFields = ['page', 'sort', 'limit', 'fields'];
  removedFields.forEach((field) => delete objectQuerry[field]);

  let query = blogModel.find(objectQuerry);

  // Sorting
  if (req.query.sort) {
    const sortParams = req.query.sort.split(',').join(' ');
    query = query.sort(sortParams);
  } else {
    // sorting by the most recent blog posted
    query = query.sort('-createdAt');
  }

  //Pagination
  const page = req.query.page * 1 || 1;
  const limit = req.query.limit * 1 || 20;
  const skip = (page - 1) * limit;

  if (req.query.page) {
    const numArticles = await blogModel
      .countDocuments()
      .where({ state: 'Published' });
    if (skip >= numArticles) {
      throw new serverError('Page does not exist', 404);
    }
  }

  query = query.skip(skip).limit(limit);

  //Displaying a single published blop post
  const publishedBlogPost = await blogModel
    .find(query)
    .where({ state: 'Published' })
    .populate('user', { firstname: 1, lastname: 1, _id: 1 });

  res.status(200).json({
    status: 'success',
    result: publishedBlogPost.length,
    curentPage: page,
    limit: limit,
    totalPages: Math.ceil(publishedBlogPost.length / limit),
    data: {
      publishedBlogPost,
    },
  });
});

////////////////////////////////////////////////////////////////
/*
 * CREAT A NEW BLOG ARTICLE
 * route: get /api/blogs
 */
////////////////////////////////////////////////////////////////
exports.creatBlog = tryCatchErr(async (req, res, next) => {
  const { title, description, state, tags, body } = req.body;

  if (!title || !description || !state || !tags || !body) {
    return next(new serverError('Provide all required information', 401));
  }

  // Get/Authenticate the user creating the blog
  const user = await userModel.findById(req.user._id);
  console.log(req.user._id);

  //Calculating the average read time of the blog
  let avgWPM = 250;
  const readTime = Math.ceil(body.split(/\s+/).length / avgWPM);
  const reading_time =
    readTime < 1 ? `${readTime + 1} minute read` : `${readTime} minutes read`;

  const author = `${user.firstname} ${user.lastname}`;

  const newblogArticle = new blogModel({
    title: title,
    description: description,
    author: req.user._id,
    reading_time: reading_time,
    state: state,
    tags: tags,
    body: body,
    user: user._id,
  });

  //   //save the blog article
  const savedBlogArticle = await newblogArticle.save();

  //Add the article to the author's blogs
  user.articles = user.articles.concat(savedBlogArticle._id);

  await user.save();
  res.status(201).json({
    message: 'Blog Article Created successfully',
    data: {
      blog: savedBlogArticle,
    },
  });
});

/////////////////////////////////////// ////////////////////////
/*
 * Get a single blog post
 * Get /api/blogs/:id
 */
////////////////////////////////////////////////////////////////

exports.getBlogById = tryCatchErr(async (req, res, next) => {
  const blog = await blogModel
    .findById(req.params.id)
    .where({ state: 'Published' })
    .populate('user', { firstname: 1, lastname: 1, _id: 1 });

  if (!blog) {
    return next(new serverError('Blog article not found', 404));
  }

  //Updating the read count
  blog.read_count += 1;

  //Save to DB
  blog.save();

  res.status(201).json({
    status: 'Success',
    blog,
  });
});

//////////////////////////////////////////////////////////////////
/*
 * Get all blog posts by user ID
 * Get /api/blogs
 */
//////////////////////////////////////////////////////////////////
exports.getUserArticle = tryCatchErr(async (req, res, next) => {
  const user = req.user;

  const queryObject = { ...req.query };

  const removedFields = ['page', 'sort', 'limit'];
  removedFields.forEach((field) => delete queryObject[field]);

  let blogQuerry = blogModel.find({ user });

  // Sorting
  if (req.blogQuerry.sort) {
    const sortBy = req.blogQuerry.sort.split(',').join(' ');
    blogQuerry = blogQuerry.sort(sortBy);
  } else {
    blogQuerry = blogQuerry.sort('-createdAt'); // default sorting : starting from the most recent
  }

  // Pagination
  // convert to number and set default value to 1
  const page = req.blogQuerry.page * 1 || 1;
  const limit = req.blogQuerry.limit * 1 || 20;
  const skip = (page - 1) * limit;

  if (req.blogQuerry.page) {
    const numArticles = await blogQuerry.countDocuments();
    if (skip >= numArticles)
      throw new serverError('This page does not exist', 404);
  }
  blogQuerry = blogQuerry.skip(skip).limit(limit);

  blogQuerry = blogQuerry.populate('user', {
    firstname: 1,
    lastname: 1,
    _id: 1,
  });

  const articles = await blogQuerry;

  return res.status(200).json({
    status: 'success',
    result: articles.length,
    data: {
      articles: articles,
    },
  });
});

/////////////////////////////////////////////////////////////////////
/*
 * Update blog post by Author

 */
////////////////////////////////////////////////////////////////////////////////////////////////

exports.updateBlog = tryCatchErr(async (req, res, next) => {
  const { title, description, state, tags, body } = req.body;

  const user = req.user;

  const blogPostId = await blogModel.findById(req.params.id);
  //confirm user credentials
  if (user.id !== blogPostId.user._id.toString()) {
    return next(
      new serverError('Authorization is required to update this document', 401)
    );
  }

  //Update Blog
  const updatedBlogPost = await blogModel.findByIdAndUpdate(
    { _id: req.params.id },
    {
      $set: {
        title: title,
        description: description,
        state: state,
        tags: tags,
        body: body,
      },
    },
    {
      new: true,
    }
  );
  res.status(201).json({
    status: 'Success',
    data: {
      updatedBlogPost,
    },
  });
});

//////////////////////////////////////////////////////////////////////
/*
 *Delete blog post by Author
 * Protected route
 */
//////////////////////////////////////////////////////////////////////
exports.deleteBlog = tryCatchErr(async (req, res, next) => {
  const user = req.user;

  const blogPostId = await blogModel.findById(req.params.id);
  const blogAuthor = await userModel.findById(user.id);

  //console.log(blogPostId, blogAuthor);

  if (user.id !== blogPostId.user._id.toString()) {
    return next(
      new serverError('Authorization is required to delete this document')
    );
  }
  await blogModel.findByIdAndDelete(req.params.id);

  const index = blogAuthor.articles.indexOf(req.params.id);
  if (index === -1) {
    return next(new serverError('Blog post not found', 404));
  }
  blogAuthor.articles.splice(index, 1);
  await blogAuthor.save();

  res.status(201).json({
    status: 'Success',
    message: 'Blog post deleted successfully',
  });
});

error_controller.js

module.exports = (err, req, res, next) => {
  err.statusCode = err.statusCode || 500;
  err.status = err.status || 'error';
  res.status(err.statusCode).json({
    status: err.status,
    message: err.message,
  });
};

Routes
In the route folder, create a "user_route.js" and "blog_route.js" files
user_route.js

 const express = require('express');

const { createUser, login } = require('./../controllers/users_controller');

const router = express.Router();

router.post('/register', createUser);
router.post('/authenticate', login);

module.exports = router;

blog_route.js

const express = require('express');

const {
  getAllBlogs,
  creatBlog,
  getBlogById,
  getUserArticle,
  updateBlog,
  deleteBlog,
} = require('../controllers/blog_controller');
const { authenticate } = require('../controllers/users_controller');

const router = express.Router();

router.route('/').get(getAllBlogs).post(authenticate, creatBlog);

router.route('/:id').get(getBlogById);

router
  .route('/blog_aticles/:id')
  .get(authenticate, getUserArticle)
  .put(authenticate, updateBlog)
  .delete(authenticate, deleteBlog);

module.exports = router;

In the project's root folder, create a utilites folder will store our errors. It will contain two files "catchErrors.js" and "serverError.js"
catchError.js

const tryCatchError = (name) => {
  return (req, res, next) => {
    name(req, res, next).catch(next);
  };
};

module.exports = tryCatchError;

serverError.js

class serverErr extends Error {
  constructor(message, statusCode) {
    super(message);
    this.statusCode = statusCode;
    this.status = `${statusCode}`.startsWith('4') ? 'fail' : 'error';
    this.isOperational = true;
    Error.captureStackTrace(this, this.constructor);
  }
}

module.exports = serverErr;

Now, we update our index.js file.

const express = require('express');
const logger = require('morgan');
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

const users = require('./app/api/routes/user_routes');
const blogs = require('./app/api/routes/blog_route');
const CONFIG = require('./app/api/config/config');
const connectToDb = require('./app/api/Db/mongodb');
const errorHandler = require('./app/api/controllers/error_controllers');
const serverError = require('././app/api/utilities/serverError');

const app = express();
app.use(logger('dev'));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());

//CONNECT to MongoDB
connectToDb();

app.use('/api/users', users);
app.use('/api/blogs', blogs);

app.get('/api', function (req, res) {
  return res
    .status(201)
    .json({ test_page: 'A step further to becoming a worldclass developer' });
});

//Undefined route error handler
app.all('*', function (req, res, next) {
  next(new serverError('Undefined route, page not found.', 404));
});

//HANDLE ERROR
app.use(errorHandler);

app.listen(CONFIG.PORT, () => {
  console.log('Node server listening on port 3000');
});

Now, we can connect to our database and test our code.

Conclusion
In this project we created a blog API that performs basic CRUD operations, using Express.js, MongoDb and jsonwebtoken for authentication. I would appreciate your reviews. Thank you

DEV Community: Osamuyi

How to Cache Database Results with Redis in Node.js

Prerequisite

Getting Started

Step 1: Project Setup

Step 2: Retrieve data from an API without caching

Step 3: Implementing Caching using Redis

Conclusion

Count Number of Times an Item Appears in an Array

Count the number of items using reduce() method

Count the number of items using for of loop

Conclusion

Solving Leetcode's "Richest Customer Wealth" Challange with Javascript

A step-by-step Guide to Creating a Blogging API/App with Nodejs/Express and MongoDb

Count the number of items using `reduce()` method

Count the number of items using `for of` loop