@imksh/create 1.0.30 → 1.0.32

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

@@ -1,154 +1,126 @@
-import { Request, Response, NextFunction } from "express";
+import { Request, Response } from "express";
 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";
+import { asyncHandler } from "../utils/asyncHandler.js";
+import { SuccessResponse } from "../utils/SuccessResponse.js";
+import { ApiError } from "../utils/ApiError.js";
 
-export const signup = async (req: Request, res: Response, next: NextFunction) => {
-  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: any = 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);
-  }
+const toSafeUser = (user: unknown): Record<string, unknown> => {
+  const obj: Record<string, unknown> =
+    user && typeof user === "object" && "toObject" in user && typeof (user as { toObject: () => unknown }).toObject === "function"
+      ? { ...((user as { toObject: () => Record<string, unknown> }).toObject()) }
+      : { ...((user as Record<string, unknown>) || {}) };
+  delete obj.password;
+  return obj;
 };
 
-export const login = async (req: Request, res: Response, next: NextFunction) => {
-  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: any = 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);
+export const signup = asyncHandler(async (req: Request, res: Response) => {
+  const { name, email, phone, password, otp } = req.body;
+  if (!email || !password || !name || !otp) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
+  const newUser = await authService.signup({ name, email, phone, password, otp });
+  const token = await generateToken(newUser, res);
+  const safeUser = toSafeUser(newUser);
+  SuccessResponse(res, 201, "Registration Successful", { user: safeUser, token });
+});
 
-export const logout = async (req: Request, res: Response, next: NextFunction) => {
-  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);
+export const login = asyncHandler(async (req: Request, res: Response) => {
+  const { email, password } = req.body;
+  if (!email || !password) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
+  const user = await authService.login({ email, password });
+  const token = await generateToken(user, res);
+  const safeUser = toSafeUser(user);
+  SuccessResponse(res, 200, "Login successfully", { user: safeUser, token });
+});
 
-export const getMe = async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const safeUser: any = 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);
-  }
-};
+export const logout = asyncHandler(async (req: Request, res: Response) => {
+  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: Request, res: Response) => {
+  const safeUser = toSafeUser(req.user);
+  SuccessResponse(res, 200, "User Authenticated", safeUser);
+});
 
-export const genSignupOtp = async (req: Request, res: Response, next: NextFunction) => {
-  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);
+export const genSignupOtp = asyncHandler(async (req: Request, res: Response) => {
+  const { email } = req.body;
+  if (!email) {
+    throw new ApiError(400, "Email is required.");
   }
-};
+  await authService.generateSignupOtp(email);
+  SuccessResponse(res, 200, "Signup Otp sent successfully");
+});
 
-export const genOtp = async (req: Request, res: Response, next: NextFunction) => {
-  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);
+export const genOtp = asyncHandler(async (req: Request, res: Response) => {
+  const { email } = req.body;
+  if (!email) {
+    throw new ApiError(400, "Email is required.");
   }
-};
+  await authService.generateOtp(email);
+  SuccessResponse(res, 200, "Otp sent successfully");
+});
 
-export const verifyOtp = async (req: Request, res: Response, next: NextFunction) => {
-  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);
+export const verifyOtp = asyncHandler(async (req: Request, res: Response) => {
+  const { email, otp } = req.body;
+  if (!email || !otp) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
+  const user = await authService.verifyOtp({ email, otp });
+  await genOtpToken(user, res);
+  SuccessResponse(res, 200, "Otp verified successfully");
+});
 
-export const resetPassword = async (req: Request, res: Response, next: NextFunction) => {
-  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 resetPassword = asyncHandler(async (req: Request, res: Response) => {
+  const { newPassword } = req.body;
+  if (!newPassword) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
+  if (!req.user || typeof (req.user as unknown as { save?: unknown }).save !== "function") {
+    throw new ApiError(401, "Not authorized");
+  }
+  await authService.resetPassword(req.user as unknown as authService.UserWithSave, newPassword);
+  SuccessResponse(res, 200, "Password updated successfully");
+});
 
-export const updateMe = async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    const { name, phone } = req.body;
-    const user = await authService.updateProfile(req.user._id, {
-      name,
-      phone,
-      file: req.file,
-    });
-    const safeUser: any = user.toObject();
-    delete safeUser.password;
-    res.status(200).json({ success: true, data: safeUser });
-  } catch (error) {
-    logger.error("Error updating profile", error);
-    next(error);
+export const updateMe = asyncHandler(async (req: Request, res: Response) => {
+  const { name, phone } = req.body;
+  const userId = String(req.user?._id || req.user?.id || "");
+  const user = await authService.updateProfile(userId, {
+    name,
+    phone,
+    file: req.file,
+  });
+  const safeUser = toSafeUser(user);
+  SuccessResponse(res, 200, "Profile updated successfully", safeUser);
+});
+
+export const savePushToken = asyncHandler(async (req: Request, res: Response) => {
+  const { token } = req.body;
+  if (!token) {
+    throw new ApiError(400, "Token is required.");
   }
-};
+  const userId = String(req.user?._id || req.user?.id || "");
+  await authService.savePushToken(userId, token);
+  SuccessResponse(res, 200, "Push token saved successfully");
+});
 
