@imksh/create 1.0.0

package/templates/mern-ts/server/src/middleware/auth.middleware.ts

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

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

package/templates/mern-ts/server/src/models/pushSubscription.model.ts

@@ -0,0 +1,32 @@
+import mongoose from "mongoose";
+
+const pushSubscriptionSchema = new mongoose.Schema(
+  {
+    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("PushSubscription", pushSubscriptionSchema);

package/templates/mern-ts/server/src/models/user.model.ts

@@ -0,0 +1,43 @@
+import mongoose from "mongoose";
+
+const userSchema = new mongoose.Schema(
+  {
+    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("User", userSchema);
+export default User;

package/templates/mern-ts/server/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;

package/templates/mern-ts/server/src/routes/index.ts

@@ -0,0 +1,10 @@
+import express from "express";
+import authRoutes from "./auth.route.js";
+import uploadRoutes from "./upload.route.js";
+
+const router = express.Router();
+
+router.use("/auth", authRoutes);
+router.use("/upload", uploadRoutes);
+
+export default router;

package/templates/mern-ts/server/src/routes/upload.route.ts

@@ -0,0 +1,11 @@
+import express from "express";
+import { upload } from "../middleware/multer.js";
+import { uploadFile } from "../controllers/upload.controller.js";
+import { protect } from "../middleware/auth.middleware.js";
+import { uploadLimiter } from "../middleware/rateLimiter.js";
+
+const router = express.Router();
+
+router.post("/", protect, uploadLimiter, upload.single("file"), uploadFile);
+
+export default router;

package/templates/mern-ts/server/src/services/auth.service.ts

@@ -0,0 +1,115 @@
+import User from "../models/user.model.js";
+import Otp from "../models/otp.model.js";
+import bcrypt from "bcrypt";
+import { generateToken } from "../utils/jwt.js";
+import { sendOtpEmail } from "../utils/emailOtp.js";
+import { uploadSingleToCloudinary, deleteFromCloudinary } from "../utils/cloudinaryUpload.js";
+import logger from "../utils/logger.js";
+
+export const authService = {
+  signup: async ({ name, email, phone, password }: any) => {
+    const existingUser = await User.findOne({ email });
+    if (existingUser) {
+      const err: any = new Error("User already exists");
+      err.status = 409;
+      throw err;
+    }
+    const salt = await bcrypt.genSalt(10);
+    const hashedPassword = await bcrypt.hash(password, salt);
+    const photoURL = `https://placehold.co/600x400?text=${name.charAt(0).toUpperCase()}`;
+    const newUser = await User.create({
+      name,
+      email: email.toLowerCase(),
+      phone,
+      role: "user",
+      password: hashedPassword,
+      avatar: { url: photoURL, publicId: "" },
+    });
+    return newUser;
+  },
+
+  login: async ({ email, password }: any) => {
+    const user = await User.findOne({ email });
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+    const isValid = await bcrypt.compare(password, user.password);
+    if (!isValid) {
+      const err: any = new Error("Invalid Credentials");
+      err.status = 401;
+      throw err;
+    }
+    return user;
+  },
+
+  generateOtp: async (email: string) => {
+    const user = await User.findOne({ email });
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+    const existingOtp = await Otp.findOne({ email });
+    if (existingOtp) {
+      await existingOtp.deleteOne();
+    }
+    const otp = Math.floor(100000 + Math.random() * 900000).toString();
+    const hashedOtp = await bcrypt.hash(otp, 10);
+    await Otp.create({ email, otp: hashedOtp });
+    await sendOtpEmail(email, otp);
+    return true;
+  },
+
+  verifyOtp: async ({ email, otp }: any) => {
+    const user = await User.findOne({ email });
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+    const existingOtp = await Otp.findOne({ email });
+    if (!existingOtp) {
+      const err: any = new Error("OTP match failed");
+      err.status = 400;
+      throw err;
+    }
+    const isMatched = await bcrypt.compare(otp, existingOtp.otp);
+    if (!isMatched) {
+      const err: any = new Error("OTP match failed");
+      err.status = 400;
+      throw err;
+    }
+    return user;
+  },
+
+  resetPassword: async (user: any, newPassword: any) => {
+    const hashedPassword = await bcrypt.hash(newPassword, 10);
+    user.password = hashedPassword;
+    await user.save();
+    return true;
+  },
+
+  updateProfile: async (userId: any, { name, phone, file }: any) => {
+    const user = await User.findById(userId);
+    if (!user) {
+      const err: any = new Error("User not found");
+      err.status = 404;
+      throw err;
+    }
+    if (name) user.name = name;
+    if (phone) user.phone = phone;
+    if (file) {
+      const uploadResult = await uploadSingleToCloudinary(file, { folder: "codelab/avatars" });
+      if (user.avatar && user.avatar.publicId) {
+        await deleteFromCloudinary(user.avatar.publicId).catch((err) =>
+          logger.error("Old avatar delete error", err)
+        );
+      }
+      user.avatar = { url: uploadResult.url, publicId: uploadResult.publicId };
+    }
+    await user.save();
+    return user;
+  },
+};

package/templates/mern-ts/server/src/types/express.d.ts

@@ -0,0 +1,10 @@
+import { Express } from "express";
+
+declare global {
+  namespace Express {
+    interface Request {
+      user?: any;
+      file?: any;
+    }
+  }
+}

package/templates/mern-ts/server/src/utils/cloudinaryUpload.ts

@@ -0,0 +1,44 @@
+import cloudinary from "../config/cloudinary.js";
+import logger from "./logger.js";
+
+const uploadToCloudinary = async (file: any, options: any = {}) => {
+  if (!file?.buffer) {
+    throw new Error("Invalid file.");
+  }
+  const dataURI = `data:${file.mimetype};base64,${file.buffer.toString("base64")}`;
+  const result = await cloudinary.uploader.upload(dataURI, {
+    folder: options.folder || "uploads",
+    ...options,
+  });
+  return {
+    url: result.secure_url,
+    publicId: result.public_id,
+  };
+};
+
+export const uploadSingleToCloudinary = async (file: any, options: any = {}) => {
+  try {
+    return await uploadToCloudinary(file, options);
+  } catch (error) {
+    logger.error("Cloudinary Upload Error", error);
+    throw new Error("Failed to upload image.");
+  }
+};
+
+export const uploadMultipleToCloudinary = async (files: any[] = [], options: any = {}) => {
+  try {
+    return await Promise.all(files.map((file) => uploadToCloudinary(file, options)));
+  } catch (error) {
+    logger.error("Cloudinary Upload Error", error);
+    throw new Error("Failed to upload images.");
+  }
+};
+
+export const deleteFromCloudinary = async (publicId: string) => {
+  try {
+    return await cloudinary.uploader.destroy(publicId);
+  } catch (error) {
+    logger.error("Cloudinary Delete Error", error);
+    throw new Error("Failed to delete image.");
+  }
+};

package/templates/mern-ts/server/src/utils/emailOtp.ts

@@ -0,0 +1,30 @@
+import sendEmail from "../config/email.js";
+
+const APP_NAME = process.env.APP_NAME || "My App";
+const APP_URL = process.env.APP_URL || "";
+const APP_PRIMARY_COLOR = process.env.APP_PRIMARY_COLOR || "#2563eb";
+
+export const emailOtp = (otp: string, expiry = 10) => ({
+  subject: `${APP_NAME} - Verification Code`,
+  html: `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>${APP_NAME}</title>
+</head>
+<body style="margin:0;padding:40px;background:#f3f4f6;font-family:Arial,sans-serif;">
+  <div style="background:#fff;border-radius:12px;padding:30px;max-width:500px;margin:auto;">
+    <h2>Verification Code</h2>
+    <p>Your code is valid for ${expiry} minutes:</p>
+    <div style="font-size:32px;font-weight:bold;color:${APP_PRIMARY_COLOR};text-align:center;margin:20px 0;">${otp}</div>
+  </div>
+</body>
+</html>
+`,
+});
+
+export const sendOtpEmail = async (to: string, otp: string, expiry = 10) => {
+  const template = emailOtp(otp, expiry);
+  await sendEmail(to, template.subject, template.html);
+};

package/templates/mern-ts/server/src/utils/genOtpToken.ts

@@ -0,0 +1,22 @@
+import jwt from "jsonwebtoken";
+import { Response } from "express";
+
+const genOtpToken = (user: any, res?: Response) => {
+  const JWT_SECRET = process.env.JWT_SECRET || "fallbacksecret";
+  const token = jwt.sign({ id: user._id || user.id }, JWT_SECRET, {
+    expiresIn: "10m",
+  });
+
+  if (res) {
+    res.cookie("token", token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "strict",
+      maxAge: 10 * 60 * 1000, // 10 minutes
+    });
+  }
+
+  return token;
+};
+
+export default genOtpToken;

package/templates/mern-ts/server/src/utils/generateVapidKeys.ts

@@ -0,0 +1,12 @@
+import webpush from "web-push";
+import logger from "./logger.js";
+
+const generateVapidKeys = () => {
+  const vapidKeys = webpush.generateVAPIDKeys();
+  logger.info("Generated VAPID Keys:");
+  logger.info(`Public Key: ${vapidKeys.publicKey}`);
+  logger.info(`Private Key: ${vapidKeys.privateKey}`);
+  return vapidKeys;
+};
+
+export default generateVapidKeys;

package/templates/mern-ts/server/src/utils/jwt.ts

@@ -0,0 +1,27 @@
+import jwt from "jsonwebtoken";
+import { Response } from "express";
+
+export const generateToken = (user: any, res?: Response) => {
+  const payload = { id: user._id || user.id };
+  const JWT_SECRET = process.env.JWT_SECRET || "fallbacksecret";
+  const token = jwt.sign(payload, JWT_SECRET, { expiresIn: "30d" });
+  
+  if (res) {
+    res.cookie("token", token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "strict",
+      maxAge: 30 * 24 * 60 * 60 * 1000, // 30 days
+    });
+  }
+  return token;
+};
+
+export const verifyToken = (token: string) => {
+  try {
+    const JWT_SECRET = process.env.JWT_SECRET || "fallbacksecret";
+    return jwt.verify(token, JWT_SECRET);
+  } catch (error) {
+    return null;
+  }
+};

package/templates/mern-ts/server/src/utils/logger.ts

@@ -0,0 +1,27 @@
+const colors = {
+  reset: "\x1b[0m",
+  info: "\x1b[36m", // Cyan
+  success: "\x1b[32m", // Green
+  warn: "\x1b[33m", // Yellow
+  error: "\x1b[31m", // Red
+  timestamp: "\x1b[90m", // Gray
+};
+
+type LogLevel = "info" | "success" | "warn" | "error";
+
+const formatMessage = (level: LogLevel, message: string) => {
+  const timestamp = new Date().toISOString();
+  return `${colors.timestamp}[${timestamp}]${colors.reset} ${colors[level] || colors.reset}[${level.toUpperCase()}]${colors.reset} ${message}`;
+};
+
+export const logger = {
+  info: (msg: string) => console.log(formatMessage("info", msg)),
+  success: (msg: string) => console.log(formatMessage("success", msg)),
+  warn: (msg: string) => console.warn(formatMessage("warn", msg)),
+  error: (msg: string, err?: any) => {
+    console.error(formatMessage("error", msg));
+    if (err) console.error(err);
+  },
+};
+
+export default logger;

package/templates/mern-ts/server/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/templates/next/_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/next/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "next-template",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "react": "^18",
+    "react-dom": "^18",
+    "next": "14.0.3"
+  },
+  "devDependencies": {
+    "eslint": "^8",
+    "eslint-config-next": "14.0.3"
+  }
+}

package/templates/next/src/app/layout.js

@@ -0,0 +1,7 @@
+export default function RootLayout({ children }) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  )
+}