Forem: Bliss Abhademere

How To Get Started From Express To NestJS: Complete Guide

Bliss Abhademere — Mon, 05 Feb 2024 12:01:36 +0000

Introduction:

Backend Developers like myself in the Node.js space looking to transition from Express.js a flexible and often straight forward framework to Nest.js a more structured and organized architecture to enhance the maintainability and scalability of your application. In this guide, we'll explore the key concepts of Nest.js, providing detailed examples and code snippets along the way.

Advantages of NestJS over Express:

NestJS offers several benefits that makes it an appealing alternative choice for developers:

Modularity: NestJS is built with modularity in mind, allowing you to organize your code into manageable modules.
Dependency Injection: NestJS also comes with built-in dependency which simplifies code organization and promotes testability.
Decorators and Metadata: NestJS use of decorators and metadata simplifies the creation of controllers, services, and modules.
Typescript and Microservices: NestJS is built with Typescript and Microservices in mind, providing strong typing and enhanced developer experience in using microservices like RabbitMQ, Kafka.

Resources

NestJS Project Setup

Installing the NestJS CLI

To get started, install the NestJS CLI globally:



npm install -g @nestjs/cli

The NestJS CLI simplies nest project creation and component generation, providing a seamless development experience.

NestJS Project Creation

Next, we create a new NestJS project named "my-nest-app":



nest new my-nest-app

After this command is executed on your CLI you get a prompt asking your preferred package manager:



⚡  We will scaffold your app in a few seconds..

? Which package manager would you ❤️  to use? (Use arrow keys)
> npm
  yarn
  pnpm

Now once your preference has been selected, the project structure and necessary dependencies installs. Navigate to the project directory:



cd my-nest-app

Application Structures: NestJS vs. Express

Let's compare the directory structures of NestJS and Express: NestJS Project Structure



src/
|-- controllers/
|   |-- app.controller.ts
|-- modules/
|   |-- app.module.ts
|-- services/
|   |-- app.service.ts
|-- main.ts

Express Project Structure



routes/
|-- appRoutes.js
|-- userRoutes.js
|-- ...
models/
|-- userModel.js
|-- ...
app.js

In NestJS, we organize our code into modules, controllers, and services, promoting a modular and scalable architecture.

Controllers in NestJS vs. Routes in Express

Introduction to Controllers

In NestJS, controllers play a crucial role in handling incoming requests and shaping the application's behavior. They're similar to Express routes but provide additional features.

Comparing Controllers to Routes

Let's consider a CRUD example to illustrate the differences between controllers in NestJS and routes in Express.

NestJS Controller



import { Controller, Get, Post, Body } from '@nestjs/common';
import { CatsService } from './cats.service';
import { Cat } from './interfaces/cat.interface';

@Controller('cats')
export class CatsController {
  constructor(private readonly catsService: CatsService) {}

  @Get()
  findAll(): Cat[] {
    return this.catsService.findAll();
  }

  @Post()
  create(@Body() createCatDto: any): string {
    return `This action adds a new cat: ${createCatDto.name}`;
  }
}

The @Controller decorator specifies the base route for all the routes defined within the controller.

Express Routes



const express = require('express');
const router = express.Router();
const catsService = require('../services/cats.service');

router.get('/', (req, res) => {
  const allCats = catsService.findAll();
  res.json(allCats);
});

router.post('/', (req, res) => {
  const newCat = req.body;
  res.send(`This action adds a new cat: ${newCat.name}`);
});

module.exports = router;

In Express, routes are defined using the express.Router() and then exported.

Dependency Injection and Services

Understanding Dependency Injection in NestJS

NestJS embraces the concept of dependency injection (DI) for managing and injecting dependencies into components. In contrast to Express, which often relies on singleton patterns, NestJS promotes the use of injectable services.

Transitioning from Singleton Patterns to Injectable Services Let's refactor a simple Express service to a NestJS injectable service.

Express Singleton Service



class CatService {
  constructor() {
    this.cats = [];
  }

  findAll() {
    return this.cats;
  }
}

module.exports = new CatService();

In this example, the service is a singleton instance exported for global use.

NestJS Injectable Service



import { Injectable } from '@nestjs/common';

