neatnode 1.0.1 → 3.0.0

package/templates/express-rest-api/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "project-name",
+  "version": "1.0.0",
+  "description": "",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "bcryptjs": "^3.0.2",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.1.0",
+    "express-rate-limit": "^8.2.1",
+    "helmet": "^8.1.0",
+    "joi": "^18.0.1",
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^8.19.2",
+    "morgan": "^1.10.1",
+    "winston": "^3.18.3"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.10"
+  }
+}

package/templates/express-rest-api/server.js

@@ -0,0 +1,14 @@
+import app from "./src/app.js";
+import { connectDB } from "./src/config/db.config.js";
+import { config } from "./src/config/env.config.js";
+import logger from "./src/config/logger.config.js";
+const PORT = config.port || 3000;
+
+// Connect to the database
+connectDB();
+
+// Start the server
+app.listen(PORT, () => {
+  logger.info(`Server is running on port ${PORT}`);
+});
+

package/templates/express-rest-api/src/app.js

@@ -0,0 +1,55 @@
+import express from 'express';
+import cors from 'cors';
+import morgan from 'morgan';
+
+// ROUTE_IMPORTS_START
+import authRoutes from './routes/user.route.js'
+// ROUTE_IMPORTS_END
+
+import { errorHandler, notFound } from './middleware/error.middleware.js';
+import { config } from './config/env.config.js';
+import helmet from 'helmet';
+import { rateLimiter } from './middleware/rateLimiter.js';
+
+
+
+
+// instance 
+const app = express();
+
+// middlewares
+app.use(cors({
+    origin: config.allowedOrigins,
+    // { credentials: true } // uncomment this if you need to work with cookies
+}));
+
+
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(morgan('dev'));
+app.use(helmet());
+
+// routes
+
+// ROUTE_USES_START
+app.use("/api/auth", authRoutes);
+// ROUTE_USES_END
+
+
+// default route
+
+app.get("/", (req, res) => {
+    res.status(200).json({ message: "API is running..." });
+});
+
+// health check route with rate limiting
+app.get("/health", rateLimiter(20), (req, res) => {
+    res.status(200).json({ status: "OK", message: "ALL IS WELL😂..." });
+});
+
+
+// error handling middlewares
+app.use(notFound);
+app.use(errorHandler);
+
+export default app;

package/templates/express-rest-api/src/config/db.config.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+import { config } from "./env.config.js";
+import logger from "./logger.config.js";
+
+export const connectDB = async () => {
+    try {
+        await mongoose.connect(config.dbUri);
+        logger.info("✔ Database connected");
+
+    } catch (error) {
+        logger.error("✖ Database connection error:", error);
+        process.exit(1);
+    }
+}

package/templates/express-rest-api/src/config/env.config.js

@@ -0,0 +1,13 @@
+import dotenv from "dotenv";
+dotenv.config();
+
+export const config = {
+    jwtSecret: process.env.JWT_SECRET,
+    dbUri: process.env.MONGODB_URI,
+    port: process.env.PORT || 3000,
+    nodeEnv: process.env.NODE_ENV || "development",
+    allowedOrigins: [ process.env.CLIENT_URL,
+        "http://localhost:5137",
+    ],
+    
+}

package/templates/express-rest-api/src/config/logger.config.js

@@ -0,0 +1,20 @@
+import winston from "winston";
+
+const { combine, timestamp, printf, colorize } = winston.format;
+
+const logFormat = printf(({ level, message, timestamp }) => {
+  return `[${timestamp}] ${level}: ${message}`;
+});
+
+const logger = winston.createLogger({
+  level: "info",
+  format: combine(colorize(), timestamp({ format: "HH:mm:ss" }), logFormat),
+  transports: [
+    new winston.transports.Console(),
+    // new winston.transports.File({ filename: "logs/app.log" })
+    // To log to a file, uncomment the File transport above.
+  ],
+});
+
+export default logger;
+

package/templates/express-rest-api/src/controllers/user.controller.js

@@ -0,0 +1,35 @@
+import { createUserService, getUserService, loginUserService } from "../services/user.service.js";
+import sendResponse from "../utils/ApiResponse.js";
+import catchAsync from "../utils/catchAsync.js";
+
+// Controller to create a new user
+export const createUser = catchAsync(async (req, res, next) => {
+    const { name, email, password } = req.body;
+
+    // Create a new user
+    const user = await createUserService({ name, email, password });
+
+    // Send response
+    sendResponse(res, 201, "User created successfully", { user });
+});
+
+// Controller to login user
+export const loginUser = catchAsync(async (req, res, next) => {
+    const { email, password } = req.body;
+
+    //   Login user
+    const { user, token } = await loginUserService({ email, password });
+
+    // Send response
+    sendResponse(res, 200, "Login successful", { user, token });
+});
+
+// Controller to get user by logged in User ID
+export const getUser = catchAsync(async (req, res, next) => {
+    const userId = req.user.userid;
+
+    const user = await getUserService(userId);
+    if (!user) return next(new ApiError(404, "User not found"));
+
+    sendResponse(res, 200, "User retrieved successfully", { user });
+});

