sk-test-node-deploy 1.0.0

package/template/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "nodejs-boilerplate",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "nodemon src/app.ts",
+    "build": "tsc",
+    "start": "node dist/app.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "compression": "^1.8.1",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "helmet": "^8.1.0",
+    "joi": "^18.0.2",
+    "jsonwebtoken": "^9.0.3",
+    "mongoose": "^9.0.2",
+    "multer": "^2.0.2",
+    "socket.io": "^4.8.2"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/compression": "^1.8.1",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/mongoose": "^5.11.96",
+    "@types/multer": "^2.0.0",
+    "@types/node": "^25.0.3",
+    "@types/socket.io": "^3.0.1",
+    "nodemon": "^3.1.11",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/template/src/app.ts

@@ -0,0 +1,68 @@
+import express, { Application, Router } from "express";
+import dotenv from "dotenv";
+import http from "http";
+import { Server } from "socket.io";
+
+import authRoutes from "./routes/auth.routes";
+import userRoutes from "./routes/user.routes";
+import fileRoutes from "./routes/file.routes";
+
+import { initializeSocket } from "./socket/socker.handler";
+import { connectDB } from "./config/database";
+
+dotenv.config();
+
+const app: Application = express();
+const server = http.createServer(app);
+
+const io = new Server(server, {
+  cors: {
+    origin: "*",
+    methods: ["GET", "POST"],
+  },
+});
+
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Health check route
+app.get("/", (req, res) => {
+  res.json({
+    status: 200,
+    message: "API is running successfully",
+    data: {
+      version: "1.0.0",
+      timestamp: new Date().toISOString(),
+    },
+  });
+});
+
+app.use("/api/v1/auth", authRoutes);
+app.use("/api/v1/users", userRoutes);
+app.use("/api/v1/files", fileRoutes);
+
+initializeSocket(io);
+
+const PORT = process.env.PORT || 3000;
+
+const startServer = async () => {
+  try {
+    await connectDB();
+
+    server.listen(PORT, () => {
+      console.log(`Server running on  http://localhost:${PORT}`);
+    });
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  }
+};
+
+startServer();
+
+process.on("unhandledRejection", (err: Error) => {
+  console.error("Unhandled Rejection:", err.message);
+  server.close(() => process.exit(1));
+});
+
+export { app, io };

package/template/src/config/database.ts

@@ -0,0 +1,12 @@
+import mongoose from "mongoose";
+
+export const connectDB = async (): Promise<void> => {
+  try {
+    const mongoURI = process.env.MONGODB_URI;
+    await mongoose.connect(mongoURI as string);
+    mongoose.connection.on("error", (err) => { });
+  } catch (error) {
+    console.error("MongoDB connection error:", error);
+    process.exit(1);
+  }
+};

package/template/src/controllers/auth.controller.ts

