Creating a Real-time Employee Management System with Next.js and WebSockets

Real-time functionality is a feature that allows your application to receive and send data in real-time, without the need for the user to refresh the page. One way to achieve this is by using WebSockets, which provide a two-way communication channel between the client and the server.

In this tutorial, we will show you how to add real-time functionality to a Next.js application using WebSockets. We will be using this example of an employee management system for a company. By the end of this tutorial, you will have a fully-functioning employee management system that updates in real-time using WebSockets.

Step 1: Setting up a Next.js project

The first step is to set up a new Next.js project. You can do this by running the following command:

npx create-next-app my-employee-system

This command will create a new directory called “my-employee-system” that contains the basic structure of a Next.js app.

 

Step 2: Installing WebSocket packages

To add real-time functionality to your Next.js application, you will need to install the ‘ws’ package. You can do this by running the following command in your Next.js project directory:

npm install ws

 

Step 3: Creating a WebSocket server

Create a new file in the root of your project directory called “websocket.js”. In this file, you will create a new WebSocket server using the ‘ws’ package. This server will handle the communication between the client and the server in real-time.

Here’s an example of how you can create a WebSocket server using the ‘ws’ package in Node.js:

const WebSocket = require('ws');

const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', (ws) => {
  ws.on('message', (message) => {
    console.log(`Received message: ${message}`);
    ws.send(`Echo: ${message}`);
  });
});

This code creates a new WebSocket server on port 8080 using the WebSocket.Server() method from the ‘ws’ package. It also sets up an event listener for when a new connection is made and another event listener for when a message is received. When a message is received, the server will log the message to the console and then send back an “Echo” of the message to the client.

You can add more functionality to this WebSocket server, such as handling different types of messages, broadcasting messages to all connected clients, and more. For example, if you want to broadcast message to all connected clients you can use wss.clients.forEach(function each(client) {client.send(message);});

You can also create multiple WebSocket server to handle different types of events by creating different instances of the WebSocket.Server, each listening on a different port or path.

 

Step 4: Connecting the WebSocket server to the Next.js server

Now that you have created a WebSocket server, you need to connect it to your Next.js server. You can do this by importing the WebSocket server in your Next.js server file (server.js) and passing it the http server object.

Here’s an example of how you can connect a WebSocket server to your Next.js server:

// Import the http module from the built-in Node.js library
const http = require('http');
const WebSocket = require('ws');

// Import the Next.js functions for creating the server
const { createServer } = require('next');
const app = next({ dev: process.env.NODE_ENV !== 'production' });
const handle = app.getRequestHandler();

// Start the Next.js server
app.prepare().then(() => {
  // Create the http server
  const server = http.createServer((req, res) => {
    handle(req, res);
  });
  
  // Create the WebSocket server and pass it the http server object
  const wss = new WebSocket.Server({ server });

  // Set up event listeners for the WebSocket server
  wss.on('connection', (ws) => {
    ws.on('message', (message) => {
      console.log(`Received message: ${message}`);
      ws.send(`Echo: ${message}`);
    });
  });

  // Start the http server
  server.listen(3000, (err) => {
    if (err) throw err;
    console.log('> Ready on http://localhost:3000');
  });
});

 

Step 5: Creating a WebSocket client

Create a new file in your Next.js application called “websocketClient.js”. This file will be used to create a new WebSocket client that will connect to the WebSocket server and listen for events.

import React, { useEffect } from 'react';
const WebSocket = require('ws');

function MyPage() {
    useEffect(() => {
        // Create the WebSocket connection
        const ws = new WebSocket('ws://localhost:8080');

        // Set up event listeners for the WebSocket connection
        ws.onopen = () => {
            console.log('WebSocket connection opened');
            ws.send('Hello, Server!');
        };

        ws.onmessage = (event) => {
            console.log(`Server says: ${event.data}`);
        };

        ws.onclose = () => {
            console.log('WebSocket connection closed');
        };

        // Clean up the WebSocket connection when the component unmounts
        return () => {
            ws.close();
        };
    }, []);

    return <div>WebSocket connection established</div>;
}

