DevRiff RSS Feed

Build RESTful API using Node.js, Express and MongoDB

Sun, 28 Mar 2021 00:00:00 GMT

In this post, we are going to perform CRUD(Create, Read, Update and Delete) operations in Node, Express, and MongoDB and we will also follow Model View Controller (MVC) pattern.

Requirements

Download and Install Node Js.
Download and Install MongoDB.
Download and Install PostMan.
You should have Some basic knowledge about Javascript and ES6.
Curiosity and Interest ;)

Server Setup

We will initialize our project npm init.

then we will add our dependencies express js and mongoose.

Express: It is the framework for the Node.js web application. It provides routing, templating, Middleware, etc.
Mongoose: It is an Object Data Modeling (ODM) library for MongoDB and Node.js. As we know that MongoDB is NoSQL. It is very flexible and we don't need to provide schema or structure. So mongoose helps us to provide MongoDB validations, Type Casting, Query Building, Hooks, etc.

To install the dependency in node, write npm i --save express and npm i --save mongoose in terminal.

{SS of dependency installation and package.json}

Now require the express then initialize the variable app and call express.

After that initialize another variable called PORT_NUMBER and assign value 9000. Our Server will listen to this number. To listen we will call app.listen() function then pass PORT_NUMBER as an argument, pass a callback function. where console Server is running on 9000.

const express = require("express")
const app = express()

const PORT_NUMBER = 9000
app.listen(PORT_NUMBER, () => {
  console.log(`Server is running on ${PORT_NUMBER}`)
})

Let's make an API.

app.get("/api", (req, res) => {
  return res.send("<h1> Hello World! </h1>")
})

In the above code we have called a functionget() then passed the path of the API and a callback function which has two arguments:req,res.

Express sends us two objects in this callback, which we called req and res, they represent the Request and the Response objects.

Request is the HTTP request. It gives us all the request information, including the request parameters, the headers, the body of the request, and more. The request object is enhanced version of the Node's own request object. This object has various properties like body, param, query, param etc.

Response is the HTTP response object that we’ll send to the client.

Let's create a small project where we will perform CRUD operations. Our Project Structure:

Middleware

Express has the middleware concept where middleware is the function that has access to the request, response object, and next middleware function in the application’s request-response cycle.

// app.js

// Express Middleware (Body Parser)
app.use(express.json())
// Our Middleware function to log some request's properties.
app.use((req, res, next) => {
  console.log("Method =======>>", req.method)
  console.log("Url =======>>", req.url)
  console.log("Body =======>>", req.body)
  console.log("Query =======>>", req.query)
  console.log("Params =======>>", req.params)
  next()
})

express.json() is the function that parses incoming request bodies in a middleware before your handlers, available under the req.body property.

Mongoose

Let's connect to our local MongoDB.

// app.js

const mongoose = require("mongoose")

// DB Connection
mongoose.connect(
  "mongodb://localhost:27017/devriff",
  { useNewUrlParser: true, useUnifiedTopology: true },
  error => {
    if (error) {
      console.log(error.message)
      throw error
    }
    console.log("MongoDB Connected Successfully.")
  }
)

// To log all queries that mongoose execute.
mongoose.set("debug", true)

MVC

Model View Controller (MVC) is a design pattern that divides application logic into three components which are interconnected.

Model
View
Controller

Let's create a schema for the post-collection.

Model

The Model Component is responsible for data-related logic.

// PostModel.js

const mongoose = require("mongoose")

const postSchema = mongoose.Schema(
  {
    title: {
      type: String,
      required: true,
    },
    description: {
      type: String,
      required: true,
    },
    author: {
      type: String,
      required: true,
    },
    created: {
      type: Number,
      default: Date.now(),
    },
  },
  {
    versionKey: false,
    timestamps: true,
  }
)

module.exports = mongoose.model("posts", postSchema)

In the above code, we have required mongoose to then call the schema function and pass our schema object. In schema we have to define keys and their data type, also they are required or not. we have also passed another argument which is also an object where mongoose we do not add version key in the record and we will add timestamps which will be createAt and updateAt key.

After that, we are calling the model function of the mongoose and where are passing a string as the name of our collection, which is post and another argument postSchema.

Now let's create a controller where we are going to perform our CRUD operations.

Controller

The Controller act as an interface between Model and View. It takes input from the view and interprets then informs the model to make a change according to the user's input.

// PostController.js

const PostModel = require("../Models/PostModel")

const postController = {
  // Create Post
  savePost: async (req, res) => {
    await new PostModel(req.body).save()
    return res.json({ message: "Post added successfully!" })
  },
  // Get Post By ID
  getPostById: async (req, res) => {
    // data validation
    if (!req.params.id) {
      return res.json({ error: "Id is required" })
    }
    const postBydId = await PostModel.findOne({ _id: req.params.id })
    return res.json({ data: postBydId })
  },
  // Get all Posts
  getPosts: async (req, res) => {
    const allPosts = await PostModel.find({})
    return res.json({ data: allPosts })
  },
  // Update Post
  updatePost: async (req, res) => {
    // data validation
    if (!req.body._id) {
      return res.json({ error: "Id is required" })
    }
    await PostModel.updateOne({ _id: req.body._id }, { $set: { ...req.body } })
    return res.json({ message: "Post updated successfully!" })
  },
  // Delete Post
  deletePost: async (req, res) => {
    // data validation
    if (!req.params.id) {
      return res.json({ error: "Id is required" })
    }
    await PostModel.deleteOne({ _id: req.params.id })
    return res.json({ message: "Post deleted successfully!" })
  },
}

