please I need help.
My default route in Express is causing the app to crash instead of handling unmatched routes. Below is the error I’m getting:
C:UsersJohn Doewilliampioneer_students_backendnode_modulespath-to-regexpdistindex.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:UsersJohn Doewilliampioneer_students_backendnode_modulespath-to-regexpdistindex.js:73:19)
at lexer (C:UsersJohn Doewilliampioneer_students_backendnode_modulespath-to-regexpdistindex.js:91:27)
...
[nodemon] app crashed - waiting for file changes before starting...
here is my code
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-sec-sch.netlify.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);
}
};
Observation
The crash happens only when a route is not matched (i.e., hits app.all(“*”)).
The error refers to path-to-regexp, which is used internally by Express.
I don’t use any malformed dynamic route like /: anywhere as far as I can tell.
What I’ve Tried
Commented out app.all(“*”) and the app doesn’t crash anymore.
Checked my routers for malformed paths like /:, but I couldn’t find any.
Question
Why is my app.all(“*”) causing the Missing parameter name error?
Is there something wrong with how my routes are defined?
How do I properly define a catch-all route without causing this crash?
Thank You