export default MyPage;

This code creates a new WebSocket connection using the WebSocket() constructor, passing the URL of the WebSocket server as an argument. Then it sets up event listeners for the WebSocket connection, such as onopen, onmessage, and onclose. When the WebSocket connection is opened, it sends a message to the server saying “Hello, Server!” and listens for messages coming back. When the WebSocket connection is closed, it logs a message to the console.

It’s also important to cleanup the WebSocket connection when the component unmounts. This is done by returning a function from the useEffect hook that calls the close() method on the WebSocket instance.

You can also send and receive more complex data than just strings, such as JSON. To do this, you will need to use the JSON.stringify() method to convert your JavaScript objects to JSON strings before sending them, and the JSON.parse() method to convert JSON strings to JavaScript objects when receiving them.

 

Step 6: Using WebSockets in your Next.js pages

Now that you have set up the WebSocket server and client, you can use them in your Next.js pages to add real-time functionality. For example, you can use the WebSocket client to send a message to the server when an employee is added, and then update the employee list on the client in real-time using the WebSocket server’s response.

Here’s an example of how you can use WebSockets in a Next.js page to create a real-time employee management system:

import React, { useState, useEffect } from 'react';
const WebSocket = require('ws');

function EmployeeManagement() {
  const [employees, setEmployees] = useState([]);

  useEffect(() => {
    const ws = new WebSocket('ws://localhost:8080');

    ws.onopen = () => {
      console.log('WebSocket connection opened');
    };

    ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      if (data.action === 'get_employees') {
        setEmployees(data.employees);
      }
    };

    ws.onclose = () => {
      console.log('WebSocket connection closed');
    };

    return () => {
      ws.close();
    };
  }, []);

  const handleAddEmployee = (employee) => {
    const ws = new WebSocket('ws://localhost:8080');

    ws.onopen = () => {
      ws.send(JSON.stringify({ action: 'add_employee', employee }));
    };
  };

  const handleRemoveEmployee = (employeeId) => {
    const ws = new WebSocket('ws://localhost:8080');

    ws.onopen = () => {
      ws.send(JSON.stringify({ action: 'remove_employee', employeeId }));
    };
  };

  return (
    <div>
      <EmployeeList employees={employees} onRemove={handleRemoveEmployee} />
      <AddEmployeeForm onSubmit={handleAddEmployee} />
    </div>
  );
}

export default EmployeeManagement;

In this example, we have a state variable employees that is used to store the list of employees and a useEffect hook that sets up a WebSocket connection to the server. When the WebSocket connection is opened, it sends a message to the server requesting the current list of employees. When the server sends a message back with the employee data, the employees state variable is updated with the new data.

We also have two functions handleAddEmployee and handleRemoveEmployee which are used to send messages to the server to add or remove an employee. These functions create a new WebSocket connection and send a message with the appropriate action and data when invoked.

Note that we are also using the JSON.stringify() method to convert JavaScript objects to JSON strings before sending them, and the JSON.parse() method to convert JSON strings to JavaScript objects when receiving them. This is because WebSockets only support

 

Step 7: Deploying the Next.js and WebSocket

Once you have built your Next.js application with WebSockets, you can deploy it to a hosting service. You can use a service like Heroku or Vercel to deploy your Next.js app and a service like Amazon Web Services (AWS) or Google Cloud Platform (GCP) to deploy your WebSocket server.

 

Conclusion

In this tutorial, you’ve learned how to add real-time functionality to a Next.js application using WebSockets. You’ve seen how to set up a Next.js project, install the necessary packages, create a WebSocket server, connect it to your Next.js server, create a WebSocket client, and use WebSockets in your Next.js pages. You’ve also seen an example of how to use WebSockets to create a real-time employee management system. By following the steps outlined in this tutorial, you should be able to add real-time functionality to your own Next.js applications using WebSockets. Remember to test your implementation in a test environment before going live and also to follow the best security practices. Be sure to also check out the official documentation and other resources for more information and examples on how to use WebSockets with Next.js.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top