chore/feat: user, auth, role base auth, global routes

Author: DrakeBackend

README.md

@@ -9,21 +9,33 @@
 - TypeScript Support and Config
 - Basic CLI for crating new module
 
-### How to use CLI
-
 ```bash
 npm install tsx --save-dev
 or
 npm install -g tsx
 npm install -g bun
 bun install
+
+# Add any package
+bun add packageName
+
+# Add Dev Package
+bun add --save-dev packageName
 ```
 
+### Start For Development
+
+```bash
+bun start dev
+```
+
+### How to use CLI
+
 ```bash
 
 npm run cli
 
-or 
+or
 
 make cli
 ```
@@ -32,15 +44,21 @@ make cli
 - Based on that will create controller, route and validation files inside API folder
 
 ### Recommended Folder Structure:
+
  <!-- Feature-based Structure design pattern -->
-  ______
+
+---
+
 < Hi! >
- ------
+
+---
+
         \   ^__^
          \  (oo)\_______
             (__)\       )\/\
                 ||----w |
                 ||     ||
+
 ```bash
 
 project-root/
@@ -112,6 +130,6 @@ project-root/
 
 ```
 
-### Auth Module Working 
+### Auth Module Working
 
-- Auth With JWT
+- Auth With JWT

bun.lockb

@@ -19,11 +19,17 @@
     "cli": "tsx  ./script/index.ts"
   },
   "dependencies": {
+    "@types/bcrypt": "^5.0.2",
+    "@types/jsonwebtoken": "^9.0.7",
+    "bcrypt": "^5.1.1",
     "compression": "^1.7.4",
     "cors": "^2.8.5",
     "dotenv": "^16.4.5",
     "express": "^5.0.1",
     "helmet": "^8.0.0",
+    "http-status-codes": "^2.3.0",
+    "joi": "^17.13.3",
+    "jsonwebtoken": "^9.0.2",
     "morgan": "^1.10.0",
     "supertest": "^7.0.0"
   },
@@ -47,6 +53,7 @@
     "globals": "^15.11.0",
     "husky": "^9.1.6",
     "lint-staged": "^15.2.10",
+    "mongoose": "^8.9.5",
     "prettier": "^3.3.3",
     "rimraf": "^6.0.1",
     "tsx": "^4.19.1",

package.json

