create-nodets-app-nish 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nodets-app-nish",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Command line tool to create a new Node.js + Express + MongoDB + TypeScript project template",
   "license": "ISC",
   "author": "krish112407",

package/templates/nodejs-typescript/src/app.ts

@@ -14,4 +14,10 @@ app.use(express.urlencoded({extended:true,limit:"16kb"}))
 app.use(express.static("public"))
 app.use(cookieParser())
 
+import adminRouter from "./routers/admin.routes.js";
+import userRouter from "./routers/user.routes.js";
+
+app.use("/api/v1/admin", adminRouter);
+app.use("/api/v1/users", userRouter);
+
 export {app}

package/templates/nodejs-typescript/src/controllers/admin/admin.auth.controller.ts

@@ -0,0 +1,70 @@
+import { Admin } from "../../models/admin.models.js";
+import { asyncHandler } from "../../utils/asyncHandler.js";
+import { returnResponse } from "../../utils/apiResponse.js";
+import { Request , Response} from "express";
+
+const createAdmin = asyncHandler(async (req: Request, res: Response) => {
+    const { username, email, password } = req.body;
+
+    if ([username, email, password].some(field => field?.trim() === "")) {
+        return returnResponse(res, 400, "All fields are required", null);
+    }
+
+    const existingAdmin = await Admin.findOne({ 
+        $or: [{ username }, { email }] 
+    });
+
+    if (existingAdmin) {
+        return returnResponse(res, 400, "Admin already exists", null);
+    }
+
+    const admin = await Admin.create({ username, email, password });
+
+    const createdAdmin = await Admin.findById(admin._id).select("-password");
+
+    if (!createdAdmin) {
+        return returnResponse(res, 500, "Something went wrong while creating admin", null);
+    }
+
+    return returnResponse(res, 201, "Admin created successfully", createdAdmin);
+});
+
+const loginAdmin = asyncHandler(async (req: Request, res: Response) => {
+    const { email, password } = req.body;
+
+    if (!email || !password) {
+        return returnResponse(res, 400, "Email and password are required", null);
+    }
+
+    const admin = await Admin.findOne({ email });
+
+    if (!admin) {
+        return returnResponse(res, 404, "Admin not found", null);
+    }
+
+    const isPasswordValid = await admin.isPasswordCorrect(password);
+
+    if (!isPasswordValid) {
+        return returnResponse(res, 401, "Invalid credentials", null);
+    }
+
+    const accessToken = admin.generateAccessToken();
+
+    const loggedInAdmin = await Admin.findById(admin._id).select("-password");
+
+    const options = {
+        httpOnly: true,
+        secure: true
+    };
+
+    return res
+        .status(200)
+        .cookie("accessToken", accessToken, options)
+        .json({
+            statusCode: 200,
+            data: { admin: loggedInAdmin, accessToken },
+            message: "Admin logged in successfully"
+        });
+});
+
+export { createAdmin, loginAdmin };

package/templates/nodejs-typescript/src/controllers/user/user.auth.controller.ts

@@ -0,0 +1,70 @@
+import { User } from "../../models/user.models.js";
+import { asyncHandler } from "../../utils/asyncHandler.js";
+import { returnResponse } from "../../utils/apiResponse.js";
+import { Request, Response } from "express";
+
+const registerUser = asyncHandler(async (req: Request, res: Response) => {
+    const { username, email, password } = req.body;
+
+    if ([username, email, password].some(field => field?.trim() === "")) {
+        return returnResponse(res, 400, "All fields are required", null);
+    }
+
+    const existingUser = await User.findOne({
+        $or: [{ username }, { email }]
+    });
+
+    if (existingUser) {
+        return returnResponse(res, 400, "User with this email or username already exists", null);
+    }
+
+    const user = await User.create({ username, email, password });
+
+    const createdUser = await User.findById(user._id).select("-password");
+
+    if (!createdUser) {
+        return returnResponse(res, 500, "Something went wrong while registering user", null);
+    }
+
+    return returnResponse(res, 201, "User registered successfully", createdUser);
+});
+
+const loginUser = asyncHandler(async (req: Request, res: Response) => {
+    const { email, password } = req.body;
+
+    if (!email || !password) {
+        return returnResponse(res, 400, "Email and password are required", null);
+    }
+
+    const user = await User.findOne({ email });
+
+    if (!user) {
+        return returnResponse(res, 404, "User not found", null);
+    }
+
+    const isPasswordValid = await user.isPasswordCorrect(password);
+
+    if (!isPasswordValid) {
+        return returnResponse(res, 401, "Invalid credentials", null);
+    }
+
+    const accessToken = user.generateAccessToken();
+
+    const loggedInUser = await User.findById(user._id).select("-password");
+
+    const options = {
+        httpOnly: true,
+        secure: true
+    };
+
+    return res
+        .status(200)
+        .cookie("accessToken", accessToken, options)
+        .json({
+            statusCode: 200,
+            data: { user: loggedInUser, accessToken },
+            message: "User logged in successfully"
+        });
+});
+
+export { registerUser, loginUser };

