Express по умолчанию приложение сбоя маршрута-отсутствующее имя параметра при Path-re-regexp ⇐ Javascript

[Anonymous]

Пожалуйста, нужна помощь. Ниже приведена ошибка, которую я получаю: < /p>
C:\Users\John Doe\william\pioneer_students_backend\node_modules\path-to-regexp\dist\index.js:73
throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);
^

TypeError: Missing parameter name at 1: https://git.new/pathToRegexpError
at name (C:\Users\John Doe\william\pioneer_students_backend\node_modules\path-to-regexp\dist\index.js:73:19)
at lexer (C:\Users\John Doe\william\pioneer_students_backend\node_modules\path-to-regexp\dist\index.js:91:27)
...
[nodemon] app crashed - waiting for file changes before starting...
< /code>
Вот мой код < /p>
const express = require("express");
const cookieParser = require("cookie-parser");
const cors = require("cors");
const rateLimit = require("express-rate-limit");
const helmet = require("helmet");

const memberRouter = require("./router/memberRouter");
const stateRouter = require("./router/stateRouter");
const adminRouter = require("./router/adminRouter");
const customError = require("./utils/customError");
const globalErrorHandler = require("./controller/errorController");

const app = express();

const loginLimiter = rateLimit({
max: 10,
windowMs: 60 * 60 * 1000,
message:
"We have received too many request from this IP. Please try again after one hour.",
});

const generalLimiter = rateLimit({
max: 100,
windowMs: 60 * 60 * 1000,
message:
"We have received too many request from this IP. Please try again after one hour.",
});

app.use(
cors({
// origin: "https://pioneer-students-of-st-marks-se ... etlify.app",
origin: "http://localhost:5173",
credentials: true,
})
);
app.use(cookieParser());
app.use(express.json({ limit: "10kb" }));
app.use(helmet());

app.use("/api/v1/register", generalLimiter, memberRouter);
app.use("/api/v1/states", generalLimiter, stateRouter);
app.use("/api/v1/admin", loginLimiter, adminRouter);

app.all("*", (req, res, next) => {
const err = new customError(
`Can't find the url ${req.originalUrl} on this server`,
404
);

next(err);
});

app.use(globalErrorHandler);
module.exports = app;

const express = require("express");
const multer = require("multer");
const { storage } = require("./../config/cloudinaryConfig");
const upload = multer({ storage });

const {
getUsers,
createUser,
updateUser,
deleteUser,
getUser,
getSearchedUsers,
} = require("./../controller/memberController");
const { protect } = require("./../controller/adminController");

const router = express.Router();

// routes

router.route("/search").get(getSearchedUsers);
router
.route("/")
.get(getUsers)
.post(protect, upload.single("profilePic"), createUser);

router
.route("/:id")
.get(getUser)
.patch(upload.single("profilePic"), updateUser)
.delete(protect, deleteUser);

module.exports = router;

const express = require("express");
const {
getAllAdmins,
signup,
updateAdmin,
deleteAdmin,
login,
logout,
protect,
verified,
} = require("../controller/adminController");

const router = express.Router();

router.route("/").get(getAllAdmins);
router.route("/protected").get(protect, (req, res) => {
res.json({
id: req.admin.id,
firstName: req.admin.firstName,
});
});
router.route("/signup").post(signup);
router.route("/login").post(login);
router.route("/logout").post(logout);
router.route("/verify").get(protect, verified);
router.route("/:id").patch(updateAdmin).delete(deleteAdmin);

module.exports = router;

const express = require("express");

const {
CreateStates,
getAllStates,
updateState,
deleteState,
} = require("../controller/stateController");

const router = express.Router();

router.route("/").get(getAllStates).post(CreateStates);
router.route("/:id").patch(updateState).delete(deleteState);

module.exports = router;

const { cloudinary } = require("../config/cloudinaryConfig");
const Members = require("../modal/memberModel");
const CustomError = require("../utils/customError");
const asyncErrorHandler = require("./../utils/asyncErrorHandler");

exports.getUsers = asyncErrorHandler(async (req, res, next) => {
const page = parseInt(req.query.page) || 1;
const limit = parseInt(req.query.limit) || 2;

const members = await Members.find(
{},
"firstName lastName email phone profilePic"
)
.skip((page - 1) * limit)
.limit(limit);

const total = await Members.countDocuments();
res.status(200).json({
status: "success",
count: members.length,
data: {
members,
total,
page,
totalPages: Math.ceil(total / limit),
},
});
});