@Injectable()
export class CatsService {
  private cats = [];

  findAll(): any[] {
    return this.cats;
  }
}

By using the @Injectable decorator, we define a service that can be injected into controllers or other services.

ORM in NestJS

Setting Up TypeORM Entity

NestJS supports various Object-Relational Mapping (ORM) and Object-Document Mapping (ODM) libraries. Let's set up a TypeORM entity for PostgreSQL:

InstallTypeORM and PostgreSQL Package



npm install --save @nestjs/typeorm typeorm pg

Configure the module in app.module.ts:



import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { CatsModule } from './cats/cats.module';

@Module({
  imports: [
    CatsModule,
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'nestuser',
      password: 'nestpassword',
      database: 'nestjs',
      synchronize: true,
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
    }),
  ],
})
export class AppModule {}

Define a TypeORM entity in cats/cat.entity.ts:



import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class Cat {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  age: number;

  @Column()
  breed: string;
}

This example sets up a PostgreSQL database with TypeORM and defines a Cat entity.

Data Validation and Validation Pipes

Class Validators and Global Validation Pipe

NestJS simplifies data validation using class validators and global validation pipes. Let's explore how to use these features.

Using Class Validators Create a DTO (Data Transfer Object) in cats/dto/create-cat.dto.ts:



import { IsString, IsInt } from 'class-validator';

export class CreateCatDto {
  @IsString()
  readonly name: string;

  @IsInt()
  readonly age: number;

  @IsString()
  readonly breed: string;
}

In the corresponding controller, use the DTO with class validation:



import { Controller, Post, Body, UsePipes, ValidationPipe } from '@nestjs/common';
import { CreateCatDto } from './dto/create-cat.dto';
import { CatsService } from './cats.service';

@Controller('cats')
export class CatsController {
  constructor(private readonly catsService: CatsService) {}

  @Post()
  @UsePipes(new ValidationPipe({ transform: true }))
  create(@Body() createCatDto: CreateCatDto): string {
    this.catsService.create(createCatDto);
    return `Cat ${createCatDto.name} created successfully`;
  }
}

Here, the @UsePipes(new ValidationPipe({ transform: true })) decorator applies the global validation pipe to the create route, validating incoming data against the CreateCatDto schema. The transform: true option automatically transforms incoming payload data into instances of the DTO.

Global Validation Pipe Configuration

Configure the global validation pipe in main.ts:



import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe({ transform: true }));
  await app.listen(3000);
}
bootstrap();

In this configuration, useGlobalPipes applies the validation pipe globally for all routes, ensuring that data is validated and transformed consistently across the application.

Now, every incoming request to your NestJS application will undergo validation against the defined DTO schemas, providing a robust and centralized approach to data validation.

Testing in NestJS

Writing Tests for NestJS Applications

NestJS includes built-in testing utilities that make it easy to write unit and integration tests for your application. Let's explore testing approaches using Jest in NestJS compared to testing in Express.

Setting Up Jest

NestJS Jest is a popular testing framework that works seamlessly with NestJS. Install the required packages:



npm install --save-dev @nestjs/testing jest @nestjs/schematics

Configure Jest injest.config.js:



module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
};

Writing a Basic Unit Test

Let's write a simple unit test for a service in cats/cats.service.spec.ts:



import { Test, TestingModule } from '@nestjs/testing';
import { CatsService } from './cats.service';

describe('CatsService', () => {
  let service: CatsService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [CatsService],
    }).compile();

    service = module.get<CatsService>(CatsService);
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  it('should return an array of cats', () => {
    const cats = service.findAll();
    expect(Array.isArray(cats)).toBe(true);
  });
});

In this example, we're testing the CatsService to ensure it returns an array of cats.

Running Tests

Execute the tests with the following command:



npm run test

Jest will run the tests and provide feedback on their success or failure.

Conclusion

Migrating from Express to NestJS might be overwhelming at first, but the benefits of a structured and modular architecture will greatly enhance your maintainability and scalability of your application.

Here’s a link to my main blog site: Bliss Articles

I appreciate you taking the time to read this😁. Please think about giving it a ❤️ if you found it useful and instructive and bookmarking✅ for later use. Please post your queries and remarks in the comments box if you have any. I'm eager to hear your thoughts. Up until then!

