DEV Community: Sachin Sarawgi

Getting started with Spring Boot and Liquibase

Sachin Sarawgi — Tue, 11 Apr 2023 07:23:07 +0000

Java developers often use the Spring Boot framework to create web apps. It has a number of features that make it simple to start using and develop reliable, scalable apps. An open-source tool for managing database schema is called Liquibase. It makes it simple for developers to handle database changes, migrate between schema versions, and version control the database schema. Using a straightforward example, we’ll go over how to get started with Spring Boot and Liquibase in this tutorial.

Step 1: Create a new Spring Boot project

To create a new Spring Boot project, you can use the Spring Initializr. This web-based tool allows you to generate a new Spring Boot project with all the necessary dependencies and configurations.

Open your web browser and navigate to the Spring Initializr website at https://start.spring.io/.
Fill in the following details: – Project: Maven Project – Language: Java – Spring Boot: 3.0.5 – Group: com.springboot – Artifact: learningLiquibase – Packaging: Jar – Java: 11 – Description: Getting started with Spring Boot & Liquibase
Click on Add dependencies and add the following dependencies: – Spring Web – Spring Data JPA – H2 Database – Liquibase Migration
Click on Generate and download the generated zip file.
After all configuration, the setup should look like this.

Step 2: Setup the database

In this example, we’ll use the H2 database. Spring Boot comes with auto-configuration for H2, so we don’t need additional configuration.

Open the application.properties file located in the src/main/resources directory and add the following properties

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=learner
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialectydsfjbm

These properties configure the H2 database for our application.

Create a new file called schema.sql in the src/main/resources directory and add the following SQL statements:

CREATE TABLE customer (
  id INT PRIMARY KEY,
  name VARCHAR(50)
);

This will create a table called customer with two columns: id and name.

Step 3: Configure Liquibase

Liquibase provides a way to version control the database schema and manages database changes. In this step, we’ll configure Liquibase for our Spring Boot application.

Create a new file called liquibase.properties in the src/main/resources directory and add the following properties:

spring.liquibase.change-log=classpath:/db/changelog/db.changelog-master.yaml

This property tells Liquibase where to find the changelog file.

Create a following directory path db/changelog in the src/main/resources directory.
Create a new file called db.changelog-master.yaml in the src/main/resources/db/changelog directory and add the following content:

databaseChangeLog:
  - include:
      file: classpath:/db/changelog/changes/001-initial-schema.sql

This file defines a master changelog that includes a single changelog file called 001-initial-schema.sql.

Create a new directory called changes in the src/main/resources/db/changelog directory.
Create a new file called 001-initial-schema.sql in the src/main/resources/db/changelog/changes directory and add the following SQL statements:

CREATE TABLE customer (
  id INT PRIMARY KEY,
  name VARCHAR

This file contains the same SQL statements that we added to schema.sql. This is because we want Liquibase to create the same database schema that we defined in schema.sql.

Step 4: Create a REST Controller

Create a new file called CustomerController.java in the src/main/java/com/springboot/learningLiquibase directory and add the following content:

   package com.springboot.learningLiquibase;

   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.http.HttpStatus;
   import org.springframework.http.ResponseEntity;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;

   import java.util.List;

   @RestController
   public class CustomerController {

       @Autowired
       private CustomerRepository customerRepository;

       @GetMapping("/customers")
       public ResponseEntity<List<Customer>> getAllCustomers() {
           List<Customer> customers = customerRepository.findAll();
           return new ResponseEntity<>(customers, HttpStatus.OK);
       }
   }

This class defines a REST controller with a single endpoint that returns a list of customers. It uses the CustomerRepository to retrieve the data from the database.

Create a new file called CustomerRepository.java in the src/main/java/com/springboot/learningLiquibase directory and add the following content:

package com.springboot.learningLiquibase;

import org.springframework.data.jpa.repository.JpaRepository;

public interface CustomerRepository extends JpaRepository<Customer, Integer> {
}

This interface extends the JpaRepository interface and defines a repository for the Customer entity. It provides methods for common database operations such as findAll(), findById(), save(), and delete().

Create a new file called Customer.java in the src/main/java/com/springboot/learningLiquibasedirectory and add the following content:

package com.springboot.learningLiquibase;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class Customer {

    @Id
    private Integer id;

    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

This class defines the Customer entity with two properties: id and name. It uses JPA annotations to map the entity to the customer table in the database.

Step 5: Run the application

Open a terminal window and navigate to the root directory of the project.
Build the application by running the following command

java -jar target/liquibase-demo-0.0.1-SNAPSHOT.jar

This will start the application and listen for incoming HTTP requests.

Step 6: Test the application

Open a web browser and navigate to http://localhost:8080/customers.
You should see a JSON response containing an empty array []. This is because we still need to add customers to the database.
Open a command prompt and navigate to the root directory of the project.
Run the following command to start the H2 console:

java -jar target/liquibase-demo-0.0.1-SNAPSHOT.jar --spring.h2.console.enabled=true

This will start the H2 console and open a web browser window.

In the H2 console, enter the following JDBC URL:

jdbc:h2:mem:testdb

This will connect to the in-memory H2 database.

Click on the Connect button.
You should see the CUSTOMER table in the list of tables. Click on the table
Click on the SQL tab and enter the following SQL statement to insert a new customer:

INSERT INTO CUSTOMER (ID, NAME) VALUES (1, 'John Doe');

This will insert a new row into the CUSTOMER table with id 1 and name "John Doe".

Click on the Run button to execute the SQL statement.
Refresh the web browser window and you should see a JSON response containing a single customer with id 1 and name "John Doe".

Congratulations! You have successfully created a Spring Boot application with Liquibase integration and tested it by adding a new customer to the database and retrieving the data through a REST API.

Step 7: Additional configuration

By default, Liquibase will look for a changelog file named db.changelog-master.yaml in the resources/db/changelog directory. You can change the location of the file by setting the spring.liquibase.change-log property in the application.properties file.
For example, to use a changelog file named liquibase-changelog.yaml in the root directory of the project, add the following line to the application.properties file:

spring.liquibase.change-log=classpath:/liquibase-changelog.yaml

You can also configure Liquibase to use a different database than H2. To do this, you need to add the appropriate JDBC driver dependency to the pom.xml file and set the spring.datasource.url, spring.datasource.username, and spring.datasource.password properties in the application.properties file. For example, to use MySQL as the database, add the following dependency to the pom.xml file:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.23</version>
</dependency>

Then, set the following properties in the application.properties file:

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password

Replace mydb, root, and password with your own database name, username, and password, respectively.

That’s it! You now have a fully functional Spring Boot application with Liquibase integration. You can use this project as a starting point for your own applications and customize them as needed.

If you like the content, make sure to live a like :).

How to build a URL Shortener like bitly or shorturl using Node.js

Sachin Sarawgi — Fri, 19 Jun 2020 19:14:53 +0000

In this blog, we will see how to build a URL Shortner like bitly or shorturl using NodeJS.

We may have heard many times that people are asking to build a URL shorter as an interview question, it’s not that complex but giving it a start to build one is complex though :).

So without wasting time let’s do it.

What is a URL Shortner

A URL shortener is a simple tool that takes a long URL and turns it into whatever URL you would like it to be.

Why we need it

Sometimes the links to a location or generally to a social platform become so big that it becomes difficult to manage them. A URL shorter will help in managing, track-compile click data, and one important point they promote sharing.

npm Packages We Are Going To Use

config : It lets you define a set of default parameters, and extend them for different deployment environments (development, QA, staging, production, etc.). For production, we have to define production.js similarly for development devlopment.js. By default, it will look for default.js.

This will be used to store config related to DB and others.

valid-url: This module collects common URI validation routines to make input validation, and maintaining easier and more readable. All functions return an untainted value if the test passes, and undefined if it fails.

This will be used to validate the URL given by the user for a shortening purpose.

shortid: ShortId creates amazingly short non-sequential URL-friendly unique ids.

This will be used to generate a unique id for each shortened URL.

express: The Express philosophy is to provide small, robust tooling for HTTP servers, making it a great solution for single-page applications, web sites, hybrids, or public HTTP APIs.

This will be used to create the server and route different HTTP path.

mongoose: Mongoose is a MongoDB object modeling tool designed to work in an asynchronous environment. Mongoose supports both promises and callbacks. As they use promise we will use async and await feature of JS.

This will be used for connecting with MongoDB, saving, updating and querying the DB.

Next, let’s setup MongoDB for setting our database.

Setting Up MongoDB Atlas

I wanted to use the cloud setup of MongoDB instead of a local setup, you can choose what fits better for you.

