@imksh/create 1.0.0

package/templates/node-prisma-ts/README.md

@@ -0,0 +1,73 @@
+# Node.js TypeScript Prisma Backend Boilerplate
+
+A production-ready, strongly-typed Node.js & Express boilerplate project with best-practice architectures, modular routing, Prisma ORM, and TSX engine compilation.
+
+## Features
+
+- ⚙️ **Modular Architecture:** Express application setup decoupled into `app.ts` (middleware + router wiring) and `index.ts` (server initialization & db connection).
+- 🗄️ **Prisma ORM:** Built-in PostgreSQL datasource configuration and schema mapping for `User`, `Otp`, and `PushSubscription` models.
+- 📝 **Colorized Logging:** Zero-dependency custom logger with timestamped success, warning, info, and error layouts.
+- 🛡️ **Security Out-of-the-Box:** Pre-configured with Helmet headers, CORS policies, and global rate limiters (`apiLimiter`, `authLimiter`, `uploadLimiter`).
+- 🔑 **Authentication & JWT:** Custom middlewares for route protection, sign-ups, and log-ins with HTTP-only cookie-based tokens.
+- 📧 **SMTP Mailer & OTP:** Standard mailer transport using Gmail NodeMailer wrapper, integrated with an OTP generator and email template.
+- 🖼️ **File Uploads:** Cloudinary integration utilizing Multer memory buffers for secure, single or multi-file uploads.
+- 🔌 **Socket.io Setup:** Pre-installed Socket.io hooks mapping connected user sessions to active sockets.
+- ✉️ **Web Push:** Push notifications integration powered by VAPID key generators and web-push subscriptions.
+- 📦 **TSX Engine:** Fast TS runner with native ESM specifier resolution support.
+
+## Getting Started
+
+### 1. Configure Environment Variables
+
+Create a `.env` file in the root directory (based on `.env.example`):
+
+```env
+PORT=5002
+JWT_SECRET=your_super_secret_jwt_key
+DATABASE_URL=postgresql://user:password@localhost:5432/db_name
+
+# Cloudinary
+CLOUDINARY_CLOUD_NAME=your_cloud_name
+CLOUDINARY_API_KEY=your_api_key
+CLOUDINARY_API_SECRET=your_api_secret
+
+# SMTP Settings
+GMAIL_USER=your_email@gmail.com
+GMAIL_PASSCODE=your_app_password
+
+# Web Push
+VAPID_SUBJECT=mailto:your_email@example.com
+VAPID_PUBLIC_KEY=your_vapid_public_key
+VAPID_PRIVATE_KEY=your_vapid_private_key
+```
+
+### 2. Install & Sync Schema
+
+```bash
+# Install dependencies
+npm install
+
+# Push database schema changes locally
+npm run db:push
+
+# Generate Prisma Client types
+npm run db:generate
+
+# Start development server with reload (via tsx)
+npm run dev
+
+# Build the project to JS
+npm run build
+```
+
+## API Endpoints
+
+### Auth Routes (`/api/auth`)
+- `POST /signup` - Registers a new user session
+- `POST /login` - Log in user and write token cookie
+- `POST /logout` - Clear token session cookies
+- `GET /me` - Returns logged-in user profile (requires auth)
+- `PUT /me` - Edit profile info and upload avatars (requires auth)
+
+### Upload Routes (`/api/upload`)
+- `POST /` - Securely uploads image/file to Cloudinary (requires auth)

package/templates/node-prisma-ts/_gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

