Muhammad Sufiyan's Blog

Backend

Muhammad Sufiyan's photo
Muhammad Sufiyan
·

4 min read

Backend Development Documentation

This section provides an overview of the key concepts and technologies we have covered in backend development during the SMIT Batch 10 training. Refer to this guide for a summary of the topics and use it as a reference for your projects.

1. Introduction to Backend Development

Backend development involves creating the server-side logic, databases, and APIs that power the functionality of web applications. It focuses on data storage, retrieval, and processing, ensuring that the front-end interacts smoothly with the backend services.

2. Node.js

Node.js is a runtime environment that allows you to execute JavaScript on the server-side.

  • Setup and Installation:

    • Install Node.js from nodejs.org.

    • Initialize a new project with npm init.

    • Install dependencies using npm install.

  • Key Concepts:

    • Modules and npm: Using built-in modules (e.g., fs, http) and npm packages.

    • Event-driven architecture: Understanding event loops and asynchronous programming.

3. Express.js

Express.js is a minimalist web framework for Node.js, designed to build web applications and APIs.

  • Setting up an Express Application:

    • Create an Express app:

      Copy

        const express = require('express');
  const app = express();
  app.listen(3000, () => console.log('Server running on port 3000'));

    • Define routes:

      Copy

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

    • Middleware: Functions that process requests before they reach the route handler.

      Copy

        app.use(express.json());
  app.use(express.urlencoded({ extended: true }));

4. RESTful API Development

APIs (Application Programming Interfaces) allow communication between the client and server.

  • CRUD Operations:

    • Create, Read, Update, Delete operations using HTTP methods (POST, GET, PUT, DELETE).

Copy

    app.post('/data', (req, res) => { /* create logic */ });
    app.get('/data/:id', (req, res) => { /* read logic */ });
    app.put('/data/:id', (req, res) => { /* update logic */ });
    app.delete('/data/:id', (req, res) => { /* delete logic */ });

5. Working with Databases

Databases store and manage application data.

  • MongoDB:

    • NoSQL database that stores data in JSON-like documents.

    • Setting up MongoDB: Install and run MongoDB locally or use MongoDB Atlas.

    • Mongoose: ODM (Object Data Modeling) library for MongoDB.

Copy

    const mongoose = require('mongoose');
    mongoose.connect('mongodb://localhost:27017/mydatabase', { useNewUrlParser: true, useUnifiedTopology: true });

    const schema = new mongoose.Schema({ name: String, age: Number });
    const Model = mongoose.model('Model', schema);

  • Performing CRUD Operations with Mongoose:

    Copy

      const item = new Model({ name: 'John', age: 30 });
  item.save();

  Model.find({}, (err, items) => { /* read logic */ });
  Model.findByIdAndUpdate(id, { age: 35 }, (err, item) => { /* update logic */ });
  Model.findByIdAndDelete(id, (err) => { /* delete logic */ });

6. Authentication and Authorization

Securing applications by verifying user identity and controlling access.

  • JWT (JSON Web Tokens):

    • Generate tokens upon user login.

    • Verify tokens for protected routes.

Copy

    const jwt = require('jsonwebtoken');
    const token = jwt.sign({ userId: user._id }, 'secret_key');

  • Middleware for Protected Routes:

    Copy

      const auth = (req, res, next) => {
    const token = req.header('Authorization').replace('Bearer ', '');
    const decoded = jwt.verify(token, 'secret_key');
    req.user = decoded;
    next();
  };
  app.get('/protected', auth, (req, res) => { /* protected logic */ });

7. Error Handling and Debugging

Implementing error handling and debugging techniques to ensure robust applications.

  • Try/Catch Blocks:

    • Catching and handling errors in asynchronous code.

Copy

    app.get('/route', async (req, res) => {
      try {
        const data = await someAsyncFunction();
        res.send(data);
      } catch (error) {
        res.status(500).send(error.message);
      }
    });

  • Debugging Tools:

    • Using console.log for basic debugging.

    • Node.js built-in debugger.

    • IDE/debugger integration (e.g., VSCode).

8. Deployment

Deploying applications to production environments.

  • Hosting Platforms:

    • Vercel, Cyclic, Railway.

  • Deployment Steps:

    • Prepare the application for production (e.g., environment variables, build process).

    • Use version control (Git) for code management.

    • Deploy the application to the chosen hosting platform.

Additional Resources

Conclusion

Backend development is a critical aspect of web development, providing the necessary infrastructure for front-end applications to function. By understanding and applying these concepts, you will be able to build robust, scalable, and secure web applications. Keep practicing, stay curious, and don't hesitate to ask questions if you need further clarification on any topic. Happy coding!

Instructor: Muhammad Sufiyan

Linkedin: linkedin.com/in/innosufiyan

backendNode.jsExpressMongoDB