Получение [jwt не определено] при извлечении данных из бэкэнда MongoDB - - PullRequest
0 голосов
/ 24 октября 2019

вопрос довольно понятен. Я регистрирую / регистрирую пользователей в базе данных mongoDB. Они регистрируются нормально и также генерируется токен доступа [на основе jwt]. Теперь, когда я отправляю запрос в базу данных для получения списка пользователей, я получаю эту ошибку - jwt не определено.

Стоит отметить, чтоПользователи также в моем бэкэнде могут иметь два типа ролей - базовые и административные. И только пользователь с правами администратора может получить список всех пользователей, отправив accessToken в заголовке в качестве параметра авторизации Bearer.

У меня есть 2 основных файла в структуре моего внутреннего проекта, в которых используются методы jwt.accessкак jwt.verify или jwt.signIn ;это server.js и userController.js [отдельный файл, в котором я написал все отдельные методы, связанные с БД].

Насколько мне известно, все необходимые пакеты есть в моем проекте - экспресс, узел, jwa, jws, jsonwebtoken, mongo, mongoose, bcrypt, cors и т. д. Так в чем проблема?

Мой route.js ->

const User = require('../models/user.model');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');

const { roles } = require('../models/roles');


const JWT_SECRET = "$#GR24T4344$#$@#%ETWWTEME%$6";

async function hashPassword(password) {
    return await bcrypt.hash(password, 10);
}


async function validatePassword(plainPassword, hashedPassword) {
    return await bcrypt.compare(plainPassword, hashedPassword);
}


exports.grantAccess = function (action, resource) {
    return async (req, res, next) => {
        try {
            const permission = roles.can(req.user.role)[action](resource);
            if (!permission.granted) {
                return res.status(401).json({
                    error: "You don't have enough permission to perform this action"
                });
            }
            next();
        } catch (error) {
            next(error);
        }
    }
}


exports.allowIfLoggedin = async (req, res, next) => {
    try {
        const user = res.locals.loggedInUser;
        if (!user)
            return res.status(401).json({
                error: "You need to be logged in to access this route"
            });
        req.user = user;
        next();
    } catch (error) {
        next(error);
    }
}


exports.signup = async (req, res, next) => {
    try {
        const { role, email, password } = req.body;
        const hashedPassword = await hashPassword(password);
        const newUser = new User({ email, password: hashedPassword, role: role || "basic" });
        const accessToken = jwt.sign({ userId: newUser._id }, JWT_SECRET, {
            expiresIn: "1d"
        });
        newUser.accessToken = accessToken;
        await newUser.save();
        res.json({
            data: newUser,
            message: "You have signed up successfully"
        });
    } catch (error) {
        next(error);
    }
}


exports.login = async (req, res, next) => {
    try {
        const { email, password } = req.body;
        const user = await User.findOne({ email });
        if (!user)
            return next(new Error('Email does not exist'));
        const validPassword = await validatePassword(password, user.password);
        if (!validPassword)
            return next(new Error('Password is not correct'));
        const accessToken = jwt.sign({ userId: user._id }, JWT_SECRET, {
            expiresIn: "1d"
        });
        await User.findByIdAndUpdate(user._id, { accessToken });
        res.status(200).json({
            data: { email: user.email, role: user.role },
            accessToken
        });
    } catch (error) {
        next(error);
    }
}


exports.getUsers = async (req, res, next) => {
    const users = await User.find({});
    res.status(200).json({
        data: users
    });
}


exports.getUser = async (req, res, next) => {
    try {
        const userId = req.params.userId;
        const user = await User.findById(userId);
        if (!user)
            return next(new Error('User does not exist'));
        res.status(200).json({
            data: user
        });
    } catch (error) {
        next(error);
    }
}


exports.updateUser = async (req, res, next) => {
    try {
        const { role } = req.body;
        const userId = req.params.userId;
        await User.findByIdAndUpdate(userId, { role });
        const user = await User.findById(userId);
        res.status(200).json({
            data: user
        });
    } catch (error) {
        next(error);
    }
}


exports.deleteUser = async (req, res, next) => {
    try {
        const userId = req.params.userId;
        await User.findByIdAndDelete(userId);
        res.status(200).json({
            data: null,
            message: 'User has been deleted'
        });
    } catch (error) {
        next(error);
    }
}

Мой server.js ->

const express = require('express');
const bodyParser = require('body-parser');
const cors = require('cors');
const PORT = 4000;
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const playerRoutes = express.Router();
const userRoutes = express.Router();
const userController = require('./controllers/userController');
const user_routes = require('./apiroutes/route');
const app = express();

const JWT_SECRET = "$#GR24T4344$#$@#%ETWWTEME%$6";


const users = "users";

require("dotenv").config({path: __dirname+ '../.env'});



let Player = require('./models/player.model');
let User = require('./models/user.model');

app.use(cors());
app.use(bodyParser.json());

app.use(
    bodyParser.urlencoded({
        extended: false
    })
);

mongoose.connect('mongodb://127.0.0.1:27017/playerDB', function (err, db) {
    if (err)
        throw err;
    db.createCollection(users, function (err, resp) {
        if (err)
            throw err;
        console.log("Collection created!");

    });
}, { useNewUrlParser: true });


const connection = mongoose.connection;

connection.once('open', function () {
    console.log("MongoDB database connection established successfully");
});

..... blablablaaaa


app.use('/playerDB', playerRoutes);


app.use(async (req, res, next) => {

    res.header("Access-Control-Allow-Origin", "*");

    if (req.headers["x-access-token"]) {
        try {
            const accessToken = req.headers["x-access-token"];
            const { userId, exp } = await jwt.verify(accessToken, JWT_SECRET);
            // If token has expired
            if (exp < Date.now().valueOf() / 1000) {
                return res.status(401).json({
                    error: "JWT token has expired, please login to obtain a new one"
                });
            }
            res.locals.loggedInUser = await User.findById(userId);
            next();
        } catch (error) {
            next(error);
        }
    } else {
        next();
    }


});


app.use('/users', user_routes);


app.listen(PORT, function () {
    console.log("Server is running on Port: " + PORT);
});

Надеюсь, вы понимаете мой подход и сценарий? Вы можете догадаться, где это могло пойти не так? Любая идея? Отсутствует пакет npm или что-то более важное?

С нетерпением ждем некоторых советов по этой проблеме! Кажется, не могу найти способ!

1 Ответ

1 голос
/ 24 октября 2019

кажется, вы забыли добавить эту строку в server.js

const jwt = require('jsonwebtoken');

При регистрации и входе в систему это не вызывало проблем, потому что для этих запросов req.headers ["x-access-token "] был нулевым, и код не достиг блока if, в котором вы использовали jwt, но однажды пришел запрос с этим заголовком (например, getUsers), код попытался использовать jwt.verify, но поскольку jwt не был импортированэто дало ошибку.

...