Steps for setting up cloud MongoDB Atlas account:

Visit the site https://www.mongodb.com/cloud/atlas
Make an account, the cloud setup is free
Create a cluster

Go to Connect, create a user
Go to connect your application, you will see a URL (just remember the location of URL). Password will be replaced by your account password.

Setting Up The Project

Create a separate directory for your project urlshortner , open that directory in your favorite IDE. I am using Visual Studio Code here.

Go inside the folder and type npm init , give the necessary details for setting up the project.

Next, we need to download necessary node packages which we discussed earlier, type following command to download them

npm i express config mongoose shortid valid-url

The above command will update package.jsonwith the dependencies and download the needed packages inside node_modules folder.

Phewwwwww, Let’s Do The Coding Part Now

Open your code editor. Create a folder for storing the config, give the folder name config . Create a file inside folder default.js and give your MongoDB connect URL (we setup it earlier, I told you to remember it 😂) and baseURL.

replace the username and password with the user and password we created in MongoDB atlas.
allowedClick is a kind of restriction, that how many times the same URL can be used. Later can be used for pricing purpose. You can change it depending on your needs.

Config file for MongoDB setup

We will import necessary packages and connect with MongoDB

Define Schema For Storing URL Details

mongoose.Schema will define the document details which it will store. When we will code it will be much clear what each detail does.

urlCode : This will store the unique id related to each URL.

longURL : This is the URL which we need to short.

shortUrl : This is the actual short URL

clickCount : This stores how many times users have used the short URL.

Define Route for Shortening the URL

Create a folder name routes , inside that create a file shorturl.js which will have the code for shortening the URL.

Let’s understand the code.🤓🤓🤓

First of all, we imported the necessary packages which will be required later on. Used express package to create a route, using that route created an HTTP POST handler.

Next marked it async as it ensures that the function returns a promise, and wraps non-promises in it. Using async allow us to useawait , it makes JavaScript wait until that promise settles and returns its result.

We take out the URL submitted for shortening purposes from the request body, also fetch base URL which is mentioned in default.js . Next, we check if the URL submitted for shortening is a valid URL or not using the isUri method of valid-url package.

After the checking is successful we will query MongoDB to check if the URL sent for shortening already shorten or not. If shorten just return that result else short the URL.

mongoose methods returns a promise so we added await before it to wait till we get response.

For shortening the URL we will generate a unique id using generate method of shortid package. Next, append baseURL with the unique id to generate a URL as a short URL. Also, as the short URL is generated for the first time we will mark the clikcCount to be zero. Save the document and return the result as JSON.

Sample response (sending an amazon product links which need to be shortened).

Define Route for Redirecting the Short URL top Destination

Create a new file inside routes folder named getshortenurl.js .

Let’s understand the code. 🤓🤓🤓

First of all, we imported the necessary packages which will be required later on. Used express package to create a route, using that route created an HTTP GET handler. The URL will be getting shortUrl as a parameter. This parameter is the unique code that we appended to the baseUrl.

Next, we extract the shortUrl in a separate variable. As the code is unique so we can search the DB if we have any document with that unique code. The return result is stored in a variable.

If the return result is a document that means we have already shortened the URL. Check the clicked count of the returned document if the clicked count is passed the limit which we set in default.js, if yes return an error else increase the click count of the document and update it in the DB also, redirect to the long URL using the redirect method of res object.

Let’s Combine Everything

We need to have the main file which will combine all this together, remember we haven’t created the server yet. 😅😅😅

The baseURL which we configured in default.js has the value http://localhopst:8000/v1, because our app is running in localhost and the server is listening on POST 8000. The URL for getShortenUrlRoute is /v1/ so that is appended to the baseUrl..

Let’s understand the code.🤓🤓🤓

Import necessary packages with that import the routes which we have created in previous step, import config for MongoDB connection.

Connect to the DB, create the server and connect to a PORT (here it’s 8000).

app.use(express.json({})) this will parse incoming request body in JSON format.

Next, connect the router to the appropriate URL. Now let’s hope things work out. Start the app by using node index.js and play.

After creating a short URL paste the short URL in your browser it should redirect to the main URL.

I hope this blog will help you in understanding the basics of how to make a URL shorter. For code, you can refer to here on GitHub.

If you enjoyed reading this, don’t forget the like. 👏

Thank you.

If you enjoyed the content buy me a coffee. SachinSarawgi.

Twitter Bot Using NodeJS, Step By Step Guide To Develop

Sachin Sarawgi — Wed, 17 Jun 2020 04:26:32 +0000

We will build from scratch a Twitter Bot using NodeJS which will Retweet.

In this blog, we will understand how to build a Twiter bot that will retweet every time a tweet related to #100DaysOfCode is twitter using NodeJS.

It’s better to set up a new Twitter account where we can put any random thing. Once done with the final version of the bot we can deploy it to our main Twitter account.

Topics Covered

Setting up the Project
Setting up config details
Search tweet using Twitter Search Tweet API
Retweet using Twitter POST Tweet API
Combine Search & Post Twitter API
Deploy the app on Heroku
Enhancement to the code

Setting up the project

Download and Install NodeJS from here.
Create a separate directory from your command line mkdir twitterbot.
Go inside the directory cd twitterbot
Setup the project files usingnpm init , fill the proper details. This will create a package.json file.
Install twit node package npm install twit --save . Extra attribute save will save the package name in a list of dependencies in package.json file.
Create a js file where you will write code, the file name should be the same as which you gave while mentioning the main file detail in npm init.

That’s all for now to set up the project. Open the project in your favorite editor.

twit package will hide many of the boilerplate code for us. We just need to worry about the Twitter APIs.

Setting up config details

Open the main file in your editor. Let’s say the file name is twitterbot.js.
Import twit module which is present inside the twit package which we downloaded in our previous step let twit = require('twit'); .

Create a twit object with config details.

For getting all the above details we need to create an app on Twitter. From there we will get above four details.

Sign in to your Twitter account.
Go to https://developer.twitter.com/en/apps
Make sure we have our phone number associated with the account we logged in.
Click on Create an App.
Give a unique App Name, fill Application description, Website URL, and _Tell us how this app will be used _fields.
Click on Create. Our app has been created.
Go to Key and tokens tab copy Consumer API key and Consumer API Secret key. Fill it in our twitterbot.js file.
Click on Generate Access token & access token secret, copy Access token, and Access token secret. Fill it in our twitterbot.js file.

Run your file twitterbot.js to see if the code we have written is correct or not. Though nothing dynamic happening here.

Search tweet using Twitter Search Tweet API

We will use the get method exposed by the twit package. It takes the twitter search API and optional parameters, callback function as input. T.get('search/tweets', [params], [callback]);

The second optional argument has search query details. Suppose we want to search for Tweet having #100DaysOfCode as a hashtag, also we want to fetch 10 results at a time. For date, we will hard code it for now for some date.

The q key will have the text for which we want to search and the date from which the tweet should be searched. Right now the date is hardcoded, count tells upper bound of how many tweets should be given as a result.

Now we need a function which will be called as a callback. Suppose for now we want to log the tweet message whenever we get a result of the search tweet.

data.statuses will give us the array of tweets that it found based on the query parameter. tweetMsgs[i].textwill give the text message of each tweet.

Final code for search tweet after callback function.

For more on Search API.

Retweet using Twitter POST Tweet API

We will use the post method exposed by the twit package. It takes the twitter search API and optional parameters, callback function as input. T.get('statuses/retweet/:id', {id: tweetid}, [callback]).

The API id key has the value of the id_str (it is a field inside the tweet JSON which we want to retweet). Suppose tweetMsg variable is a JSON value of a tweet.

T.post('statuses/retweet/:id', { id: tweetMsg.id\_str });

tweetMsg.id_str will give the value from JSON.

Now we need a function which will be called as a callback. Suppose for now we will log if the tweet was successful or not.

For more on Retweet API.

Combine Search & Post Twitter API

Now let us combine the search and post Twitter API. We will retweet each of the tweets present inside the search result.

Updated code can be found here on GitHub. Remember to put config details for Twit object. Added function to give the date in real-time. setTimeout method is used to retweet in some interval.

Deploy the app on Heroku

We will be using Heroku to deploy our twitter bot.

Register in Heroku online
Create an App in the Heroku dashboard online

Local Machine Setup

Install Heroku https://devcenter.heroku.com/articles/heroku-cli
Go inside the project folder and execute git init
Then bind the project with Heroku remote by executing heroku git:remote -a {appname} . appname is the app name in Heroku.
Execute the following commands to push code and run remotely
git add .
git commit -m “message"
git push heroku master This will start executing out a bot on Heroku.
heroku logs to check logs of the app on the server.

