@imksh/create 1.0.27 → 1.0.30

package/templates/{mern-react-native/server → layers/node-prisma/typescript}/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "/Users/karan/workspace/Projects/boilerplate/test-app-node-ts",
+  "name": "node-prisma-ts-template",
   "version": "1.0.0",
   "main": "src/index.ts",
   "type": "module",
@@ -7,26 +7,30 @@
     "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": "^7.0.0",
     "bcrypt": "^5.1.1",
-    "cloudinary": "^2.0.0",
     "compression": "^1.7.4",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",
     "dotenv": "^16.3.1",
-    "expo-server-sdk": "^6.1.0",
     "express": "^4.18.2",
     "express-rate-limit": "^7.1.4",
     "helmet": "^7.1.0",
     "jsonwebtoken": "^9.0.2",
-    "mongoose": "^8.0.0",
     "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"
+    "web-push": "^3.6.6",
+    "pg": "^8.11.3",
+    "@prisma/adapter-pg": "^7.0.0",
+    "expo-server-sdk": "^3.10.0"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",
@@ -37,12 +41,12 @@
     "@types/jsonwebtoken": "^9.0.5",
     "@types/morgan": "^1.9.9",
     "@types/multer": "^1.4.11",
-    "@types/node": "^20.9.0",
     "@types/nodemailer": "^6.4.14",
     "@types/web-push": "^3.6.3",
-    "nodemon": "^3.0.1",
-    "ts-node": "^10.9.1",
+    "@types/node": "^20.9.0",
+    "prisma": "^7.0.0",
     "tsx": "^4.23.1",
-    "typescript": "^5.2.2"
+    "typescript": "^5.2.2",
+    "@types/pg": "^8.11.0"
   }
 }

package/templates/layers/node-prisma/typescript/prisma/schema.prisma

@@ -0,0 +1,52 @@
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+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())
+  type      PushSubscriptionType @default(WEB)
+
+  // For Web Push
+  endpoint  String?              @unique
+  keys      Json?
+
+  // For Expo
+  token     String?              @unique
+
+  userId    String?
+  user      User?                @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  createdAt DateTime             @default(now())
+  updatedAt DateTime             @updatedAt
+  deletedAt DateTime?
+}
+
+enum PushSubscriptionType {
+  WEB
+  EXPO
+}

package/templates/layers/node-prisma/typescript/prisma.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from '@prisma/config'
+import 'dotenv/config'
+
+export default defineConfig({
+  schema: 'prisma/schema.prisma',
+  migrations: {
+    path: 'prisma/migrations',
+  },
+  datasource: {
+    url: process.env.DATABASE_URL,
+  },
+})

package/templates/layers/node-prisma/typescript/src/config/prisma.ts

@@ -0,0 +1,24 @@
+import { PrismaClient } from "@prisma/client";
+import { Pool } from "pg";
+import { PrismaPg } from "@prisma/adapter-pg";
+import dotenv from "dotenv";
+import logger from "../utils/logger.js";
+
+dotenv.config();
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+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: any) {
+    logger.error(`Prisma Database connection failed: ${error.message}`, error);
+    process.exit(1);
+  }
+};
+
+export default connectDB;

package/templates/layers/node-prisma/typescript/src/controllers/push.controller.ts

