DEV Community: Raj Jeswal

Expressjs: Javascript written in ECMAScript 2015 (ES6)

Raj Jeswal — Sun, 19 Dec 2021 12:08:33 +0000

Prerequisites

This tutorial assumes that you have the following:

Basic knowledge of Node
Node installed on your machine
Any code or text editor of your choice

Initially, create Express application with command in terminal.

npx express-generator < your-project-name > --no-view

Here, --no-view flag means that we will not use any template engine such as handlebars, ejs or pug, for our skeleton Express application.

After creating your application, you need to go to your application directory. For Windows Powershell and Linux terminals, use:

cd your-project-name

Then open your desired text editor. For me I only use VSCode so I have my terminal and my text editor open at the same time. But you can use any text editor you want.

Install dependencies with the following command:

npm install

Once we have the generated project ready, we need to install the dependencies and move some folders. Run this command to install other packages.

Here we can use three different kinds or methods to do our job with ease.

First Method:

Type the following in terminal:

npm install esm

and also install nodemon for specific project only as

npm install --save-dev nodemon  or npm install -D nodemon

Nodemon automatically restarts your application and allows you to test new changes to your Express app faster, or install as a global NPM dependency

npm install -g nodemon

Enable esm for packages: Use esm to load the main ES module and export it as CommonJS in the main entry file, index.js.

require = require("esm")(module);
module.exports = require("./app.js");

create a new file, app.js and add the following.

const express = require('express');
import express from 'express';

var app = express();
var PORT = 3000;

app.listen(PORT, function(err){
    if (err) console.log("Error in server setup")
    console.log("Server listening on Port", PORT);
})

run the app with:

npm start

at this stage if you had any problems use the
codesendbox link as a reference.

Second Method:

add the following in project's package.json file.

"type": "module"

and voila, but you need to add extensions with all files, which you want to add as import, like (filename.js), as example:

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

at this stage if you had any problems use the
codesendbox link as a reference.

Third Method:

using Babel setup

What is Babel?

Babel is a JavaScript compiler, that helps you use the ES6 functions of the JavaScript programming language.

add the following packages, we use the command

npm install --save-dev @babel/core @babel/cli @babel/preset-env @babel/node babel-plugin-module-resolver rimraf

npm install -D @babel/core @babel/cli @babel/preset-env @babel/node babel-plugin-module-resolver rimraf

after installing the packages, add the following in project's package.json file.

"scripts": {
    "build": "npm run clean && babel ./src --out-dir dist --copy-files",
    "clean": "rimraf dist",
    "prod": "npm run -s build",
    "start": "node dist/app.js",
    "dev": "nodemon --exec babel-node src/app.js"
},

So once you are done with the installation, create a new file called .babelrc to configure babel. Add the following text in it.

{
  "presets": ["@babel/preset-env"],
  "plugins": [
    [
      "module-resolver",
      {
        "alias": {
          "@routes": "./src/routes"
        }
      }
    ]
  ]
}

conclusion

We learned how to use ES6 in our Node.js project to write the latest JavaScript functions in the best way.

Feel free to check the code on GitHub Repository if you had any trouble following the last part of this article, when we included Babel as a JavaScript compiler.

If you have any questions or comments about this article, please do not hesitate to reach out.

Thank you for reading.

Credits

Express.js, the minimal and flexible Node.js web application framework: https://expressjs.com/

Esm, Tomorrow's ECMAScript modules today!: https://github.com/standard-things/esm#readme

Nodemon, reload, automatically: https://nodemon.io/

Babel, is a JavaScript compiler: https://babeljs.io/docs/en/usage

How to use MongoDB in Node.js application

Raj Jeswal — Sun, 19 Dec 2021 10:56:49 +0000

Prerequisites

This tutorial assumes that you have the following:

Basic knowledge of Node
Node installed on your machine
Any code or text editor of your choice
MongoDB installed locally

MongoDB is an open-source non-relational document database and leading NoSQL database that provides support for JSON-like storage.