module.exports = postController

All the functions are pretty straightforward, we have pass req and res and tried to validate our request then we have performed the MongoDB operations with the help of mongoose.

If you have read our MongoDB post, we have just done the same operations. With little change that now we are using mongoose and using some of its function like for insert, we are using save function to save a record.

After that, we have returned our data/message in the JSON form using res.json().

Routes

Routes could act as a view where it collects data or input from the user.

// app.js

// POST APIs
const postRoutes = require("./Routes/PostRoute")
app.use("/api/post", postRoutes)

In the above code, we are importing routes, using middleware where we are passing /api/post path which means any request starting with this path and with any method will execute the postRoutes.

// PostRoute.js

const express = require("express")
const router = express.Router()
const postController = require("../Controllers/PostController")

router.get("/", postController.getPosts)
router.get("/:id", postController.getPostById)
router.post("/", postController.savePost)
router.put("/", postController.updatePost)
router.delete("/:id", postController.deletePost)

module.exports = router

As we can see in the above code we have called Router class to create modular and mountable route handlers. A Router instance is a complete middleware.

So we have various methods like get, post, put, delete , patch etc and passed the path of the api and controller method.
In the path :id is the param so that we can get id from URL with the help of req.param property.

Let's run and check our all APIs.

POST

GET

All Posts:

Post By Id:

PUT

Updated Post:

DELETE

Deleted Post:

Conclusion

We have implemented REST API and Crud Functionality using Node.js, Express and Mongodb. I didn't use an optimized way. It was one of the ways to implement. You can also check my other post about Vanilla Node.js (without any framework). Thanks for reading. if you found any issues or you have any query please contact.

Getting Started with Postgres

Sun, 08 Nov 2020 00:00:00 GMT

In this post, we will go through some of the basic of PostgreSQL and will perform CRUD operations.

What is PostgreSQL or Postgres?

Postgres is an open-source object-relational database. PostgreSQL supports both SQL (relational) and JSON (non-relational) querying. It is also one of the most used databases in the industry for production and deployment. It uses SQL Structured Query Language to access and manipulate databases.

What is relational database?

You may have encountered this term at your university or in your job as a software engineer.

A relational database is a type of database that stores and provides access to data points that are related to one another. The creation of a relational database requires schema, where defines how the data is organized and how the relations among them are associated.

In the above image, we have a car database in which we have 4 tables (cars, engines, wheels, and pistons). With the help of 3 tables (Engine, wheels, and pistons) we have created cars.

So in every table, we have id which is a primary key. The primary key is the unique key in that table, The id of (Engine, wheels, and pistons) we are using to create the car table, so the primary key of those tables is a foreign key in the car table. This is a basic example of a relationship between tables.

Some Basic Concepts

Table: In RDBMS (Relational Database Model) data is organized in the form of row and column. It is the most common and simplest form to store data in a relational database.
Column: A column is a vertical entity in a table that contains all information associated with a specific field in a table.
Field: It is a column in a table, which holds a specific value in a table.
Row: A row of data in each individual entry of a column that exists in the table.

Installation

You can follow PostgreSQL Downloads according to your operating system to install in your own system.

Login

we can run psql -U postgres to login in Postgres database as a postgres user which we had set up in installing the procedure.

Create a User

To create a user in Postgres, so we can create a user, with a password also adding the validity of the user.

CREATE USER user_name WITH PASSWORD 'password' VALID UNTIL '2021-01-01';

Granting Privileges

We can grant permissions or privileges to the user.

To list all users and their privileges, we can use \du command.

Remove Privileges

We can also delete users from the database but before deleting a user we have to delete that user has owned (tables, Sequences, and functions, etc).

DROP OWNED BY user_name;
DROP USER user_name;

CRUD:

Create

Creat to create a table, defining a schema and datatypes of the columns.

CREATE TABLE users(
id INT NOT NULL,
first_name VARCHAR(150),
last_name VARCHAR(150),
email VARCHAR(50),
age INT
);

To view all Tables.

First select current \c database_name;. Then \dt to list all tables.

Insert values in our users table.

INSERT INTO table_name(column1, column2, …)
VALUES (value1, value2, …);

INSERT INTO users(id, first_name, last_name, email, age) VALUES (2, 'Jignesh', 'Verma','jeegu@yopmail.com', 31);

Read

We can read data from our table by SELECT Query/Statement.

SELECT * FROM users;

In the above example, we have query all the data from the table. We can filter out with the help of the where clause.

 select id, first_name, age from users where age > 20;

For sorting, we can use order by column_name DESC and ASC.

SELECT id, first_name, age FROM users ORDER BY id DESC;

Update

To update any row in our table, UPDATE query to update or manipulate the existing data in our table.

UPDATE table_name SET cloumn = value;

UPDATE users SET first_name = 'Jignesh (JIGU)' where id = 2;

We can also modify(add, delete or rename) the column with the help of the ALTER statement.

ALTER TABLE table_name RENAME COLUMN prev_column TO new_column;

ALTER TABLE users RENAME COLUMN age TO bio_age;

DELETE

DELETE statement allows you to delete one or more rows from a table.

DELETE FROM table_name WHERE condition;

DELETE FROM users WHERE age= 31;