package/templates/node-prisma-ts/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "node-prisma-ts-template",
+  "version": "1.0.0",
+  "main": "src/index.ts",
+  "type": "module",
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "db:push": "prisma db push",
+    "db:generate": "prisma generate",
+    "generate:vapid": "node ./src/utils/generateVapidKeys.js"
+  },
+  "dependencies": {
+    "@prisma/client": "^5.6.0",
+    "bcrypt": "^5.1.1",
+    "compression": "^1.7.4",
+    "cookie-parser": "^1.4.6",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "express-rate-limit": "^7.1.4",
+    "helmet": "^7.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "morgan": "^1.10.0",
+    "multer": "^1.4.5-lts.1",
+    "cloudinary": "^2.0.0",
+    "nodemailer": "^6.9.7",
+    "socket.io": "^4.7.2",
+    "web-push": "^3.6.6"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^5.0.2",
+    "@types/compression": "^1.7.5",
+    "@types/cookie-parser": "^1.4.6",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/morgan": "^1.9.9",
+    "@types/multer": "^1.4.11",
+    "@types/nodemailer": "^6.4.14",
+    "@types/web-push": "^3.6.3",
+    "@types/node": "^20.9.0",
+    "prisma": "^5.6.0",
+    "tsx": "^4.23.1",
+    "typescript": "^5.2.2"
+  }
+}

package/templates/node-prisma-ts/prisma/schema.prisma

@@ -0,0 +1,41 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id               String             @id @default(uuid())
+  email            String             @unique
+  name             String
+  phone            String?
+  password         String
+  role             String             @default("user")
+  avatarUrl        String?
+  avatarPublicId   String?
+  createdAt        DateTime           @default(now())
+  updatedAt        DateTime           @updatedAt
+  pushSubscriptions PushSubscription[]
+}
+
+model Otp {
+  id        String   @id @default(uuid())
+  email     String   @unique
+  otp       String
+  createdAt DateTime @default(now())
+}
+
+model PushSubscription {
+  id        String   @id @default(uuid())
+  endpoint  String   @unique
+  p256dh    String
+  auth      String
+  role      String   @default("user")
+  userId    String?
+  user      User?    @relation(fields: [userId], references: [id], onDelete: Cascade)
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}

package/templates/node-prisma-ts/src/app.ts

@@ -0,0 +1,36 @@
+import express, { Request, Response, NextFunction } from "express";
+import helmet from "helmet";
+import cors from "cors";
+import compression from "compression";
+import cookieParser from "cookie-parser";
+import morgan from "morgan";
+import apiRoutes from "./routes/index.js";
+import { notFound, errorHandler } from "./middleware/errorHandler.js";
+import { apiLimiter } from "./middleware/rateLimiter.js";
+
+const app = express();
+
+app.use(helmet());
+app.use(
+  cors({
+    origin: process.env.CLIENT_URL || "http://localhost:5173",
+    credentials: true,
+  })
+);
+app.use(compression());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(cookieParser());
+app.use(morgan("dev"));
+
+app.use(apiLimiter);
+app.use("/api", apiRoutes);
+
+app.get("/api/health", (req: Request, res: Response) => {
+  res.status(200).json({ success: true, message: "API is running" });
+});
+
+app.use(notFound);
+app.use(errorHandler);
+
+export default app;

package/templates/node-prisma-ts/src/config/cloudinary.ts

@@ -0,0 +1,9 @@
+import { v2 as cloudinary } from "cloudinary";
+
+cloudinary.config({
+  cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
+  api_key: process.env.CLOUDINARY_API_KEY,
+  api_secret: process.env.CLOUDINARY_API_SECRET,
+});
+
+export default cloudinary;

package/templates/node-prisma-ts/src/config/db.ts

@@ -0,0 +1,16 @@
+import { PrismaClient } from "@prisma/client";
+import logger from "../utils/logger.js";
+
+export const prisma = new PrismaClient();
+
+const connectDB = async () => {
+  try {
+    await prisma.$connect();
+    logger.success("Prisma Database connected successfully");
+  } catch (error: any) {
+    logger.error(`Prisma Database connection failed: ${error.message}`, error);
+    process.exit(1);
+  }
+};
+
+export default connectDB;

package/templates/node-prisma-ts/src/config/dotenv.ts

@@ -0,0 +1,2 @@
+import dotenv from "dotenv";
+dotenv.config();

package/templates/node-prisma-ts/src/config/email.ts