package/templates/express-rest-api/src/middleware/auth.middleware.js

@@ -0,0 +1,36 @@
+import { verifyAccessToken } from "../utils/Token.js";
+
+
+// Middleware to protect routes
+export const protect = (req, res, next) => {
+    const token = req.headers.authorization.split(' ')[1];
+
+    // Check for token
+    if (!token || !token.startsWith('Bearer ')) {
+        return res.status(401).json({ message: 'Unauthorized' });
+    }
+
+    // Verify token
+    const decoded = verifyAccessToken(token);
+
+    // Check if token is valid
+    if (!decoded) {
+        return res.status(401).json({ message: 'Unauthorized' });
+    }
+
+    // Attach token
+    req.user = decoded;
+    next();
+};
+
+// Middleware to restrict access based on user roles
+export const restrictTo = (...roles) => {
+    return (req, res, next) => {
+        if (!roles.includes(req.user.role)) {
+            return res.status(403).json({ message: 'Forbidden' });
+        }
+        next();
+    };
+};
+
+

package/templates/express-rest-api/src/middleware/error.middleware.js

@@ -0,0 +1,32 @@
+import { config } from "../config/env.config.js";
+import logger from "../config/logger.config.js";
+import ApiError from "../utils/ApiError.js";
+
+
+// Global error handling middleware
+export const errorHandler = (err, req, res, next) => {
+  logger.error("Error 💥", err);
+
+  let { statusCode, message } = err;
+  if (!statusCode) statusCode = 500;
+
+  // Handle operational errors
+  if (err.isOperational) {
+    return res.status(err.statusCode).json({
+      success: false,
+      message: err.message,
+    });
+  }
+
+  // For unexpected errors (like coding bugs, db crashes, etc.)
+  res.status(statusCode).json({
+    success: false,
+    message,
+  });
+};
+
+// Handle invalid routes
+export const notFound = (req, res, next) => {
+  const error = new ApiError(404, `Not Found - ${req.originalUrl}`);
+  next(error);
+};

package/templates/express-rest-api/src/middleware/rateLimiter.js

@@ -0,0 +1,13 @@
+import rateLimit from "express-rate-limit";
+
+export const rateLimiter = (max = 10) =>
+    rateLimit({
+        windowMs: 15 * 60 * 1000, // 15 minutes
+        max, // limit each IP to max requests per windowMs
+        message: {
+            success: false,
+            message: "Too many requests, please try again later."
+        },
+        standardHeaders: true, // return rate limit info in headers
+        legacyHeaders: false,
+    });

package/templates/express-rest-api/src/middleware/validateRequest.middleware.js

@@ -0,0 +1,15 @@
+// Generic middleware to validate req.body against a Joi schema
+const validate = (schema) => (req, res, next) => {
+  const { error } = schema.validate(req.body, { abortEarly: false });
+
+  if (error) {
+    return res.status(400).json({
+      success: false,
+      errors: error.details.map((err) => err.message),
+    });
+  }
+
+  next();
+};
+
+export default validate;

package/templates/express-rest-api/src/models/user.model.js

@@ -0,0 +1,31 @@
+import mongoose from "mongoose";
+
+const userSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true,
+        min: 3,
+        max: 30,
+    },
+    email: {
+        type: String,
+        required: true,
+        unique: true,
+    },
+    password: {
+        type: String,
+        required: true,
+        min: 6,
+    },
+    role: {
+        type: String,
+        enum: ['user', 'admin'],
+        default: 'user',
+    },
+},{
+    timestamps: true,
+});
+
+const User = mongoose.model("user", userSchema);
+
+export default User;

package/templates/express-rest-api/src/routes/user.route.js

@@ -0,0 +1,14 @@
+import express from "express";
+import { getUser, createUser, loginUser } from "../controllers/user.controller.js";
+import { createUserSchema, loginSchema } from "../schemas/user.schema.js";
+import validate from "../middleware/validateRequest.middleware.js";
+import { protect } from "../middleware/auth.middleware.js";
+
+const router = express.Router();
+
+router.get("/me", protect, getUser);
+router.post("/create", validate(createUserSchema), createUser);
+router.post("/login", validate(loginSchema), loginUser);
+
+
+export default router;

package/templates/express-rest-api/src/schemas/user.schema.js