We can drop the table in postgres.

DROP TABLE table_name

DROP TABLE users CASCADE;

In the above query we have used cascade keywordto remove all dependent objects first before dropping the user table.

Conclusion:

In this post, we have implemented CRUD functionality in Postgres. The database plays important role in all the types of development from Web to Application, From Backend to QA. So hope this post helps. Thanks for reading. if you found any issues or you have any query please contact.

Getting Started with MongoDB

Mon, 17 Aug 2020 00:00:00 GMT

In this post, we are going to go through some basic concepts of MongoDB and will Perform CRUD operations on console.

What is MongoDB?

MongoDB is an open-source database management system (DBMS). It is based on a document-oriented database. it is a NoSQL database, which means it doesn’t store data in tables and rows as in relational databases. It stores data in JSON-like documents which can be very flexible as we don't have to define the structure, such as the fields or the types of their values. In same collection, documents can have different keys and different data types.

Some Basic Concepts

Database: It is a physical container that stores our collections. Single MongoDB Server can have multiple databases.
Collection: It is a group of documents. It is similar to the Table concept in RDBMS. The collection doesn't force our documents to have the same keys and same data types as Table does in RDBMS.
Document: It is the set of keys and values. It has a flexible schema, which means it can have different keys and data types in the same collection.

Data Types:

Some basic data types in MongoDB

String: "hello world." is an example of the string. String in MongoDB must be UTF-8 valid.
Integer: It is used to store numeric data.
Boolean: It is used to store boolean data, true or false.
Arrays: It is used to store a collection of data. Example: ['Hello','world','!']
Object: It is used to store embedded data.
ObjectId: It is used to store document _id, it is a unique id that is generated by default. you can say the primary key in the document.

Some more data types to explore here.

Example of MongoDB document:

{
  "_id": ObjectId("5ef0ec62f4347b6a39c856332"), // ObjectId
  "name": "Jignesh Verma", // string
  "age": 16, // integer
  "isStudent": true, // boolean
  "isEmployed": false,
  "favFruits": [ // array
    "Mango",
    "Apple"
  ],
  "totalBankBalance": null, // null
  "dob": ISODate("2014-02-14T10:50:42.389Z"), // date
  "school": { // object
    "name": "Rishi High School",
    "adderess": "Nainital, Uttarakhand"
  },
  "created": 1592847458901.0 // timestamp
}

Installation

You can follow these posts to install in your own system.

CRUD:

Create:

You can create a database by using the use keyword.

and use the db command to check which database we are currently using.

let's create our collection.

