For initial the project, create the folder with command:#

mkdir express

Initial package.json file#

npm init -y

In the terminal, type this command to install the package, as shown below:#

npm install express

You can check the results in the package.json file. Under the dependencies section, express should appear like this:#

{
  "name": "express",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "express": "^4.21.2"
  }
}

If it appears like this, it means the library has been successfully installed. Every time you install a library, it will always be listed under the dependencies section in the package.json file.

This confirms that the installation was successful and the library is ready to use in your project!

Route Syntax#

app.METHOD(PATH, HANDLER)

Example of a GET route:#

app.get('/', (req, res) => {
  res.send('Hello World!');
});

Plain text#

res.send('Hello, world!');

JSON response#

res.json({ message: 'Hello, world!' });

Status codes#

res.status(404).send('Not found');

Redirecting#

res.redirect('http://example.com');

Example : Exporting Functions#

function add(a, b) {
  return a + b;
}

function subtract(a, b) {
  return a - b;
}

module.exports = { add, subtract };

const math = require('./math');

console.log(math.add(5, 3));       
console.log(math.subtract(5, 3)); 

Install dotenv: First, you need to install the dotenv package from npm:#

npm i dotenv

Application-level middleware#

Bind application-level middleware to an instance of the app object by using the app.use() and app.METHOD() functions, where METHOD is the HTTP method of the request that the middleware function handles (such as GET, PUT, or POST) in lowercase.

This example shows a middleware function with no mount path. The function is executed every time the app receives a request.

const express = require('express')
const app = express()

app.use((req, res, next) => {
  console.log('Time:', Date.now())
  next()
})

To skip the rest of the middleware functions from a router middleware stack, call next() to pass control to the next route.

NOTE

next() will work only in middleware functions that were loaded by using the app.METHOD() or router.METHOD() functions.

This example shows a middleware sub-stack that handles GET requests to the /user/:id path.

app.get('/user/:id', (req, res, next) => {
  // if the user ID is 0, skip to the next route
  if (req.params.id === '0') next('route')
  // otherwise pass the control to the next middleware function in this stack
  else next()
}, (req, res, next) => {
  // send a regular response
  res.send('regular')
})

// handler for the /user/:id path, which sends a special response
app.get('/user/:id', (req, res, next) => {
  res.send('special')
})

Middleware can also be declared in an array for reusability. This example shows an array with a middleware sub-stack that handles GET requests to the /user/:id path

function logOriginalUrl (req, res, next) {
  console.log('Request URL:', req.originalUrl)
  next()
}

function logMethod (req, res, next) {
  console.log('Request Type:', req.method)
  next()
}

const logStuff = [logOriginalUrl, logMethod]
app.get('/user/:id', logStuff, (req, res, next) => {
  res.send('User Info')
})

Error-handling middleware#

WARNING

Error-handling middleware always takes four arguments. You must provide four arguments to identify it as an error-handling middleware function. Even if you don’t need to use the next object, you must specify it to maintain the signature. Otherwise, the next object will be interpreted as regular middleware and will fail to handle errors.

Define error-handling middleware functions in the same way as other middleware functions, except with four arguments instead of three, specifically with the signature (err, req, res, next):

app.use((err, req, res, next) => {
  console.error(err.stack)
  res.status(500).send('Something broke!')
})

For details about error-handling middleware, see: Error handling.

Explain the code structure#

• In app.get(), this is where we declare the path that allows the client to send a request to.

NOTE

The client refers to the application or software that initiates the request (referred to as a request). After the API receives the request, it processes it and sends data back (referred to as a response).

• The .get() method refers to sending a request using the GET method.
  • app.get('/', (req, res) => {}) has two parameters:
  • The first parameter, '/', specifies the path where data can be sent. The second parameter (req, res) is a function that handles the request. After receiving the data sent by the client (through req), the variables req = request represent the data sent by the client (or user), and res = response is the response object that defines how the API will send data back.
  • res.send('Hello world') is sending a response from the API back to the client.

Example#

// models/User.js
class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }
}

module.exports = User;

Example when using model to DB generator for MongoDB#

const mongoose = require('mongoose')
const UserSchema = new mongoose.Schema({
    username: {
        type: String,
        required: true,
        unique: true,
    },
    password: {
        type: String,
        required: true,
    },
    role: {
        type: String,
        default: 'user',
    },
})

const UserModel = mongoose.model('User', UserSchema)
module.exports = UserModel

Example#

const User = require('../models/User');

exports.getUserProfile = (req, res) => {
  const userId = req.params.id;
  
  User.find(userId, (err, user) => {
    if (err) {
      return res.status(500).send("Error fetching user data");
    }
    res.render('userProfile', { user });  
  });
};

Create .env file by create at same level of package.json#

MONGO_URI=DATABASE_URI
PORT=PORT

Create Folder name configs && Create file name database.js and put the content into file#

const mongoose = require('mongoose')
const dotenv = require('dotenv')
dotenv.config()
exports.connect = () => {
    try {
        mongoose.connect(process.env.MONGO_URI, {
            useNewUrlParser: true,
            useUnifiedTopology: true,
        })
    } catch (err) {
        process.exit(1)
    }
}

Create folder name model && Create file name user.model.js and put the content into file#

const mongoose = require('mongoose')
const UserSchema = new mongoose.Schema({
    name: {
        type: String,
        required: true,
    },
    username: {
        type: String,
        required: true,
        unique: true,
    },
    password: {
        type: String,
        required: true,
    }
})

const UserModel = mongoose.model('User', UserSchema)
module.exports = UserModel

Create folder name controllers && create file name user.controller.js and put the content into file#

const getUsersController = async (req, res) => {
    try {
        const query = await UserModel.find().select('-_id -password').exec()
        return res.status(200).send(query)
    } catch (err) {
        return res.status(400).send({ error: err.message })
    }
}

module.exports = { getUsersController }

Create folder name routes && Create file name user.route.js and put the content into file#

const express = require('express')
const router = express.Router()
const {
    getUsersController,
} = require('../controllers/user')

router.get('/', getUsersController)

module.exports = router

The content in app.js#

const express = require('express')
const app = express()
const dotenv = require('dotenv')
const db = require('./db/conn')
db.connect()
dotenv.config()

// import user route
const userRoute = require('./routes/user.route.js')


// buitin middleware
app.use(express.json())

const port = process.env.PORT || 3000

app.use('/users', userRoute)

// Error Handling
app.use((err, req, res, next) => {
    err.statusCode = err.statusCode || 404
    err.status = err.status || 'Not Found!'

    res.status(err.statusCode).send({
        status: err.status,
        message: err.cusMessage || 'Unknown Error',
        code: err.code || 0,
    })
    next()
})

app.listen(port, () => {
    console.log(`server running on ${port}`)
})