@@ -0,0 +1,28 @@
+import nodemailer from "nodemailer";
+import logger from "../utils/logger.js";
+
+const sendEmail = async (to: string, subject: string, message: string) => {
+  try {
+    const transporter = nodemailer.createTransport({
+      service: "gmail",
+      auth: {
+        user: process.env.GMAIL_USER,
+        pass: process.env.GMAIL_PASSCODE,
+      },
+    });
+
+    const mailOptions = {
+      from: process.env.GMAIL_USER,
+      to,
+      subject,
+      html: message,
+    };
+
+    const res = await transporter.sendMail(mailOptions);
+    logger.success(`Email sent to ${to}: ${res.messageId}`);
+  } catch (error) {
+    logger.error("Failed to send email", error);
+  }
+};
+
+export default sendEmail;

package/templates/node-prisma-ts/src/config/socket.ts

@@ -0,0 +1,54 @@
+import { Server } from "socket.io";
+import logger from "../utils/logger.js";
+
+let io: Server;
+
+const userSocketMap: { [key: string]: Set<string> } = {};
+
+const initializeSocket = (server: any) => {
+  io = new Server(server, {
+    cors: {
+      origin: ["http://localhost:5173"],
+      credentials: true,
+    },
+  });
+
+  io.on("connection", (socket) => {
+    const userId = socket.handshake.auth.userId as string | undefined;
+
+    if (!userId) {
+      logger.warn("No userId, disconnecting socket");
+      socket.disconnect();
+      return;
+    }
+
+    logger.info(`Socket connected: ${socket.id} (User: ${userId})`);
+
+    if (!userSocketMap[userId]) {
+      userSocketMap[userId] = new Set<string>();
+    }
+    userSocketMap[userId].add(socket.id);
+
+    socket.on("disconnect", (reason) => {
+      if (!userId) return;
+      userSocketMap[userId].delete(socket.id);
+      logger.info(`Socket disconnected: ${socket.id} (Reason: ${reason})`);
+    });
+  });
+
+  return io;
+};
+
+export const getIO = () => {
+  if (!io) {
+    throw new Error("Socket.IO has not been initialized yet");
+  }
+  return io;
+};
+
+const getReceiverSocketIds = (userId: string) =>
+  userSocketMap[userId] ? Array.from(userSocketMap[userId]) : [];
+
+export { io, getReceiverSocketIds, userSocketMap };
+
+export default initializeSocket;

package/templates/node-prisma-ts/src/config/webPush.ts

@@ -0,0 +1,9 @@
+import webpush from "web-push";
+
+webpush.setVapidDetails(
+  process.env.VAPID_SUBJECT as string || "", 
+  process.env.VAPID_PUBLIC_KEY as string || "",
+  process.env.VAPID_PRIVATE_KEY as string || ""
+);
+
+export default webpush;

package/templates/node-prisma-ts/src/controllers/auth.controller.ts