We can list all databases in our mongo server by using show dbs. Empty Database will not be listed. (if Database has no collection. Then it would be considered as empty.

Now we can insert a document in users collection.

We have inserted one document, let's insert multiple documents at a same time by using db.collectionName.insertMany([{}]).

Read:

We can retrieve all documents by find operation.

we can also specify query criteria to identify documents in find operation.

Here we have filtered users by age, where we found users greater than equal to 11. $gte is a MongoDB operator which matches values that are greater than or equal to a specified value. You can learn more about operators in this Article Mongodb Operator Manual.

We can format or prettify our data by using pretty() function.

There is another find query which is similar to the find but there is a predefined limit which is one.

As we can add a limit to the find and skip the number of documents by limit() and skip() function respectively.

The limit() method limits the number of documents in the result documents.

The skip() method controls the starting point of the results documents. The following operation skips the first 2 documents in the collection and returns all remaining documents

Update:

Modifies an existing document or ducuments in a collection. db.collectionName.update() method can update fields or replace existing document.

To update or create specific fields we can use $set operator.

We updated the one document where "_id" = ObjectId("5f3a85bba730d6aa35fd3faf") and with the help of $set operator, where we have updated one field age and added new field salary on that document.

we can delete a field by using $unset operator.

Here we have removed the salary key from all the documents. The multi true option allows updating all the document which matches the where criteria.

We can also pass upsert true as an option. which tells update the document if it exists else to create. db.users.update({},{$unset:{age:""}},{upsert:true})

Delete:

MongoDB provides db.collectionName.deleteMany() db.collectionName.deleteOne() two functions to remove documents from collections. To delete all documents db.collectionName.deleteMany({}) pass empty in filter clause.

db.collectionName.deleteOne({}) removes one document which matches the provided criteria.

db.collectionName.deleteMany({}) removes all the document which matches the provided cirteria.

{name:{$exists : true }} selects the document which has name field in the collection.

Conclusion:

In this post, we have implemented CRUD functionality in MongoDB. Thanks for reading. if you found any issues or you have any query please contact.

Getting Started with Elasticsearch: A basic overview

Wed, 01 Jan 2020 00:00:00 GMT

In this post, we will cover some basic concepts of elasticsearch, mapping and indexing the data, and searching on that data.

What is Elasticsearch?

Elastic search is an open source, distributed NoSQL database, full text search engine based on the lucene library. It is built on Java. It uses schema or table free JSON documents and provides REST APIs interface to interact with it.

Elasticsearch is scalable and very useful for big data up to petabytes of structured and unstructured data.

Before we start

There are some useful key concepts of elasticsearch.

Document

The document expressed as a JSON object. It is the collection of keys and values. It is stored in the Index. We will search for documents in indices.

Indices

The index is the optimized collection of different types of documents. We will index documents so that we can search in the index for a document.

By default, Elasticsearch indexes all data in every field and each indexed field has a dedicated, optimized data structure. It provides functionality to mappings the data dynamically or explicitly to define mappings to take full control of how fields are stored and indexed.

Index contain inverted indices that let you search across everything.

Node

Any time that you start an instance of Elasticsearch, you are starting a node.

Cluster

A collection of connected nodes is called a cluster. If you are running a single node of Elasticsearch, then you have a cluster of one node. It provides aggregated indexing and search capabilities across all nodes.

Shard

A shard is a single Lucene instance. The index is grouping of one or more physical shards. By breaking index into shards which makes them independent and can be stored in any node.

Replicas

Elasticsearch allows us to create replicas of shards and indexes. Which provides the availability of the data in case of failure and also improves the performance of searching by running a parallel search in these replicas.

Installation

You can download and follow the setup guide from here.

To interact with RESTFUL Apis we are going to use Postman.

We are going to use the default URL and port http://localhost:9200 for this post.

Mapping

Mapping is a schema definition where we define the data type of all fields in a document. Schema stored in an index.

Manually Mapping to create an index.


PUT http://localhost:9200/index_name

Content-Type: application/json  PUT /students

{
    "mappings": {
        "properties": {
            "age": {
                "type": "integer"
            },
            "email": {
                "type": "keyword"
            },
            "name": {
                "type": "text"
            },
            "school": {
                "type": "text"
            }
        }
    }
}

View Mapping.

We can view the mapping of an index.


GET http://localhost:9200/index_name/_mapping

GET /students/_mapping

Update Mapping.

We can add new fields in the existing mapping of an index. We can’t update existing fields for that we need to delete and create a new one.


PUT  http://localhost:9200/students/_mapping

Content-Type: application/json  PUT /students/_mapping
{
    "properties": {
        "city": {
            "type": "text",
            "index": false
        }
    }
}

Delete Mapping

We can delete a Mapping of an index.


DELETE http://localhost:9200/index_name/

DELETE /students/

Create Document

We can create an index document with a simple PUT request we can provide unique id at the end of the URL.


POST student/_doc/id

{
  "age":10,
	"email":"rajesh@gmail.com",
	"name":"Rajesh",
	"school":"xyz school",
	"city":"New Delhi"

}

Create Document without providing ID.

Get All Documents

We can get all the documents in our student index.


GET http://localhost:9200/students/_search

GET /students/_search

Search or Query in Elastic Search

We can search or query our data in two ways:

URI Search
Request Body Search

URI Search

We can search by URI Search where we mention our index name after that q param which has a field name with value separated by a colon. Request URI searches do not support the full Elasticsearch Query DSL but are handy for testing.

GET http://localhost:9200/students/_search?q=name:ramesh

GET /students/_search?q=field_name:value

Spaces, special characters, etc needs to be URL encoded which can be a little tricky to write that’s why I recommend Request Body Search.

Request Body Search

URI search is not the best way to query in Elasticsearch. So better is we use Request Body Search. The search request can be executed with a search DSL, which includes the Query DSL within its body.

Think of the Query DSL as an AST (Abstract Syntax Tree) of queries, consisting of two types of clauses:

Leaf query clauses Leaf query clauses look for a particular value in a particular field, such as the match, term or range queries. These queries can be used by themselves.

Compound query clauses Compound query clauses wrap other leaf or compound queries and are used to combine multiple queries in a logical fashion (such as the bool or dis_max query), or to alter their behavior (such as the constant_score query).

In Elasticsearch when we query document, it matches documents and sort by relevance score which is present in the meta field of the result.

Query Type can calculate relevance scores differently so it depends upon where the query clause is in Query or Filter Context.

Query Context

It provides the relevance score in the meta field according to how well the query matches the document. Query context is in effect whenever a query clause is passed to a query parameter, such as the query parameter in the search API.

Filter Context

It tells that the query matches the document. Yes or no is the only answer no scores are calculated.

Filter context is in effect whenever a query clause is passed to a filter parameter, such as the filter or must_not parameters in the bool query, the filter parameter in the constant_score query, or the filter aggregation.


http://localhost:9200/students/_search

{
    "query": {
        "bool": {
            "must": [
                {
                    "match": {
                        "school": "xyz"
                    }
                }
            ],
            "filter": [
                {
                    "range": {
                        "age": {
                            "gt": 10
                        }
                    }
                }
            ]
        }
    }
}

In the above Query, Query Parameter represents the Query Context and Bool, Must and Match Clauses lie in the query context and describes how well each document will match the school: “xyz”,

Filter Parameter represents the Filter Context and Filter and Range clauses lie in the filter context and provide yes or no that document’s age is greater than 10.

Match Query

It finds all the documents which match the query’s input value should be in the field. An order doesn’t matter.


GET http://localhost:9200/students/_search
{
	"query":{
		"match":{
			"school":"zy school"
		}
	}
}

Match Phrase Query

It finds all the documents which match the query’s input value should be in the same order.

GET http://localhost:9200/students/_search
{
	"query":{
		"match_phrase":{
			"school":"zy school"
		}
	}
}

Proximity Query

With High Slop you can get results on the basis that documents contained the words in the phrase. But order can be changed on the basis of slop value.

Slop determines how many words being in between phrase terms. Higher the value of slop higher the number of words can appear in between the phrase terms.

With Low slop

GET http://localhost:9200/students/_search
{
    "query": {
        "match_phrase": {
            "school": {
                "query": "school jkl",
                "slop": 0
            }
        }
    }
}

With High slop

GET http://localhost:9200/students/_search

{
    "query": {
        "match_phrase": {
            "school": {
                "query": "school jkl",
                "slop": 100
            }
        }
    }
}

Pagination

We can implement pagination in our query result for that we can send from and size parameters in our query where from defines the offset from the first result you want to return and size defines the total or the maximum number of the result you want to return.

GET http://localhost:9200/students/_search

Conclusion

Now we have covered some basic concepts of the elastic, CRUD in Mapping, CRUD in Document, Query or Searching the Document and Pagination. You can learn more from Elasticsearch documentation. Thanks for reading!

Create REST API and CRUD in Vanilla Node.js, No Framework

Sun, 22 Sep 2019 00:00:00 GMT

In this post, we are going to build REST APIs using Vanilla Node.js, No Framework and implement CRUD (CREATE, READ, UPDATE and DELETE) functionality.

What is Node.js

Node.js is an open-source, cross-platform, Javascript Environment that allows javascript to run out of the browser so we can run javascript out on the server to produce dynamic web page content means we can produce content before it is sent to the user's web browser. It is built on Google Chrome's JavaScript Engine (V8 Engine).

You can read more about node.js here.

Requirements

Download and Install Node Js.
Download and Install Post Man
You should have Some basic knowledge about Javascript and ES6.
Curiosity and Interest ;)

