I don't know why my get request sometimes works but sometimes doesn't (404 not found)

Question

I'm currently learning angular and working on a project with a mongoDB database and express for my APIs. I want to fetch the comments of a post by the post ID,

The get request returns me a list of comments. the problem is when I first run node js the get request doesn't work, it only works when I first post a new comment and then run the get request for the comments again.

And as long as node is running the get request will continue to work whenever it's called for, until I restart node once again for the error to happen again. it returns a 404 not found error.

This error doesn't happen with any other route, but my code is the same in all of them.

PS : I Have made sure that the function is getting the post id before the get request is made.

this is my server.js file

let express = require('express'),
   path = require('path'),
   mongoose = require('mongoose'),
   cors = require('cors'),
   bodyParser = require('body-parser'),
   dbConfig = require('./database/db');

//create Error definition
const createError = require('http-errors');

// Connecting with mongo db
mongoose.Promise = global.Promise;
mongoose.connect(dbConfig.db, {
   useNewUrlParser: true
}).then(() => {
      console.log('Database sucessfully connected')
   },
   error => {
      console.log('Database could not connected: ' + error)
   }
)

const userRoute = require('./routes/user.route');
const postRoute = require('./routes/post.route');
const galleryRoute = require('./routes/Gallery.route');
const likeRoute = require('./routes/Like.Route');
const commentRoute = require('./routes/Comment.route');
const shareRoute = require('./routes/Share.route');
const profilePicRoute = require('./routes/ProfilePic.route');

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

app.use(cors()); 
app.use(express.static(path.join(__dirname, 'dist/mean-stack-crud-app')));
app.use('/', express.static(path.join(__dirname, 'dist/mean-stack-crud-app')));

app.use('/api/users', userRoute);
app.use('/api/posts', postRoute);
app.use('/api/likes', likeRoute);
app.use('/api/profilePics', profilePicRoute);
app.use('/api/comments', commentRoute);
app.use('/api/shares', shareRoute);
app.use('/api/gallery', galleryRoute);

// Create port
const port = process.env.PORT || 4000;
const server = app.listen(port, () => {
  console.log('Connected to port ' + port)
})

// Find 404 and hand over to error handler
app.use((req, res, next) => {
   next(createError(404));
});

// error handler
app.use(function (err, req, res, next) {
  console.error(err.message); // Log error message in our server's console
  if (!err.statusCode) err.statusCode = 500; // If err has no specified error code, set error code to 'Internal Server Error (500)'
  res.status(err.statusCode).send(err.message); // All HTTP requests must have a response, so let's send back an error with its status code and message
});

this is my commentRoute.js

const express = require('express');
const commentRoute = express.Router();
// Comment model
let Comment = require('../models/Comment');
const createError = require('http-errors');

//multer for pic upload
const uploadMedia = require('../middleware/picUpload')

// Add Comment
commentRoute.route('/create').post((req, res, next) => {

  // if(req?.files[0]){
  //   newComment.media = req?.files[0]
  // }

  let newComment = req.body;
  newComment.creationDate = new Date(req.body.creationDate)
  console.log(newComment)
  Comment.create(newComment, (error, data) => {

    // if (error instanceof multer.MulterError ) {
    //   error.message += "\nmulter Error";
    //   return next(error)
    // }else

      if (error){
        return next(error)
      }
      else {
        res.json(data);
      }
  })

//Get comments by parent ID
commentRoute.route('/read/byParentId/:idParent').get( async (req, res, next) => {
  await Comment.find({idParent : req.params.idParent}, (error, data) => {
    if(error){
      return next(error)
    }else{
      res.json(data)
    }
  })
})

})

module.exports = commentRoute;

this is my mongoose comment schema

const mongoose = require('mongoose');
const Schema = mongoose.Schema;
// Define collection and schema
let Comment = new Schema({
   
    idUser: {
        type : String
    },

    idParent : {
       type : String
    },

    text : {
        type : String
    },

    media : {
        fieldname : { type : String },
        originalname : { type : String },
        encoding : { type : String },
        mimetype : { type : String },
        buffer : { type : Buffer },
    },

    creationDate : {
        type : Date
    }

},
{
   collection: 'comments'
})
module.exports = mongoose.model('Comment', Comment);

this is my client side http get request

baseUrl = 'http://localhost:4000/api/comments'; 
  headers = new HttpHeaders().set('Content-Type', 'application/json');

  constructor(private http : HttpClient) { }

  getCommentsByParentId(idParent : any){
    return this.http.get(`${this.baseUrl}/read/byParentId/${idParent}`);
  }

this is how I consume the api in the client side

  getComments(){
    this.commentService.getCommentsByParentId(this.idPost).subscribe({
      next : (res : any) => {
        this.comments = res
        this.commentsCount = res.length
      },
      error : (err : any) => {
        console.log("error getting comment list for post "+this.idPost)
      }
    })
  }

client side error :

server side error :

thank you.

Edit :

post without the list of comments before I post a new comment

post after I post a new comment

Answer 1

Well, that's very obvious that the server can't find the entity in the DB. You need to check one of the following:

1. Maybe when you restart the node server, you restart the db too. that can happen if you're using docker-compose locally. then when you run your node server again your DB starts but there's no data in the DB, therefore the service can't find any data.
2. After service restart you're using non-existing ID because of wrong UI flow.

I would guess that you're facing the first option.