@imksh/create 1.0.27 → 1.0.30

package/templates/{mern-ts/server → layers/node/typescript}/package.json

@@ -25,7 +25,8 @@
     "multer": "^1.4.5-lts.1",
     "nodemailer": "^6.9.7",
     "socket.io": "^4.7.2",
-    "web-push": "^3.6.6"
+    "web-push": "^3.6.6",
+    "expo-server-sdk": "^3.10.0"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",

package/templates/{mern-ts/server → layers/node/typescript}/src/controllers/auth.controller.ts

@@ -138,3 +138,17 @@ export const updateMe = async (req: Request, res: Response, next: NextFunction)
     next(error);
   }
 };
+
+export const savePushToken = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { token } = req.body;
+    if (!token) {
+      return next({ status: 400, message: "Token is required." });
+    }
+    await authService.savePushToken(req.user._id, token);
+    res.status(200).json({ success: true, message: "Push token saved successfully" });
+  } catch (error) {
+    logger.error("Error saving push token", error);
+    next(error);
+  }
+};

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

@@ -0,0 +1,73 @@
+import { Request, Response, NextFunction } from "express";
+import PushSubscription from "../models/pushSubscription.model.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; // supports both mongoose and prisma IDs
+    
+    if (!subscription) {
+      return next({ status: 400, message: "Invalid subscription payload" });
+    }
+
+    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 PushSubscription.findOne({ expoPushToken: subscription.token });
+      if (existingSub) {
+        if (userId && String(existingSub.user) !== String(userId)) {
+          existingSub.user = userId; await existingSub.save();
+        }
+        return res.status(200).json({ success: true, message: "Already subscribed." });
+      }
+
+      await PushSubscription.create({
+        type: "EXPO",
+        expoPushToken: subscription.token,
+        user: userId || undefined
+      });
+    } else {
+      const existingSub = await PushSubscription.findOne({ endpoint: subscription.endpoint });
+      if (existingSub) {
+        if (userId && String(existingSub.user) !== String(userId)) {
+          existingSub.user = userId; await existingSub.save();
+        }
+        return res.status(200).json({ success: true, message: "Already subscribed." });
+      }
+
+      await PushSubscription.create({
+        type: "WEB",
+        endpoint: subscription.endpoint,
+        keys: subscription.keys,
+        user: userId || undefined
+      });
+    }
+
+    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 PushSubscription.deleteOne({ endpoint });
+
+    res.status(200).json({ success: true, message: "Unsubscribed." });
+  } catch (error) {
+    logger.error("Error in push unsubscribe controller", error);
+    next(error);
+  }
+};

package/templates/{mern-ts/server → layers/node/typescript}/src/models/pushSubscription.model.ts

@@ -1,11 +1,14 @@
 import mongoose, { Document } from "mongoose";
 