Server Setup

Let’s require http module in app.js file and assign it to the http variable.

const http = require("http")

Now let’s create our server by calling createServer() function from http module, which is an asynchronous function and takes a callback function as a parameter where let's pass two parameters request and response then assign that CreateServer() function to the const = server variable.

const server = http.createServer((request, response) => {
  response.writeHead(200, { "Content-Type": "application/json" })
  response.write(JSON.stringify(JSON.stringify({ message: "Hello World!" })))
  response.end()
})

request and response variables provide the functionality to read a request from our client and send back a response to the client respectively. Both request and response don’t maintain their own states to store data.

In the above function, we are sending a response where first we are writing the response header what kind of response we are sending to the browser or client. In the header, we are sending 200 which is a status code.

Status code defines what kind of response you want to send like if you didn’t find any user in database as per user's request you can send 404 which means not found. 200 status code means successful. You can read more about the status codes in Official Docs.

And another parameter in the header is what kind of data we are going to send like JSON, plain text or HTML. So we are going to send json we had defined application/json.

Now in next line response.write() are passing json object as a String because data travels in connection only in String form.

Let's end our response stream by calling response.end() which tells that response ends here to the client.

After that let's bound our server variable to Listening event will be emitted to listen to a specific port number.

server.listen(9000, () => {
  console.log(`Server running on Port 9000`)
})

.listen is an asynchronous function where we are passing a callback function that will console the string Server running on Port 9000.

We can now run our program. To run a program open a terminal and go to the app.js's directory and run node app.js

Yeah!!! Now our server is running

we can hit the URL http://localhost:9000 in postman. let's see the response.

Yess!!!!! our server is sending response too.

Now we can see our response's Headers. In Header Content-Type of our application is application/json/ and some other stuff.

Creating API

Let’s move to create an API. For API we need to define the HTTP Method and HTTP Url.

We can Get Url and it’s Method By Request Parameter.

const server = http.createServer((request, response) => {
  console.log(`Url is ${request.url} and Method is ${request.method}`)
})

Request:

Console:

We can differentiate between in URLs with the help of Method and URL.

const server = http.createServer((request, response) => {
  let url = request.url
  let method = request.method

  switch (method) {
    case "GET":
      if (url === "/") {
        response.writeHead(200, { "Content-Type": "application/json" })
        response.write(JSON.stringify({ message: "Hello World" }))
        response.end()
      }
      break

    default:
      response.writeHead(200, { "Content-Type": "text/plain" })
      response.write("Url Not Found")
      response.end()
  }
})

Response:

Crud Application

We are going to create REST APIs for small Contact Application where we are going to perform CRUD operations.

For Database let's take an array which we are going to declare at Global Scope. But always remember that if we are going to restart our application then our array will be empty every time.

Create :

Now let’s create a user contact object for that we are going to use the post Http method. In the switch case of our createServer function, we need to make a case for post request.

switch (method) {
    case "POST":
      if (url === "/post") {
        response.writeHead(200, { "Content-Type": "application/json" });
        response.write(JSON.stringify({ message: "Hello From Post" }));
        response.end();
      }
      break;
    default:
      response.writeHead(200, { "Content-Type": "text/plain" });
      response.write("Url Not Found");
      response.end();
  }
});

And to retrieve the data from client side. we can make our own body-parser not the same just a small replica.

If you have worked with express js then you probably familiar with body-parser. If not then just simply understand that body-parser is a library that extracts the entire body portion of an incoming request stream and exposes it on req.body as something easier to interface with.

So let's implement our function.

async function bodyParser(request) {
  return new Promise((resolve, reject) => {
    let totalChunked = ""
    request
      .on("error", err => {
        console.error(err)
        reject()
      })
      .on("data", chunk => {
        totalChunked += chunk // Data is in chunks, concatenating in totalChunked
      })
      .on("end", () => {
        request.body = JSON.parse(totalChunked) // Adding Parsed Chunked into request.body
        resolve()
      })
  })
}