@@ -0,0 +1,124 @@
+import { Request, Response, NextFunction } from "express";
+import { authService } from "../services/auth.service.js";
+import { generateToken } from "../utils/jwt.js";
+import genOtpToken from "../utils/genOtpToken.js";
+import logger from "../utils/logger.js";
+
+export const signup = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { name, email, phone, password } = req.body;
+    if (!email || !password || !name) {
+      return next({ status: 400, message: "All fields are required." });
+    }
+    const newUser = await authService.signup({ name, email, phone, password });
+    const token = await generateToken(newUser, res);
+    const safeUser: any = { ...newUser };
+    delete safeUser.password;
+    res.status(201).json({ message: "Registration Successful", data: safeUser, token });
+  } catch (error) {
+    logger.error("Error in signup controller", error);
+    next(error);
+  }
+};
+
+export const login = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { email, password } = req.body;
+    if (!email || !password) {
+      return next({ status: 400, message: "All fields are required." });
+    }
+    const user = await authService.login({ email, password });
+    const token = await generateToken(user, res);
+    const safeUser: any = { ...user };
+    delete safeUser.password;
+    res.status(200).json({ message: "Login successfully", data: safeUser, token });
+  } catch (error) {
+    logger.error("Error in login controller", error);
+    next(error);
+  }
+};
+
+export const logout = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    res.clearCookie("token", {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "strict",
+      path: "/",
+    });
+    res.status(200).json({ message: "Logout Successfully" });
+  } catch (error) {
+    logger.error("Error in logout controller", error);
+    next(error);
+  }
+};
+
+export const getMe = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    res.status(200).json({ message: "User Authenticated", data: req.user });
+  } catch (error) {
+    logger.error("Error in getMe controller", error);
+    next(error);
+  }
+};
+
+export const genOtp = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { email } = req.body;
+    if (!email) {
+      return next({ status: 400, message: "Email is required." });
+    }
+    await authService.generateOtp(email);
+    res.status(200).json({ message: "Otp sent successfully" });
+  } catch (error) {
+    logger.error("Error in genOtp", error);
+    next(error);
+  }
+};
+
+export const verifyOtp = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { email, otp } = req.body;
+    if (!email || !otp) {
+      return next({ status: 400, message: "All fields are required." });
+    }
+    const user = await authService.verifyOtp({ email, otp });
+    await genOtpToken(user, res);
+    res.status(200).json({ message: "Otp verified successfully" });
+  } catch (error) {
+    logger.error("Error in verifyOtp", error);
+    next(error);
+  }
+};
+
+export const resetPassword = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { newPassword } = req.body;
+    const currentUser = req.user;
+    if (!newPassword) {
+      return next({ status: 400, message: "All fields are required." });
+    }
+    await authService.resetPassword(currentUser, newPassword);
+    res.status(200).json({ message: "Password updated successfully" });
+  } catch (error) {
+    logger.error("Error in resetPassword", error);
+    next(error);
+  }
+};
+
+export const updateMe = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { name, phone } = req.body;
+    const user = await authService.updateProfile(req.user.id, {
+      name,
+      phone,
+      file: req.file,
+    });
+    const safeUser: any = { ...user };
+    delete safeUser.password;
+    res.status(200).json({ success: true, data: safeUser });
+  } catch (error) {
+    logger.error("Error updating profile", error);
+    next(error);
+  }
+};

package/templates/node-prisma-ts/src/controllers/upload.controller.ts

@@ -0,0 +1,22 @@
+import { Request, Response, NextFunction } from "express";
+import { uploadSingleToCloudinary } from "../utils/cloudinaryUpload.js";
+import logger from "../utils/logger.js";
+
+export const uploadFile = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({ success: false, message: "No file uploaded" });
+    }
+    const result = await uploadSingleToCloudinary(req.file, {
+      folder: req.body.folder || "general_uploads",
+    });
+    res.status(200).json({
+      success: true,
+      message: "File uploaded successfully",
+      data: result,
+    });
+  } catch (error) {
+    logger.error("Upload controller error", error);
+    next(error);
+  }
+};

package/templates/node-prisma-ts/src/index.ts

@@ -0,0 +1,17 @@
+import dotenv from "dotenv";
+import http from "http";
+import app from "./app.js";
+import connectDB from "./config/db.js";
+import logger from "./utils/logger.js";
+
+dotenv.config();
+
+const PORT = process.env.PORT || 5000;
+
+connectDB();
+
+const server = http.createServer(app);
+
+server.listen(PORT, () => {
+  logger.success(`Server is running on port ${PORT}`);
+});

package/templates/node-prisma-ts/src/middleware/auth.middleware.ts

@@ -0,0 +1,45 @@
+import { Request, Response, NextFunction } from "express";
+import { verifyToken } from "../utils/jwt.js";
+import logger from "../utils/logger.js";
+import { prisma } from "../config/db.js";
+
+export const protect = async (req: Request, res: Response, next: NextFunction) => {
+  let token: string | undefined;
+
+  if (req.cookies?.token) {
+    token = req.cookies.token;
+  } else if (
+    req.headers.authorization &&
+    req.headers.authorization.startsWith("Bearer")
+  ) {
+    token = req.headers.authorization.split(" ")[1];
+  }
+
+  if (!token) {
+    return res.status(401).json({ message: "Not authorized, no token provided" });
+  }
+
+  try {
+    const decoded: any = verifyToken(token);
+    if (!decoded) {
+      return res.status(401).json({ message: "Not authorized, invalid token" });
+    }
+
+    const user = await prisma.user.findUnique({
+      where: { id: decoded.id },
+    });
+
+    if (!user) {
+      return res.status(401).json({ message: "Not authorized, user not found" });
+    }
+
+    const safeUser: any = { ...user };
+    delete safeUser.password;
+
+    req.user = safeUser;
+    return next();
+  } catch (error: any) {
+    logger.error("Auth middleware error", error);
+    return res.status(401).json({ message: "Not authorized, token verification failed" });
+  }
+};