@@ -0,0 +1,43 @@
+import joi from "joi";
+
+// Schema for creating a new user
+export const createUserSchema = joi.object({
+    name: joi.string().min(3).max(30).required().messages({
+        'string.min': 'Name should have a minimum length of 3',
+        'string.max': 'Name should have a maximum length of 30',
+        'any.required': 'Name is required'
+    }),
+    email: joi.string().email().required().messages({
+        'string.email': 'Email must be a valid email',
+        'any.required': 'Email is required'
+    }),
+    password: joi.string().min(6).required().messages({
+        'string.min': 'Password should have a minimum length of 6',
+        'any.required': 'Password is required'
+    }),
+});
+
+// Schema for updating an existing user
+export const updateUserSchema = joi.object({
+    name: joi.string().min(3).max(30).messages({
+        'string.min': 'Name should have a minimum length of 3',
+        'string.max': 'Name should have a maximum length of 30',
+    }),
+    email: joi.string().email().messages({
+        'string.email': 'Email must be a valid email',
+    }),
+    password: joi.string().min(6).messages({
+        'string.min': 'Password should have a minimum length of 6',
+    }),
+});
+
+// Schema for user login
+export const loginSchema = joi.object({
+    email: joi.string().email().required().messages({
+        'string.email': 'Email must be a valid email',
+        'any.required': 'Email is required'
+    }),
+    password: joi.string().required().messages({
+        'any.required': 'Password is required'
+    }),
+});

package/templates/express-rest-api/src/services/user.service.js

@@ -0,0 +1,54 @@
+import bcrypt from "bcryptjs";
+import User from "../models/user.model.js";
+import ApiError from "../utils/ApiError.js";
+import { generateToken } from "../utils/Token.js";
+
+export const createUserService = async ({ name, email, password }) => {
+  // Check if user exists
+  const existing = await User.findOne({ email });
+  if (existing) throw new ApiError(409, "User already exists");
+
+  // Hash password
+  const salt = await bcrypt.genSalt(10);
+  const hashedPassword = await bcrypt.hash(password, salt);
+
+  // Create user
+  const user = await User.create({
+    name,
+    email,
+    password: hashedPassword,
+  });
+
+  const userObj = user.toObject(); // Convert Mongoose document to plain object
+  delete userObj.password; // Remove password field
+  delete userObj.__v;
+  delete userObj.createdAt;
+  delete userObj.updatedAt;
+
+  return userObj;
+};
+
+export const loginUserService = async ({ email, password }) => {
+    // Find user by email
+    const user = await User.findOne({ email });
+    if (!user) throw new ApiError(404, "Invalid Email or password");
+
+    // Check password
+    const isMatch = await bcrypt.compare(password, user.password);
+    if (!isMatch) throw new ApiError(401, "Invalid email or Password"); // notice the capitals, can be used for testing else keep it consistent
+
+    // Generate JWT token
+    const token = generateToken({userid: user._id, role: user.role}, '7h');
+
+    const userObj = user.toObject(); // Convert Mongoose document to plain object
+    delete userObj.password; // Remove password field
+    delete userObj.__v;
+    delete userObj.createdAt;
+    delete userObj.updatedAt;
+
+    return { user: userObj, token };
+};
+
+export const getUserService = async (userId) => {
+  return await User.findById(userId).select("-password -__v -createdAt -updatedAt");
+}

package/templates/express-rest-api/src/utils/ApiError.js

@@ -0,0 +1,17 @@
+class ApiError extends Error {
+  constructor(statusCode, message, errors = [], stack = "") {
+    super(message);
+    this.statusCode = statusCode;
+    this.errors = errors;
+    this.isOperational = true;
+
+
+    if (stack) {
+      this.stack = stack;
+    } else {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+export default ApiError;

package/templates/express-rest-api/src/utils/ApiResponse.js

@@ -0,0 +1,9 @@
+const sendResponse = (res, statusCode, message, data = {}) => {
+  res.status(statusCode).json({
+    success: statusCode < 400,
+    message,
+    ...data
+  });
+};
+
+export default sendResponse;

package/templates/express-rest-api/src/utils/CatchAsync.js

@@ -0,0 +1,5 @@
+const catchAsync = (fn)=>(req, res, next)=>{
+    fn(req, res, next).catch(next);
+}
+
+export default catchAsync;

package/templates/express-rest-api/src/utils/Token.js

@@ -0,0 +1,16 @@
+import jwt from "jsonwebtoken"
+import { config } from "../config/env.config.js";
+
+// Generate JWT token
+export const generateToken = (payload, expiresIn = '1h') => {
+    return jwt.sign(payload, config.jwtSecret, { expiresIn });
+}
+
+// Verify JWT token
+export const verifyAccessToken = (token) => {
+    try {
+        return jwt.verify(token, config.jwtSecret);
+    } catch (error) {
+        return null;
+    }
+};

package/templates/express-socket/.env.example

@@ -0,0 +1,5 @@
+PORT=3000
+MONGODB_URI=mongodb://localhost:27017/mydatabase
+JWT_SECRET=your_jwt_secret_key
+NODE_ENV=development
+