exports.createUser = asyncErrorHandler(async (req, res, next) => {
let profilePicUrl = null;

if (req.file) {
const result = await cloudinary.uploader.upload(req.file.path, {
folder: "profilePics",
});

profilePicUrl = { url: result.secure_url, public_id: result.public_id };
}
const memberData = { ...req.body, profilePic: profilePicUrl };

const newMember = await Members.create(memberData);

res.status(201).json({
status: "success",
message: "Member successfully created",
data: {
newMember,
},
});
});

exports.updateUser = asyncErrorHandler(async (req, res, next) => {
let updatedData = { ...req.body };

const updateMember = await Members.findById(req.params.id);

if (!updateMember) {
return next(
new CustomError("Member not found. Please provide a valid ID", 404)
);
}

if (req.file) {
if (updateMember.profilePic && updateMember.profilePic.public_id) {
await cloudinary.uploader.destroy(updateMember.profilePic.public_id);
}

const uploadResult = await new Promise((resolve, reject) => {
cloudinary.uploader
.upload_stream(
{
folder: "profile_pics",
},
(error, result) => {
if (error) reject(error);
else resolve(result);
}
)
.end(req.file.buffer);
});
updatedData.profilePic = {
url: uploadResult.secure_url,
public_id: uploadResult.public_id,
};
}

const updatedMember = await Members.findByIdAndUpdate(
req.params.id,
updatedData,
{
new: true,
runValidators: true,
}
);

res.status(200).json({
status: "success",
data: {
updatedMember,
},
});
});

exports.deleteUser = asyncErrorHandler(async (req, res, next) => {
const deleteMember = await Members.findById(req.params.id);
if (!deleteMember) {
return next(
new CustomError("Member not found. Please provide a valid ID", 400)
);
}
if (deleteMember.profilePic) {
const parts = deleteMember.profilePic.split("/");
const fileName = parts[parts.length - 1];
const publicId = fileName.split(".")[0];
await cloudinary.uploader.destroy(publicId);
}
await Members.findByIdAndDelete(req.params.id);
res.status(201).json({
message: "Member deleted successfully",
});
});

exports.getSearchedUsers = asyncErrorHandler(async (req, res, next) => {
const { lastName } = req.query;

const searchedMembers = await Members.find(
{ lastName },
"firstName lastName email phone profilePic"
);
if (searchedMembers.length === 0) {
return next(
new CustomError(
"No member with the given surname was found. Please provide the correct surname",
400
)
);
}
res.status(200).json({
status: "Success",
data: {
searchedMembers,
},
});
});

exports.getUser = asyncErrorHandler(async (req, res, next) => {
const member = await Members.findById(req.params.id);
if (!member) {
return next(
new CustomError("User not found. Please provide a valid ID", 400)
);
}
res.status(200).json({
status: "Success",
data: {
member,
},
});
});

const CustomError = require("../utils/customError");
const States = require("./../modal/stateModel");
const asyncErrorHandler = require("./../utils/asyncErrorHandler");

exports.CreateStates = asyncErrorHandler(async (req, res, next) => {
const createdStates = await States.create(req.body);
res.status(201).json({
status: "success",
data: {
states: createdStates,
},
});
});

exports.getAllStates = asyncErrorHandler(async (req, res, next) => {
const getStates = await States.find({ isActive: true })
.select("state value localGovernments")
.sort({ state: 1 });
res.status(200).json({
data: {
getStates,
},
});
});

exports.updateState = asyncErrorHandler(async (req, res, next) => {
const UpdatedState = await States.findByIdAndUpdate(req.params.id, req.body, {
new: true,
runValidators: true,
});
if (!UpdatedState) {
return next(new CustomError("State not found", 404));
}
res.status(200).json({
status: "success",
data: {
UpdatedState,
},
});
});

exports.deleteState = asyncErrorHandler(async (req, res, next) => {
const id = req.params.id;
const deleteState = await States.findByIdAndUpdate(
id,
{ isActive: false },
{ new: true, runValidators: true }
);

if (!deleteState) {
return next(new CustomError("State not found", 404));
}

res.status(200).json({
status: "success",
});
});

const Admin = require("./../modal/adminModel");
const jwt = require("jsonwebtoken");
const util = require("util");
const asyncErrorHandler = require("./../utils/asyncErrorHandler");
const CustomError = require("../utils/customError");