@@ -0,0 +1,100 @@
+import { Request, Response, NextFunction } from "express";
+import { prisma } from "../config/prisma.js";
+import logger from "../utils/logger.js";
+
+export const subscribe = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  try {
+    const subscription = req.body;
+    const userId = req.user?._id || req.user?.id;
+
+    if (!subscription) {
+      return next({ status: 400, message: "Invalid subscription payload" });
+    }
+
+    // Determine type: EXPO if token is present, else WEB
+    const isExpo = !!subscription.token;
+    const isWeb = !!(subscription.endpoint && subscription.keys);
+
+    if (!isExpo && !isWeb) {
+      return next({ status: 400, message: "Missing token (EXPO) or endpoint/keys (WEB)" });
+    }
+
+    if (isExpo) {
+      const existingSub = await prisma.pushSubscription.findUnique({
+        where: { token: subscription.token },
+      });
+
+      if (existingSub) {
+        if (userId && existingSub.userId !== userId) {
+          await prisma.pushSubscription.update({
+            where: { token: subscription.token },
+            data: { userId },
+          });
+        }
+        return res.status(200).json({ success: true, message: "Already subscribed." });
+      }
+
+      await prisma.pushSubscription.create({
+        data: {
+          type: "EXPO",
+          token: subscription.token,
+          userId: userId || null,
+        },
+      });
+    } else {
+      const existingSub = await prisma.pushSubscription.findUnique({
+        where: { endpoint: subscription.endpoint },
+      });
+
+      if (existingSub) {
+        if (userId && existingSub.userId !== userId) {
+          await prisma.pushSubscription.update({
+            where: { endpoint: subscription.endpoint },
+            data: { userId },
+          });
+        }
+        return res.status(200).json({ success: true, message: "Already subscribed." });
+      }
+
+      await prisma.pushSubscription.create({
+        data: {
+          type: "WEB",
+          endpoint: subscription.endpoint,
+          keys: subscription.keys,
+          userId: userId || null,
+        },
+      });
+    }
+
+    res.status(201).json({ success: true, message: "Subscription created." });
+  } catch (error) {
+    logger.error("Error in push subscribe controller", error);
+    next(error);
+  }
+};
+
+export const unsubscribe = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  try {
+    const { endpoint } = req.body;
+    if (!endpoint) {
+      return next({ status: 400, message: "Endpoint required" });
+    }
+
+    await prisma.pushSubscription
+      .delete({ where: { endpoint } })
+      .catch(() => {});
+
+    res.status(200).json({ success: true, message: "Unsubscribed." });
+  } catch (error) {
+    logger.error("Error in push unsubscribe controller", error);
+    next(error);
+  }
+};

package/templates/{node-ts → layers/node-prisma/typescript}/src/index.ts

@@ -1,7 +1,7 @@
 import dotenv from "dotenv";
 import http from "http";
 import app from "./app.js";
-import connectDB from "./config/db.js";
+import connectDB from "./config/prisma.js";
 import logger from "./utils/logger.js";
 
 dotenv.config();

package/templates/{node/src/middleware/auth.middleware.js → layers/node-prisma/typescript/src/middleware/auth.middleware.ts}

@@ -1,10 +1,15 @@
-import jwt from "jsonwebtoken";
-import User from "../models/user.model.js";
+import { Request, Response, NextFunction } from "express";
 import { verifyToken } from "../utils/jwt.js";
 import logger from "../utils/logger.js";
+import { prisma } from "../config/prisma.js";
+
+export const protect = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  let token: string | undefined;
 