Basic terms also change in SQL and NoSQL based databases to map data, since in Sql based database you have tables but nosql database has collections, SQL based database has rows but nosql database has documents, SQL based database has columns but nosql database has fields, Sql based database has relationships, but nosql database has linked and embedded documents.

Connecting MongoDB with your application using Mongoose, Mongoose is an object document mapper (ODM) used to establish a connection to the MongoDB database in NodeJS.

install mongoose on your project via this command.

npm install mongoose

Before launching your server, add the following code:

const mongoose = require('mongoose');

mongoose.Promise = global.Promise;

mongoose.connect('mongodb://localhost:27017/< DB Name >', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

db = mongoose.connection;

db.on('error', console.error.bind(console, 'connection error:'));

db.once('open', function () {
  console.log('Connected to Mongoose');
});

module.exports = db;

When you restart your Node.js server, you should see in your terminal "Connected to MongoDB database" if your connection is well established. Otherwise, a message containing the error if the connection could not be established.

Running Queries With Mongoose

Mongoose requires you to define its schemas before manipulating its objects. Let's start by creating the first schema in a user.js file.

const { Schema, model } = require('mongoose');

const userSchema = new Schema({
    firstName:  String,
    lastName: String,
    email:   String,
  });

const User = model('User', userSchema);

module.exports = User;

This file will contain the User module, which is a mongoose schema. We have the properties that a user can contain. Once this schema is defined, you can now use the mongoose schema methods to perform our create, read, update, or delete operations (CRUD functionality).

const User = require('./user.js');

Create a user

app.post('/users', async (req, res) => {
  try {
    let { firstname, lastname, email } = req.body;

    const user = await new User({ firstname, lastname, email });

    const result = await user.save();

    return res.status(201).json({ status: true, data: result });
  } catch (error) {
    res.status(500).json({ status: false, errors: error });
  }
});

List all users

app.get('/users', async (req, res) => {
  try {
    const user = await User.find();
    return res.status(200).json({ status: true, data: user });
  } catch (error) {
    res.status(500).json({ status: false, errors: error });
  }
});

Pick a user

app.get('/users/:id', async (req, res) => {
  try {
    const user = await User.findById(req.params.id);
    return res.status(200).json({ status: true, data: user });
  } catch (error) {
    res.status(500).json({ status: false, errors: error });
  }
});

Update a user

app.put('/users/:id', async (req, res) => {
  try {
    let { firstname, lastname, email } = req.body;

    const user = await User.findOne({ _id: req.params.id });

    if (!user) return res.status(404).json({ status: false, error: 'No User' });

    user.firstname = firstname ? firstname : user.firstname;
    user.lastname = lastname ? lastname : user.lastname;
    user.email = email ? email : user.email;

    const updatedUser = await user.save();

    return res.status(200).json({ status: true, data: updatedUser });
  } catch (error) {
    res.status(500).json({ status: false, errors: error });
  }
});

Delete a user

app.delete('/users/:id', async (req, res) => {
  try {
    const user = await User.findOne({ _id: req.params.id });

    if (!user) return res.status(404).json({ status: false, error: 'No User' });

    await user.remove();
    return res
      .status(200)
      .json({ status: true, msg: 'User deleted successfully!' });
  } catch (error) {
    console.log(error);
    res.status(500).json({ status: false, errors: error });
  }
});

conclusion

We learned how to use Mongoose ODM to connect to the Mongodb database in our Node.js project.

Feel free to check the code on GitHub Repository if you had any trouble following this tutorial.

If you have any questions or comments about this article, please do not hesitate to reach out.

Thank you for reading.

Credits

MongoDB, Built by developers, for developers: https://www.mongodb.com/

Mongoose, is a MongoDB object modeling tool: https://mongoosejs.com/

Setup and Customize Bootstrap styles in Next.js

Raj Jeswal — Sun, 19 Dec 2021 09:25:25 +0000

Prerequisites

This tutorial assumes that you have the following:

Basic knowledge of Node.js
Node 12.22.0 or later installed on your machine,
Any code or text editor of your choice

To create a new NextJS project, type and run:

npx create-next-app@latest < Your APP's NAME >

Steps to follow:

Installing Bootstrap

Let's start by installing the required NPM packages.

npm install bootstrap react-bootstrap sass

Sass Support, for more information check this link.

Next.js allows you to import Sass using the extensions .scss and .sass. You can use Sass at the component level through CSS modules and the extension .module.scss or .module.sass.

Creating a Custom SCSS

Let us now create a custom scss file in the styles/scss directory, and name it < ANY-NAME-OF-YOUR-CHOICE >.scss. In this file, we need to import Bootstrap’s bootstrap.scss. For the sake of simplicity, let us override the default colour system provided by Bootstrap.

$primary-color: #64FF00;

@import '/node_modules/bootstrap/scss/bootstrap.scss';

Configuring Next Config

The best part about the newer versions of Next is that they provide built-in support for SASS / SCSS. All we need to tell Next is where our styles are stored by setting next.config.js and adding the following code snippet:

const path = require('path')

module.exports = {
  sassOptions: {
    includePaths: [path.join(__dirname, 'styles')],
  },
}

Importing Bootstrap

The final step is to import our custom Bootstrap into our project. Based on where we need to use the custom styles, we can import our global.scss. In this example, let us configure it to be used by the entire project.

In pages/_app.js file, we need to add the following code:

import 'styles/scss/< ANY-NAME-OF-YOUR-CHOICE >.scss'

function MyApp({ Component, pageProps }) {
  return <Component {...pageProps} />
}

export default MyApp

conclusion

We learned, how to configured Bootstrap in our next NextJS project.

Feel free to check the code on GitHub Repository, if you had any trouble following this tutorial.

If you have any questions or comments about this article, please do not hesitate to reach out.

Thank you for reading.

Credits

Next.js, The React Framework for Production: https://nextjs.org/

Bootstrap, the world’s most popular framework : https://getbootstrap.com/

React-Bootstrap, Bootstrap framework for React.js : https://react-bootstrap.github.io/

How to use Sequelize ORM in Node Js App

Raj Jeswal — Sun, 19 Dec 2021 08:30:52 +0000

Sequelize, the very popular and stable promise-based Node.js ORM that has GitHub 25.36k stars, is a mapping tool, or object relational mapper, for sql databases such as Postgres, MySQL, MariaDB, SQLite and Microsoft SQL Server to convert SQL statements to javascript objects. It has strong support for transactions, relationships, lazy and anxious loading, read replication, and more.

Current version is Sequelize v6 supports Node v10 and above.

Prerequisites

This tutorial assumes that you have the following:

Basic knowledge of Node.js
Node installed on your machine
Any code or text editor of your choice
Atleast one database like mysql, mariadb, postgresql or sqlite3 installed locally

Sequelize is available via npm. You have to install sequelize as a dependency in your project.

npm install --save sequelize

You'll also have to install One of the following driver manually for your database of choice:

npm install --save pg pg-hstore (for Postgres)
npm install --save mysql2 (for mysql)
npm install --save mariadb (for mariadb)
npm install --save sqlite3 (for sqlite3)
npm install --save tedious (for Microsoft SQL Server)

Connecting to a database

To connect to the database, you must create a Sequelize instance.

for this, create a new file like sequelize-connection.js.

sequelize-connection.js

const { Sequelize } = require('sequelize');

Connecting to a database

Passing parameters separately (other dialects)

const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'mysql' || 'mariadb' || 'postgres' || 'mssql'
});

