basic express app created

server/config/db.ts

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+
+const connectDB = async () => {
+  try {
+    console.log("Connecting to MongoDB...");
+    await mongoose.connect(process.env.MONGODB_URI!);
+    console.log("✅ MongoDB Connected");
+  } catch (error) {
+    console.error(error);
+  }
+};
+
+export default connectDB;

server/controllers/authControllers.ts

@@ -0,0 +1,124 @@
+import { Request, Response } from "express";
+import jwt from 'jsonwebtoken'
+import { User } from "../models/User.js";
+import bcrypt from "bcrypt";
+import { AuthRequest } from "../middlewares/auth.js"
+
+// Helper to generate JWT Token  
+const generateToken = (id: string)=>{
+    return jwt.sign({id}, process.env.JWT_SECRET as string, {expiresIn: "30d"} )
+}
+
+// Resister a new User 
+// Post /api/uath/register
+export const registerUser = async (req: Request, res: Response): Promise<void> => {
+    try{ 
+        const { name, email, password, phone, role } = req.body;
+
+        if(!name || !email || !password){
+            res.status(400).json({message: "Please Enter all required Fieds"})
+            return;
+        }
+        //  Check if user exists 
+        const userExists = await User.findOne({email})
+        if(userExists){  res.status(400).json({message: "User already exists "})
+            return;
+        }
+
+        //  Hash password
+        const salt = await bcrypt.genSalt(10)
+        const hashedPassword = await bcrypt.hash(password, salt)
+
+        // creat user
+        const user = await User.create({
+            name,
+            email,
+            password: hashedPassword,
+            phone,
+            role,
+        })
+
+        if(user){
+            res.status(201).json({
+                _id: user._id,
+                name: user.name,
+                email: user.email,
+                phone: user.phone,
+                role: user.role,
+                token: generateToken(user._id.toString())
+            })
+        }else{
+            res.status(400).json({message: "Invailid User data"});
+        }
+    } catch (error : any){
+        console.error(error);
+        res.status(400).json({message: error.message});
+
+    }
+ }
+
+ // Authentication a User & get token 
+// Post /api/uath/register
+export const loginUser = async (req: Request, res: Response): Promise<void> => {
+    try{
+        const { email, password} = req.body;
+
+        if( !email || !password){
+            res.status(400).json({message: "Please provide email and password"})
+            return;
+        }
+        //  Check for user 
+       const user = await User.findOne({email})
+       if(!user){
+        res.status(400).json({message: "Invailid email or password"});
+        return;
+
+       }
+
+    //    Check if password matches (useeer.password isnot undefined because we queried it ) 
+    const isMatch = await bcrypt.compare(password, user.password ||  "" )
+    if(!isMatch){
+        res.status(400).json({message: "Invailid email or password"});
+        return;
+    }
+      res.json({
+                _id: user._id,
+                name: user.name,
+                email: user.email,
+                phone: user.phone,
+                role: user.role,
+                token: generateToken(user._id.toString())
+            })
+
+
+    } catch (error: any){
+          console.error(error);
+        res.status(400).json({message: error.message});
+
+    }
+ }
+ // get user profile 
+// GET /api/uath/me
+// access Private
+export const getMe = async (req: AuthRequest, res: Response): Promise<void> => {
+    try{
+        if (!req.user){
+            res.status(401).json({message: "Not Authorized"})
+            return;
+
+        }
+        res.json(req.user)
+    } catch (error) {
+    console.error(error);
+
+    if (error instanceof Error) {
+        res.status(400).json({
+            message: error.message
+        });
+    } else {
+        res.status(400).json({
+            message: "Unknown error"
+        });
+    }
+}
+ }

server/middlewares/auth.ts

@@ -0,0 +1,74 @@
+import { Request, Response, NextFunction } from "express";
+import jwt from "jsonwebtoken";
+import { User, IUser } from "../models/User.js";
+
+export interface AuthRequest extends Request {
+    user?: IUser;
+}
+
+export const protect = async (
+    req: AuthRequest,
+    res: Response,
+    next: NextFunction
+): Promise<void> => {
+
+    let token;
+
+    if (
+        req.headers.authorization &&
+        req.headers.authorization.startsWith("Bearer")
+    ) {
+        try {
+
+            token = req.headers.authorization.split(" ")[1];
+
+            const decoded = jwt.verify(
+                token,
+                process.env.JWT_SECRET!
+            ) as { id: string };
+
+            const user = await User.findById(decoded.id).select("-password");
+
+            if (!user) {
+                res.status(401).json({
+                    message: "Not authorized, user not found"
+                });
+                return;
+            }
+
+            req.user = user;
+
+            next();
+
+        } catch (error) {
+            console.error("Auth Middleware Error:", error);
+
+            res.status(401).json({
+                message: "Not authorized, token failed"
+            });
+            return;
+        }
+    }
+
+    if (!token) {
+        res.status(401).json({
+            message: "Not authorized, no token"
+        });
+        return;
+    }
+}
+export const adminOnly = (req: AuthRequest, res: Response, next: NextFunction ): void=> {
+    if(req.user &&req.user.role==="admin"){
+        next()
+    }else{
+        res.status(403).json({message:" Access denied, admin role required"});
+    }
+}
+
+export const ownerOnly = (req: AuthRequest, res: Response, next: NextFunction ): void=> {
+    if(req.user &&(req.user.role==="owner"|| req.user.role==="admin")){
+        next()
+    }else{
+        res.status(403).json({message:" Access denied, admin role required"});
+    }
+}

server/models/User.ts

@@ -0,0 +1,33 @@
+import {Document, model, Schema } from "mongoose"
+
+export interface IUser extends Document{
+    name: string;
+    email: string;
+    password?: string;
+    phone?: string;
+    role: "user" | "admin" | "owner";
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+const UserSchema = new Schema<IUser>(
+    {
+        name: {type: String, required: true, trim: true},
+        email: {type: String, required: true, unique: true, trim: true, lowercase: true},
+        password: {type: String, required: true, minlength: 6},
+        phone: {type: String, trim: true, minlength: 6 },
+        role: {type: String, enum: ["user" , "admin" , "owner"], default: "user"},
+
+    },
+    {timestamps: true}
+
+
+)
+//  Remove password when converting to JSON
+UserSchema.set("toJSON", {
+    transform: (doc, ret)=>{
+        delete ret.password;
+        return ret;
+    }
+})
+export const User = model<IUser>("User", UserSchema)