package/templates/nodejs-typescript/src/interface/user.interface.ts

@@ -0,0 +1,11 @@
+import { Document } from "mongoose";
+
+interface IUser extends Document {
+    username: string;
+    email: string;
+    password: string;
+    generateAccessToken(): string;
+    isPasswordCorrect(password: string): Promise<boolean>;
+}
+
+export type { IUser };

package/templates/nodejs-typescript/src/middlewares/auth.middleware.ts

@@ -0,0 +1,62 @@
+import { Request, Response, NextFunction } from "express";
+import jwt from "jsonwebtoken";
+import { asyncHandler } from "../utils/asyncHandler.js";
+import { Admin } from "../models/admin.models.js";
+import { User } from "../models/user.models.js";
+import { returnResponse } from "../utils/apiResponse.js";
+
+// Extend Express Request interface to include admin and user
+declare global {
+    namespace Express {
+        interface Request {
+            admin?: any;
+            user?: any;
+        }
+    }
+}
+
+export const verifyAdmin = asyncHandler(async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const token = req.cookies?.accessToken || req.header("Authorization")?.replace("Bearer ", "");
+
+        if (!token) {
+            return returnResponse(res, 401, "Unauthorized request", null);
+        }
+
+        const decodedToken = jwt.verify(token, process.env.JWT_SECRET as string) as any;
+
+        const admin = await Admin.findById(decodedToken?._id).select("-password");
+
+        if (!admin) {
+            return returnResponse(res, 401, "Invalid Access Token", null);
+        }
+
+        req.admin = admin;
+        next();
+    } catch (error) {
+        return returnResponse(res, 401, "Invalid Access Token", null);
+    }
+});
+
+export const verifyUser = asyncHandler(async (req: Request, res: Response, next: NextFunction) => {
+    try {
+        const token = req.cookies?.accessToken || req.header("Authorization")?.replace("Bearer ", "");
+
+        if (!token) {
+            return returnResponse(res, 401, "Unauthorized request", null);
+        }
+
+        const decodedToken = jwt.verify(token, process.env.JWT_SECRET as string) as any;
+
+        const user = await User.findById(decodedToken?._id).select("-password");
+
+        if (!user) {
+            return returnResponse(res, 401, "Invalid Access Token", null);
+        }
+
+        req.user = user;
+        next();
+    } catch (error) {
+        return returnResponse(res, 401, "Invalid Access Token", null);
+    }
+});

package/templates/nodejs-typescript/src/models/admin.models.ts

@@ -21,7 +21,7 @@ const AdminSchema = new mongoose.Schema<AdminType>({
         type: String,
         required: true
     }
-})
+}, { timestamps: true })
 
 AdminSchema.pre("save", async function () {
     if (this.isModified("password")) {

package/templates/nodejs-typescript/src/models/user.models.ts

@@ -0,0 +1,46 @@
+import type { IUser } from "../interface/user.interface.js";
+import mongoose, { Document } from "mongoose";
+import jwt from "jsonwebtoken";
+import bcrypt from "bcrypt";
+
+type UserType = IUser & Document;
+
+const UserSchema = new mongoose.Schema<UserType>({
+    username: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    password: {
+        type: String,
+        required: true
+    }
+}, { timestamps: true });
+
+UserSchema.pre("save", async function (next) {
+    if (this.isModified("password")) {
+        this.password = await bcrypt.hash(this.password, 10);
+    }
+    next();
+});
+
+UserSchema.methods.generateAccessToken = function (): string {
+    return jwt.sign({
+        _id: this._id,
+        username: this.username,
+        email: this.email
+    }, process.env.JWT_SECRET as string, {
+        expiresIn: "1d"
+    });
+};
+
+UserSchema.methods.isPasswordCorrect = async function (password: string): Promise<boolean> {
+    return await bcrypt.compare(password, this.password);
+};
+
+export const User = mongoose.model<UserType>("User", UserSchema);

package/templates/nodejs-typescript/src/routers/admin.routes.ts

@@ -0,0 +1,9 @@
+import { Router } from "express";
+import { createAdmin, loginAdmin } from "../controllers/admin/admin.auth.controller.js";
+
+const router = Router();
+
+router.route("/register").post(createAdmin);
+router.route("/login").post(loginAdmin);
+
+export default router;

package/templates/nodejs-typescript/src/routers/user.routes.ts

@@ -0,0 +1,9 @@
+import { Router } from "express";
+import { registerUser, loginUser } from "../controllers/user/user.auth.controller.js";
+
+const router = Router();
+
+router.route("/register").post(registerUser);
+router.route("/login").post(loginUser);
+
+export default router;