Exciting projects to build using Socket.IO Node.js Express

Bliss Abhademere — Wed, 22 Mar 2023 20:06:36 +0000

Introduction

Socket.io is a popular library for real-time web applications that enables bidirectional communication between the client and server. Node.js and Express are popular back-end frameworks often used with Socket.io to build scalable and robust real-time applications. In this article we'll explore some exciting projects to develop using Socket.io, Node.js, and Express. These projects can help you hone your abilities and improve your portfolio as a novice or an experienced developer.
So let's get started and investigate some intriguing project ideas!

Prerequisites

Frameworks

Node.js
npm
Express
Socket.io
VS Code

Resources

Before diving into the projects, it is essential to have a basic understanding of Node.js, Express.js, and Socket.io. Here are some resources to get you started:

Node.js Documentation
Express.js Documentation
Socket.io Documentation

Project 1: Real-time Chat Application

The first project is a real-time chat application that allows users to send and receive messages in real time. The application will set up a two-way communication channel between the server and the client using Socket.io and serve the web pages using Express.js.
Here is a code snippet that demonstrates how to create a Socket.io server and listen for incoming connections:



const express = require('express');
const http = require('http');
const socketIo = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

io.on('connection', (socket) => {
  console.log('A user connected');

  socket.on('disconnect', () => {
    console.log('A user disconnected');
  });
});

This code creates an HTTP server using the http module, an Express.js application using the socket.io module, and an HTTP server using the socket.io module. The io.on() method listens for incoming connections and logs a message when a user connects or disconnects.

We can use the socket to transmit and receive messages using socket.on() and emit() method. Here is an example of how to broadcast a message to all connected clients:



socket.on('chat message', (msg) => {
  io.emit('chat message', msg);
});

This code listens for a chat message event from the client and then broadcasts the message to all connected clients using the io.emit() method.

Here is a link to a complete tutorial on how to build a real-time chat application with Socket.io, Node.js, and Express.js: Building a Real-time Chat Application with Socket.io, Node.js, and Express.js

Project 2: Real-time Dashboard Application

The second project is a real-time dashboard application that displays real-time data from a data source, such as a database or an API. The application will use Socket.io to stream the data to the client in real-time and Express.js to serve the web pages.

Here is a code snippet that demonstrates how to stream data using Socket.io:



const io = socketIo(server);

io.on('connection', (socket) => {
  console.log('A user connected');

  const interval = setInterval(() => {
    // Get data from the data source
    const data = getData();

    // Send the data to the client
    socket.emit('data', data);
  }, 1000);

  socket.on('disconnect', () => {
    console.log('A user disconnected');
    clearInterval(interval);
  });
});

This code listens for incoming connections and then streams data to the client every second using the socket.emit() method. The setInterval() method is used to continuously fetch data from the data source and emit it to the client.

Here is a link to a complete tutorial on how to build a real-time dashboard application with Socket.io, Node.js, and Express.js: Building a Real-time Dashboard Application with Socket.io, Node.js, and Express.js

Project 3: Multiplayer Game

The third project is a multiplayer game that allows multiple players to play together in real-time. Socket.io and Express.js will be used by the game to synchronize game state between the server and clients and to serve web pages.

Here is a code snippet that demonstrates how to synchronize the game state using Socket.io:



io.on('connection', (socket) => {
console.log('A user connected');

// Add the player to the game
socket.on('add player', (player) => {
// Add the player to the game state
gameState.addPlayer(player);

// Send the updated game state to all connected clients
io.emit('game state', gameState);
});

// Move the player in the game
socket.on('move player', (player) => {
// Move the player in the game state
gameState.movePlayer(player);

// Send the updated game state to all connected clients
io.emit('game state', gameState);
});

// Remove the player from the game
socket.on('remove player', (player) => {
// Remove the player from the game state
gameState.removePlayer(player);

// Send the updated game state to all connected clients
io.emit('game state', gameState);
});

socket.on('disconnect', () => {
console.log('A user disconnected');

// Remove the player from the game
gameState.removePlayer(socket.id);

// Send the updated game state to all connected clients
io.emit('game state', gameState);
});
});