// console.log(require("crypto").randomBytes(64).toString("hex"));

const signToken = (id, res) => {
const token = jwt.sign({ id }, process.env.SECRET_WORD, {
expiresIn: process.env.LOGIN_EXPIRES,
});

res.cookie("jwt", token, {
httpOnly: true,
sameSite: "strict",
maxAge: 24 * 60 * 60 * 1000,
secure: process.env.NODE_ENV !== "development",
});
};

exports.getAllAdmins = asyncErrorHandler(async (req, res, next) => {
const allAdmins = await Admin.find();
res.status(200).json({
status: "success",
count: allAdmins.length,
data: {
allAdmins,
},
});
});

exports.signup = asyncErrorHandler(async (req, res, next) => {
const newAdmin = await Admin.create(req.body);

const token = signToken(newAdmin._id, res);

res.status(200).json({
status: "success",
token,
data: {
newAdmin,
},
});
});

exports.updateAdmin = asyncErrorHandler(async (req, res, next) => {
const updateAdminData = await Admin.findByIdAndUpdate(
req.params.id,
req.body,
{
new: true,
runValidators: true,
}
);

if (!updateAdminData) {
return next(
new CustomError("Admin not found. please provide a valid ID", 400)
);
}

res.status(200).json({
status: "Success",
data: {
updateAdminData,
},
});
});

exports.deleteAdmin = asyncErrorHandler(async (req, res, next) => {
const deleteAdminData = await Admin.findByIdAndDelete(req.params.id);
if (!deleteAdminData) {
return next(
new CustomError("Admin not found. Please provide a valid ID", 400)
);
}

res.status(201).json({
status: "success",
});
});

exports.login = asyncErrorHandler(async (req, res, next) => {
const { email, password } = req.body;

if (!email || !password) {
return next(new CustomError("Please provide Email and Password", 400));
}

const adminLogin = await Admin.findOne({ email }).select("+password");

const isMatch = await adminLogin.comparePassword(
password,
adminLogin.password
);

if (!adminLogin || !isMatch) {
return next(
new CustomError(
"Password does not match. please provide a correct password",
400
)
);
}

const token = signToken(adminLogin._id, res);

res.status(200).json({
status: "success",
token,
data: {
name: adminLogin.firstName,
},
});
});

exports.protect = asyncErrorHandler(async (req, res, next) => {
const token = req.cookies.jwt;

if (!token) {
return next(new CustomError("You are not loggedIn. Please login", 401));
}

const decodedToken = await util.promisify(jwt.verify)(
token,
process.env.SECRET_WORD
);

const currentUser = await Admin.findById(decodedToken.id);
if (!currentUser) {
return next(new CustomError("Admin with given token does not exit", 401));
}

req.admin = currentUser;
next();
});

exports.logout = (req, res) => {
res.cookie("jwt", "", {
httpOnly: true,
sameSite: "strict",
secure: process.env.NODE_ENV !== "development",
expires: new Date(0),
});

res.status(200).json({
status: "success",
message: "Logout successful",
});
};

exports.verified = (req, res) => {
res.status(200).json({
status: "success",
data: {
username: req.admin.firstName,
},
});
};

function dev(res, error) {
res.status(error.statusCode).json({
status: error.status,
message: error.message,
stackTrace: error.stack,

});
}

function prod(res, error) {
if (isOperational) {
res.status(error.statusCode).json({
status: error.status,
message: error.message,
});
} else {
res.status(error.statusCode).json({
status: "error",
message: "Something went wrong. Please try again later",
});
}
}

module.exports = (error, req, res, next) => {
error.statusCode = error.statusCode || 500;
error.status = error.status || "fail";

if (process.env.NODE_ENV === "development") {
dev(res, error);
}

if (process.env.NODE_ENV === "production") {
prod(res, error);
}
};
< /code>
Наблюдение < /p>
Сбой происходит только тогда, когда маршрут не соответствует (то есть, попадает в app.all ("*")). < /p>
Ошибка перерадывает в любом случае, я использую какую-либо Malfexp, который используется внутри. Скажите. < /p>
Что я попробовал
прокомментировал app.all ("*"), а приложение больше не сбои. Ошибка?>

Подробнее здесь: https://stackoverflow.com/questions/796 ... -to-regexp