@imksh/create 1.0.27 → 1.0.28

package/templates/node-ts/README.md

@@ -1,71 +0,0 @@
-# Node.js TypeScript Backend Boilerplate
-
-A production-ready, strongly-typed Node.js & Express boilerplate project with best-practice architectures, modular routing, and TypeScript compilation.
-
-## Features
-
-- ⚙️ **Modular Architecture:** Express application setup decoupled into `app.ts` (middleware + router wiring) and `index.ts` (server initialization & db connection).
-- 📝 **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 runtime TS loader supporting ESM resolutions natively with instant reloads.
-
-## 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
-MONGO_URI=your_mongodb_connection_uri
-
-# Cloudinary
-CLOUDINARY_CLOUD_NAME=your_cloud_name
-CLOUDINARY_API_KEY=your_api_key
-CLOUDINARY_API_SECRET=your_api_secret
-
-# SMTP Settings
-SMTP_USER=your_email@gmail.com
-SMTP_PASS=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 & Start Development
-
-```bash
-# Install dependencies
-npm install
-
-# Start development server with reload (via tsx)
-npm run dev
-
-# Build the project to JS
-npm run build
-
-# Start production compiled server
-npm start
-```
-
-## 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-ts/_gitignore

@@ -1,24 +0,0 @@
-# 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-ts/src/app.ts

@@ -1,36 +0,0 @@
-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-ts/src/config/cloudinary.ts

@@ -1,9 +0,0 @@
-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-ts/src/config/db.ts

@@ -1,15 +0,0 @@
-import mongoose from "mongoose";
-import logger from "../utils/logger.js";
-
-const connectDB = async () => {
-  try {
-    const MONGO_URI = process.env.MONGO_URI || "mongodb://localhost:27017/test";
-    const conn = await mongoose.connect(MONGO_URI);
-    logger.success(`MongoDB connected: ${conn.connection.host}`);
-  } catch (error: any) {
-    logger.error(`MongoDB connection error: ${error.message}`, error);
-    process.exit(1);
-  }
-};
-
-export default connectDB;

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

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

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

@@ -1,28 +0,0 @@
-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.SMTP_USER,
-        pass: process.env.SMTP_PASS,
-      },
-    });
-
-    const mailOptions = {
-      from: process.env.SMTP_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-ts/src/config/socket.ts

@@ -1,54 +0,0 @@
-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-ts/src/config/webPush.ts

@@ -1,9 +0,0 @@
-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-ts/src/controllers/auth.controller.ts

@@ -1,126 +0,0 @@
-import { Request, Response, NextFunction } from "express";
-import * as 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.toObject();
-    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.toObject();
-    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 {
-    const safeUser: any = req.user.toObject();
-    delete safeUser.password;
-    res.status(200).json({ message: "User Authenticated", data: safeUser });
-  } 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.toObject();
-    delete safeUser.password;
-    res.status(200).json({ success: true, data: safeUser });
-  } catch (error) {
-    logger.error("Error updating profile", error);
-    next(error);
-  }
-};

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

@@ -1,22 +0,0 @@
-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-ts/src/index.ts

@@ -1,17 +0,0 @@
-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-ts/src/middleware/auth.middleware.ts

@@ -1,38 +0,0 @@
-import { Request, Response, NextFunction } from "express";
-import User from "../models/user.model.js";
-import { verifyToken } from "../utils/jwt.js";
-import logger from "../utils/logger.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" });
-    }
-
-    req.user = await User.findById(decoded.id).select("-password");
-    if (!req.user) {
-      return res.status(401).json({ message: "Not authorized, user not found" });
-    }
-
-    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-ts/src/middleware/errorHandler.ts

@@ -1,16 +0,0 @@
-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-ts/src/middleware/multer.ts

@@ -1,20 +0,0 @@
-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-ts/src/middleware/rateLimiter.ts

@@ -1,53 +0,0 @@
-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-ts/src/models/otp.model.ts

@@ -1,27 +0,0 @@
-import mongoose, { Document } from "mongoose";
-
-export interface IOtp extends Document {
-  email: string;
-  otp: string;
-  createdAt: Date;
-}
-
-const otpSchema = new mongoose.Schema<IOtp>({
-  email: {
-    type: String,
-    required: true,
-  },
-  otp: {
-    type: String,
-    required: true,
-  },
-  createdAt: {
-    type: Date,
-    default: Date.now(),
-    expires: 300,
-  },
-});
-
-const Otp = mongoose.model<IOtp>("Otp", otpSchema);
-
-export default Otp;

package/templates/node-ts/src/models/pushSubscription.model.ts

@@ -1,45 +0,0 @@
-import mongoose, { Document } from "mongoose";
-
-export interface IPushSubscription extends Document {
-  endpoint: string;
-  keys: {
-    p256dh: string;
-    auth: string;
-  };
-  user?: mongoose.Types.ObjectId;
-  role: "admin" | "user";
-  expiresAt: Date;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-const pushSubscriptionSchema = new mongoose.Schema<IPushSubscription>(
-  {
-    endpoint: {
-      type: String,
-      required: true,
-      unique: true,
-    },
-    keys: {
-      p256dh: { type: String, required: true },
-      auth: { type: String, required: true },
-    },
-    user: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "User",
-    },
-    role: {
-      type: String,
-      enum: ["admin", "user"],
-      default: "user",
-    },
-    expiresAt: {
-      type: Date,
-      default: () => new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
-      index: { expires: 0 },
-    },
-  },
-  { timestamps: true },
-);
-
-export default mongoose.model<IPushSubscription>("PushSubscription", pushSubscriptionSchema);

package/templates/node-ts/src/models/user.model.ts

@@ -1,57 +0,0 @@
-import mongoose, { Document } from "mongoose";
-
-export interface IUser extends Document {
-  name: string;
-  email: string;
-  phone?: string;
-  avatar?: {
-    publicId?: string;
-    url?: string;
-  };
-  password?: string;
-  role: "user" | "admin" | "other";
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-const userSchema = new mongoose.Schema<IUser>(
-  {
-    name: {
-      type: String,
-      required: [true, "Name is required"],
-      trim: true,
-    },
-
-    email: {
-      type: String,
-      required: [true, "Email is required"],
-      unique: true,
-      lowercase: true,
-      trim: true,
-    },
-    phone: {
-      type: String,
-    },
-    avatar: {
-      publicId: {
-        type: String,
-      },
-      url: {
-        type: String,
-      },
-    },
-    password: {
-      type: String,
-      required: [true, "Password is required"],
-    },
-    role: {
-      type: String,
-      enum: ["user", "admin", "other"],
-      default: "user",
-    },
-  },
-  { timestamps: true },
-);
-
-const User = mongoose.model<IUser>("User", userSchema);
-export default User;