This code listens for incoming connections and then handles events such as adding a player, moving a player, and removing a player from the game state. Socket.io synchronizes the server and clients' game sessions using the gameState object, which serves as a game's state storage.

Here is a link to a complete tutorial on how to build a multiplayer game with Socket.io, Node.js, and Express.js: Building a Multiplayer Game with Socket.io, Node.js, and Express.js

Conclusion

Socket.io, Node.js, and Express.js are essential tools for building real-time applications that require low latency and high throughput. This article covered some sample projects software engineers can create using these tools. You can create your real-time applications and benefit from Socket.io, Node.js, and Express.js by following the sample code snippets and tutorials.

Here’s a link to my main blog site: Bliss Articles

Real-Time Applications with Node.js and WebSockets

Bliss Abhademere — Fri, 17 Feb 2023 09:02:06 +0000

Real-time web applications have gained popularity in recent years. These programs provide real-time data flow without the need to repeatedly refresh web pages by facilitating smooth communication between clients and servers. Due to their scalability, speed, and user-friendliness, Node.js and related technologies, like Express and WebSockets, are preferred options for developing real-time applications.

What is WebSockets?

WebSockets is a protocol for two-way communication between a client and a server, allowing data to be sent and received in real time. WebSockets overcome the limitations of traditional HTTP communication, which requires establishing a new connection for each request. WebSockets enable the establishment of a persistent connection, which allows data to be delivered and received at any time, without the need to initiate a new connection.
Building a Real-Time Application with Node.js and WebSockets
In this article, we'll use Node.js, Express, and WebSockets to create a straightforward real-time chat application. The application will allow multiple users to communicate in real time.

Prerequisites

Before we begin, ensure that you have the following installed:

Node.js
npm
Express
Socket.IO

Setting up the Project
First, create a new directory for your project and initialize it with npm:

mkdir real-time-chat
cd real-time-chat
npm init

Install the required packages:

npm install express socket.io --save

Create a new file named server.js and add the following code:

const express = require('express');
const app = express();
const server = require('http').Server(app);
const io = require('socket.io')(server);

app.use(express.static(__dirname + '/public'));

app.get('/', (req, res) => {
  res.sendFile(__dirname + '/public/index.html');
});

io.on('connection', (socket) => {
  console.log('a user connected');

  socket.on('disconnect', () => {
    console.log('user disconnected');
  });

  socket.on('chat message', (msg) => {
    console.log('message: ' + msg);
    io.emit('chat message', msg);
  });
});

server.listen(3000, () => {
  console.log('listening on *:3000');
});

We import the needed package in this code., set up the Express app, and create a new server using the http module. We also set up the Socket.IO server, which allows us to communicate in real-time with our clients.
Static files are supplied from the specified directory by the app.use() function. This instance is serving files from the public directory.

The app.get() method sets up a route to the home page, which provides access to the public directory's index.html file.
A connection listener is established by the io.on() method, which watches for connections from clients.

When a client disconnects, an event called "disconnect" is released, and the socket.on() procedure watches for it. We log a note to the console whenever a client disconnects.

The "chat message" event, which is released whenever a client sends a message, is also monitored by the socket.on() method.
When a message is received, we emit it to all clients using io.emit()and log it to the console.

Finally, we launch the server and open port 3000 for listening.

Creating the Frontend

Create a new directory called public, and add a new file called index.html to it. The code below should be added to this file:

<!DOCTYPE html>
<html>
  <head>
    <title>Real-Time Chat Application</title>
    <link rel="stylesheet" type="text/css" href="style.css">
  </head>
  <body>
    <div class="chat-container">
      <header>
        <h1>Real-Time Chat Application</h1>
      </header>
      <main class="chat-window">
        <ul class="message-list"></ul>
        <form id="message-form">
          <input type="text" name="message" placeholder="Type your message here">
          <button>Send</button>
        </form>
      </main>
    </div>
    <script src="/socket.io/socket.io.js"></script>
    <script src="script.js"></script>
  </body>
</html>