Here in the above code, we made an async bodyParser Function in which we are returning a new Promise in which we have declared a total chunked variable which is a string type.

Node is an event-driven io. So bodyParser Function is listening on error first if we got an error than promise will be rejected if not then on data event we are going to concatenate all data which is coming from the client which is in a buffered form so it is a chunk data.

After that request event is going to end than we parsed our total chunked string into a JSON object which is a readable and understandable form for us then assigning that object into request.body.

Now we have created a separate function postHandler where we have to await for bodyParser after we are pushing our user contact info from request.body into our global array or DB and sending our response.

/*
  handles post request
*/
async function postHandler(request, response) {
  try {
    await bodyParser(request)
    db.push(request.body)
    response.writeHead(200, { "Content-Type": "application/json" })
    response.write(JSON.stringify(db))
    response.end()
  } catch (err) {
    response.writeHead(400, { "Content-type": "text/plain" })
    response.write("Invalid body data was provided")
    response.end()
  }
}

// Server configuration
const server = http.createServer((request, response) => {
  let url = request.url
  let method = request.method

  switch (method) {
    case "POST":
      if (url === "/post") {
        postHandler(request, response)
      }
      break
    default:
      response.writeHead(200, { "Content-Type": "text/plain" })
      response.write("Url Not Found")
      response.end()
  }
})

In the server function, we are only calling postHandler in Post case where we have passed request and response in POST method.

Now our Post is working. Let's move on to Read.

Read :

In read we just basically have to return our DB or array.

const server = http.createServer((request, response) => {
  let url = request.url
  let method = request.method

  switch (method) {
    case "POST":
      if (url === "/post") {
        postHandler(request, response)
      }
      break
    // Get Case where we are handling /post url
    case "GET":
      if (url === "/post") {
        getPosts(request, response)
      }
      break

    default:
      response.writeHead(400, { "Content-type": "text/plain" })
      response.write("Invalid URL")
      response.end()
  }
})

// Returning the DB array.
const getPosts = (request, response) => {
  response.writeHead(200, { "Content-Type": "application/json" })
  response.write(JSON.stringify(db))
  response.end()
}

We just created the case for GET method wherein GET case we are calling the getPosts Method where we are passing the request and response.

And In getPosts Method we are just writing Headers and Stringfy our JSON into String then writing Responses for Client and returning that response.

Update :

In Put Http Request we are going to update the db for specific contact by db index.

This is not an efficient way to update DB by index but here we are going to do that and we can update on the id of contact but we didn't make an id field in starting so let's continue with the index but you can improve by doing with the id of a particular contact.

So Url is not going to fixed so we are not going to check for fixed url in PUT case.

const server = http.createServer((request, response) => {
  let url = request.url
  let method = request.method

  switch (method) {
    case "POST":
      if (url === "/post") {
        postHandler(request, response)
      }
      break

    case "GET":
      if (url === "/post") {
        getPosts(request, response)
      }
      break

    // Case for PUT HTTP request
    case "PUT":
      putPosts(request, response)
      break

    default:
      response.writeHead(400, { "Content-type": "text/plain" })
      response.write("Invalid URL")
      response.end()
  }
})

// putPosts Handler Function which is going to handle put requests.
async function putPosts(request, response) {
  try {
    // Getting url for request stream.
    let url = request.url

    // Js string function to split url
    let idQuery = url.split("?")[1]
    let idKey = idQuery.split("=")[0] // index of our DB array which will be id
    let idValue = idQuery.split("=")[1] // Index Value

    if (idKey === "id") {
      // Calling bodyParser to get Data from request stream
      await bodyParser(request)

      // Appending Request body into provided index
      db[idValue - 1] = request.body
      response.writeHead(200, { "Content-Type": "application/json" })
      response.write(JSON.stringify(db))
      response.end()
    } else {
      response.writeHead(400, { "Content-type": "text/plain" })
      response.write("Invalid Query")
      response.end()
    }
  } catch (err) {
    response.writeHead(400, { "Content-type": "text/plain" })
    response.write("Invalid body data was provided", err.message)
    response.end()
  }
}

We are calling putPosts function in which is our handler function to handle put request where we are passing request and response to it.

putPosts is asynchronous where we are splitting the URL to get our id's value that id will help us to find contact info for a specific user.

After we check that param is id then we are calling our body-parser after that we just assigning value to that particular index value than returning our DB as a response to the client.

Delete :

So similarly like we implemented PUT case and we going to implement DELETE case with a little tweak in deletePost handler function we are going to splice array on the particular requested index.

const deletePost = (request, response) => {
  let url = request.url

  let idQuery = url.split("?")[1]
  let idKey = idQuery.split("=")[0]
  let idValue = idQuery.split("=")[1]

  if (idKey === "id") {
    db.splice(idValue - 1, 1)
    response.writeHead(200, { "Content-type": "text/plain" })
    response.write("Delete Success")
    response.end()
  } else {
    response.writeHead(400, { "Content-type": "text/plain" })
    response.write("Invalid Query")
    response.end()
  }
}
const server = http.createServer((request, response) => {
  let url = request.url
  let method = request.method
  console.log(method, url)
  switch (method) {
    case "POST":
      if (url === "/post") {
        postHandler(request, response)
      }
      break

    case "GET":
      if (url === "/post") {
        getPosts(request, response)
      }
      break

    case "PUT":
      putPosts(request, response)
      break

    // Delete Case
    case "DELETE":
      deletePost(request, response)
      break

    default:
      response.writeHead(400, { "Content-type": "text/plain" })
      response.write("Invalid URL")
      response.end()
  }
})
server.listen(9000, () => {
  console.log(`Server running on Port 9000`)
})