Enhancement to the code

We can add a function that will give us a date in real-time so that we don’t have to hard code the date, which tells from which date we want the read the Tweet.
Instead of directly retweet we can add a delay to our tweets so that not all are getting tweeted at the same time. We can use setTimeout for that.

I hope this blog will help you to understand how a simple Twitter Bot can be designed using NodeJS.

Updated code can be found here on GitHub, added code for making a tweet as favorite. Remember to put config details for Twit object. Added function to give the date in real-time.

If you enjoyed reading this, don’t forget the like. 👏

Thank you. Follow me on _ Twitter._

{ "Objects" : "In JavaScript" }

Sachin Sarawgi — Mon, 15 Jun 2020 06:05:27 +0000

This article will cover Objects in JavaScript. It’s best suited for someone new to JavaScript.

Topic Covered

Objects & Its Use Case
Object Properties
How to Access Object Properties
Add & Delete Property
Nested Object
Object Methods
How to Execute Object Methods

Objects & Its Use Case

Suppose a use case where we have to receive a Person details from a user. One approach could be to define multiple variables to get each type of detail like firstName, lastName, phoneNumber, streetNo, address, pincode, etc. This list can grow. There will be so many of them that handling and passing it across different execution points will be a headache. Well here comes the Object as a savior.

In Object, we can store multiple variables (called Property) together, and also the methods which work on those variables.

Here is how to declare an Object in JavaScript. This doesn’t have anything its just an empty object.

var person = {  
}

Object Properties

Object properties are kind of variables only that holds some value. They are represented by a label and then a colon, followed by the value of the label. The value can be of any type be it number, string, array, or even another object 😱.

var person = {  
  name: 'your name'  
}

All valid variables can be treated as a label. But if we want something which is not a valid variable, we have to include that label in single quotes.

var person = {  
  name: 'your name',  
  'my address': 'your address'  
}

Note: We use comma to separate multiple properties in an Object.

How to Access Object Properties

Once we have our object we would like to access it right? JavaScript provides two ways to do this. Once by dot notation and another one is to mention property name within single quotes inside square brackets.

Access property using dot notation

var person = {  
  name: 'your name',  
  'my address': 'your address'  
}

console.log(person.name);

Access property using square brackets

var person = {  
  name: 'your name',  
  'my address': 'your address'  
}

console.log(person['name']);

Note: Now one may ask how we will access label which is not valid variable name. We do this by accessing them using a square bracket. A label that is not a valid variable name cannot be accessed using dot notation.

var person = {  
  name: 'your name',  
  'my address': 'your address'  
}