In this HTML file, we create the structure for the chat interface. We have a header that displays the application's name, a "main" element with the chat window and a message-sending form, and a script tag that loads the socket.io client library and our client-side JavaScript file.
Creating a form to send messages requires the use of the <form> tag. We'll attach a listener to it when the form is submitted because it has an id attribute with the value "message-form" set.

A placeholder attribute on the form's <input> tag with the name "message" prompts the user to "Type your message here" as a hint.

Additionally, there is a "Send"-labeled <button> tag that the user can click to submit the form.

In the <script> tag, we'll create a new instance of the socket.io client and attach event listeners for the form submission and receiving chat messages. Let's add the script.js file and add the following code:

const socket = io();

// Handle form submission
const form = document.getElementById('message-form');
form.addEventListener('submit', e => {
  e.preventDefault();
  const messageInput = form.elements.message;
  const message = messageInput.value.trim();
  if (message) {
    socket.emit('chat message', message);
    messageInput.value = '';
  }
});

// Handle incoming chat messages
const messageList = document.querySelector('.message-list');
socket.on('chat message', message => {
  const li = document.createElement('li');
  li.textContent = message;
  messageList.appendChild(li);
});

In this client-side JavaScript code, we first create a new instance of the socket.io client using io(). Then, we attach an event listener for the form submission using addEventListener(). Inside the event listener, we prevent the default form submission behavior using e.preventDefault(), get the message input using form.elements.message, and emit a chat message event with the message to the server using socket.emit(). We also clear the message input value using messageInput.value = " ".
We also attach an event listener for receiving chat messages using socket.on(). Inside the event listener, we create a new list item element using document.createElement() and add the received message as text content using li.textContent. Then, we append the list item to the message list using messageList.appendChild(li).

Conclusion

With this code, we have a functional real-time chat application that allows users to send and receive messages in real-time. We can start the server using node index.js and navigate to http://localhost:3000 in a web browser to test it out.
Congratulations on building your first real-time application with Node.js, Express, and WebSockets!

Integrate your Node.js and Express.js App with Socket.IO

Bliss Abhademere — Wed, 08 Feb 2023 10:44:42 +0000

Introduction

Integrating Node.js, Express.js, and Socket.IO is required when creating real-time online applications. These technologies provide server-side web development projects with quick, scalable, and user-friendly solutions.

You will discover how to combine these technologies in this tutorial to create a real-time chat application.

Prerequisites

Basic knowledge of Node.js, Express.js and JavaScript.
Node.js and npm installed on your machine.

Step 1: Install dependencies

Before starting, install the essential dependencies, including Node.js, Express.js, and Socket.IO. Use npm to accomplish this:

npm install express socket.io

Step 2: Set up a basic Express.js server

Your chat application will be built on a simple Express.js server that you create in this phase. The code below creates an HTTP server by calling require("http") on an Express.js server. Server (app), which listens on a certain port:

const express = require('express');
const app = express();
const server = require('http').Server(app);
const port = process.env.PORT || 3000;

server.listen(port, () => {
  console.log(`Server started on port ${port}`);
});

Step 3: Integrate Socket.IO

You must incorporate Socket.IO if you want to provide your chat application real-time capabilities. Add the following code to your Express.js server to accomplish this:

const io = require('socket.io')(server);

io.on('connection', socket => {
  console.log('User connected');

  socket.on('disconnect', () => {
    console.log('User disconnected');
  });
});

By supplying the server to require("socket.io") in this case, io is constructed. When a client connects to the server, the code then waits for a "connection" event to be produced. The code logs a message to the console to show that a connection has been formed when one is made. A "disconnect" event is released when a user disconnects, and the code writes a message to the console to let the user know that they have disconnected.

Step 4: Add chat functionality

You can now give your chat application conversation features after integrating Socket.IO. You can achieve this by issuing a chat message event to all connected clients after listening for a chat message event from the client.

io.on('connection', socket => {
  console.log('User connected');

  socket.on('chat message', message => {
    io.emit('chat message', message);
  });

  socket.on('disconnect', () => {
    console.log('User disconnected');
  });
});

Here, the code uses socket.on('chat message', message => ... ) to monitor the client for a "chat message" event. The code utilizes the io.emit() function to send out a "chat message" event to all connected clients whenever a "chat message" event is received. In this manner, the message will be delivered to all connected clients, who will then be able to see it in the conversation.