@@ -0,0 +1,219 @@
+import { Request, Response } from "express";
+import User from "../models/user.model";
+import { JWTUtil } from "../utils/jwt.util";
+import bcrypt from "bcryptjs";
+
+class AuthController {
+  async refreshToken(req: Request, res: Response) {
+    try {
+      const { refreshToken } = req.body;
+
+      if (!refreshToken) {
+        return res.status(400).json({
+          status: 400,
+          message: "Refresh token is required",
+        });
+      }
+
+      const decoded = JWTUtil.verifyRefreshToken(refreshToken);
+
+      if (!decoded) {
+        return res.status(401).json({
+          status: 401,
+          message: "Invalid or expired refresh token",
+        });
+      }
+
+      const user = await User.findById(decoded.userId).select("+refreshToken");
+
+      if (!user || user.refreshToken !== refreshToken) {
+        return res.status(401).json({
+          status: 401,
+          message: "Invalid refresh token",
+        });
+      }
+
+      const newAccessToken = JWTUtil.generateToken({
+        userId: user._id.toString(),
+        email: user.email,
+      });
+
+      return res.status(200).json({
+        status: 200,
+        message: "Token refreshed successfully",
+        data: {
+          accessToken: newAccessToken,
+        },
+      });
+    } catch (error) {
+      return res.status(500).json({
+        status: 500,
+        message: "Token refresh failed",
+      });
+    }
+  }
+
+  async register(req: Request, res: Response) {
+    try {
+      const { name, email, password } = req.body;
+
+      const existingUser = await User.findOne({ email });
+      if (existingUser) {
+        return res.status(400).json({
+          status: 400,
+          message: "Email already registered",
+        });
+      }
+
+      const user = await User.create({
+        name,
+        email,
+        password,
+      });
+
+      const accessToken = JWTUtil.generateToken({
+        userId: user._id.toString(),
+        email: user.email,
+      });
+
+      const refreshToken = JWTUtil.generateRefreshToken({
+        userId: user._id.toString(),
+        email: user.email,
+      });
+
+      user.refreshToken = refreshToken;
+      await user.save();
+
+      return res.status(201).json({
+        status: 201,
+        message: "User registered successfully",
+        data: {
+          user: {
+            id: user._id,
+            name: user.name,
+            email: user.email,
+          },
+          accessToken,
+          refreshToken,
+        },
+      });
+    } catch (error) {
+      return res.status(500).json({
+        status: 500,
+        message: "Registration failed",
+      });
+    }
+  }
+
+  async login(req: Request, res: Response) {
+    try {
+      const { email, password } = req.body;
+
+      const user = await User.findOne({ email }).select("+password");
+
+      if (!user) {
+        return res.status(401).json({
+          status: 401,
+          message: "Invalid credentials",
+        });
+      }
+
+      const isPasswordValid = await bcrypt.compare(password, user.password);
+
+      if (!isPasswordValid) {
+        return res.status(401).json({
+          status: 401,
+          message: "Invalid credentials",
+        });
+      }
+
+      const accessToken = JWTUtil.generateToken({
+        userId: user._id.toString(),
+        email: user.email,
+      });
+
+      const refreshToken = JWTUtil.generateRefreshToken({
+        userId: user._id.toString(),
+        email: user.email,
+      });
+
+      user.refreshToken = refreshToken;
+      await user.save();
+
+      return res.status(200).json({
+        status: 200,
+        message: "Login successful",
+        data: {
+          user: {
+            id: user._id,
+            name: user.name,
+            email: user.email,
+          },
+          accessToken,
+          refreshToken,
+        },
+      });
+    } catch (error) {
+      return res.status(500).json({
+        status: 500,
+        message: "Login failed",
+      });
+    }
+  }
+
+  async logout(req: Request, res: Response) {
+    try {
+      const userId = req.user?.userId;
+
+      if (!userId) {
+        return res.status(401).json({
+          status: 401,
+          message: "User not authenticated",
+        });
+      }
+
+      await User.findByIdAndUpdate(userId, { refreshToken: null });
+
+      return res.status(200).json({
+        status: 200,
+        message: "Logout successful",
+      });
+    } catch (error) {
+      return res.status(500).json({
+        status: 500,
+        message: "Logout failed",
+      });
+    }
+  }
+
+  async getProfile(req: Request, res: Response) {
+    try {
+      const user = await User.findById(req.user?.userId);
+
+      if (!user) {
+        return res.status(404).json({
+          status: 404,
+          message: "User not found",
+        });
+      }
+
+      return res.status(200).json({
+        status: 200,
+        message: "Profile retrieved successfully",
+        data: {
+          id: user._id,
+          name: user.name,
+          email: user.email,
+          createdAt: user.createdAt,
+        },
+      });
+    } catch (error) {
+      return res.status(500).json({
+        status: 500,
+        message: "Failed to get profile",
+      });
+    }
+  }
+}
+
+export const authController = new AuthController();

package/template/src/controllers/file.controller.ts

