@imksh/create 1.0.28 → 1.0.31

package/templates/layers/node/typescript/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "/Users/karan/workspace/Projects/boilerplate/test-app-node-ts",
+  "name": "node-ts-template",
   "version": "1.0.0",
   "main": "src/index.ts",
   "type": "module",
@@ -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/layers/node/typescript/src/controllers/push.controller.ts

@@ -7,26 +7,47 @@ export const subscribe = async (req: Request, res: Response, next: NextFunction)
     const subscription = req.body;
     const userId = req.user?._id || req.user?.id; // supports both mongoose and prisma IDs
     
-    if (!subscription || !subscription.endpoint) {
+    if (!subscription) {
       return next({ status: 400, message: "Invalid subscription payload" });
     }
 
-    const existingSub = await PushSubscription.findOne({ endpoint: subscription.endpoint });
+    const isExpo = !!subscription.token;
+    const isWeb = !!(subscription.endpoint && subscription.keys);
 
-    if (existingSub) {
-      if (userId) {
-        existingSub.user = userId; await existingSub.save();
-      }
-      return res.status(200).json({ success: true, message: "Already subscribed." });
+    if (!isExpo && !isWeb) {
+      return next({ status: 400, message: "Missing token (EXPO) or endpoint/keys (WEB)" });
     }
 
-    
-    await PushSubscription.create({
-      endpoint: subscription.endpoint,
-      keys: subscription.keys,
-      user: userId || undefined
-    });
-    
+    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) {

package/templates/layers/node/typescript/src/models/pushSubscription.model.ts

@@ -2,6 +2,7 @@ import mongoose, { Document } from "mongoose";
 
 // Handles both Web Push (endpoint + keys) and Expo Push (expoPushToken)
 export interface IPushSubscription extends Document {
+  type: "WEB" | "EXPO";
   endpoint?: string;
   keys?: {
     p256dh: string;
@@ -17,6 +18,11 @@ 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,

package/templates/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);

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

@@ -1,20 +1,74 @@
 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";
 
-export const sendPushToUser = async (userId: string, title: string, body: string, url: string = "/") => {
+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 payload = JSON.stringify({ title, body, url });
-    const subs = await PushSubscription.find({ user: userId });
-       for (const sub of subs) {
-         await webpush.sendNotification({ endpoint: sub.endpoint, keys: sub.keys }, payload).catch(err => {
-           if (err.statusCode === 404 || err.statusCode === 410) {
-             sub.deleteOne();
-           } else {
-             logger.error("Push Error", err);
-           }
-         });
-       }
+    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/layers/node-prisma/javascript/package.json

@@ -11,7 +11,7 @@
     "generate:vapid": "node ./src/utils/generateVapidKeys.js"
   },
   "dependencies": {
-    "@prisma/client": "^5.6.0",
+    "@prisma/client": "^7.0.0",
     "bcrypt": "^5.1.1",
     "compression": "^1.7.4",
     "cookie-parser": "^1.4.6",
@@ -26,10 +26,13 @@
     "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",
-    "prisma": "^5.6.0"
+    "prisma": "^7.0.0"
   }
 }

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

@@ -4,7 +4,6 @@ generator client {
 
 datasource db {
   provider = "postgresql"
-  url      = env("DATABASE_URL")
 }
 
 model User {
@@ -29,13 +28,25 @@ model Otp {
 }
 
 model PushSubscription {
-  id        String   @id @default(uuid())
-  endpoint  String   @unique
-  p256dh    String
-  auth      String
-  role      String   @default("user")
+  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
+  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/{db.js → prisma.js}

@@ -1,7 +1,15 @@
 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";
 
-export const prisma = new PrismaClient();
+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 {

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

@@ -1,34 +1,73 @@
 import { prisma } from "../config/db.js";
 import logger from "../utils/logger.js";
 
-export const subscribe = async (req, res, next) => {
+export const subscribe = async (
+  req,
+  res,
+  next,
+) => {
   try {
     const subscription = req.body;
-    const userId = req.user?._id || req.user?.id; // supports both mongoose and prisma IDs
-    
-    if (!subscription || !subscription.endpoint) {
+    const userId = req.user?._id || req.user?.id;
+
+    if (!subscription) {
       return next({ status: 400, message: "Invalid subscription payload" });
     }
 
-    const existingSub = await prisma.pushSubscription.findUnique({ where: { endpoint: subscription.endpoint } });
+    // Determine type: EXPO if token is present, else WEB
+    const isExpo = !!subscription.token;
+    const isWeb = !!(subscription.endpoint && subscription.keys);
 
-    if (existingSub) {
-      if (userId) {
-        await prisma.pushSubscription.update({ where: { endpoint: subscription.endpoint }, data: { userId } })
-      }
-      return res.status(200).json({ success: true, message: "Already subscribed." });
+    if (!isExpo && !isWeb) {
+      return next({ status: 400, message: "Missing token (EXPO) or endpoint/keys (WEB)" });
     }
 
-    
-    await prisma.pushSubscription.create({
-      data: {
-        endpoint: subscription.endpoint,
-        p256dh: subscription.keys.p256dh,
-        auth: subscription.keys.auth,
-        userId: userId || null
+    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) {

package/templates/layers/node-prisma/javascript/src/utils/pushHelper.js

@@ -1,21 +1,69 @@
 import webpush from "../config/webPush.js";
+import { Expo } from "expo-server-sdk";
 import logger from "./logger.js";
-import { prisma } from "../config/db.js";
+import { prisma } from "../config/prisma.js";
 
-export const sendPushToUser = async (userId, title, body, url = "/") => {
+const expo = new Expo();
+
+export const sendPushToUser = async (
+  userId,
+  title,
+  body,
+  url = "/",
+) => {
   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);
-           }
-         });
-       }
+    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);
   }