+// Handles both Web Push (endpoint + keys) and Expo Push (expoPushToken)
 export interface IPushSubscription extends Document {
-  endpoint: string;
-  keys: {
+  type: "WEB" | "EXPO";
+  endpoint?: string;
+  keys?: {
     p256dh: string;
     auth: string;
   };
+  expoPushToken?: string;
   user?: mongoose.Types.ObjectId;
   role: "admin" | "user";
   expiresAt: Date;
@@ -15,15 +18,27 @@ export interface IPushSubscription extends Document {
 
 const pushSubscriptionSchema = new mongoose.Schema<IPushSubscription>(
   {
+    type: {
+      type: String,
+      enum: ["WEB", "EXPO"],
+      default: "WEB",
+    },
+    // Web Push fields
     endpoint: {
       type: String,
-      required: true,
-      unique: true,
+      sparse: true,
     },
     keys: {
-      p256dh: { type: String, required: true },
-      auth: { type: String, required: true },
+      p256dh: { type: String },
+      auth: { type: String },
+    },
+
+    // Expo Push field
+    expoPushToken: {
+      type: String,
+      sparse: true,
     },
+
     user: {
       type: mongoose.Schema.Types.ObjectId,
       ref: "User",

package/templates/{mern-react-native/server → layers/node/typescript}/src/models/user.model.ts

@@ -10,7 +10,7 @@ export interface IUser extends Document {
   };
   password?: string;
   role: "user" | "admin" | "other";
-  expoPushTokens: [string];
+  expoPushTokens: string[];
   createdAt: Date;
   updatedAt: Date;
 }

package/templates/{mern-ts/server → layers/node/typescript}/src/routes/auth.route.ts

@@ -6,6 +6,7 @@ import {
   logout,
   updateMe,
   genSignupOtp,
+  savePushToken,
 } from "../controllers/auth.controller.js";
 import { protect } from "../middleware/auth.middleware.js";
 import { apiLimiter } from "../middleware/rateLimiter.js";
@@ -20,5 +21,6 @@ router.post("/login", login);
 router.post("/logout", logout);
 router.get("/me", protect, getMe);
 router.put("/me", protect, updateMe);
+router.post("/push-token", protect, savePushToken);
 
 export default router;

package/templates/{mern-ts/server → layers/node/typescript}/src/services/auth.service.ts

@@ -46,9 +46,9 @@ export const signup = async ({ name, email, phone, password, otp }: any) => {
 };
 export const login = async ({ email, password }: any) => {
   const user = await User.findOne({ email });
-  if (!user) {
-    const err: any = new Error("User not found");
-    err.status = 404;
+  if (!user || !user.password) {
+    const err: any = new Error("Invalid Credentials");
+    err.status = 401;
     throw err;
   }
   const isValid = await bcrypt.compare(password, user.password);
@@ -146,3 +146,20 @@ export const updateProfile = async (
   await user.save();
   return user;
 };
+
+/**
+ * Save Expo Push Token
+ */
+export const savePushToken = async (userId: string, token: string) => {
+  const user = await User.findById(userId);
+  if (!user) {
+    const err: any = new Error("User not found");
+    err.status = 404;
+    throw err;
+  }
+  if (!user.expoPushTokens.includes(token)) {
+    user.expoPushTokens.push(token);
+    await user.save();
+  }
+  return user;
+};

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

@@ -0,0 +1,75 @@
+import webpush from "../config/webPush.js";
+import { Expo, ExpoPushMessage, ExpoPushTicket } from "expo-server-sdk";
+import logger from "./logger.js";
+import PushSubscription from "../models/pushSubscription.model.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 PushSubscription.find({ user: 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 sub.deleteOne();
+            } else {
+              logger.error("Web Push Error", err);
+            }
+          }
+        })
+      );
+    }
+
+    // Expo Push
+    if (expoSubs.length > 0) {
+      const messages: ExpoPushMessage[] = [];
+      for (const sub of expoSubs) {
+        if (!sub.expoPushToken || !Expo.isExpoPushToken(sub.expoPushToken)) continue;
+        messages.push({
+          to: sub.expoPushToken,
+          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/{mern/server → layers/node-prisma/javascript}/package.json

@@ -1,14 +1,17 @@
 {
-  "name": "node-template",
+  "name": "node-prisma-template",
   "version": "1.0.0",
   "main": "src/index.js",
   "type": "module",
   "scripts": {
     "start": "node src/index.js",
     "dev": "nodemon src/index.js",
+    "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",
     "compression": "^1.7.4",
     "cookie-parser": "^1.4.6",
@@ -20,13 +23,16 @@
     "jsonwebtoken": "^9.0.2",
     "morgan": "^1.10.0",
     "multer": "^1.4.5-lts.1",
-    "mongoose": "^8.0.0",
     "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": {
-    "nodemon": "^3.0.1"
+    "nodemon": "^3.0.1",
+    "prisma": "^7.0.0"
   }
 }

package/templates/layers/node-prisma/javascript/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/javascript/prisma.config.js

@@ -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/javascript/src/config/prisma.js

@@ -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) {
+    logger.error("Prisma Database connection failed", error);
+    process.exit(1);
+  }
+};
+
+export default connectDB;

package/templates/layers/node-prisma/javascript/src/controllers/push.controller.js

@@ -0,0 +1,93 @@
+import { prisma } from "../config/db.js";
+import logger from "../utils/logger.js";
+
+export const subscribe = async (
+  req,
+  res,
+  next,
+) => {
+  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, res, next) => {
+  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/layers/node-prisma/javascript/src/utils/pushHelper.js

@@ -0,0 +1,70 @@
+import webpush from "../config/webPush.js";
+import { Expo } from "expo-server-sdk";
+import logger from "./logger.js";
+import { prisma } from "../config/prisma.js";
+
+const expo = new Expo();
+
+export const sendPushToUser = async (
+  userId,
+  title,
+  body,
+  url = "/",
+) => {
+  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 };
+          try {
+            await webpush.sendNotification(pushSub, payload);
+          } catch (err) {
+            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 = [];
+      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);
+  }
+};