I’m working on an Express.js application and I’m having trouble accessing cookies from incoming requests. cookies in the browser, req.cookies is always [Object: null prototype] {} but alredy cookie having in browser. Here are the steps I’ve taken and for fetching api using redux-tookit-query for fetching API

Jobroute.js
 

const express = require("express");
const {AppliedCandidate,RejectedSingleCandidate,ShortlistCandidate} = require("../controllers/JobController");
const Verifyorg = require("../middlewares/Verifyorg");
const VerifyToken= require('../middlewares/verifytoken');

const router = express.Router()
router.get('/jobdetail/:id',VerifyToken,Verifyorg,AppliedCandidate);
router.patch('/reject/:applicationId/:candidateId',VerifyToken,Verifyorg, RejectedSingleCandidate);
router.put('/shortlist/:applicationId/:candidateId',Verifyorg , VerifyToken , ShortlistCandidate);

module.exports = router;

Already using this NPM packages :

cookie-parser is correctly installed

Main Index.js file code :

const express = require('express');
const app = express();
const cookieParser = require('cookie-parser');
const bodyParser = require('body-parser');
const cors = require('cors');
require('dotenv').config();
var morgan = require('morgan')
const port = process.env.PORT;
const errorHandler = require('./handler/errorhandler');
const fileUpload = require('express-fileupload');
const ConnectDB = require('./config/DbConfig');
app.use(cookieParser());

ConnectDB();

const corsOptions = {
  origin:'http://localhost:5173',
  credentials: true,
  methods: ["GET", "POST", "PUT", "DELETE","PATCH"],
  allowedHeaders: ["Content-Type", "Authorization"]
};

app.use((req, res, next) => {
  console.log(req.cookies);
  res.header('Access-Control-Allow-Origin', 'http://localhost:5173');
  next();

});
app.use(morgan('dev'));
morgan(':method :url :status :res[content-length] - :response-time ms')




app.use(cors(corsOptions));

app.use(express.json());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(fileUpload({ limits: { fileSize: 5 * 1024 * 1024 }, useTempFiles: true }));



//Routes

const jobroutes = require('./routes/JobRoutes');
const Orgroutes = require('./routes/OrgRoute');
const Userroute = require('./routes/UserauthRoute');

app.use('/api/user', Userroute);
app.use('/api/org', Orgroutes);
app.use('/api/job', jobroutes);

app.use(errorHandler);

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

verifytoken.js code here :

const jwt = require("jsonwebtoken");
const SECERET_KEY = process.env.JWT_SECRET;

const VerifyToken = async (req, res, next) => {
  try {
    const {accesstoken} = req?.cookies;



    if (!accesstoken) {
      return res.status(401).send({ message: 'Unauthorized user access' });
    }
    jwt.verify(accesstoken, SECERET_KEY, (err, decodedToken) => {
      if (err) {
        return res.status(403).send({ message: 'Invalid or expired token' });
      }else{
        req.user = decodedToken;
        next();
      }
    });
} catch (err) {

     return res.status(500).send({ message: err.message });
}
};


module.exports = VerifyToken

redux toolkit code :

import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react';

export const jobApi = createApi({
  reducerPath: 'jobApi',
  baseQuery: fetchBaseQuery({ baseUrl: 'http://localhost:8800/api/job' }),
  refetchOnMountOrArgChange: true,
  tagTypes: ['job', 'org'],
  endpoints: (builder) => ({
    searchJobs: builder.query({
      query: (searchparams) => {
        console.log(searchparams);
        return {
          url: '/post/search',
          method: 'GET',
          params: searchparams,
          transformResponse: (jobs) => jobs.reverse(),
        };
      },
      providesTags: ['job'],
    }),
    getJobById: builder.query({
      query: (id) => `/getjob/${id}`,
      providesTags: ['job'],
    }),
    getJobcategory: builder.query({
      query: () => `/category`,
      invalidatesTags: ['job'],
    }),
    JobdetailWithCandidate: builder.query({
      query: (id) => `/jobdetail/${id}`,
      headers: { 'Content-Type': 'application/json' },
      credentials: 'include',
      invalidatesTags: ['job'],
    }),
    createJob: builder.mutation({
      query: (FormData) => ({
        url: '/create',
        method: 'POST',
        body: FormData,
        headers: { 'Content-Type': 'application/json' },
        credentials: 'include',
      }),
      invalidatesTags: ['job', 'org'],
    }),
    RejectedSingleCandidate: builder.mutation({
      query: ({ applicationId, candidateId }) => ({
        url: `/reject/${applicationId}/${candidateId}`,
        method: 'PATCH',
        credentials: 'include',
      }),
      invalidatesTags: ['job'],
    }),
  }),
});

export const {
  useGetJobcategoryQuery,
  useCreateJobMutation,
  useGetJobByIdQuery,
  useJobdetailWithCandidateQuery,
  useSearchJobsQuery,
  useRejectedSingleCandidateMutation,
} = jobApi;

export default jobApi;

// getJobs: builder.query({
//   query: () => '/getall/jobs',
//   providesTags: ["job"],
//   transformResponse: (jobs) => jobs.reverse(),
//   refetchOnMountOrArgChange: true,
// }),