@imksh/create 1.0.31 → 1.0.33

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

@@ -1,146 +1,101 @@
 import * as authService from "../services/auth.service.js";
 import { generateToken } from "../utils/jwt.js";
 import genOtpToken from "../utils/genOtpToken.js";
-import logger from "../utils/logger.js";
-
-export const signup = async (req, res, next) => {
-  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 = { ...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);
+import { asyncHandler } from "../utils/asyncHandler.js";
+import { SuccessResponse } from "../utils/SuccessResponse.js";
+import { ApiError } from "../utils/ApiError.js";
+
+export const signup = asyncHandler(async (req, res) => {
+  const { name, email, phone, password } = req.body;
+  if (!email || !password || !name) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
-
-export const login = async (req, res, next) => {
-  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 = { ...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);
+  const newUser = await authService.signup({ name, email, phone, password });
+  const token = await generateToken(newUser, res);
+  const safeUser = { ...newUser };
+  delete safeUser.password;
+  SuccessResponse(res, 201, "Registration Successful", { user: safeUser, token });
+});
+
+export const login = asyncHandler(async (req, res) => {
+  const { email, password } = req.body;
+  if (!email || !password) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
-
-export const logout = async (_req, res, next) => {
-  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);
+  const user = await authService.login({ email, password });
+  const token = await generateToken(user, res);
+  const safeUser = { ...user };
+  delete safeUser.password;
+  SuccessResponse(res, 200, "Login successfully", { user: safeUser, token });
+});
+
+export const logout = asyncHandler(async (_req, res) => {
+  res.clearCookie("token", {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "strict",
+    path: "/",
+  });
+  SuccessResponse(res, 200, "Logout Successfully");
+});
+
+export const getMe = asyncHandler(async (req, res) => {
+  const safeUser = { ...req.user };
+  delete safeUser.password;
+  SuccessResponse(res, 200, "User Authenticated", safeUser);
+});
+
+export const genOtp = asyncHandler(async (req, res) => {
+  const { email } = req.body;
+  if (!email) {
+    throw new ApiError(400, "Email is required.");
   }
-};
-
-export const getMe = async (req, res, next) => {
-  try {
-    res.status(200).json({ message: "User Authenticated", data: req.user });
-  } catch (error) {
-    logger.error("Error in getMe controller", error);
-    next(error);
+  await authService.generateOtp(email);
+  SuccessResponse(res, 200, "Otp sent successfully");
+});
+
+export const verifyOtp = asyncHandler(async (req, res) => {
+  const { email, otp } = req.body;
+  if (!email || !otp) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
-
-export const genOtp = async (req, res, next) => {
-  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);
+  const user = await authService.verifyOtp({ email, otp });
+  await genOtpToken(user, res);
+  SuccessResponse(res, 200, "Otp verified successfully");
+});
+
+export const resetPassword = asyncHandler(async (req, res) => {
+  const { newPassword } = req.body;
+  const currentUser = req.user;
+  if (!newPassword) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
-
-export const verifyOtp = async (req, res, next) => {
-  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);
+  await authService.resetPassword(currentUser, newPassword);
+  SuccessResponse(res, 200, "Password updated successfully");
+});
+
+export const updateMe = asyncHandler(async (req, res) => {
+  const { name, phone } = req.body;
+  const user = await authService.updateProfile(req.user.id, {
+    name,
+    phone,
+    file: req.file,
+  });
+  const safeUser = { ...user };
+  delete safeUser.password;
+  SuccessResponse(res, 200, "Profile updated successfully", safeUser);
+});
+
+export const googleLogin = asyncHandler(async (req, res) => {
+  const { idToken } = req.body;
+  if (!idToken) {
+    throw new ApiError(400, "idToken is required.");
   }
-};
-
-export const resetPassword = async (req, res, next) => {
-  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, res, next) => {
-  try {
-    const { name, phone } = req.body;
-    const user = await authService.updateProfile(req.user.id, {
-      name,
-      phone,
-      file: req.file,
-    });
-    const safeUser = { ...user };
+  const user = await authService.googleLogin(idToken);
+  const token = await generateToken(user, res);
+  const safeUser = user;
+  if (safeUser.password !== undefined) {
     delete safeUser.password;
-    res.status(200).json({ success: true, data: safeUser });
-  } catch (error) {
-    logger.error("Error updating profile", error);
-    next(error);
   }
-};
+  SuccessResponse(res, 200, "Google Login successfully", { user: safeUser, token });
+});

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

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

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

@@ -1,26 +1,19 @@
 import { uploadSingleToCloudinary } from "../utils/cloudinaryUpload.js";
-import logger from "../utils/logger.js";
+import { asyncHandler } from "../utils/asyncHandler.js";
+import { SuccessResponse } from "../utils/SuccessResponse.js";
+import { ApiError } from "../utils/ApiError.js";
 
 /**
  * Handle single file uploads to Cloudinary
  */
-export const uploadFile = async (req, res, next) => {
-  try {
-    if (!req.file) {
-      return res.status(400).json({ success: false, message: "No file uploaded" });
-    }
+export const uploadFile = asyncHandler(async (req, res) => {
+  if (!req.file) {
+    throw new ApiError(400, "No file uploaded");
+  }
 
-    const result = await uploadSingleToCloudinary(req.file, {
-      folder: req.body.folder || "general_uploads",
-    });
+  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);
-  }
-};
+  SuccessResponse(res, 200, "File uploaded successfully", result);
+});

package/templates/layers/node-prisma/javascript/src/middleware/auth.middleware.js

@@ -1,6 +1,7 @@
 import { verifyToken } from "../utils/jwt.js";
 import logger from "../utils/logger.js";
 import { prisma } from "../config/db.js";
+import { ApiError } from "../utils/ApiError.js";
 
 export const protect = async (req, res, next) => {
   let token;
@@ -14,13 +15,13 @@ export const protect = async (req, res, next) => {
   }
 
   if (!token) {
-    return res.status(401).json({ message: "Not authorized, no token provided" });
+    return next(new ApiError(401, "Not authorized, no token provided"));
   }
 
   try {
     const decoded = verifyToken(token);
     if (!decoded) {
-      return res.status(401).json({ message: "Not authorized, invalid token" });
+      return next(new ApiError(401, "Not authorized, invalid token"));
     }
 
     const user = await prisma.user.findUnique({
@@ -28,7 +29,7 @@ export const protect = async (req, res, next) => {
     });
 
     if (!user) {
-      return res.status(401).json({ message: "Not authorized, user not found" });
+      return next(new ApiError(401, "Not authorized, user not found"));
     }
 
     // Exclude password
@@ -39,6 +40,6 @@ export const protect = async (req, res, next) => {
     return next();
   } catch (error) {
     logger.error("Auth middleware error", error);
-    return res.status(401).json({ message: "Not authorized, token verification failed" });
+    return next(new ApiError(401, "Not authorized, token verification failed"));
   }
 };

package/templates/layers/node-prisma/javascript/src/middleware/errorHandler.js

@@ -1,11 +1,11 @@
+import { ApiError } from "../utils/ApiError.js";
+
 /**
  * Not Found Middleware
  * Catches all unmatched requests and forwards a 404 error
  */
 export const notFound = (req, res, next) => {
-  const error = new Error(`Not Found - ${req.originalUrl}`);
-  res.status(404);
-  next(error);
+  next(new ApiError(404, `Not Found - ${req.originalUrl}`));
 };
 
 /**
@@ -13,10 +13,12 @@ export const notFound = (req, res, next) => {
  * Formats error responses nicely in JSON
  */
 export const errorHandler = (err, req, res, next) => {
-  const statusCode = err.status || err.statusCode || (res.statusCode === 200 ? 500 : res.statusCode);
+  const statusCode = err.statusCode || err.status || (res.statusCode === 200 ? 500 : res.statusCode);
   res.status(statusCode).json({
     success: false,
+    statusCode,
     message: err.message || "An unexpected error occurred",
+    errors: err.errors || [],
     stack: process.env.NODE_ENV === "production" ? undefined : err.stack,
   });
 };

package/templates/layers/node-prisma/javascript/src/routes/auth.route.js

@@ -5,6 +5,7 @@ import {
   getMe,
   logout,
   updateMe,
+  googleLogin,
 } from "../controllers/auth.controller.js";
 import { protect } from "../middleware/auth.middleware.js";
 import { apiLimiter } from "../middleware/rateLimiter.js";
@@ -15,6 +16,7 @@ router.use(apiLimiter);
 
 router.post("/signup", signup);
 router.post("/login", login);
+router.post("/google", googleLogin);
 router.post("/logout", logout);
 router.get("/me", protect, getMe);
 router.put("/me", protect, updateMe);