I am trying to create a socket.io based connection in my localhost server running on port 80. All of a sudden it has stopped working as i did not see my debug statements in session middleware as well as the console.log messages in my io event “connection” indicating a problem about socket connection. Any help to resolve the issue would be greatly appreciated.

Here is code of my server.js

const express = require('express'); // Express Framework
const axios = require('axios'); // HTTP Request Maker
const fs = require('fs'); // File System Module
const app = express(); // Express Instance
const bodyParser = require('body-parser'); // Post Request Data Fetcher
const hbs = require('hbs'); // Template Engine
const cookieParser = require('cookie-parser'); // For Login
const path = require('path');
const compression = require("compression"); // Optimizer
const http = require('http');  // http request maker
const nodemon = require('nodemon'); // For Server Restart 
const multer = require('multer');
const cors = require('cors'); // Cross Enviornment
const storage = multer.memoryStorage();
const MongoStore = require('connect-mongo');
const session = require('express-session');
const port = process.env.PORT || 80;
// Session Configuration

const sessionMiddleware = session({
  secret: 'random_secret_key_for_session_configuration', // Use a strong secret key
  resave: false,
  saveUninitialized: false,
  store: MongoStore.create({ mongoUrl: 'mongodb://localhost:27017' }) // Replace with your MongoDB URL
});

// Database Schemas
const RegisterUser = require("./models/registerUser")
const jwt = require("jsonwebtoken")
app.use(sessionMiddleware)

// Socket.IO Chat App

const socketIo = require('socket.io');
const server = http.createServer(app);
const io = socketIo(server);

const getSocketsFromSession = (request) => {
  return request.user ? request.user._id: null;
}
try{

  console.log("this statement is being called")

  io.use((socket, next) => {
    console.log("DEBUG POINT 1: Middleware called for socket ID:", socket.id);
    sessionMiddleware(socket.request, {}, (err) => {
      if (err) {
        console.error("Session middleware error:", err);
        return next(err);
      }
      console.log("Session data in middleware:", socket.request.session);
      next();
    });
  });
}

catch(error){
console.log("Error in using middleware", error)
}




let connectedSockets = {};

// Socket.io Events
io.on("connection", async function(socket){

  console.log("DEBUG POINT 4")
  try{

    
    const session = await socket.request.session;
    const userData = {}
    console.log("Session Data from Server.js", session)
    session.loggedIn?console.log(`${session.userFirstName} ${session.userLastName} has been connected with socket id ${socket.id}`): console.log(`Anonymous User has been connected `)
    if (session.loggedIn){
      connectedSockets[socket.id] = session._id
      console.log("User has been mapped with socket object")
      userData.name = `${session.userFirstName} ${session.userLastName}`
      userData.email = session.userEmail;
      userData.id = session.userId;
      userData.message = undefined

      console.log("User Data Object", userData)
    }
    else{
      connectedSockets[socket.id] = 'Anonymous';
    }
  }
  catch(error){
    console.log("Error while mapping sockets to session", error)
  }

  socket.on("chatMessage", function(messageData){
    console.log("Message from client ", messageData.message)

    io.emit("chatMessage", messageData)
  })
 
  socket.on('disconnect', async () => {
    const session = socket.request.session;
    const disconnectedUserName = session.userFirstName;
    console.log("Disconnected User Name", disconnectedUserName)
    console.log(`User ${session.userFirstName} ${session.userLastName} disconnected`);
    delete connectedSockets[socket.id];

    io.emit('usersList', Object.values(connectedSockets))
});
})

// Database
const mongoose = require('mongoose');
require("./db/conn")


// JWT Token Generation

const createToken = async() => {
  const token = jwt.sign({_id:"668042780026b6991062fe9c"}, "random_secret_key_making_sure_its_more_than_32chars_long")
  expiresIn:"15 minutes"
}
createToken()

// Middlewares

app.use(cookieParser());
// Enable CORS
app.use(cors());

// To get form data
app.use(express.urlencoded({ extended: false }));
app.use(express.json());


// Paths
const staticPath = path.join(__dirname, "../public");
const templatePath = path.join(__dirname, "../templates/views");
const partialsPath = path.join(__dirname, "../templates/partials");
const messagePath = path.join(__dirname, "../dev-data/messages");
const routesPath = path.join(__dirname, "../routes");

app.set('view engine', 'hbs');
app.set('views', templatePath);
app.use(express.static(staticPath));
hbs.registerPartials(partialsPath);

// Security Middleware
const helmet = require('helmet');
app.use(helmet()); // Setting Security Headers

app.use('/', require('../routes/pages'));

// Set Helper

// Register the 'eq' helper
hbs.registerHelper('eq', function (a, b) {
    return a === b;
  });

  // app.listen(port, () => {
  //   console.log(`Server is running on port ${port}`);
  // });

  // Error Handeling

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

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

Here is my code of auth middleware just in case

const jwt = require("jsonwebtoken");
const RegisterUser = require("../src/models/registerUser");

const secret_key = "just_a_random_32bits_secret_key_used_for_jwt_token_authentication";

const auth = async (req, res, next) => {
    try {
        const token = req.cookies.jwt;
        if (!token) {
            return res.status(401).send({ error: "Access Denied. No token provided." });
        }

        const verifyUser = jwt.verify(token, secret_key);

        // Getting Users Data
        const user = await RegisterUser.findOne({ _id: verifyUser._id }); // Await the promise
        if (!user) {
            return res.status(401).send({ error: "Access Denied. User not found." });
        }
        console.log("User Email:", user.userEmail);
        console.log("Validated User Authentication for _id", user._id);
        // Add user to request object
        
        req.session.userId = user._id;
        req.session.userFirstName = user.userFirstName;
        req.session.loggedIn = true;
        req.session.userLastName = user.userLastName;
        req.session.userEmail = user.userEmail;
        req.user = user;

        next();
    } catch (error) {
        res.status(401).send({ error: "Invalid token or user not authenticated." });
    }
};

module.exports = auth;

And here is the implementation of the socket connection in my frontend. I am using HBS Template engine

  <script src="/socket.io/socket.io.js"></script>
     <script>
    // Connect to the server using socket.io
    const socket = io();

    socket.on('chatMessage', function(messageData){
        console.log(messageData)
    })

    const inputMessageForm = document.getElementById("chat-input-form");
    const inputMessageField = document.getElementById("inputMessage");
    const messages = document.getElementById("chat-messages-box");

    function addMessages(messageData){
        const li = document.createElement('li');
        li.textContent = messageData.message;
        messages.appendChild(li)
    }

    inputMessageForm.addEventListener('submit', function(e){
        e.preventDefault();
        if(inputMessageField.value){
            socket.emit("chatMessage", inputMessageField.value);
            inputMessageField.value = '';
        }
    })

    socket.on("chatMessage", function(messageData){
        addMessages(message)
    })

    </script>

Thank you so much for your time. Any help would be greatly appreciated. Thank you.