@imksh/create 1.0.31 → 1.0.33

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

@@ -1,181 +1,119 @@
 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, otp } = req.body;
-
-    if (!email || !password || !name || !otp) {
-      return next({ status: 400, message: "All fields are required." });
-    }
-
-    const newUser = await authService.signup({ name, email, phone, password, otp });
-    const token = await generateToken(newUser, res);
-    const safeUser = newUser.toObject();
-    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, otp } = req.body;
+  if (!email || !password || !name || !otp) {
+    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.toObject();
-    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, otp });
+  const token = await generateToken(newUser, res);
+  const safeUser = newUser.toObject();
+  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.toObject();
+  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 = typeof req.user?.toObject === "function" ? req.user.toObject() : { ...req.user };
+  delete safeUser.password;
+  SuccessResponse(res, 200, "User Authenticated", safeUser);
+});
+
+export const genSignupOtp = 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 {
-    const safeUser = req.user.toObject();
-    delete safeUser.password;
-    res.status(200).json({ message: "User Authenticated", data: safeUser });
-  } catch (error) {
-    logger.error("Error in getMe controller", error);
-    next(error);
+  await authService.generateSignupOtp(email);
+  SuccessResponse(res, 200, "Signup Otp sent successfully");
+});
+
+export const genOtp = asyncHandler(async (req, res) => {
+  const { email } = req.body;
+  if (!email) {
+    throw new ApiError(400, "Email is required.");
   }
-};
-
-export const genSignupOtp = async (req, res, next) => {
-  try {
-    const { email } = req.body;
-
-    if (!email) {
-      return next({ status: 400, message: "Email is required." });
-    }
-
-    await authService.generateSignupOtp(email);
-    res.status(200).json({ message: "Signup Otp sent successfully" });
-  } catch (error) {
-    logger.error("Error in genSignupOtp", 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.toObject();
+  delete safeUser.password;
+  SuccessResponse(res, 200, "Profile updated successfully", safeUser);
+});
+
+export const savePushToken = asyncHandler(async (req, res) => {
+  const { token } = req.body;
+  if (!token) {
+    throw new ApiError(400, "Token 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);
+  await authService.savePushToken(req.user._id, token);
+  SuccessResponse(res, 200, "Push token saved successfully");
+});
+
+export const googleLogin = asyncHandler(async (req, res) => {
+  const { idToken } = req.body;
+  if (!idToken) {
+    throw new ApiError(400, "idToken is required.");
   }
-};
-
-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.toObject();
+  const user = await authService.googleLogin(idToken);
+  const token = await generateToken(user, res);
+  const safeUser = typeof user.toObject === "function" ? user.toObject() : { ...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);
-  }
-};
-
-export const savePushToken = async (req, res, next) => {
-  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);
   }
-};
+  SuccessResponse(res, 200, "Google Login successfully", { user: safeUser, token });
+});

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

@@ -1,72 +1,65 @@
 import PushSubscription from "../models/pushSubscription.model.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; // supports both mongoose and prisma IDs
-    
-    if (!subscription) {
-      return next({ status: 400, message: "Invalid subscription payload" });
-    }
+export const subscribe = asyncHandler(async (req, res) => {
+  const subscription = req.body;
+  const userId = req.user?._id || req.user?.id; // supports both mongoose and prisma IDs
 
-    const isExpo = !!subscription.token;
-    const isWeb = !!(subscription.endpoint && subscription.keys);
+  if (!subscription) {
+    throw new ApiError(400, "Invalid subscription payload");
+  }
 
-    if (!isExpo && !isWeb) {
-      return next({ status: 400, message: "Missing token (EXPO) or endpoint/keys (WEB)" });
-    }
+  const isExpo = !!subscription.token;
+  const isWeb = !!(subscription.endpoint && subscription.keys);
 
-    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." });
-      }
+  if (!isExpo && !isWeb) {
+    throw new ApiError(400, "Missing token (EXPO) or endpoint/keys (WEB)");
+  }
 
-      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." });
+  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 SuccessResponse(res, 200, "Already subscribed.");
+    }
 
-      await PushSubscription.create({
-        type: "WEB",
-        endpoint: subscription.endpoint,
-        keys: subscription.keys,
-        user: userId || undefined
-      });
+    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 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 PushSubscription.create({
+      type: "WEB",
+      endpoint: subscription.endpoint,
+      keys: subscription.keys,
+      user: userId || undefined,
+    });
   }
-};
 
-export const unsubscribe = async (req, res, next) => {
-  try {
-    const { endpoint } = req.body;
-    if (!endpoint) {
-      return next({ status: 400, message: "Endpoint required" });
-    }
+  SuccessResponse(res, 201, "Subscription created.");
+});
 
-    await PushSubscription.deleteOne({ endpoint });
-
-    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 PushSubscription.deleteOne({ endpoint });
+  SuccessResponse(res, 200, "Unsubscribed.");
+});

package/templates/layers/node/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/javascript/src/middleware/auth.middleware.js

@@ -1,7 +1,7 @@
-import jwt from "jsonwebtoken";
 import User from "../models/user.model.js";
 import { verifyToken } from "../utils/jwt.js";
 import logger from "../utils/logger.js";
+import { ApiError } from "../utils/ApiError.js";
 
 export const protect = async (req, res, next) => {
   let token;
@@ -15,29 +15,23 @@ 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"));
     }
 
     req.user = await User.findById(decoded.id).select("-password");
     if (!req.user) {
-      return res
-        .status(401)
-        .json({ message: "Not authorized, user not found" });
+      return next(new ApiError(401, "Not authorized, user not found"));
     }
 
     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/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/javascript/src/routes/auth.route.js

@@ -7,6 +7,7 @@ import {
   updateMe,
   genSignupOtp,
   savePushToken,
+  googleLogin,
 } from "../controllers/auth.controller.js";
 import { protect } from "../middleware/auth.middleware.js";
 import { apiLimiter } from "../middleware/rateLimiter.js";
@@ -18,6 +19,7 @@ router.use(apiLimiter);
 router.post("/send-signup-otp", genSignupOtp);
 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);