@imksh/create 1.0.31 → 1.0.33

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

@@ -1,124 +1,108 @@
-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 } = 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: any = { ...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);
-  }
+const toSafeUser = (user: unknown): Record<string, unknown> => {
+  const safeUser: Record<string, unknown> = { ...((user as Record<string, unknown>) || {}) };
+  delete safeUser.password;
+  return safeUser;
 };
 
-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 };
-    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 } = req.body;
+  if (!email || !password || !name) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
+  const newUser = await authService.signup({ name, email, phone, password });
+  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 {
-    res.status(200).json({ message: "User Authenticated", data: req.user });
-  } 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 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 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 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 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 resetPassword = asyncHandler(async (req: Request, res: Response) => {
+  const { newPassword } = req.body;
+  const userId = String(req.user?.id || req.user?._id || "");
+  if (!newPassword) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
+  if (!userId) {
+    throw new ApiError(401, "Not authorized");
+  }
+  await authService.resetPassword({ id: userId }, newPassword);
+  SuccessResponse(res, 200, "Password updated 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 updateMe = asyncHandler(async (req: Request, res: Response) => {
+  const { name, phone } = req.body;
+  const userId = String(req.user?.id || req.user?._id || "");
+  if (!userId) {
+    throw new ApiError(401, "Not authorized");
   }
-};
+  const user = await authService.updateProfile(userId, {
+    name,
+    phone,
+    file: req.file,
+  });
+  const safeUser = toSafeUser(user);
+  SuccessResponse(res, 200, "Profile updated successfully", safeUser);
+});
 
-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 };
-    delete safeUser.password;
-    res.status(200).json({ success: true, data: safeUser });
-  } catch (error) {
-    logger.error("Error updating profile", 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-prisma/typescript/src/controllers/push.controller.ts

@@ -1,100 +1,84 @@
-import { Request, Response, NextFunction } from "express";
+import { Request, Response } from "express";
 import { prisma } from "../config/prisma.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;
+export const subscribe = asyncHandler(async (req: Request, res: Response) => {
+  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: 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(() => {});
+  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: Request, res: Response) => {
+  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/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-prisma/typescript/src/middleware/auth.middleware.ts

@@ -2,9 +2,11 @@ import { Request, Response, NextFunction } from "express";
 import { verifyToken } from "../utils/jwt.js";
 import logger from "../utils/logger.js";
 import { prisma } from "../config/prisma.js";
+import { ApiError } from "../utils/ApiError.js";
 
 export const protect = async (
   req: Request,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   res: Response,
   next: NextFunction,
 ) => {
@@ -20,15 +22,13 @@ export const protect = async (
   }
 
   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"));
     }
 
     const user = await prisma.user.findUnique({
@@ -36,20 +36,16 @@ export const protect = async (
     });
 
     if (!user) {
-      return res
-        .status(401)
-        .json({ message: "Not authorized, user not found" });
+      return next(new ApiError(401, "Not authorized, user not found"));
     }
 
-    const safeUser: any = { ...user };
+    const safeUser: Record<string, unknown> = { ...user };
     delete safeUser.password;
 
     req.user = safeUser;
     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-prisma/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-prisma/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-prisma/typescript/src/routes/auth.route.ts

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