-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);
+export const googleLogin = asyncHandler(async (req: Request, res: Response) => {
+  const { idToken } = req.body;
+  if (!idToken) {
+    throw new ApiError(400, "idToken is required.");
   }
-};
+  const user = await authService.googleLogin(idToken);
+  const token = await generateToken(user, res);
+  const safeUser = toSafeUser(user);
+  SuccessResponse(res, 200, "Google Login successfully", { user: safeUser, token });
+});

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

@@ -1,73 +1,66 @@
-import { Request, Response, NextFunction } from "express";
+import { Request, Response } from "express";
 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: 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" });
-    }
+export const subscribe = asyncHandler(async (req: Request, res: Response) => {
+  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: Request, res: Response, next: NextFunction) => {
-  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: Request, res: Response) => {
+  const { endpoint } = req.body;
+  if (!endpoint) {
+    throw new ApiError(400, "Endpoint required");
   }
-};
+
+  await PushSubscription.deleteOne({ endpoint });
+  SuccessResponse(res, 200, "Unsubscribed.");
+});

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

@@ -1,22 +1,15 @@
-import { Request, Response, NextFunction } from "express";
+import { Request, Response } from "express";
 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";
 
-export const uploadFile = async (req: Request, res: Response, next: NextFunction) => {
-  try {
-    if (!req.file) {
-      return res.status(400).json({ success: false, message: "No file uploaded" });
-    }
-    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);
+export const uploadFile = asyncHandler(async (req: Request, res: Response) => {
+  if (!req.file) {
+    throw new ApiError(400, "No file uploaded");
   }
-};
+  const result = await uploadSingleToCloudinary(req.file, {
+    folder: req.body.folder || "general_uploads",
+  });
+  SuccessResponse(res, 200, "File uploaded successfully", result);
+});

package/templates/layers/node/typescript/src/middleware/auth.middleware.ts

@@ -2,8 +2,14 @@ import { Request, Response, NextFunction } from "express";
 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: Request, res: Response, next: NextFunction) => {
+export const protect = async (
+  req: Request,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  res: Response,
+  next: NextFunction
+) => {
   let token: string | undefined;
 
   if (req.cookies?.token) {
@@ -16,23 +22,23 @@ export const protect = async (req: Request, res: Response, next: NextFunction) =
   }
 
   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: any = verifyToken(token);
+    const decoded = verifyToken(token) as { id: string } | null;
     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: any) {
+  } catch (error: unknown) {
     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/typescript/src/middleware/errorHandler.ts

@@ -1,16 +1,29 @@
 import { Request, Response, NextFunction } from "express";
+import { ApiError } from "../utils/ApiError.js";
+
+export interface HttpError extends Error {
+  statusCode?: number;
+  status?: number;
+  errors?: unknown[];
+}
 
 export const notFound = (req: Request, res: Response, next: NextFunction) => {
-  const error = new Error(`Not Found - ${req.originalUrl}`);
-  res.status(404);
-  next(error);
+  next(new ApiError(404, `Not Found - ${req.originalUrl}`));
 };
 
-export const errorHandler = (err: any, req: Request, res: Response, next: NextFunction) => {
-  const statusCode = err.status || err.statusCode || (res.statusCode === 200 ? 500 : res.statusCode);
+export const errorHandler = (
+  err: HttpError,
+  req: Request,
+  res: Response,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  next: NextFunction,
+) => {
+  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/typescript/src/middleware/rateLimiter.ts

@@ -21,8 +21,8 @@ const createLimiter = ({
     legacyHeaders: false,
     skipSuccessfulRequests,
 
-    keyGenerator: (req: any) => {
-      return req.user?.id || req.ip || req.headers["x-forwarded-for"] || req.socket.remoteAddress;
+    keyGenerator: (req: Request) => {
+      return String(req.user?.id || req.user?._id || req.ip || req.headers["x-forwarded-for"] || req.socket.remoteAddress || "unknown");
     },
 
     handler: (req: Request, res: Response) => {

package/templates/layers/node/typescript/src/routes/auth.route.ts

@@ -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);