console.log(person['my address']); // correct  
console.log(person.my address // wrong

Note: If the label accessed is not inside Object, undefined will be returned.

Add & Delete Property

Suppose we have the object which is already declared and defined. JavaScript gives us the power to add new property whenever we want 😆.

var person = {  
  name: 'your name',  
  'my address': 'your address'  
}

person.pincode = 'pincode';  
person['country'] = 'country';

We can also delete a property once its use is over so that we are not keeping unnecessary data.

var person = {  
  name: 'your name',  
  'my address': 'your address'  
}

person.pincode = 'pincode';  
person['country'] = 'country';

delete person.country;  
delete person['name'];

Nested Object

As we previously read that object can be nested too. Here is how to declare them and access

var person = {  
  name: 'your name',  
  address: {  
    street: 'street',  
    'road no': 1  
  }  
}

console.log(person.address.street); // will print 'street'  
console.log(person.address['road no']); //will print 1

Note: In the case of nested Object the dot and square bracket notation can be combined.

Object Methods

It’s very good to bind property and the method which works on that property together. Similarly like different data type values, a label can also hold a function definition. For more on function. Here is how we do it in javaScript

var person = {  
  name: 'your name',  
  address: {  
    street: 'street',  
    'road no': 1  
  },  
  printMyName: function(){  
    console.log('your name');  
  }  
}

It’s not similar to what we do in a normal function definition. Here we write first the label, then a colon, then the function definition inside the function() block.

We can also access the other property of the Object inside function definition using this keyword.

var person = {  
  name: 'your name',  
  address: {  
    street: 'street',  
    'road no': 1  
  },  
  printMyName: function(){  
    console.log(this.name);  
  }  
}

Inside function parenthesis, we can any argument like a normal function. For accessing function argument we don’t need this as their scope is local to function definition.

var person = {  
  name: 'your name',  
  address: {  
    street: 'street',  
    'road no': 1  
  },  
  printWhatIPass: function(myVar){  
    console.log(myVar);  
  }  
}

How to Execute Object Methods

We can call object methods by using dot notation. If the function takes some argument we can pass that too.

var person = {  
  name: 'your name',  
  address: {  
    street: 'street',  
    'road no': 1  
  },  
  printMyName: function(){  
    console.log(this.name);  
  },  
  printWhatIPass: function(myVar){  
    console.log(myVar);  
  }  
}

console.log(person.printMyName()); // will print 'your name'

//will print 'my own text'  
console.log(person.printWhatIPass('my own text'));

This ends the discussion about Objects, it’s property and methods.

Reached till here, give me follow up to get the latest stories.

If you enjoyed reading this, don’t forget the like. 👏

Thank you.

Basic HTTP Server Using NodeJS From Scratch

Sachin Sarawgi — Sun, 14 Jun 2020 04:46:31 +0000

In this blog, we will see how to create an HTTP Server to handle GET, POST, PUT, DELETE request method type from scratch.

We need to have Node.js installed in our machine for the code to work. We will be using ‘http’ module provided out of the box to get the request and response object. We will not use any other custom library.

Steps For Creating A HTTP Server

Create Server using http module and add a listener
Do the necessary entry check for the request
Extract request method type
Writing handler for Http GET request
Writing handler for Http POST request
Writing handler for Http PUT request
Writing handler for Http DELETE request

1. Create Server using http module and add a listener

First of all, we need to create a server that will listen to some particular port. So that if any request comes to that port the listener will be called.

We can do this using http module.

const server = http.createServer(requestListener);  
server.listen(8090);

createServer method accepts the listener as an argument. listen method takes the port number where it will keep listening.

Let’s see what empty requestListener method looks like.

const requestListener = function (req, res) {  
 //all the code goes inside it  
}

2. Do the necessary entry check for the request

Suppose we want our server to support REST API, and we want to have the following checks on request object:

Content-Type is application/json
Accept is application/json.

We will be using req object to get headers details and check the required values.

const REQUIRED_CONTENT_TYPE = 'application/json';  
const ACCEPT_ENCODING_1 = 'application/json';  
const ACCEPT_ENCODING_2 = '*/*';

const entryCheck = function (req) {  
  const contentType = req.headers["content-type"];  
  if (!contentType.includes(REQUIRED_CONTENT_TYPE)) {  
    throw new Error("Sorry we only support content type as json format.");  
  }  

  const accept = req.headers["accept"];  
  if (!(accept.includes(ACCEPT_ENCODING_1) ||  
accept.includes(ACCEPT_ENCODING_2))) {  
    throw new Error("Sorry we only support accept json format.");  
  }  
}

Let’s understand what’s going on.

First, we declare constant for content-type and accept header which our server will support
Next entryCheck is the method where we will check if the request headers have the required and matching details.
If either Content-type or Accept is not matching we will throw an error.

Now let’s see how we will call this method from type listener.

const requestListener = function (req, res) {  
  try {  
    entryCheck(req);  
  } catch (error) {  
    res.writeHead(400);  
    res.end(error.message);  
}

writeHead method takes the HTTP Status code, it could be any valid status code. It has some optional parameters too, the second is a status message and the third is headers.
end method takes the response body which will be shown to the user. After this method, the response is sent back and the whole request-response process is done.

Note: We can add multiple entry checks depending on our condition like a cookie, hostname/IP address, a particular header etc.

3. Extract request method type

We need to know HTTP method type to handle each one of them separately.

const requestListener = function (req, res) {  
  try {  
    entryCheck(req);  
    const methodType = req.method.toUpperCase();  
    ......

method property of request object gives us the Http method type like GET, POST, PUT, DELETE.

Next, we can use switch to handle different Http requests type differently

....  
switch(methodType){  
  case 'GET':  
    break;  
  case 'POST':  
    break;  
  case 'PUT':  
    break;  
  case 'DELETE':  
    break;  
}

4. Writing handler for Http GET request

Http GET requests are generally for finding an existing object by sending unique details

We can simply return a generic response in every kind of Http method type.

case 'GET':  
  res.writeHead(200);  
  res.end(`We received ${methodType} type request`);  
  break;

But instead of just returning simple response let’s create some object and apply operations on it.

Let us consider an employee object with the following fields:

{   
  "_id": "5ec02a534587193b1c607e2c",  
  "name": {  
    "first": "Pace",  
    "last": "Simmons"  
  },  
  "company": "MOLTONIC",  
  "email": "pace.simmons@moltonic.co.uk",  
  "phone": "+1 (941) 562-2930",  
  "address": "274 Dikeman Street, Somerset, Nevada, 6375"  
}

We will have an object containing an array of above employee objects.

let employeeData = [  
 {   
  "_id": "5ec02a534587193b1c607e2c",  
  "name": {  
    "first": "Pace",  
    "last": "Simmons"  
  },  
  "company": "MOLTONIC",  
  "email": "pace.simmons@moltonic.co.uk",  
  "phone": "+1 (941) 562-2930",  
  "address": "274 Dikeman Street, Somerset, Nevada, 6375"  
 },  
 ......  
]

Consider GET request where we will ask for particular employee detail by providing the _id value.

localhost:8090/5ec02a53d8ba79b6992ba757

Now we will need one method which will search for the request _id in the array of objects. We will write one method to search employee based on _id:

let findEmployee = (id) => {  
  return employeeData.find((employee) => {  
    if (employee._id === id)  
      return employee;  
  });  
}

Let’s rewrite the GET Http handler code

const requestListener = function (req, res) {  
  ....  
  case 'GET':  
    getMethodHandler(url, req, res);  
    break;  
  ....  
}

const getMethodHandler = (url, req, res) => {  
  const employeeId = url.substring(1);  
  const employee = findEmployee(employeeId);  
  if (!employee) {  
    res.writeHead(400);  
    res.end(`The employee with id ${employeeId} is not present.`);  
    return;  
  }  
  res.writeHead(200);  
  res.end(JSON.stringify(employee));  
}

We have written a separate method

First, we found the requested _id
We pass that _id to findEmployee method to get the employee object
Next, we check if an employee object is found or not if not we throw an error.
If everything goes fine we return the employee object in the response body.

5. Writing handler for Http POST request

Http POST requests are generally for inserting the new objects. In our case, we will add the received employee object to the array. Let’s write code for that method

let addEmployee = (employee) => {  
  employeeData.push(employee);  
}

Next, we need to handle the POST request and parse the request body to get the employee object we need to insert:

const requestListener = function (req, res) {  
  ....  
  case 'POST':  
    getRequestBodyAndGenerateResponse(req, res, postMethodHandler);  
    break;  
  ....  
}

const getRequestBodyAndGenerateResponse = (req, res, callback) => {  
  let body = '';  
  req.on('data', chunk => {  
    body += chunk.toString();  
  });  
  req.on('end', () => {  
    callback(res, JSON.parse(body));  
  });  
}

const postMethodHandler = (res, body) => {  
  try {  
    let reqBody = body;  
    addEmployee(reqBody)  
    res.writeHead(200);  
    res.end(`The Employee object with id is ${reqBody._id} added.`);  
}

Let’s understand what we did here.

We defined a method getRequestBodyAndGenerateResponse(req, res, postMethodHandler).
This method reads the data from req object by listening for ‘data’ event and append it to one variable body.
Once the ‘end’ event is triggered means the request body read completely, it parses the string into JSON and calls the callback function passed to it.
This callback function is the one that prepares the response object.
In the callback function first, we add the employee to employee array.
Then prepare a response and sent it to the user.

6. Writing handler for Http PUT request

Http PUT requests are generally for updating the old objects. In our case, we will update the received employee object if present inside the array. Let’s write code for that method

let findAndReplace = (employee) => {  
  let employeeFound = findEmployee(employee._id);  
  if (employeeFound) {  
    for (var key in employee) {  
      employeeFound[key] = employee[key];  
    }  
  return true;  
  } else {  
    return false;  
  }  
}

Next, we need to handle PUT request and parse the request body to get the employee object we need to update:

const requestListener = function (req, res) {  
  ....  
  case 'PUT':  
    getRequestBodyAndGenerateResponse(req, res, putMethodHandler);  
    break;  
  ....  
}

const putMethodHandler = (res, body) => {  
  let reqBody = body;  
  findAndReplace(reqBody);  
  res.writeHead(200);  
  res.end(`The Employee object with id is ${reqBody._id} replaced.`);  
}

Let’s understand what we did here.

We defined a method getRequestBodyAndGenerateResponse(req, res, putMethodHandler).
This method reads the data from req object by listening for ‘data’ event and append it to one variable body.
Once the ‘end’ event is triggered means the request body read completely, it parses the string into JSON and calls the callback function passed to it.
This callback function is the one that prepares the response object.
In the callback function first, we update the received employee object inside the employee array.
Then prepare a response and sent it to the user.

7. Writing handler for Http DELETE request

Http DELETE requests are generally for deleting an existing object. In our case, we will delete the received employee object _id from the array. Let’s write code for that method

let deleteEmployee = (id) => {  
  let length = employeeData.length;  
  while (length--) {  
    if (employeeData[length]  
    && employeeData[length]["_id"] === id) {  
      employeeData.splice(length, 1);  
      return true;  
    }  
  }  
  return false;  
}

Next, we need to handle the DELETE request, get _id of the employee, and delete that object from the array.

const requestListener = function (req, res) {  
  ....  
  case 'PUT':  
    deleteMethodHandler(url, req, res);  
    break;  
  ....  
}

const deleteMethodHandler = (url, req, res) => {  
  const employeeId = url.substring(1);  
  const response = deleteEmployee(employeeId);  
  res.writeHead(200);  
  res.end(`The employee with id ${employeeId} is deleted.`);  
}

Let’s understand what we did here.

First, we found the requested _id
We pass that _id to deleteEmployee method to delete the employee object
If everything goes fine we delete the employee object.
Then prepare a response and sent it to the user.

You can find the above code here. I tried to convert it into a modular format by separating data, methods, and using a module export-import feature of JS.

If you enjoyed reading this, don’t forget the like. 👏

Thank you.

ES5 Function To ES6 Arrow Function

Sachin Sarawgi — Sun, 14 Jun 2020 04:38:22 +0000

With the introduction to ES6, there are many new features added in JavaScript one of them is Arrow Function. In this blog, we will discuss in detail how to use this feature. It’s best suited for someone new to JavaScript.

Topic Covered

Introduction to Arrow Function
Arrow Function Without Parameter
Arrow Function With Parameter
Return Value from Arrow Function

Introduction to Arrow Function

The arrow function concept was introduced in ES6. With the help of this, we can write a shorter and concise syntax for a normal function which we used to write in ES5.

Normal function to print “Hello World”

var printer = function(){  
  console.log("Hello World");  
}  
printer();

Arrow function to print “Hello World”

var printer = () => {  
  console.log("Hello World");  
}

Note: In arrow function, if there is only one statement then we don't even need to use ‘{}’ curly braces.

var printer = () => console.log("Hello World");

Arrow Function Without Parameter

This type of arrow function is similar to what we have written in the above examples. But remember:

Even if there are no arguments to the function ‘()’ parenthesis should be there.
If the function is of single statement ‘{}’ curl braces can be removed
If the function has multiple statements the ‘{}’ curl braces is a must.

Arrow Function With Parameter

In this type of arrow function, we pass the arguments inside the ‘()’ parathesis, it’s just that function keyword is not there.

var getSum = (myVar1, myVar2) => {  
  var result = myVar1 + myVar2;  
  return result;  
}  
getSum(5, 10);

We can write the above function is a single line by directly returning the result.

var getSum = (myVar1, myVar2) => { return myVar1 + myVar2 };  
getSum(5, 10);

Note: The return keyword is by default in a single line statement in case of arrow function. That’s the reason we didn’t remove the return keyboard, as in a single line statement without curl braces return keyword throws an exception.

var getSum = (myVar1, myVar2) => return myVar1 + myVar2;  
//this will throw exception saying unexpected token 'return'

If we want we have to remove the return keyword and ‘{}’ curl braces together.

var getSum = (myVar1, myVar2) => myVar1 + myVar2;  
getSum(5, 10);

Return Value from Arrow Function

In the case of multiple line functions, we have to write the return keyword explicitly for returning a value.

var getIteratorSum = (itr) => {  
  var result = 0;  
  for(var i =0 ;i <itr; i++){  
    result += i;  
  }  
  return result;  
}  
console.log(getIteratorSum(5));

This ends our discussion on the arrow function feature in ES6.

Follow me over Medium for such articles @CodeSprintPro

REST API With NodeJS Using SQLite3 and Express

Sachin Sarawgi — Fri, 12 Jun 2020 17:55:20 +0000

In this blog, we will discuss how to create REST API which provides CRUD functionality to an entity using NodeJS.

Topics Covered

What is REST
What is CRUD
REST & CRUD Together
REST Standards and Response Code Recommendation
Setting Up Database and Initial NodeJs File
GET API With NodeJS
POST API With NodeJS
PUT API With NodeJS
DELETE API With NodeJS

If you already know the concept you can jump onto the Setting Up Database and Initial NodeJS File section.

What is REST

REST stands for Representation State Transfer, we can think it as an architectural style standard which simplifies the communication between computer systems. The computer system which is REST compliant also called REStful systems.

RESTful systems are stateless and separate the concern of client and server in an HTTP communication protocol.

Separation of Client & Server

The development of the client and server can take place independently. We

don’t have to bother while changing how each side work.

Until and unless both sides know which format of the message to send, which is understood by the other side, they can be developed independently.

Statelessness

Client and Server don’t have to know the state of the other side while communicating. They can understand each other messages without knowing anything about the previous message.

From https://restfulapi.net/statelessness/

Each request from the client to server must contain all of the information necessary to understand the request, and cannot take advantage of any stored context on the server. Session state is therefore kept entirely on the client. client is responsible for storing and handling all application state related information on client side.

The statelessness behavior gives the power to scale, be a reliable and quick performer. For more on REST.

What is CRUD

When we build API, we need it to provide four basic functionalities namely Create, Read, Update, and Delete a resource. The CRUD paradigm is common in constructing web applications because it provides a memorable framework for reminding developers of how to construct full, usable models.

REST & CRUD Together

In the REST API, each verb in CRUD relates to a specific HTTP method.

Create — POST
Read — GET
Update — PUT
Delete — Delete

The above four are the basic building blocks for a persistent backend system.

REST Standards and Response Code Recommendation

Let us take an entity type for an example and explain the recommendation based on that.

We will take an Employee entity here. DB Diagram for the employee table.

Before writing code let us understand the different REST API which we will write for employee resources.

Create REST API Request

To create a resource in employees entity we use an HTTP POST request. POST creates a new resource of the specified resource type.

Before we start discussing let’s fix the message format we will communicate to JSON.

Let’s imagine employee resource, we want to add a new employee to the existing lists.

Request Format

Request format will have always the resource name in plural format. Like here we are working on employee resource the API should point to employees.

http://localhost:8080/employees/

Request Body

The body will be the new employee object detail in JSON format. In the case of a POST request, we will not pass the primary key as that will be automatically generated by the system.

{  
  "last_name": "Sarawgi",  
  "first_name": "Sachin",  
  "title": "Software Developer",  
  "address": "India",  
  "country_code": "IN"  
}

HTTP Method Type: POST

Response Body

The response body of a POST request should contain the newly created resource with the primary key.

{  
  "employee_id": 1,  
  "last_name": "Sarawgi",  
  "first_name": "Sachin",  
  "title": "Software Developer",  
  "address": "India",  
  "country_code": "IN"  
}

Response Code: When we try to create a new resource and it’s successful then the server should return 201 (CREATED) response code.

GET REST API Request

To read a particular item/row in an employee entity we use an HTTP GET request. Reading a resource should never change any information. GET requests can be used to read a particular item in a resource or read the whole list of items.

Let’s imagine employee resource, we want to read a particular employee from the existing lists.

Request Format

For reading a particular employee we will pass the primary key of the item.

http://localhost:8080/employees/1

For reading all the employees from the employee resource list.

http://localhost:8080/employees/

Request Body: In the case of GET request, we don't send any request body.

HTTP Method Type: GET

Response Body

The response body of a GET request should contain the employee object we request for.

If we requested for a particular employee it should be like:

{  
  "employee_id": 1,  
  "last_name": "Sarawgi",  
  "first_name": "Sachin",  
  "title": "Software Developer",  
  "address": "India",  
  "country_code": "IN"  
}

If we requested for all employees, the response should be an array of employee

[  
  {  
    "employee_id": 1,  
    "last_name": "Sarawgi",  
    "first_name": "Sachin",  
    "title": "Software Developer",  
    "address": "India",  
    "country_code": "IN"  
  },  
  {  
    "employee_id": 2,  
    "last_name": "Chandan",  
    "first_name": "Praveen",  
    "title": "Senior Software Developer",  
    "address": "India",  
    "country_code": "IN"  
  }  
]

Response Code: When we try to read a resource and it’s successful then the server should return 200 (OK) response code.

Update REST API Request

To update a resource in employees entity we use an HTTP PUT request. PUT updates an already existing resource of the specified resource type.

Let’s imagine employee resource, we want to update an old employee with the new title.

Request Format

Request format will have always the resource name in plural format. Like here we are working on employee resources the API should point to employees.

http://localhost:8080/employees/

Request Body

The body will be the old employee object detail in JSON format. In the case of a PUT request, we will pass the primary key as that will be needed to identify the resource.

{  
  "employee_id": 1,  
  "last_name": "Sarawgi",  
  "first_name": "Sachin",  
  "title": "Senior Software Developer",  
  "address": "India",  
  "country_code": "IN"  
}

HTTP Method Type: PUT

Response Body: The response body of a PUT request is not necessary if asked we can return the updated employee object.

Response Code: When we try to update an old resource and it’s successful then the server should return 200 (OK) response code.

DELETE REST API Request

To delete a particular item/row in an employee entity we use an HTTP DELETE request. It is used to remove a resource from the system.

Let’s imagine employee resource, we want to delete a particular employee from the existing lists.

We should never provide bulk delete functionality.

Request Format

For deleting a particular employee we will pass the primary key of the item.

http://localhost:8080/employees/1

Request Body: In the case of DELETE request, we don’t send any request body.

HTTP Method Type: DELETE

Response Body: The response body of a DELETE request is not necessary.

Response Code: When we try to delete an old resource and it’s successful then the server should return 200 (OK) response code.

Setting Up Database and Initial NodeJs File

Create a workspace in your local machine where you will write all the code. Type npm init to set up the project with basic details. Run below command inside the folder.

Runnpm install sqlite3 --save to use the sqlite3 package in our project
Runnpm install express --save to use express package from npm

Create a file with the name restwithnodejssqlite3.js and write below code:

const sqlite3 = require('sqlite3');
const express = require("express");
var app = express();

const HTTP_PORT = 8000
app.listen(HTTP_PORT, () => {
    console.log("Server is listening on port " + HTTP_PORT);
});

const db = new sqlite3.Database('./emp_database.db', (err) => {
    if (err) {
        console.error("Erro opening database " + err.message);
    } else {

        db.run('CREATE TABLE employees( \
            employee_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\
            last_name NVARCHAR(20)  NOT NULL,\
            first_name NVARCHAR(20)  NOT NULL,\
            title NVARCHAR(20),\
            address NVARCHAR(100),\
            country_code INTEGER\
        )', (err) => {
            if (err) {
                console.log("Table already exists.");
            }
            let insert = 'INSERT INTO employees (last_name, first_name, title, address, country_code) VALUES (?,?,?,?,?)';
            db.run(insert, ["Chandan", "Praveen", "SE", "Address 1", 1]);
            db.run(insert, ["Samanta", "Mohim", "SSE", "Address 2", 1]);
            db.run(insert, ["Gupta", "Pinky", "TL", "Address 3", 1]);
        });
    }
});

Run the file using npm restwithnodejs.js , it will start the server on port 8000. It will also create the employee table and insert some sample records in the database.

GET API With NodeJS

Now the server is up and running and the table is ready with some sample database.

Next step is to query the table to get a particular employee based on the employee_id .

app.get("/employees/:id", (req, res, next) => {
    var params = [req.params.id]
    db.get(`SELECT * FROM employees where employee_id = ?`, [req.params.id], (err, row) => {
        if (err) {
          res.status(400).json({"error":err.message});
          return;
        }
        res.status(200).json(row);
      });
});

We can also write API for getting all the employee we can

app.get("/employees", (req, res, next) => {
    db.all("SELECT * FROM employees", [], (err, rows) => {
        if (err) {
          res.status(400).json({"error":err.message});
          return;
        }
        res.status(200).json({rows});
      });
});

### POST API With NodeJS
After getting an employee by id, we need something by which we can insert an employee

app.post("/employees/", (req, res, next) => {
    var reqBody = re.body;
    db.run(`INSERT INTO employees (last_name, first_name, title, address, country_code) VALUES (?,?,?,?,?)`,
        [reqBody.last_name, reqBody.first_name, reqBody.title, reqBody.address, reqBody.country_code],
        function (err, result) {
            if (err) {
                res.status(400).json({ "error": err.message })
                return;
            }
            res.status(201).json({
                "employee_id": this.lastID
            })
        });
});

PUT API With NodeJS

Now suppose we want to update the existing employee.

app.patch("/employees/", (req, res, next) => {
    var reqBody = re.body;
    db.run(`UPDATE employees set last_name = ?, first_name = ?, title = ?, address = ?, country_code = ? WHERE employee_id = ?`,
        [reqBody.last_name, reqBody.first_name, reqBody.title, reqBody.address, reqBody.country_code, reqBody.employee_id],
        function (err, result) {
            if (err) {
                res.status(400).json({ "error": res.message })
                return;
            }
            res.status(200).json({ updatedID: this.changes });
        });
});

DELETE API With NodeJS

Code for deleting a particular employee from the table

app.delete("/employees/:id", (req, res, next) => {
    db.run(`DELETE FROM user WHERE id = ?`,
        req.params.id,
        function (err, result) {
            if (err) {
                res.status(400).json({ "error": res.message })
                return;
            }
            res.status(200).json({ deletedID: this.changes })
        });
});

This ends our coding part, we can run the file using node restwithnodejssqlite3.js , try hitting the API using Postman. I hope this helps to understand the concepts of REST, CRUD, and how to write it in terms of coding using NodeJS. The complete code for the project can be found here.

If you enjoyed reading this, don’t forget the like. 👏

Thank you.

Follow me over Medium for such articles @CodeSprintPro

11 Mantras To Become A Better Programmer

Sachin Sarawgi — Fri, 12 Jun 2020 15:43:45 +0000

Learn how to become a better programmer in your daily life. Do you want to make yourself a better programmer? Here are some tips which can guide you on the way.

1. Never Fear From New Things

You should never fear to do anything new in this world of Software Engineering. If you are not open to trying your hands on something new, it's very difficult to grow as a programmer and you may get lost in the crowd.

On the other hand, if you are open to new things you will find your knowledge increasing, confidence rising, and appreciation coming on the way.

Nobody, nobody knows everything, at some point people have to start something from scratch.

2. Learn Different Programming Language

It's okay if your project requires to need you to know Java. One may think if I learn some parts of Java he/she will survive. Sorry but that’s a very wrong notion. What if that project gets closed, what if there are no more projects based on Java (all on web dev in your department). So never ever limit yourself to that one programming language that your project requires.

You must know the basics of at least three programming languages in which you should be master of one. Like you know Java, JS, and Python but you are a master in java.

3. Clear Your Basics

This is one of the biggest mistakes which people do is they directly jump to the framework instead of studying the basic building behind that framework.

Not even framework, even if you are working on some projects which have some hi-fi code of JavaScript you must first clear your basics of JavaScript then proceed with it. Because when things get complex believe me these basics will come in handy.

It’s very good to know jQuery, but if you don’t know the basics of JavaScript on which it is built it may become difficult to handle if things get complexed in the jQuery framework.

4. Data Structures

Here comes the thing which many don’t bother to even look at. But the world is changing, nowadays if you don’t have an understanding of some common DS and Algos its difficult to even clear the first/second coding rounds on interview.

Some may say what’s the use of it, I am not going to use it in my coding. DS is not like any programming language, knowing DS & Algos helps you to think better structure, solution, the efficiency of the code.

Knowing DS will help in your daily basis work, we can give a more efficient solution instead of just giving the solution.

5. System Design & System Architecture

Lots of companies have their own engineering blog, study them. You will learn how people build their complex architecture, how they scale their system to match such a huge load of customers and also new technology which is in fashion.

Here are some of them Zomato, Swiggy, Instagram, Facebook.

You will understand complex architecture, how to scale a system, solution specific to scenarious.

6. Read Code From Github & Try to Understand

Take your favorite language and search in GitHub for open source projects based on that language. Choose any one of an open-source projects, clone it, import it in your favorite IDE. Also, you will learn new frameworks which they may have used with your favorite programming language.

Plus you can also contribute to these open source project, there is no better way to learn than contributing to open source projects. Your code may not get accepted in the first term (if they have high standard) but it's fine that’s how you learn isn't.

These open-source projects have a lot of beautiful code, you will learn a lot of new ways to solve things.

7. Always in Learning Mode

Sometimes people get lazy and think now they know what requires them to perform and they stop learning. It may happen you are working on Java 8 and suddenly after some years, you found some new X version is released and you are way behind it.

Industry always demands you to be updated with the latest at least in the technology you worked on.

Keep reading blogs, keep yourself updated with any new feature or version of your favorite programming language.

8. Build POCs

It’s doesn't matter if someone is watching you or not, do this for your better future. Build POC’s on the new thing you learned, create your repo on Github, and push it. At least you will have something to show in your resume that makes you stand different from the crowd.

9. Practice Makes You Perfect

You learn something new today, you tried a basic code it ran now you think you know that stuff and you never checked it back again. Sorry, that’s a wrong belief. It’s very easy to forget the syntax of a new programming language, so try to practice that code three-four times on different days.

Keep practicing it will make you efficient, increase your productivity, and you will have fewer errors.

10. Look For A Mentor

If you want to excel in something, look for a mentor whom you think can guide you or who is subject matter expert of it. As they have already gone through that path of mastering they know what mistakes one should avoid, what one should study.

Never feel ashamed of learning from someone who is of lesser experience then you, learning is never about age, it’s about sharing experience. If you are getting something new go for it.

11. Help Others & Let Them Help You

Last but not least if you are a master of something if you know something which others don’t please share your knowledge. Don’t let your attitude and ego come over it. Organize KT, Bootcamp within your team, department it will help others in gaining knowledge and you gaining recognition.

Answers questions on tech social platforms that you know about, write blogs that can help others. Share knowledge it will grow :).

If you enjoyed reading this, don’t forget the like. 👏

Thank you.

Follow me over Medium for such articles @CodeSprintPro

Promise to Learn Promises in JavaScript

Sachin Sarawgi — Fri, 12 Jun 2020 15:39:23 +0000

Stuck with callback hell, here is the Promise Object which promises to solve the Callback Function Problems.

JavaScript is synchronous language by nature. The asynchronous functions like a callback, promise are internal to the JavaScript engine which is part of the browser. For example, Chrome uses the Google V8 JavaScript engine. Because of this, all the functionality related to asynchronous is developed in external libraries.

In JS we can solve asynchronous features using Callback, Promises, Async Await.

Before we start please read about Callback Deep Dive in JavaScript.

Topics Covered

What are Promises
Which Use Case Solved By Promises
Problem With Callback Functions, The Callback Hell
How To Write Promise Producer Code
Promise Object Properties
How To Write Promise Consumer Code
Solving Callback Hell With Promises
### What are Promises

Promises are JavaScript object introduced in ES6 onwards, which handles the asynchronous result of an operation.

It consists of producer code which produces a result/response after some duration of time from the time when it’s called. The other part is called consumer code which consumes the result/response generated by producer code.

Which Use Case Solved By Promises

Suppose we are calling an API, and that API response time is high. That means for processing the response we have to wait till we get the response.
Suppose we are loading a JavaScript file in a function, and in the next line we are calling a function that is declared inside that script.
Suppose you want to call another API once you get the first response, another one after you get a second API response. This type of requirement is called callback chaining.

If you know Callback functionality would seem similar based on the above scenario, indeed it is but there are some major problems with a Callback function which is handled by Promise very gracefully. One of them is called Callback Hell, discussed in the next section_._

Problem With Callback Functions, The Callback Hell

A callback function easy to understand when we don’t have callback chaining or callback after callback. Let’s take a simple example, where there is only one callback function

function getAPIRequest(_callbackOnSuccess_, _callbackOnError_){  var getReq = new XMLHttpRequest();  
  getReq.open("GET", "https://reqres.in/api/users?page=2");  
  getReq.send();  
  getReq.onload = () => {  
    alert("The response is " + request.response);  
  }  
}
getAPIRequest();

In the above code, we called a GET API and once the response is received we are calling processSuccessResponse method as a callback. It seems correct, but suppose we want to call the second API once we get the first API response, similarly the third API when we get the first API response. Let’s see it as an example, we will be calling the same API for now:

function getAPIRequest(_callbackOnSuccess_, _callbackOnError_){    
  var getReq1 = new XMLHttpRequest();  
  getReq1.open("GET", "https://reqres.in/api/users?page=2");  
  getReq1.send();  
  getReq1.onload = () => {  
    alert("The response is " + request.response);  
    var getReq2 = new XMLHttpRequest();  
    getReq2.open("GET", "https://reqres.in/api/users?page=2");  
    getReq2.send();  
    getReq2.onload = () => {  
      alert("The response is " + request.response);  
      var getReq3 = new XMLHttpRequest();  
      getReq3.open("GET", "https://reqres.in/api/users?page=2");  
      getReq3.send();  
      getReq3.onload = () => {  
        alert("The response is " + request.response);  
        //another api call or some other processing  
      }  
    }  
  }  
}
getAPIRequest();

As we can see this thing can grow very large and it will become difficult to read, maintain the code, and understand if any issues come later on.

The promise is the answer to the above problem, it has consumer code that is kind of callback, and all consumers can be written separately and they will be executed one after another.

How To Write Promise Producer Code

Promise producer code is the part that produces some result or output, which later can be processed by a consumer. Let’s try to call a GET API which is like our producer code and its result will the response which we are getting from the API.

function getFirstAPIRequest() {  
  return new Promise(function(resolve, reject) {  
    var getReq = new XMLHttpRequest();  
    getReq.open("GET", "[https://reqres.in/api/users?page=2](https://reqres.in/api/users?page=2)");  
    getReq.send();  
    getReq.onload = () => {  
      if(getReq.status == 200){  
        resolve(getReq.response);  
      }else{  
        reject(new Error("There was some problem in the request."));  
      }  
    }  
  });  
}

Note: Open https://playcode.io/ and paste this code. If you want to learn do practice with this code.

The function passed to Promise is called executor, it runs automatically when the promise is created. The resolve and reject are callbacks provided by JavaScript itself.

When the executor gets the result we can call these callbacks depending on our requirement. Like in our case we called resolve in case of response status is 200 else we are calling reject.

Promise Object Properties

The Promise object created using the new keyboard has two properties state and result.

They change their values as follows

state will be pending at first, if resolve is called it will change to resolved state else if reject is called it will change to rejected state.
result will be undefined at first, response when resolve(response) is called else error when reject(error) is called.

How To Write Promise Consumer Code

If we want to consume response, we can do that in three ways in Promise using then, catch, and finally.

then Consumer Code

The then method of Promise accepts two function arguments, the first one is executed when resolve is called and the second one is executed when reject is called.

function getFirstAPIRequest() {  
  return new Promise(function(resolve, reject) {  
    var getReq = new XMLHttpRequest();  
    getReq.open("GET", "[https://reqres.in/api/users?page=2](https://reqres.in/api/users?page=2)");  
    getReq.send();  
    getReq.onload = () => {  
      if(getReq.status == 200){  
        resolve(getReq.response);  
      }else{  
        reject(new Error("There was some problem in the request."));  
      }  
    }  
  });  
}
getFirstAPIRequest()  
  .then((response) => console.log(response), (error) => console.log  
("Cannot process response"));

This will produce the following output.

If we only want to consume resolve callback we can remove second method definition:

getFirstAPIRequest()  
  .then((response) => console.log(response));

_If we only want to consume reject callback we can pass null as the first argument and second any function definition._

getFirstAPIRequest().then(null, (error) => console.log("Cannot process response"));

catch Consumer Code

For handling reject callback promise has one special method called catch. We can write our definition inside it, which will be called only in case when reject callback is called.

getFirstAPIRequest().catch((errorMsg) => console.log(errorMsg));

finally Consumer Code

There may be some cases where we want to close some resources before completing the callback. Then we use finally, it has only function definition (without any arguments) which will always be called. Once completed the execution will be passed to next function.

getFirstAPIRequest()  
  .finally(() => console.log("Closing important resources))  
  .then((response) => console.log(response), (error) => console.log  
("Cannot process response"));

Now suppose callback chaining case where we want to call another API on based on the response from the first API. Let’s see an example:

function getFirstAPIRequest() {  
  console.log("Processing first call");  
  return new Promise(function(resolve, reject) {  
    var getReq = new XMLHttpRequest();  
    getReq.open("GET", "[https://reqres.in/api/users?page=2](https://reqres.in/api/users?page=2)");  
    getReq.send();  
    getReq.onload = () => {  
      resolve(getReq.response);  
    }  
  });  
}
function getSecondAPIRequest(firstResponse) {  
  //do some processing on response, here I am passing the first simply  
  console.log("Processing second call");  
  return new Promise(function(resolve, reject) {  
    var getReq = new XMLHttpRequest();  
    getReq.open("GET", "[https://reqres.in/api/users?page=2](https://reqres.in/api/users?page=2)");  
    getReq.send();  
    getReq.onload = () => {  
      resolve(getReq.response);  
    }  
  });  
}
getFirstAPIRequest()  
  .then((response) => getSecondAPIRequest(response))  
  .then((response) => console.log(response));

This will produce the following output.

I hope all the above examples will make you understand what Promise is in JavaScript, how it is better then Callback as it gracefully handles Callback Hell.

Follow me over Medium for such articles @CodeSprintPro

Top 10 Free Data Structure Courses

Sachin Sarawgi — Fri, 12 Jun 2020 15:21:41 +0000

In this blog, I will be mentioning some of the resources for Data Structure that have quality content plus free.

Algorithm and Data Structure are two of the most important things required if you want to clear an interview for big and high paying product-based companies.

Also, someone who has good knowledge of the above two will take better decision while implementing a solution and write code which can handle incremental changes in a better way.

Some of the popular concepts of DS and Algos array, linked list, circular linked list, double linked list, binary search tree, graph, heap, stack, queue, etc.

1. Data Structures and Algorithms Specialization (Basic to Intermediate)

This course is from Coursera. This is a specialization type of course so instead of one course, this is divided into four separate courses. Although for getting the certification you need to pay, if you are looking for knowledge you can attend this course for free.

This course is offered by UNIVERSITY OF CALIFORNIA SAN DIEGO.

The four different parts of the course:

Algorithmic Toolbox: The course covers basic algorithmic techniques and ideas for computational problems arising frequently in practical applications: sorting and searching, divide and conquer, greedy algorithms, dynamic programming.
Data Structures: In this course, they will consider the common data structures that are used in various computational problems. Also, you will learn how these data structures are implemented in different programming languages.
Algorithms on Graphs: In this course, you will first learn what a graph is and what are some of the most important properties. Then you’ll learn several ways to traverse graphs and how you can do useful things while traversing the graph in some order.
Algorithms on Strings: We search for information using textual queries, we read websites, books, e-mails. All those are strings from the point of view of computer science. In this course, you will learn the string algorithm which search engines use.

2. Algorithms Specialization (Advanced)

This course is very much at the advanced level then compare to the above specialization. So I would say first go for Data Structures and Algorithms Specialization then select this one.

This course is offered by Stanford.

The four different parts of the course:

Divide and Conquer, Sorting and Searching, and Randomized Algorithms: The primary topics in this part of the specialization are: asymptotic (“Big-oh”) notation, sorting and searching, divide and conquer (master method, integer, and matrix multiplication, closest pair), and randomized algorithms (QuickSort, contraction algorithm for min cuts).
Graph Search, Shortest Paths, and Data Structures: The primary topics in this part of the specialization are: data structures (heaps, balanced search trees, hash tables, bloom filters), graph primitives (applications of breadth-first and depth-first search, connectivity, shortest paths), and their applications (ranging from deduplication to social network analysis).
Greedy Algorithms, Minimum Spanning Trees, and Dynamic Programming: The primary topics in this part of the specialization are: greedy algorithms (scheduling, minimum spanning trees, clustering, Huffman codes) and dynamic programming (knapsack, sequence alignment, optimal search trees).
Shortest Paths Revisited, NP-Complete Problems: The primary topics in this part of the specialization are: shortest paths (Bellman-Ford, Floyd-Warshall, Johnson), NP-completeness and what it means for the algorithm designer, and strategies for coping with computationally intractable problems (analysis of heuristics, local search).

3. Algorithms 1 (Basic)

This course is from Coursera. This is not a specialization, it’s a separate course. This course is free for everyone also there will be no certification given to anyone.

This course is offered by Princeton University.

This course covers the essential information that every serious programmer needs to know about algorithms and data structures, with emphasis on applications and scientific performance analysis of Java implementations. Part I covers elementary data structures, sorting, and searching algorithms.

4. Algorithms 2 (Intermediate)

This course is from Coursera. This is not a specialization, it’s a separate course. This course is free for everyone also there will be no certification given to anyone.

This course is offered by Princeton University.

This course covers the essential information that every serious programmer needs to know about algorithms and data structures, with emphasis on applications and scientific performance analysis of Java implementations. Part II focuses on graph- and string-processing algorithms.

5. Intro to Data Structures and Algorithms (Basic)

This course is from Udacity. This course will cover the following topics data structures and algorithms Searching & Sorting, Maps & Hashing, Graph, Trees. Also, this course will cover some case studies, introduce you to technical interviewing techniques, and practice interviews.

It’s good for the people who are new to DS and know a little bit of Python, as the coding will be in Python programming language.

6. Algorithms and Data Structures (Basic)

It’s a free course from eds. Although for getting the certification you need to pay, if you are looking for knowledge you can attend this course for free.

This course is offered by Microsoft.

This course will cover the following topics Algorithmic Analysis, Sorting and Searching of Algorithms, Data Structures, Linked lists, Stacks, Queues. As it starts from basic it’s good for people with zero or no knowledge of data structures and algorithms.

7. Must Do Interview Preparation (Basic to Intermediate)

This is a free course offered by geeksforgeeks. This course is based on the most frequently asked questions in product-based companies. It will help to boost your preparation for different interview rounds in tech giants. The course will have programming questions from intermediate to advanced level.

The concepts covered in this course are arrays, String, LinkedList, Stack, Queue with some advance interview-based questions.

8. Algorithms (Basic-Intermediate-Advance)

Though it’s a youtube course, it covers the algorithms from basic to advanced concepts, and obviously its free of cost.

The concepts covered in this course include divide & conquer, recursion, binary search, heap sort, merge sort, quick sort, Huffman coding, Dijkstra algorithm, 0/1 knapsack, graph, tree, stack, queue, and linked list.

9. Introduction to Algorithms and Data structures in C++ (Basic)

It’s a free course from Udemy. It gives concept related to very basic data structures like Fibonacci sequence, Dynamic programming, 0/1 Knapsack problem, Stack, check parenthesis expression questions, Queue.

It’s good for the people who are new to DS and know a little bit of C++, as the coding will be in C++ programming language.

10. Data Structure — Part I (Basic)

It’s a free course from Udemy. The topics covered in the course are among the most fundamental material in all of computer science. The students will not only understand the working behavior of data structures but also be able to implement those from scratch. The course will cover well-known data structures such as dynamic arrays, linked lists, stacks, queues, and trees.

It’s good for the people who are new to DS and know a little bit of Java, as the coding will be in Java programming language.

I hope this blog will help you to get a goods resource for learning Data Structures & Algorithms. I would say start with the basic start type course then go to intermediate and advance one. In this way your learning curve will be much better.

Follow me over Medium for such articles @CodeSprintPro

Callback Deep Dive in JavaScript

Sachin Sarawgi — Fri, 12 Jun 2020 15:15:05 +0000

In this blog, we will understand how callback function works in JavaScript and how to write one.

Topic Covered

What is a Callback Function?
Which Use Case Solved by Callback Function
Callback Function Synchronous Execution
Callback Function Asynchronous Execution
Nesting Callback Function Asynchronous Execution

What is a Callback Function

In JavaScript, functions are first-class objects. Just like we can pass objects to functions, we can pass functions as an argument to another function.

Now the functions which are passed an argument will execute later, after the function where it is passed already executed. That function is commonly known as Callback Function. Generally, this type of function waits for some event to happen or some timeout then it will get executed.

Functions that accept another function as an argument is called a higher-order function.

An understanding of callback is very much necessary. As event and callback structure is the mechanism by which JavaScript engine is managing multiple overlapped requests for I/O.

JavaScript is a synchronous language by nature. The event and callback functions are internal to the JavaScript engine which is part of the browser. For example, Chrome uses the Google V8 JavaScript engine. Because of this, all the functionality related to asynchronous is developed in external libraries.

Which Use Case Solved by Callback Function

Suppose we are calling an API, and that API response time is high. That means for processing the response we have to wait till we get the response. Now, we don’t want the user to wait till then, that will be a bad design. Here comes the Callback as a savior.
Suppose we are loading a JavaScript file in a function, and in the next line we are calling a function that is declared inside that script. This may not work as the script can be not loaded yet.

Example solution for 1st case using a callback: We can write the response processing code inside a function, pass that function as an argument to a function that is calling the API. The response processing function will wait till it gets the response to process while the main function will complete its execution and exit. Similarly, we can do something about the second use case.

Callback Function Synchronous Execution

Let’s first start with a simple example of a callback function.

function welcome(greetingMsg, callback){  
  console.log("Before calling callback");  
  callback(greetingMsg);  
  console.log("After calling callback");  
}
function sayMyName(greet){  
  console.log(greet + " Professor");  
}
welcome("Hello", sayMyName);

This is one of the simplest examples where the callback function which we passed as an argument will be executed synchronously.

This may not be an important use case of using Callback Function so let’s jump into asynchronous calling.

Callback Function Asynchronous Execution

Let’s take our first use case where we need to wait for the response to the process. We can solve it by callback function async execution.

Here we will be using XMLHttpRequest object to request an API. XMLHttpRequest object is provided by the browser, it’s built-in browser object. I have used a sample API which will give a JSON response for testing purposes.

function getAPIRequest(_callbackOnSuccess_){var getReq = new XMLHttpRequest();  
  getReq.open("GET", "https://reqres.in/api/users?page=2");  
  getReq.send();  
  getReq.onload = () => {  
    if(getReq.status == 200){  
      callbackOnSuccess(getReq);  
    }  
  }  
}
function processSucessResponse(_request_){  
  alert("The response is " + request.response);  
}
getAPIRequest(processSucessResponse);

Open https://playcode.io/ and paste this code. You will see it gives a pop up that has the API response.

XMLHttpRequest onload is an event that will occur when we get a result from the API. We can register our function for processing the response in the onload event. We are checking if the response code is 200 pass the request object to the callback function which is processSucessResponse. Let’s see how we can process an error response if the status code is 400.

function getAPIRequest(_callbackOnSuccess_, _callbackOnError_){

  var getReq = new XMLHttpRequest();  
  getReq.open("GET", "https://reqres.in/api/users?page=2");  
  getReq.send();  
  getReq.onload = () => {  
    if(getReq.status == 200){  
      callbackOnSuccess(getReq);  
    }else if(getReq.status == 400){  
      callbackOnError();  
    }  
  }  
}
function processSucessResponse(_request_){  
  alert("The response is " + request.response);  
}
function processErrorResponse(){  
  alert("The response has some errors.");  
}
getAPIRequest(processSucessResponse, processErrorResponse);

If you know ajax it can be easy as follows:

function getAPIRequest(_callbackOnSuccess){_  
  ajax("https://reqres.in/api/users?page=2", _callbackOnSuccess_);  
}
function processSucessResponse(_request_){  
  alert("The response is " + request.response);  
}
getAPIRequest(processSucessResponse);

Note: All the asynchronous functionality in JavaScript is provided by some external framework or library. Whenever JavaScript engine sees an external API call, it will ask the browser this is yours to execute, and whenever you get a response run this code (the callback function code).

The browser then waits for the response to return, whenever it has some response it will schedule the callback function execution by putting it into the event loop.

Nesting Callback Function Asynchronous Execution

It may happen after getting a response from the first API we may want to fire another request based on the result. This kind of request is like a nested API request. For simplicity, we will be calling the same API.

function getAPIRequest(_callbackOnSuccess_, _callbackOnError_){  
  var getReq = new XMLHttpRequest();  
  getReq.open("GET", "https://reqres.in/api/users?page=2");  
  getReq.send();  
  getReq.onload = () => {  
    if(getReq.status == 200){  
      callbackOnSuccess(getReq, processNestedResponse);  
    }else if(getReq.status == 400){  
      callbackOnError();  
    }  
  }  
}

function processSucessResponse(_request_, _callbackOnSuccess_){  
  alert("The response is " + request.response);  
  var getReq = new XMLHttpRequest();  
  getReq.open("GET", "https://reqres.in/api/users?page=2");  
  getReq.send();  
  getReq.onload = () => {  
    if(getReq.status == 200){  
      callbackOnSuccess(getReq);  
    }  
  }  
}
function processErrorResponse(){  
  alert("The response has some errors.");  
}
function processNestedResponse(_request_){  
  alert("The response is " + request.response);  
}
getAPIRequest(processSucessResponse, processErrorResponse);

This example explains how we can handle the nested API request.

I hope this blog gave you a better understanding of what is a callback, when we can use callback and how to write it in JavaScript code.

Follow me over Medium for such articles @CodeSprintPro