module.exports = sequelize;

Testing the connection

const { sequelize } = require('./models');

You can use the .authenticate() function to test if the connection is OK:

try {
    await sequelize.authenticate();
    // await sequelize.sync({ force: true, logging: console.log });
    console.log(`Server started on http://localhost:${port}`);
    console.log('Database connection has been established successfully.');
  } catch (error) {
    console.error('Unable to connect to the database:', error);
}

Closing the connection

Sequelize will keep the connection open by default, and use the same connection for all queries. If you need to close the connection, call sequelize.close() (which is asynchronous and returns a Promise).

To create a model

const { DataTypes } = require('sequelize');
const sequelize = require('./index');

const User = sequelize.define('users', {
  firstname: {
    type: DataTypes.STRING,
    allowNull: false,
    validate: {
      notNull: { msg: 'User must have a firstname' },
      notEmpty: { msg: 'firstname must not be empty' },
    },
  },
  lastname: {
    type: DataTypes.STRING,
    allowNull: false,
    validate: {
      notNull: { msg: 'User must have a lastname' },
      notEmpty: { msg: 'lastname must not be empty' },
    },
  },
  email: {
    type: DataTypes.STRING,
    allowNull: false,
    validate: {
      notNull: { msg: 'User must have a email' },
      notEmpty: { msg: 'Email must not be empty' },
      isEmail: { msg: 'Must be a valid email' },
    },
  },
});

