@imksh/create 1.0.24 → 1.0.26

package/templates/production-fullstack/server/src/common/middlewares/auth.middleware.ts

@@ -0,0 +1,45 @@
+import { Request, Response, NextFunction } from "express";
+import { verifyToken } from "../utils/jwt.js";
+import logger from "../../config/logger.js";
+import { prisma } from "../../config/prisma.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/production-fullstack/server/src/common/middlewares/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/production-fullstack/server/src/common/middlewares/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/production-fullstack/server/src/common/middlewares/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/production-fullstack/server/src/common/services/email.service.ts

@@ -0,0 +1,28 @@
+import nodemailer from "nodemailer";
+import logger from "../../config/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/production-fullstack/server/src/common/services/push.service.ts

@@ -0,0 +1,65 @@
+import webpush from "web-push";
+import { Expo, ExpoPushMessage } from "expo-server-sdk";
+import prisma from "../../config/prisma.js";
+import logger from "../../config/logger.js";
+
+// Initialize 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;
+
+// Initialize Expo Push
+const expo = new Expo();
+
+export const sendPushNotification = async (
+  userId: string,
+  title: string,
+  body: string,
+  data?: Record<string, unknown>
+) => {
+  try {
+    // 1. Fetch all Expo push tokens for the user
+    const subscriptions = await prisma.pushSubscription.findMany({
+      where: {
+        userId,
+        type: "EXPO",
+        token: { not: null },
+      },
+    });
+
+    if (subscriptions.length === 0) return;
+
+    // 2. Create the messages
+    const messages: ExpoPushMessage[] = [];
+    for (const sub of subscriptions) {
+      if (!sub.token || !Expo.isExpoPushToken(sub.token)) {
+        logger.error(`Push token ${sub.token} is not a valid Expo push token`);
+        continue;
+      }
+
+      messages.push({
+        to: sub.token,
+        sound: "default",
+        title,
+        body,
+        data,
+      });
+    }
+
+    // 3. Send the messages
+    const chunks = expo.chunkPushNotifications(messages);
+    for (const chunk of chunks) {
+      try {
+        await expo.sendPushNotificationsAsync(chunk);
+      } catch (error) {
+        logger.error("Error sending chunk of push notifications:", error);
+      }
+    }
+  } catch (error) {
+    logger.error("Failed to send push notification:", error);
+  }
+};

package/templates/production-fullstack/server/src/common/services/storage.service.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/production-fullstack/server/src/common/types/express.d.ts

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

package/templates/production-fullstack/server/src/common/utils/cloudinaryUpload.ts

@@ -0,0 +1,44 @@
+import cloudinary from "../services/storage.service.js";
+import logger from "../../config/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/production-fullstack/server/src/common/utils/emailOtp.ts

@@ -0,0 +1,30 @@
+import sendEmail from "../services/email.service.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/production-fullstack/server/src/common/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/production-fullstack/server/src/common/utils/generateVapidKeys.ts

@@ -0,0 +1,12 @@
+import webpush from "web-push";
+import logger from "../../config/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/production-fullstack/server/src/common/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/production-fullstack/server/src/common/utils/pushHelper.ts

@@ -0,0 +1,22 @@
+import webpush from "../services/push.service.js";
+import logger from "../../config/logger.js";
+import { prisma } from "../../config/prisma.js";
+
+export const sendPushToUser = async (userId: string, title: string, body: string, url: string = "/") => {
+  try {
+    const payload = JSON.stringify({ title, body, url });
+    const subs = await prisma.pushSubscription.findMany({ where: { userId } });
+       for (const sub of subs) {
+         const pushSub = { endpoint: sub.endpoint, keys: { p256dh: sub.p256dh, auth: sub.auth } };
+         await webpush.sendNotification(pushSub, payload).catch(err => {
+           if (err.statusCode === 404 || err.statusCode === 410) {
+             prisma.pushSubscription.delete({ where: { id: sub.id } }).catch(()=>{});
+           } else {
+             logger.error("Push Error", err);
+           }
+         });
+       }
+  } catch (error) {
+    logger.error("Error sending push notification to user", error);
+  }
+};

package/templates/production-fullstack/server/src/config/env.ts

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

package/templates/production-fullstack/server/src/config/logger.ts

@@ -0,0 +1,58 @@
+const colors = {
+  reset: "\x1b[0m",
+  info: "\x1b[36m",
+  success: "\x1b[32m",
+  warn: "\x1b[33m",
+  error: "\x1b[31m",
+  timestamp: "\x1b[90m",
+};
+
+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]
+  }[${level.toUpperCase()}]${colors.reset} ${message}`;
+};
+
+const print = (
+  level: LogLevel,
+  message: string,
+  ...meta: unknown[]
+) => {
+  const formatted = formatMessage(level, message);
+
+  switch (level) {
+    case "warn":
+      // eslint-disable-next-line no-console
+      console.warn(formatted, ...meta);
+      break;
+
+    case "error":
+      // eslint-disable-next-line no-console
+      console.error(formatted, ...meta);
+      break;
+
+    default:
+      // eslint-disable-next-line no-console
+      console.log(formatted, ...meta);
+  }
+};
+
+export const logger = {
+  info: (message: string, ...meta: unknown[]) =>
+    print("info", message, ...meta),
+
+  success: (message: string, ...meta: unknown[]) =>
+    print("success", message, ...meta),
+
+  warn: (message: string, ...meta: unknown[]) =>
+    print("warn", message, ...meta),
+
+  error: (message: string, ...meta: unknown[]) =>
+    print("error", message, ...meta),
+};
+
+export default logger;

package/templates/production-fullstack/server/src/config/prisma.ts

@@ -0,0 +1,26 @@
+import { PrismaClient } from "@prisma/client";
+import { PrismaPg } from "@prisma/adapter-pg";
+import pg from "pg";
+import logger from "./logger.js";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+const connectionString = process.env.DATABASE_URL;
+const pool = new pg.Pool({ connectionString });
+const adapter = new PrismaPg(pool);
+
+export const prisma = new PrismaClient({ adapter });
+
+const connectDB = async () => {
+  try {
+    await prisma.$connect();
+    logger.success("Prisma Database connected successfully");
+  } catch (error: unknown) {
+    const err = error as Error;
+    logger.error(`Prisma Database connection failed: ${err.message}`, err);
+    process.exit(1);
+  }
+};
+
+export default connectDB;

package/templates/production-fullstack/server/src/features/attachments/upload.controller.ts

@@ -0,0 +1,22 @@
+import { Request, Response, NextFunction } from "express";
+import { uploadSingleToCloudinary } from "../../common/utils/cloudinaryUpload.js";
+import logger from "../../config/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/production-fullstack/server/src/features/attachments/upload.routes.ts

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

package/templates/production-fullstack/server/src/features/auth/auth.controller.ts

@@ -0,0 +1,124 @@
+import { Request, Response, NextFunction } from "express";
+import * as authService from "./auth.service.js";
+import { generateToken } from "../../common/utils/jwt.js";
+import genOtpToken from "../../common/utils/genOtpToken.js";
+import logger from "../../config/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);
+  }
+};