-export const protect = async (req, res, next) => {
-  let token;
   if (req.cookies?.token) {
     token = req.cookies.token;
   } else if (
@@ -21,20 +26,27 @@ export const protect = async (req, res, next) => {
   }
 
   try {
-    const decoded = verifyToken(token);
+    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) {
+    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) {
+  } catch (error: any) {
     logger.error("Auth middleware error", error);
     return res
       .status(401)

package/templates/layers/node-prisma/typescript/src/services/auth.service.ts

@@ -0,0 +1,161 @@
+import bcrypt from "bcrypt";
+import { prisma } from "../config/prisma.js";
+import { sendOtpEmail } from "../utils/emailOtp.js";
+import {
+  uploadSingleToCloudinary,
+  deleteFromCloudinary,
+} from "../utils/cloudinaryUpload.js";
+import logger from "../utils/logger.js";
+export const signup = async ({ name, email, phone, password }: any) => {
+  const existingUser = await prisma.user.findUnique({
+    where: { 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 prisma.user.create({
+    data: {
+      name,
+      email: email.toLowerCase(),
+      phone,
+      password: hashedPassword,
+      avatarUrl: photoURL,
+      avatarPublicId: "",
+    },
+  });
+
+  return newUser;
+};
+export const login = async ({ email, password }: any) => {
+  const user = await prisma.user.findUnique({
+    where: { 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;
+};
+export const generateOtp = async (email: string) => {
+  const user = await prisma.user.findUnique({
+    where: { email },
+  });
+  if (!user) {
+    const err: any = new Error("User not found");
+    err.status = 404;
+    throw err;
+  }
+
+  const existingOtp = await prisma.otp.findUnique({
+    where: { email },
+  });
+  if (existingOtp) {
+    await prisma.otp.delete({
+      where: { email },
+    });
+  }
+
+  const otp = Math.floor(100000 + Math.random() * 900000).toString();
+  const hashedOtp = await bcrypt.hash(otp, 10);
+
+  await prisma.otp.create({
+    data: {
+      email,
+      otp: hashedOtp,
+    },
+  });
+
+  await sendOtpEmail(email, otp);
+  return true;
+};
+export const verifyOtp = async ({ email, otp }: any) => {
+  const user = await prisma.user.findUnique({
+    where: { email },
+  });
+  if (!user) {
+    const err: any = new Error("User not found");
+    err.status = 404;
+    throw err;
+  }
+
+  const existingOtp = await prisma.otp.findUnique({
+    where: { 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;
+};
+export const resetPassword = async (user: any, newPassword: any) => {
+  const hashedPassword = await bcrypt.hash(newPassword, 10);
+  await prisma.user.update({
+    where: { id: user.id },
+    data: { password: hashedPassword },
+  });
+  return true;
+};
+export const updateProfile = async (
+  userId: any,
+  { name, phone, file }: any,
+) => {
+  const user = await prisma.user.findUnique({
+    where: { id: userId },
+  });
+  if (!user) {
+    const err: any = new Error("User not found");
+    err.status = 404;
+    throw err;
+  }
+
+  const updateData: any = {};
+  if (name) updateData.name = name;
+  if (phone) updateData.phone = phone;
+
+  if (file) {
+    const uploadResult = await uploadSingleToCloudinary(file, {
+      folder: "codelab/avatars",
+    });
+
+    if (user.avatarPublicId) {
+      await deleteFromCloudinary(user.avatarPublicId).catch((err) =>
+        logger.error("Old avatar delete error", err),
+      );
+    }
+
+    updateData.avatarUrl = uploadResult.url;
+    updateData.avatarPublicId = uploadResult.publicId;
+  }
+
+  const updatedUser = await prisma.user.update({
+    where: { id: userId },
+    data: updateData,
+  });
+
+  return updatedUser;
+};

package/templates/layers/node-prisma/typescript/src/utils/pushHelper.ts

@@ -0,0 +1,77 @@
+import webpush from "../config/webPush.js";
+import { Expo, ExpoPushMessage, ExpoPushTicket } from "expo-server-sdk";
+import logger from "./logger.js";
+import { prisma } from "../config/prisma.js";
+
+const expo = new Expo();
+
+export interface PushMessagePayload {
+  title: string;
+  body: string;
+  data?: Record<string, unknown>;
+  url?: string;
+}
+
+export const sendPushToUser = async (
+  userId: string,
+  title: string,
+  body: string,
+  url: string = "/",
+) => {
+  try {
+    const subscriptions = await prisma.pushSubscription.findMany({
+      where: { userId },
+    });
+
+    if (subscriptions.length === 0) return;
+
+    const webSubs = subscriptions.filter(s => s.type === "WEB");
+    const expoSubs = subscriptions.filter(s => s.type === "EXPO");
+
+    // Web Push
+    if (webSubs.length > 0) {
+      const payload = JSON.stringify({ title, body, url });
+      await Promise.allSettled(
+        webSubs.map(async (sub) => {
+          if (!sub.endpoint || !sub.keys) return;
+          const pushSub = { endpoint: sub.endpoint, keys: sub.keys as any };
+          try {
+            await webpush.sendNotification(pushSub, payload);
+          } catch (err: any) {
+            if (err.statusCode === 404 || err.statusCode === 410) {
+              await prisma.pushSubscription.delete({ where: { id: sub.id } }).catch(() => {});
+            } else {
+              logger.error("Web Push Error", err);
+            }
+          }
+        })
+      );
+    }
+
+    // Expo Push
+    if (expoSubs.length > 0) {
+      const messages: ExpoPushMessage[] = [];
+      for (const sub of expoSubs) {
+        if (!sub.token || !Expo.isExpoPushToken(sub.token)) continue;
+        messages.push({
+          to: sub.token,
+          sound: "default",
+          title,
+          body,
+          data: { url },
+        });
+      }
+
+      const chunks = expo.chunkPushNotifications(messages);
+      for (const chunk of chunks) {
+        try {
+          await expo.sendPushNotificationsAsync(chunk);
+        } catch (error) {
+          logger.error("Error sending push notification chunk", error);
+        }
+      }
+    }
+  } catch (error) {
+    logger.error("Error sending push notification to user", error);
+  }
+};

package/templates/layers/prisma/javascript/README.md

@@ -0,0 +1,71 @@
+# Node.js Prisma Backend Boilerplate
+
+A production-ready Node.js & Express boilerplate project with best-practice architectures, modular routing, and Prisma ORM integration.
+
+## Features
+
+- ⚙️ **Modular Architecture:** Express application setup decoupled into `app.js` (middleware + router wiring) and `index.js` (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.
+
+## Getting Started
+
+### 1. Configure Environment Variables
+
+Create a `.env` file in the root directory (based on `.env.example`):
+
+```env
+PORT=5001
+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
+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 & 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
+npm run dev
+```
+
+## 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 → layers/prisma/javascript}/src/controllers/auth.controller.js

@@ -15,12 +15,10 @@ export const signup = async (req, res, next) => {
 
     const newUser = await authService.signup({ name, email, phone, password });
     const token = await generateToken(newUser, res);
-    const safeUser = newUser.toObject();
+    const safeUser = { ...newUser };
     delete safeUser.password;
 
-    res
-      .status(201)
-      .json({ message: "Registration Successful", data: safeUser, token });
+    res.status(201).json({ message: "Registration Successful", data: safeUser, token });
   } catch (error) {
     logger.error("Error in signup controller", error);
     next(error);
@@ -39,12 +37,10 @@ export const login = async (req, res, next) => {
 
     const user = await authService.login({ email, password });
     const token = await generateToken(user, res);
-    const safeUser = user.toObject();
+    const safeUser = { ...user };
     delete safeUser.password;
 
-    res
-      .status(200)
-      .json({ message: "Login successfully", data: safeUser, token });
+    res.status(200).json({ message: "Login successfully", data: safeUser, token });
   } catch (error) {
     logger.error("Error in login controller", error);
     next(error);
@@ -59,7 +55,6 @@ export const logout = async (_req, res, next) => {
       sameSite: "strict",
       path: "/",
     });
-
     res.status(200).json({ message: "Logout Successfully" });
   } catch (error) {
     logger.error("Error in logout controller", error);
@@ -69,9 +64,7 @@ export const logout = async (_req, res, next) => {
 
 export const getMe = async (req, res, next) => {
   try {
-    const safeUser = req.user.toObject();
-    delete safeUser.password;
-    res.status(200).json({ message: "User Authenticated", data: safeUser });
+    res.status(200).json({ message: "User Authenticated", data: req.user });
   } catch (error) {
     logger.error("Error in getMe controller", error);
     next(error);
@@ -138,12 +131,12 @@ export const resetPassword = async (req, res, next) => {
 export const updateMe = async (req, res, next) => {
   try {
     const { name, phone } = req.body;
-    const user = await authService.updateProfile(req.user._id, {
+    const user = await authService.updateProfile(req.user.id, {
       name,
       phone,
       file: req.file,
     });
-    const safeUser = user.toObject();
+    const safeUser = { ...user };
     delete safeUser.password;
     res.status(200).json({ success: true, data: safeUser });
   } catch (error) {