Conclusion

Now that Node.js, Express.js, and Socket.IO have been integrated, you have the ideal basis for a real-time online application. On top of this foundation, you can keep expanding and investigate the fascinating possibilities of real-time web development.

Modernizing Authentication with JWT Cookies

Bliss Abhademere — Wed, 08 Feb 2023 08:50:51 +0000

Introduction

Verifying a user's identity in a web application using authentication. Modern web applications now frequently use JSON Web Tokens (JWTs) as a means of authentication.

JWTs are distinctive because they:

Stateless (don't require server storage)
Self-contained (all necessary information is included in the token) (all necessary information is included in the token)
Simple to transfer (can be easily passed between client and server)
JWTs can be used by being kept in HTTP cookies, for example. In this post, we'll examine the advantages JWT cookies have over other authentication options and why they're a popular choice.

Security

Enhanced security is among the major advantages of using JWT cookies. JWTs are not kept on the server, in contrast to conventional session-based authentication. Instead, they are provided along with every request, saving the server from having to keep track of active session databases. Due to the fact that critical data is not kept in a single, easily accessible area, the danger of security breaches is decreased.

In addition to being digitally signed and encrypted, JWTs allow for the encryption of the data they contain and the verification of their integrity and authenticity. This makes it far more difficult for an attacker to alter a JWT's contents and pass themselves off as a user.

Scalability

Scalability is a benefit of JWT cookies as well. With conventional session-based authentication, the server must handle an increasing number of active sessions as the number of users rises. As the server must manage a huge volume of data processing and storage, this might soon become a scalability bottleneck.

Since JWT cookies are stored on the client and sent with each request, the server does not need to keep track of active sessions. This lessens the server's workload and makes it simpler to scale the application as necessary.

Interdisciplinary compatibility

Because JWT cookies are stored in HTTP cookies and are easily transferable between domains, they are compatible with cross-domain queries. Due to the ease with which authentication data can be sent across other domains and services, it is now simpler to develop applications that employ numerous domains and services.

Portability

Additionally portable, JWT cookies make it simple to move authentication data from one application to another. As a result, it is simpler to develop apps that utilize a variety of services and platforms because the authentication data can be readily transferred between them.

Conclusion

As a result of their improved security, scalability, cross-domain compatibility, and portability, JWT cookies are a popular solution for authentication in contemporary web applications. Compared to conventional session-based authentication, they have a number of benefits and are a good fit for contemporary web development. The advantages of JWT cookies and how they can be used to enhance your authentication process should be taken into account whether you are developing a new application or updating an existing one.

Forem: Bliss Abhademere

How To Get Started From Express To NestJS: Complete Guide

Introduction:

Advantages of NestJS over Express:

Resources

NestJS Project Setup

Installing the NestJS CLI

NestJS Project Creation

Application Structures: NestJS vs. Express

Controllers in NestJS vs. Routes in Express

Introduction to Controllers

Comparing Controllers to Routes

Dependency Injection and Services

Understanding Dependency Injection in NestJS

ORM in NestJS

Setting Up TypeORM Entity

Data Validation and Validation Pipes

Class Validators and Global Validation Pipe

Global Validation Pipe Configuration

Testing in NestJS

Writing Tests for NestJS Applications

Setting Up Jest

Writing a Basic Unit Test

Running Tests

Conclusion

Exciting projects to build using Socket.IO Node.js Express

Introduction

Prerequisites

Frameworks

Resources

Project 1: Real-time Chat Application

Project 2: Real-time Dashboard Application

Project 3: Multiplayer Game

Conclusion

Real-Time Applications with Node.js and WebSockets

What is WebSockets?

Prerequisites

Creating the Frontend

Conclusion

Integrate your Node.js and Express.js App with Socket.IO

Introduction

Prerequisites

Step 1: Install dependencies

Step 2: Set up a basic Express.js server

Step 3: Integrate Socket.IO

Step 4: Add chat functionality

Conclusion

Modernizing Authentication with JWT Cookies

Introduction

Security

Scalability

Interdisciplinary compatibility

Portability

Conclusion

Further Reading