@@ -1,44 +1,52 @@
-import { Request, Response } from 'express';
-import { AuthService } from '../services/auth.service';
-import { validationResult } from 'express-validator';
+import { NextFunction, Request, Response } from "express";
+import { getReasonPhrase, StatusCodes } from "http-status-codes";
+import authService from "./auth.service";
 
 class AuthController {
-  static async register(req: Request, res: Response) {
+  public async register(
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> {
     try {
-      // Validate input data
-      const errors = validationResult(req);
-      if (!errors.isEmpty()) {
-        return res.status(400).json({ errors: errors.array() });
+      const user = await authService.register(req.body);
+      res.status(StatusCodes.CREATED).json({
+        data: user,
+        message: getReasonPhrase(StatusCodes.CREATED),
+      });
+    } catch (err: unknown) {
+      if (err instanceof Error && err.message === "Email already in use") {
+        res.status(StatusCodes.CONFLICT).json({
+          message: err.message,
+        });
+        return;
       }
-
-      // Register user
-      const { username, email, password } = req.body;
-      const user = await AuthService.register(username, email, password);
-      return res.status(201).json({ message: 'User created successfully', user });
-    } catch (error) {
-      return res.status(500).json({ error: error.message });
+      next(err);
     }
   }
 
-  static async login(req: Request, res: Response) {
+  public async login(
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> {
     try {
       const { email, password } = req.body;
-      const token = await AuthService.login(email, password);
-      return res.status(200).json({ message: 'Login successful', token });
-    } catch (error) {
-      return res.status(500).json({ error: error.message });
-    }
-  }
-
-  static async authenticate(req: Request, res: Response) {
-    try {
-      const token = req.headers['authorization']?.split(' ')[1];
-      const decoded = await AuthService.authenticate(token);
-      return res.status(200).json({ message: 'Authentication successful', user: decoded });
-    } catch (error) {
-      return res.status(401).json({ error: 'Unauthorized' });
+      const token = await authService.login(email, password);
+      res.status(StatusCodes.OK).json({
+        token,
+        message: getReasonPhrase(StatusCodes.OK),
+      });
+    } catch (err: unknown) {
+      if (err instanceof Error && err.message === "Invalid email or password") {
+        res.status(StatusCodes.UNAUTHORIZED).json({
+          message: err.message,
+        });
+        return;
+      }
+      next(err);
     }
   }
 }
 
-export { AuthController };
+export default new AuthController();

public/favicon.ico

@@ -1,23 +1,9 @@
-import express from 'express';
-import { AuthController } from './auth.controller';
-import { check } from 'express-validator';
-import { AuthMiddleware } from '../middlewares/auth.middleware';
+import express from "express";
+import authController from "./auth.controller";
 
-const router = express.Router();
+const authRouter = express.Router();
 
-// Registration route
-router.post('/register', [
-  check('email').isEmail().withMessage('Invalid email format'),
-  check('password').isLength({ min: 6 }).withMessage('Password must be at least 6 characters')
-], AuthController.register);
+authRouter.post("/register", authController.register);
+authRouter.post("/login", authController.login);
 
-// Login route
-router.post('/login', [
-  check('email').isEmail().withMessage('Invalid email format'),
-  check('password').notEmpty().withMessage('Password is required')
-], AuthController.login);
-
-// Authentication middleware example
-router.get('/authenticate', AuthMiddleware.authenticate, AuthController.authenticate);
-
-export { router };
+export default authRouter;

src/api/auth/auth.controller.ts

@@ -1,51 +1,74 @@
-import bcrypt from 'bcryptjs';
-import jwt from 'jsonwebtoken';
-import { UserModel } from '../models/user.model';
+import bcrypt from "bcrypt";
+import { signToken } from "../../utils/jwt.util";
+import UserModel from "../user/user.model";
+import { IUser, UserRole } from "../user/user.types";
 
 class AuthService {
-  static async register(username: string, email: string, password: string) {
-    // Check if user exists
-    const existingUser = await UserModel.findOne({ email });
-    if (existingUser) {
-      throw new Error('User already exists');
+  public async register(userData: IUser): Promise<IUser> {
+    try {
+      const hashedPassword = await bcrypt.hash(userData.password, 10);
+      const user = await UserModel.create({
+        ...userData,
+        password: hashedPassword,
+      });
+      return user;
+    } catch (err) {
+      if (
+        err instanceof Error &&
+        "code" in err &&
+        (err as { code: number }).code === 11000
+      ) {
+        throw new Error("Duplicate key error: Email already exists");
+      }
+      if (err instanceof Error) {
+        throw new Error(`Error registering user: ${err.message}`);
+      }
+      throw new Error("Unexpected error occurred during registration");
     }
+  }
 
-    // Hash password
-    const hashedPassword = await bcrypt.hash(password, 10);
+  public async login(email: string, password: string): Promise<string> {
+    try {
+      const user = await UserModel.findOne({ email });
+      if (!user) {
+        throw new Error("Invalid email or password");
+      }
 
-    // Create and save user
-    const user = new UserModel({ username, email, password: hashedPassword });
-    await user.save();
+      const isPasswordValid = await bcrypt.compare(password, user.password);
+      if (!isPasswordValid) {
+        throw new Error("Invalid email or password");
+      }
 
-    return user;
-  }
+      const token = signToken({
+        id: user.id,
+        role: user.role,
+        email: user.email,
+        username: user.username,
+      });
 
-  static async login(email: string, password: string) {
-    const user = await UserModel.findOne({ email });
-    if (!user) {
-      throw new Error('Invalid credentials');
+      return token;
+    } catch (err: unknown) {
+      if (err instanceof Error) {
+        throw new Error(`Error during login: ${err.message}`);
+      }
+      throw new Error("Unexpected error occurred during login");
     }
-
-    // Check password
-    const isMatch = await bcrypt.compare(password, user.password);
-    if (!isMatch) {
-      throw new Error('Invalid credentials');
-    }
-
-    // Generate JWT token
-    const token = jwt.sign({ id: user._id, email: user.email }, process.env.JWT_SECRET as string, { expiresIn: '1h' });
-    return token;
   }
 
-  static async authenticate(token: string) {
+  public async checkRole(userId: string, role: UserRole): Promise<boolean> {
     try {
-      // Verify and decode the JWT token
-      const decoded = jwt.verify(token, process.env.JWT_SECRET as string);
-      return decoded;
-    } catch (error) {
-      throw new Error('Invalid or expired token');
+      const user = await UserModel.findById(userId);
+      if (!user) {
+        throw new Error("User not found");
+      }
+      return user.role === role;
+    } catch (err: unknown) {
+      if (err instanceof Error) {
+        throw new Error(`Error checking role: ${err.message}`);
+      }
+      throw new Error("Unexpected error occurred while checking role");
     }
   }
 }
 
-export { AuthService };
+export default new AuthService();