Now all set to write a simple Node.js / Express.js application that uses Sequelize to perform CRUD operations and preserve the data in the database.

Add new User

app.post('/users', async (req, res) => {
  try {
    let { firstname, lastname, email } = req.body;

    firstname = firstname.toLowerCase().trim();
    lastname = lastname.toLowerCase().trim();
    email = email.toLowerCase().trim();

    const user = await User.create({ firstname, lastname, email });

    return res.status(201).json({ status: true, data: user });
  } catch (error) {
    res.status(500).json({
      status: false,
      errors: Object.values(error.errors).map((el) => el.message),
    });
  }
});

List all Users

app.get('/users', async (req, res) => {
  try {
    const user = await User.findAll();
    return res.status(200).json({ status: true, data: user });
  } catch (error) {
    res.status(500).json({
      status: false,
      errors: Object.values(error.errors).map((el) => el.message),
    });
  }
});

Search a single User

app.get('/users/:id', async (req, res) => {
  try {
    const user = await User.findAll({ where: { id: req.params.id } });
    return res.status(200).json({ status: true, data: user });
  } catch (error) {
    res.status(500).json({
      status: false,
      errors: Object.values(error.errors).map((el) => el.message),
    });
  }
});

Update an User

app.put('/users/:id', async (req, res) => {
  try {
    let { firstname, lastname, email } = req.body;

    firstname = firstname.toLowerCase().trim();
    lastname = lastname.toLowerCase().trim();
    email = email.toLowerCase().trim();

    const id = parseInt(req.params.id, 10);
    if (Number.isNaN(id)) return res.status(400).end();

    const isUserExist = await User.findOne({ where: { id } });

    if (!isUserExist)
      return res.status(404).json({ status: false, error: 'No User' });

    const user = await User.findByPk(id);

    user.firstname = firstname ? firstname : user.firstname;
    user.lastname = lastname ? lastname : user.lastname;
    user.email = email ? email : user.email;

    const updatedUser = await user.save();

    return res.status(200).json({ status: true, data: updatedUser });
  } catch (error) {
    res.status(500).json({
      status: false,
      errors: error,
    });
  }
});

Delete an User

app.delete('/users/:id', async (req, res) => {
  try {
    const id = parseInt(req.params.id, 10);
    if (Number.isNaN(id)) return res.status(400).end();

    const isUserExist = await User.findOne({ where: { id } });

    if (!isUserExist)
      return res.status(404).json({ status: false, error: 'No User' });

    const user = await User.findByPk(id);

    await user.destroy();
    return res
      .status(200)
      .json({ status: true, msg: 'User deleted successfully!' });
  } catch (error) {
    console.log(error);
    res.status(500).json({
      status: false,
      errors: error,
    });
  }
});

Conclusion

We learned, how to configured Sequelize.js in our next Node.js project.

Feel free to check the code on GitHub Repository, if you had any trouble following this tutorial.

If you have any questions or comments about this article, please do not hesitate to reach out.

Thank you for reading.

Credits

Node.js, is a JavaScript runtime built on Chrome's V8 JavaScript engine: https://nodejs.org/en/

Express.js, Fast, unopinionated, minimalist web framework for Node.js: https://expressjs.com/

Sequelize, promise-based Node.js ORM: https://sequelize.org/