@@ -0,0 +1,31 @@
+import { Request, Response } from "express";
+
+class FileController {
+  async uploadFile(req: Request, res: Response) {
+    try {
+      if (!req.file) {
+        return res
+          .status(400)
+          .json({ success: false, message: "No file uploaded" });
+      }
+      return res.status(200).json({
+        success: true,
+        message: "File uploaded successfully",
+        data: {
+          filename: req.file.filename,
+          originalName: req.file.originalname,
+          size: req.file.size,
+          path: req.file.path,
+        },
+      });
+    } catch (error: any) {
+      return res.status(500).json({
+        success: false,
+        message: "Internal Server Error",
+        error: error?.message,
+      });
+    }
+  }
+}
+
+export const fileController = new FileController();

package/template/src/controllers/user.controller.ts

@@ -0,0 +1,160 @@
+import { Request, Response } from 'express';
+import User from '../models/user.model';
+
+class UserController {
+  async getAllUsers(req: Request, res: Response) {
+    try {
+      const page = parseInt(req.query.page as string) || 1;
+      const limit = parseInt(req.query.limit as string) || 10;
+      const skip = (page - 1) * limit;
+
+      const searchQuery = req.query.search ? {
+        $or: [
+          { name: { $regex: String(req.query.search), $options: 'i' } },
+          { email: { $regex: String(req.query.search), $options: 'i' } }
+        ]
+      } : {};
+
+      const total = await User.countDocuments(searchQuery);
+
+      const users = await User.find(searchQuery)
+        .select('-password')
+        .skip(skip)
+        .limit(limit)
+        .sort({ createdAt: -1 });
+
+      const totalPages = Math.ceil(total / limit);
+
+      const userDetails = users.map(user => ({
+        id: user._id,
+        name: user.name,
+        email: user.email,
+        createdAt: user.createdAt
+      }));
+
+      return res.status(200).json({
+        status: 200,
+        message: 'Users retrieved successfully',
+        data: userDetails,
+        pagination: {
+          page,
+          limit,
+          total,
+          totalPages
+        }
+      });
+    } catch (error) {
+      return res.status(500).json({
+        status: 500,
+        message: 'Failed to get users'
+      });
+    }
+  }
+
+  async getUserById(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+
+      const user = await User.findById(id);
+
+      if (!user) {
+        return res.status(404).json({
+          status: 404,
+          message: 'User not found'
+        });
+      }
+
+      return res.status(200).json({
+        status: 200,
+        message: 'User retrieved successfully',
+        data: {
+          id: user._id,
+          name: user.name,
+          email: user.email,
+          createdAt: user.createdAt
+        }
+      });
+    } catch (error) {
+      return res.status(500).json({
+        status: 500,
+        message: 'Failed to get user'
+      });
+    }
+  }
+
+  async updateUser(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+      const { name, email } = req.body;
+
+      if (email) {
+        const existingUser = await User.findOne({ email, _id: { $ne: id } });
+        if (existingUser) {
+          return res.status(400).json({
+            status: 400,
+            message: 'Email already in use'
+          });
+        }
+      }
+
+      const user = await User.findByIdAndUpdate(
+        id,
+        { name, email },
+        { new: true, runValidators: true }
+      );
+
+      if (!user) {
+        return res.status(404).json({
+          status: 404,
+          message: 'User not found'
+        });
+      }
+
+      return res.status(200).json({
+        status: 200,
+        message: 'User updated successfully',
+        data: {
+          id: user._id,
+          name: user.name,
+          email: user.email,
+          updatedAt: user.updatedAt
+        }
+      });
+    } catch (error) {
+      return res.status(500).json({
+        status: 500,
+        message: 'Failed to update user'
+      });
+    }
+  }
+
+  async deleteUser(req: Request, res: Response) {
+    try {
+      const { id } = req.params;
+
+      const user = await User.findByIdAndDelete(id);
+
+      if (!user) {
+        return res.status(404).json({
+          status: 404,
+          message: 'User not found'
+        });
+      }
+
+      return res.status(200).json({
+        status: 200,
+        message: 'User deleted successfully',
+        data: {
+          id: user._id
+        }
+      });
+    } catch (error) {
+      return res.status(500).json({
+        status: 500,
+        message: 'Failed to delete user'
+      });
+    }
+  }
+}
+
+export const userController = new UserController();

package/template/src/middlewares/auth.middleware.ts