package/templates/node-prisma-ts/src/middleware/errorHandler.ts

@@ -0,0 +1,16 @@
+import { Request, Response, NextFunction } from "express";
+
+export const notFound = (req: Request, res: Response, next: NextFunction) => {
+  const error = new Error(`Not Found - ${req.originalUrl}`);
+  res.status(404);
+  next(error);
+};
+
+export const errorHandler = (err: any, req: Request, res: Response, next: NextFunction) => {
+  const statusCode = err.status || err.statusCode || (res.statusCode === 200 ? 500 : res.statusCode);
+  res.status(statusCode).json({
+    success: false,
+    message: err.message || "An unexpected error occurred",
+    stack: process.env.NODE_ENV === "production" ? undefined : err.stack,
+  });
+};

package/templates/node-prisma-ts/src/middleware/multer.ts

@@ -0,0 +1,20 @@
+import multer, { FileFilterCallback } from "multer";
+import { Request } from "express";
+
+const storage = multer.memoryStorage();
+
+const fileFilter = (req: Request, file: Express.Multer.File, cb: FileFilterCallback) => {
+  if (file.mimetype.startsWith("image/")) {
+    cb(null, true);
+  } else {
+    cb(new Error("Only image files are allowed!"));
+  }
+};
+
+export const upload = multer({
+  storage,
+  fileFilter,
+  limits: {
+    fileSize: 5 * 1024 * 1024, // 5MB limit
+  },
+});

package/templates/node-prisma-ts/src/middleware/rateLimiter.ts

@@ -0,0 +1,53 @@
+import rateLimit from "express-rate-limit";
+import { Request, Response } from "express";
+
+interface LimiterConfig {
+  windowMs: number;
+  max: number;
+  message: string;
+  skipSuccessfulRequests?: boolean;
+}
+
+const createLimiter = ({
+  windowMs,
+  max,
+  message,
+  skipSuccessfulRequests = false,
+}: LimiterConfig) =>
+  rateLimit({
+    windowMs,
+    max,
+    standardHeaders: true,
+    legacyHeaders: false,
+    skipSuccessfulRequests,
+
+    keyGenerator: (req: any) => {
+      return req.user?.id || req.ip || req.headers["x-forwarded-for"] || req.socket.remoteAddress;
+    },
+
+    handler: (req: Request, res: Response) => {
+      res.status(429).json({
+        success: false,
+        message,
+      });
+    },
+  });
+
+export const apiLimiter = createLimiter({
+  windowMs: 15 * 60 * 1000,
+  max: 100,
+  message: "Too many requests. Please try again later.",
+});
+
+export const authLimiter = createLimiter({
+  windowMs: 15 * 60 * 1000,
+  max: 10,
+  skipSuccessfulRequests: true,
+  message: "Too many login attempts. Please try again later.",
+});
+
+export const uploadLimiter = createLimiter({
+  windowMs: 60 * 60 * 1000,
+  max: 20,
+  message: "Upload limit reached. Please try again in an hour.",
+});

package/templates/node-prisma-ts/src/routes/auth.route.ts

@@ -0,0 +1,22 @@
+import express from "express";
+import {
+  signup,
+  login,
+  getMe,
+  logout,
+  updateMe,
+} from "../controllers/auth.controller.js";
+import { protect } from "../middleware/auth.middleware.js";
+import { apiLimiter } from "../middleware/rateLimiter.js";
+
+const router = express.Router();
+
+router.use(apiLimiter);
+
+router.post("/signup", signup);
+router.post("/login", login);
+router.post("/logout", logout);
+router.get("/me", protect, getMe);
+router.put("/me", protect, updateMe);
+
+export default router;