Nodejs correct way of intract with DB - node.js

Question

I am working in Nodejs.
For a 'GET' route I used a method shown below:
var express = require('express');
var mongoose = require('mongoose');
var passport = require('passport');
var config = require('../config/database');
require('../config/passport')(passport);
var express = require('express');
var jwt = require('jsonwebtoken');
var router = express.Router();
var User = require("../models/user");
var Book = require("../models/book");
var router = express.Router();
router.post('/books', passport.authenticate('jwt', { session: false}), function(req, res) {
var token = getToken(req.headers);
if (token) {
console.log(req.body);
var newBook = new Book({
isbn: req.body.isbn,
title: req.body.title,
author: req.body.author,
publisher: req.body.publisher
});
newBook.save(function(err) {
if (err) {
return res.json({success: false, msg: 'Save book failed.'});
}
res.json({success: true, msg: 'Successful created new book.'});
});
} else {
return res.status(403).send({success: false, msg: 'Unauthorized.'});
}
});
router.get('/books', passport.authenticate('jwt', { session: false}), function(req, res) {
var token = getToken(req.headers);
if (token) {
Book.find(function (err, books) {
if (err) return next(err);
res.json(books);
});
} else {
return res.status(403).send({success: false, msg: 'Unauthorized Access...'});
}
});
getToken = function (headers) {
if (headers && headers.authorization) {
var parted = headers.authorization.split(' ');
if (parted.length === 2) {
return parted[1];
} else {
return null;
}
} else {
return null;
}
};
module.exports = router;
Is it correct method? because I saw some tutorials where they used GET,POST,PUT and DELETE
Can anyone please suggest a correct approach?
Check my updated full code above
is this correct way
or can you please suggest some other way
if i am wrong on this

Answer 1

So, I'll start by saying "correct" is somewhat in the eye of the beholder. There are a lot of different ways to do things depending on your goals and what you're comfortable with. Right now, you're re-doing a fair bit of stuff that you don't need to.
Personally, I tend to favor the DRY principle where possible (DRY: don't repeat yourself), so I would probably structure my code a little differently than you did.
For example, if you know that all your Books routes need to be authenticated, then you can just do something like:
// all routes on the '/books' path have to be logged in with a JWT
router.use('/books', passport.authenticate('jwt', { session: false}));
After that, req.user will be populated with the user based on however you configured your JWT strategy, and you know that any of your Books routes will be authenticated, so you can skip all of the getToken stuff you're doing.
Finally, you only showed parameterless routes, but if you end up having some routes that need parameters (e.g. if you want to PUT a specific book to update it), you'll gain a lot of reusability with router.param usage. For a simple but complete example (also switching to ES2015 syntax for more brevity):
const jwt = require('jsonwebtoken');
const router = express.Router();
const User = require("../models/user");
const Book = require("../models/book");
const router = express.Router();
router.use('/books', passport.authenticate('jwt', { session: false }));
router.param('bookId', (req, res, next, id) => {
Book.findById(id, (e, book) => {
if (e) return next(e);
// Simplified for 'not found', here req.book will just be null. you can make custom error if you want
req.book = book;
return next();
});
});
router.route('/books/:bookId')
.get((req, res) => {
if (req.book) return res.json(book);
return res.status(404).json({ msg: 'Book not found' });
});
// similarly you can add delete and put methods here if you want, and not have to req-query for the book.
router.route('/books')
.post((req, res) => {
const { isbn, title, author, publisher } = req.body
const newBook = new Book({ isbn, title, author, publisher });
newBook.save((err) => {
if (err) return next(err); // note, custom errors can be handy here
// this returns HTTP 201, which is a success, and the newBook which includes its ID
return res.status(201).json(newBook);
});
}).get((req, res) => {
Book.find((err, books) => {
if (err) return next(err);
res.json(books);
});
});
module.exports = router;

Answer 2

Yes, this is the correct way.
GET, POST, PUT, DELETE and PATCH are CRUD principles that you should follow with the API in your application. For example, you should use GET to get content and POST when you want to add something to the database. However, these are methods for the API and not the database interactions. Those depend on the database API that you are using.