@imksh/create 1.0.28 → 1.0.30

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

@@ -12,7 +12,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",
@@ -27,7 +27,10 @@
     "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",
@@ -41,8 +44,9 @@
     "@types/nodemailer": "^6.4.14",
     "@types/web-push": "^3.6.3",
     "@types/node": "^20.9.0",
-    "prisma": "^5.6.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

@@ -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/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/{db.ts → prisma.ts}

@@ -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/typescript/src/controllers/push.controller.ts

@@ -1,35 +1,74 @@
 import { Request, Response, NextFunction } from "express";
-import { prisma } from "../config/db.js";
+import { prisma } from "../config/prisma.js";
 import logger from "../utils/logger.js";
 
-export const subscribe = async (req: Request, res: Response, next: NextFunction) => {
+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 || !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) {
@@ -38,14 +77,20 @@ export const subscribe = async (req: Request, res: Response, next: NextFunction)
   }
 };
 
-export const unsubscribe = async (req: Request, res: Response, next: NextFunction) => {
+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(() => {})
+    await prisma.pushSubscription
+      .delete({ where: { endpoint } })
+      .catch(() => {});
 
     res.status(200).json({ success: true, message: "Unsubscribed." });
   } catch (error) {

package/templates/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/layers/node-prisma/typescript/src/middleware/auth.middleware.ts

@@ -1,9 +1,13 @@
 import { Request, Response, NextFunction } from "express";
 import { verifyToken } from "../utils/jwt.js";
 import logger from "../utils/logger.js";
-import { prisma } from "../config/db.js";
+import { prisma } from "../config/prisma.js";
 
-export const protect = async (req: Request, res: Response, next: NextFunction) => {
+export const protect = async (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
   let token: string | undefined;
 
   if (req.cookies?.token) {
@@ -16,7 +20,9 @@ export const protect = async (req: Request, res: Response, next: NextFunction) =
   }
 
   if (!token) {
-    return res.status(401).json({ message: "Not authorized, no token provided" });
+    return res
+      .status(401)
+      .json({ message: "Not authorized, no token provided" });
   }
 
   try {
@@ -30,7 +36,9 @@ export const protect = async (req: Request, res: Response, next: NextFunction) =
     });
 
     if (!user) {
-      return res.status(401).json({ message: "Not authorized, user not found" });
+      return res
+        .status(401)
+        .json({ message: "Not authorized, user not found" });
     }
 
     const safeUser: any = { ...user };
@@ -40,6 +48,8 @@ export const protect = async (req: Request, res: Response, next: NextFunction) =
     return next();
   } catch (error: any) {
     logger.error("Auth middleware error", error);
-    return res.status(401).json({ message: "Not authorized, token verification failed" });
+    return res
+      .status(401)
+      .json({ message: "Not authorized, token verification failed" });
   }
 };

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

@@ -1,155 +1,161 @@
 import bcrypt from "bcrypt";
-import { prisma } from "../config/db.js";
+import { prisma } from "../config/prisma.js";
 import { sendOtpEmail } from "../utils/emailOtp.js";
-import { uploadSingleToCloudinary, deleteFromCloudinary } from "../utils/cloudinaryUpload.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;
+  const existingUser = await prisma.user.findUnique({
+    where: { email },
+  });
+  if (existingUser) {
+    const err: any = new Error("User already exists");
+    err.status = 409;
+    throw err;
   }
-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;
-    }
+  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;
+  }
 
-    return user;
+  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 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({
+  const existingOtp = await prisma.otp.findUnique({
+    where: { email },
+  });
+  if (existingOtp) {
+    await prisma.otp.delete({
       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);
+  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 prisma.otp.create({
+    data: {
+      email,
+      otp: hashedOtp,
+    },
+  });
 
-    await sendOtpEmail(email, otp);
-    return true;
-  }
+  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 user = await prisma.user.findUnique({
+    where: { email },
+  });
+  if (!user) {
+    const err: any = new Error("User not found");
+    err.status = 404;
+    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;
-    }
+  const existingOtp = await prisma.otp.findUnique({
+    where: { email },
+  });
+  if (!existingOtp) {
+    const err: any = new Error("OTP match failed");
+    err.status = 400;
+    throw err;
+  }
 
-    return user;
+  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;
+  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;
   }
-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",
-      });
+  const updateData: any = {};
+  if (name) updateData.name = name;
+  if (phone) updateData.phone = phone;
 
-      if (user.avatarPublicId) {
-        await deleteFromCloudinary(user.avatarPublicId).catch((err) =>
-          logger.error("Old avatar delete error", err)
-        );
-      }
+  if (file) {
+    const uploadResult = await uploadSingleToCloudinary(file, {
+      folder: "codelab/avatars",
+    });
 
-      updateData.avatarUrl = uploadResult.url;
-      updateData.avatarPublicId = uploadResult.publicId;
+    if (user.avatarPublicId) {
+      await deleteFromCloudinary(user.avatarPublicId).catch((err) =>
+        logger.error("Old avatar delete error", err),
+      );
     }
 
-    const updatedUser = await prisma.user.update({
-      where: { id: userId },
-      data: updateData,
-    });
-
-    return updatedUser;
+    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

@@ -1,21 +1,76 @@
 import webpush from "../config/webPush.js";
+import { Expo, ExpoPushMessage, ExpoPushTicket } 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: 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 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 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/react-native/base/src/components/ui/BiometricLock.tsx

@@ -7,6 +7,7 @@ import { Colors } from "@/constants/Colors";
 import { useColorScheme } from "nativewind";
 import { Txt } from "./common/Typography";
 import Button from "./ui/buttons/Button";
+import appConfig from "@/config/appConfig";
 
 export default function BiometricLock({ children }: { children: React.ReactNode }) {
   const { isBiometricEnabled, isAppLocked, setIsAppLocked, lockDuration } = useAuthStore();
@@ -80,7 +81,7 @@ export default function BiometricLock({ children }: { children: React.ReactNode
             </View>
             <Txt variant="3xl" className="font-extrabold tracking-tight mb-2">App Locked</Txt>
             <Txt variant="base" className="opacity-70 text-center px-8">
-              Please authenticate to continue using HireMe
+              Please authenticate to continue using {appConfig.app.name}
             </Txt>
           </View>