@@ -0,0 +1,56 @@
+import { Request, Response, NextFunction } from 'express';
+import { JWTUtil } from '../utils/jwt.util';
+import User from '../models/user.model';
+
+export const authenticate = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => {
+  try {
+    // Get token from header
+    const authHeader = req.headers.authorization;
+
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      return res.status(401).json({
+        status: 401,
+        message: 'No token provided'
+      });
+    }
+
+    const token = authHeader.split(' ')[1];
+
+    // Verify token
+    const decoded = JWTUtil.verifyToken(token);
+
+    if (!decoded) {
+      return res.status(401).json({
+        status: 401,
+        message: 'Invalid or expired token'
+      });
+    }
+
+    // Check if user exists
+    const user = await User.findById(decoded.userId);
+
+    if (!user) {
+      return res.status(401).json({
+        status: 401,
+        message: 'User not found'
+      });
+    }
+
+    // Attach user to request
+    req.user = {
+      userId: decoded.userId,
+      email: decoded.email
+    };
+
+    next();
+  } catch (error) {
+    return res.status(500).json({
+      status: 500,
+      message: 'Authentication failed'
+    });
+  }
+};

package/template/src/middlewares/upload.middleware.ts

@@ -0,0 +1,27 @@
+import multer from "multer";
+
+//Storing in uploads directory
+const storage = multer.diskStorage({
+  destination: "uploads/",
+  filename(_req, file, callback) {
+    const fileName = file.originalname;
+    callback(null, `${Date.now()}-${fileName}`);
+  },
+});
+
+//FileFiller
+const fileFillter: multer.Options["fileFilter"] = (_req, file, callback) => {
+  const allowedTypes = ["application/pdf", "text/csv"];
+
+  if (!allowedTypes.includes(file.mimetype)) {
+    return callback(new Error("only PDF and CSV file allowed"));
+  }
+
+  callback(null, true);
+};
+
+export const uploadMiddleware = multer({
+  storage,
+  fileFilter: fileFillter,
+  limits: { fileSize: 2 * 1024 * 1024 },
+});

package/template/src/middlewares/validation.middleware.ts

@@ -0,0 +1,70 @@
+import { Request, Response, NextFunction } from 'express';
+import Joi from 'joi';
+
+export const validate = (schema: Joi.ObjectSchema) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const { error, value } = schema.validate(req.body, {
+      abortEarly: false,
+      stripUnknown: true
+    });
+
+    if (error) {
+      const errors = error.details.map(detail => ({
+        field: detail.path.join('.'),
+        message: detail.message
+      }));
+
+      return res.status(400).json({
+        status: 400,
+        message: 'Validation failed',
+        data: errors
+      });
+    }
+
+    req.body = value;
+    next();
+  };
+};
+
+// Validation schemas
+export const registerSchema = Joi.object({
+  name: Joi.string().min(2).max(50).required().messages({
+    'string.min': 'Name must be at least 2 characters',
+    'string.max': 'Name cannot exceed 50 characters',
+    'any.required': 'Name is required'
+  }),
+  email: Joi.string().email().required().messages({
+    'string.email': 'Please provide a valid email',
+    'any.required': 'Email is required'
+  }),
+  password: Joi.string().min(6).required().messages({
+    'string.min': 'Password must be at least 6 characters',
+    'any.required': 'Password is required'
+  })
+});
+
+export const loginSchema = Joi.object({
+  email: Joi.string().email().required().messages({
+    'string.email': 'Please provide a valid email',
+    'any.required': 'Email is required'
+  }),
+  password: Joi.string().required().messages({
+    'any.required': 'Password is required'
+  })
+});
+
+export const refreshTokenSchema = Joi.object({
+  refreshToken: Joi.string().required().messages({
+    'any.required': 'Refresh token is required'
+  })
+});
+
+export const updateUserSchema = Joi.object({
+  name: Joi.string().min(2).max(50).messages({
+    'string.min': 'Name must be at least 2 characters',
+    'string.max': 'Name cannot exceed 50 characters'
+  }),
+  email: Joi.string().email().messages({
+    'string.email': 'Please provide a valid email'
+  })
+}).min(1);