// Delete Post Handler
const deletePost = (request, response) => {
  let url = request.url

  let idQuery = url.split("?")[1]
  let idKey = idQuery.split("=")[0]
  let idValue = idQuery.split("=")[1]

  if (idKey === "id") {
    db.splice(idValue - 1, 1) // Splicing Array or DB.

    response.writeHead(200, { "Content-type": "text/plain" })
    response.write("Delete Success")
    response.end()
  } else {
    response.writeHead(400, { "Content-type": "text/plain" })
    response.write("Invalid Query")
    response.end()
  }
}

Conclusion

We have implemented REST API and Crud Functionality in Node Js without any framework. I didn't use an optimized way. It was one of the ways to implement. Thanks for reading. if you found any issues or you have any query please contact.

Source Code

App.js

const http = require("http")

let db = []

async function bodyParser(request) {
  return new Promise((resolve, reject) => {
    let totalChunked = ""
    request
      .on("error", err => {
        console.error(err)
        reject()
      })
      .on("data", chunk => {
        totalChunked += chunk
      })
      .on("end", () => {
        request.body = JSON.parse(totalChunked)
        resolve()
      })
  })
}
async function postHandler(request, response) {
  try {
    await bodyParser(request)

    db.push(request.body)
    response.writeHead(200, { "Content-Type": "application/json" })
    response.write(JSON.stringify(db))
    response.end()
  } catch (err) {
    response.writeHead(400, { "Content-type": "text/plain" })
    response.write("Invalid body data was provided", err.message)
    response.end()
  }
}
const getPosts = (request, response) => {
  response.writeHead(200, { "Content-Type": "application/json" })
  response.write(JSON.stringify(db))
  response.end()
}

async function putPosts(request, response) {
  try {
    let url = request.url

    let idQuery = url.split("?")[1]
    let idKey = idQuery.split("=")[0]
    let idValue = idQuery.split("=")[1]

    if (idKey === "id") {
      await bodyParser(request)

      db[idValue - 1] = request.body
      response.writeHead(200, { "Content-Type": "application/json" })
      response.write(JSON.stringify(db))
      response.end()
    } else {
      response.writeHead(400, { "Content-type": "text/plain" })
      response.write("Invalid Query")
      response.end()
    }
  } catch (err) {
    response.writeHead(400, { "Content-type": "text/plain" })
    response.write("Invalid body data was provided", err.message)
    response.end()
  }
}
const deletePost = (request, response) => {
  let url = request.url

  let idQuery = url.split("?")[1]
  let idKey = idQuery.split("=")[0]
  let idValue = idQuery.split("=")[1]

  if (idKey === "id") {
    db.splice(idValue - 1, 1)
    response.writeHead(200, { "Content-type": "text/plain" })
    response.write("Delete Success")
    response.end()
  } else {
    response.writeHead(400, { "Content-type": "text/plain" })
    response.write("Invalid Query")
    response.end()
  }
}
const server = http.createServer((request, response) => {
  let url = request.url
  let method = request.method
  console.log(method, url)
  switch (method) {
    case "POST":
      if (url === "/post") {
        postHandler(request, response)
      }
      break

    case "GET":
      if (url === "/post") {
        getPosts(request, response)
      }
      break

    case "PUT":
      putPosts(request, response)
      break

    case "DELETE":
      deletePost(request, response)
      break

    default:
      response.writeHead(400, { "Content-type": "text/plain" })
      response.write("Invalid URL")
      response.end()
  }
})
server.listen(9000, () => {
  console.log(`Server running on Port 9000`)
})

Sorting Algorithms

Mon, 22 Jul 2019 00:00:00 GMT

Sorting Algorithms are used to rearrange the given list or array in a certain order. In this post we are going to see working of some basic sorting algorithms like Bubble Sort, Insertion Sort, Quick Sort, Selection Sort and Merge Sort. We are going to implement these algorithms in JavaScript.

Bubble Sort

Bubble Sort is a simple sorting algorithm where the largest value bubble up to the top. It repeatedly steps through the array then compares adjacent pairs and swaps them if they are in the wrong order.

Steps involed in Bubble Sort:

We will start with the first element, compare with the next element of the array.
If the current element is greater than the next element then we will swap them.
If the current element is less than the next element, move to the next element. Repeat Step 1.

Pictorial Representation of how bubble sort will sort the given arrray.

function BubbleSort(list) {
  let temp
  for (let i = 0; i < list.length; i++) {
    for (let j = 0; j < list.length - 1; j++) {
      if (list[j] > list[j + 1]) {
        // Swap Elements
        temp = list[j]
        list[j] = list[j + 1]
        list[j + 1] = temp
      }
    }
  }
  return list
}

BubbleSort([29, 10, 14, 30, 37, 19, 18])

Selection Sort

Selection sort is a simple algorithm where it divides the list into two sublists sorted and unsorted then repeatedly finding the smallest element and push or put it in on the beginning of the sorted array.

Steps involed in Selection Sort:

First will assume the first element is the smallest so that we can use it to compare and find the smallest element in the given array then we will swap it with the first element.
We then move to the second position and will look for the next smallest element in the remaining array or sub-list then we will replace that element in the second position.
We will repeatedly move to the next position and find the smallest after that we will replace the smallest element in the next position. until the array is completely sorted.

Pictorial Representation of how selection sort will sort the given arrray.

function SelectionSort(list) {
  for (let i = 0; i < list.length; i++) {
    // Assuming First Element is Lowest
    let lowest = i

    for (let j = i + 1; j < list.length; j++) {
      if (list[j] < list[lowest]) {
        // Find the smallest
        lowest = j
      }
    }
    // replacing smallest element in the respective position
    let temp = list[i]
    list[i] = list[lowest]
    list[lowest] = temp
  }
  return list
}

SelectionSort([29, 10, 14, 30, 37, 19, 18])

Insertion Sort

Insertion Sort is also a comparison based algorithm like selection sort and bubble sort. Insertion Sort maintains two sublists sorted and unsorted. it removes one element from the input list and finds its location in the sorted list and inserts it here. It repeats until no element remains in the input list.

Steps involed in Insertion Sort:

If it is the first element, it is already sorted.
Pick the next element.
Compare with all the elements in sorted sub-list.
Shift all the the elements in sorted sub-list that is greater than the value to be sorted.
Insert the value.
Repeat until list is sorted.

Pictorial Representation of how insertion sort will sort the given arrray.

function InsertionSort(array) {
  // Starting the loop from second position
  for (var i = 1; i < array.length; i++) {
    let nextValue = array[i]
    j = i - 1

    // check if previous no. is larger than value to be inserted
    while (j >= 0 && array[j] > nextValue) {
      array[j + 1] = array[j]
      j--
    }
    // insert the number at current position
    array[j + 1] = nextValue
  }
  return array
}
InsertionSort([29, 10, 14, 30, 37, 19, 18])

Merge Sort

Merge Sort is an efficient sorting algorithm also it is a divide and conqueror algorithm where it divides the input list into two halves and then combines them in a sorted manner.

Steps involed in Merge Sort:

If it is only one element in the array it is already sorted, return.
Divide the array recursively into two halves until it can no more be divided.
Merge the smaller array into new array in sorted order then return that sorted array.

Pictorial Representation of how merge sort will sort the given arrray.

// Merging two arrays
function merge(array1, array2) {
  let results = [],
    j = 0,
    i = 0

  // Sorting and Pushing in results array
  while (i < array1.length && j < array2.length) {
    if (array2[j] > array1[i]) {
      results.push(array1[i])
      i++
    } else {
      results.push(array2[j])
      j++
    }
  }

  // Pushing Remaing elements from array1
  while (i < array1.length) {
    results.push(array1[i])
    i++
  }

  // Pushing Remaing elements from array2
  while (j < array2.length) {
    results.push(array2[j])
    j++
  }
  return results
}

// Recrusive Merge Sort
function MergeSort(array) {
  // base case to return arrayay
  if (array.length <= 1) return array

  // Dividing the Array in two halves
  let mid = Math.floor(array.length / 2)

  // Sort first and second halves
  let left = MergeSort(array.slice(0, mid))
  let right = MergeSort(array.slice(mid))

  return merge(left, right)
}

MergeSort([29, 10, 14, 30, 37, 14, 18])

Quick Sort

Quick Sort is also a divide and conqueror algorithm like Merge Sort. Quicksort first divides a large array into two smaller sub-arrays: the low elements and the high elements. Quicksort can then recursively sort the sub-arrays.

Steps involed in Merge Sort:

Find a “pivot” item in the array. we are considering first element.
Start a pointer (the left pointer) at the first item in the array.
Start a pointer (the right pointer) at the last item in the array.
While the value at the left pointer in the array is less than the pivot value, move the left pointer to the right (add 1). Continue until the value at the left pointer is greater than or equal to the pivot value.
While the value at the right pointer in the array is greater than the pivot value, move the right pointer to the left (subtract 1). Continue until the value at the right pointer is less than or equal to the pivot value.
If the left pointer is less than or equal to the right pointer, then swap the values at these locations in the array.
Move the left pointer to the right by one and the right pointer to the left by one.
If the left pointer and right pointer don’t meet, go to step 1.

Pictorial Representation of how quick sort will sort the given arrray.

function pivot(arr, start = 0, end = arr.length - 1) {
  const swap = (arr, idx1, idx2) => {
    ;[arr[idx1], arr[idx2]] = [arr[idx2], arr[idx1]]
  }

  // We are assuming the pivot is always the first element
  let pivot = arr[start]
  let swapIdx = start

  for (let i = start + 1; i <= end; i++) {
    if (pivot > arr[i]) {
      swapIdx++
      swap(arr, swapIdx, i)
    }
  }

  // Swap the pivot from the start the swapPoint
  swap(arr, start, swapIdx)
  return swapIdx
}

function QuickSort(arr, left = 0, right = arr.length - 1) {
  if (left < right) {
    let pivotIndex = pivot(arr, left, right)
    //left
    QuickSort(arr, left, pivotIndex - 1)
    //right
    QuickSort(arr, pivotIndex + 1, right)
  }
  return arr
}

QuickSort([4, 6, 9, 1, 2, 5, 3])

Consclusion

This article should have given you a good introduction how sorting algorithms work and how you can implement them in JavaScript.

The above implementation of all sorting algorithms provides you a basic understanding. They are not perfectly implemented or optimized.