@imksh/create 1.0.31 → 1.0.32

package/templates/layers/node/javascript/src/services/auth.service.js

@@ -1,3 +1,4 @@
+import { OAuth2Client } from "google-auth-library";
 import User from "../models/user.model.js";
 import Otp from "../models/otp.model.js";
 import bcrypt from "bcrypt";
@@ -5,185 +6,151 @@ import { generateToken } from "../utils/jwt.js";
 import { sendOtpEmail } from "../utils/emailOtp.js";
 import { uploadSingleToCloudinary, deleteFromCloudinary } from "../utils/cloudinaryUpload.js";
 import logger from "../utils/logger.js";
+import { ApiError } from "../utils/ApiError.js";
 
-  /**
-   * User Signup
-   */
-export const signup = async ({ name, email, phone, password, otp }) => {
-    const existingUser = await User.findOne({ email });
-    if (existingUser) {
-      const err = new Error("User already exists");
-      err.status = 409;
-      throw err;
-    }
-
-    const existingOtp = await Otp.findOne({ email });
-    if (!existingOtp) {
-      const err = new Error("OTP match failed");
-      err.status = 400;
-      throw err;
-    }
-    const isMatched = await bcrypt.compare(otp, existingOtp.otp);
-    if (!isMatched) {
-      const err = new Error("OTP match failed");
-      err.status = 400;
-      throw err;
-    }
-
-    const salt = await bcrypt.genSalt(10);
-    const hashedPassword = await bcrypt.hash(password, salt);
+const googleClient = new OAuth2Client(process.env.GOOGLE_CLIENT_ID || "");
 
-    const photoURL = `https://placehold.co/600x400?text=${name.charAt(0).toUpperCase()}`;
-
-    const newUser = await User.create({
-      name,
-      email: email.toLowerCase(),
-      phone,
-      role: "user",
-      password: hashedPassword,
-      avatar: {
-        url: photoURL,
-        publicId: "",
-      },
-    });
-
-    await existingOtp.deleteOne(); // delete OTP after successful signup
-    return newUser;
+/**
+ * User Signup
+ */
+export const signup = async ({ name, email, phone, password, otp }) => {
+  const existingUser = await User.findOne({ email });
+  if (existingUser) {
+    throw new ApiError(409, "User already exists");
   }
-  /**
-   * User Login
-   */
-export const login = async ({ email, password }) => {
-    const user = await User.findOne({ email });
-    if (!user) {
-      const err = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
-
-    const isValid = await bcrypt.compare(password, user.password);
-    if (!isValid) {
-      const err = new Error("Invalid Credentials");
-      err.status = 401;
-      throw err;
-    }
 
-    return user;
+  const existingOtp = await Otp.findOne({ email });
+  if (!existingOtp) {
+    throw new ApiError(400, "OTP match failed");
   }
-  /**
-   * Generate and Send OTP
-   */
-export const generateSignupOtp = async (email) => {
-    const user = await User.findOne({ email });
-    if (user) {
-      const err = new Error("User already exists");
-      err.status = 409;
-      throw err;
-    }
-    const existingOtp = await Otp.findOne({ email });
-    if (existingOtp) {
-      await existingOtp.deleteOne();
-    }
-    const otp = Math.floor(100000 + Math.random() * 900000).toString();
-    const hashedOtp = await bcrypt.hash(otp, 10);
-    await Otp.create({ email, otp: hashedOtp });
-    await sendOtpEmail(email, otp);
-    return true;
+  const isMatched = await bcrypt.compare(otp, existingOtp.otp);
+  if (!isMatched) {
+    throw new ApiError(400, "OTP match failed");
   }
-export const generateOtp = async (email) => {
-    const user = await User.findOne({ email });
-    if (!user) {
-      const err = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
 
-    const existingOtp = await Otp.findOne({ email });
-    if (existingOtp) {
-      await existingOtp.deleteOne();
-    }
-
-    const otp = Math.floor(100000 + Math.random() * 900000).toString();
-    const hashedOtp = await bcrypt.hash(otp, 10);
-
-    await Otp.create({
-      email,
-      otp: hashedOtp,
-    });
+  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 User.create({
+    name,
+    email: email.toLowerCase(),
+    phone,
+    role: "user",
+    password: hashedPassword,
+    avatar: { url: photoURL, publicId: "" },
+  });
+
+  await existingOtp.deleteOne();
+  return newUser;
+};
 
-    await sendOtpEmail(email, otp);
-    return true;
+/**
+ * User Login
+ */
+export const login = async ({ email, password }) => {
+  const user = await User.findOne({ email });
+  if (!user || !user.password) {
+    throw new ApiError(401, "Invalid Credentials");
   }
-  /**
-   * Verify OTP
-   */
-export const verifyOtp = async ({ email, otp }) => {
-    const user = await User.findOne({ email });
-    if (!user) {
-      const err = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
-
-    const existingOtp = await Otp.findOne({ email });
-    if (!existingOtp) {
-      const err = new Error("OTP match failed");
-      err.status = 400;
-      throw err;
-    }
-
-    const isMatched = await bcrypt.compare(otp, existingOtp.otp);
-    if (!isMatched) {
-      const err = new Error("OTP match failed");
-      err.status = 400;
-      throw err;
-    }
+  const isValid = await bcrypt.compare(password, user.password);
+  if (!isValid) {
+    throw new ApiError(401, "Invalid Credentials");
+  }
+  return user;
+};
 
-    return user;
+/**
+ * Generate Signup OTP
+ */
+export const generateSignupOtp = async (email) => {
+  const user = await User.findOne({ email });
+  if (user) {
+    throw new ApiError(409, "User already exists");
   }
-  /**
-   * Reset Password
-   */
-export const resetPassword = async (user, newPassword) => {
-    const hashedPassword = await bcrypt.hash(newPassword, 10);
-    user.password = hashedPassword;
-    await user.save();
-    return true;
+  const existingOtp = await Otp.findOne({ email });
+  if (existingOtp) {
+    await existingOtp.deleteOne();
   }
-  /**
-   * Update Profile
-   */
-export const updateProfile = async (userId, { name, phone, file }) => {
-    const user = await User.findById(userId);
-    if (!user) {
-      const err = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
+  const otp = Math.floor(100000 + Math.random() * 900000).toString();
+  const hashedOtp = await bcrypt.hash(otp, 10);
+  await Otp.create({ email, otp: hashedOtp });
+  await sendOtpEmail(email, otp);
+  return true;
+};
 
-    if (name) user.name = name;
-    if (phone) user.phone = phone;
+/**
+ * Generate OTP
+ */
+export const generateOtp = async (email) => {
+  const user = await User.findOne({ email });
+  if (!user) {
+    throw new ApiError(404, "User not found");
+  }
+  const existingOtp = await Otp.findOne({ email });
+  if (existingOtp) {
+    await existingOtp.deleteOne();
+  }
+  const otp = Math.floor(100000 + Math.random() * 900000).toString();
+  const hashedOtp = await bcrypt.hash(otp, 10);
+  await Otp.create({ email, otp: hashedOtp });
+  await sendOtpEmail(email, otp);
+  return true;
+};
 
-    if (file) {
-      const uploadResult = await uploadSingleToCloudinary(file, {
-        folder: "codelab/avatars",
-      });
+/**
+ * Verify OTP
+ */
+export const verifyOtp = async ({ email, otp }) => {
+  const user = await User.findOne({ email });
+  if (!user) {
+    throw new ApiError(404, "User not found");
+  }
+  const existingOtp = await Otp.findOne({ email });
+  if (!existingOtp) {
+    throw new ApiError(400, "OTP match failed");
+  }
+  const isMatched = await bcrypt.compare(otp, existingOtp.otp);
+  if (!isMatched) {
+    throw new ApiError(400, "OTP match failed");
+  }
+  return user;
+};
 
-      if (user.avatar && user.avatar.publicId) {
-        await deleteFromCloudinary(user.avatar.publicId).catch((err) =>
-          logger.error("Old avatar delete error", err)
-        );
-      }
+/**
+ * Reset Password
+ */
+export const resetPassword = async (user, newPassword) => {
+  const hashedPassword = await bcrypt.hash(newPassword, 10);
+  user.password = hashedPassword;
+  await user.save();
+  return true;
+};
 
-      user.avatar = {
-        url: uploadResult.url,
-        publicId: uploadResult.publicId,
-      };
+/**
+ * Update Profile
+ */
+export const updateProfile = async (userId, { name, phone, file }) => {
+  const user = await User.findById(userId);
+  if (!user) {
+    throw new ApiError(404, "User not found");
+  }
+  if (name) user.name = name;
+  if (phone) user.phone = phone;
+  if (file) {
+    const uploadResult = await uploadSingleToCloudinary(file, {
+      folder: "codelab/avatars",
+    });
+    if (user.avatar && user.avatar.publicId) {
+      await deleteFromCloudinary(user.avatar.publicId).catch((err) =>
+        logger.error("Old avatar delete error", err)
+      );
     }
-
-    await user.save();
-    return user;
+    user.avatar = { url: uploadResult.url, publicId: uploadResult.publicId };
   }
+  await user.save();
+  return user;
+};
 
 /**
  * Save Expo Push Token
@@ -191,9 +158,7 @@ export const updateProfile = async (userId, { name, phone, file }) => {
 export const savePushToken = async (userId, token) => {
   const user = await User.findById(userId);
   if (!user) {
-    const err = new Error("User not found");
-    err.status = 404;
-    throw err;
+    throw new ApiError(404, "User not found");
   }
   if (!user.expoPushTokens.includes(token)) {
     user.expoPushTokens.push(token);
@@ -201,3 +166,33 @@ export const savePushToken = async (userId, token) => {
   }
   return user;
 };
+
+/**
+ * Google Login
+ */
+export const googleLogin = async (idToken) => {
+  const ticket = await googleClient.verifyIdToken({
+    idToken,
+    audience: process.env.GOOGLE_CLIENT_ID,
+  });
+  const payload = ticket.getPayload();
+  if (!payload) {
+    throw new ApiError(401, "Invalid Google Token");
+  }
+  const { email, name, picture } = payload;
+  if (!email) {
+    throw new ApiError(400, "Email not found in Google Token");
+  }
+
+  let user = await User.findOne({ email });
+  if (!user) {
+    user = await User.create({
+      name: name || "User",
+      email: email.toLowerCase(),
+      role: "user",
+      password: "",
+      avatar: { url: picture || `https://placehold.co/600x400?text=${name?.charAt(0).toUpperCase() || 'U'}`, publicId: "" },
+    });
+  }
+  return user;
+};

package/templates/layers/node/javascript/src/utils/ApiError.js

@@ -0,0 +1,20 @@
+export class ApiError extends Error {
+  constructor(
+    statusCode,
+    message = "Something went wrong",
+    errors = [],
+    stack = "",
+  ) {
+    super(message);
+    this.statusCode = statusCode;
+    this.data = null;
+    this.success = false;
+    this.errors = errors;
+
+    if (stack) {
+      this.stack = stack;
+    } else {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}

package/templates/layers/node/javascript/src/utils/SuccessResponse.js

@@ -0,0 +1,15 @@
+export const SuccessResponse = (
+  res,
+  statusCode,
+  message = "Success",
+  data = null,
+  pagination = undefined,
+) => {
+  return res.status(statusCode).json({
+    success: statusCode < 400,
+    statusCode,
+    message,
+    data,
+    ...(pagination && { pagination }),
+  });
+};

package/templates/layers/node/javascript/src/utils/apiResponse.js

@@ -0,0 +1,4 @@
+import { SuccessResponse } from "./SuccessResponse.js";
+
+export { SuccessResponse };
+export const ApiResponse = SuccessResponse;

package/templates/layers/node/javascript/src/utils/asyncHandler.js

@@ -0,0 +1,5 @@
+export const asyncHandler = (requestHandler) => {
+  return (req, res, next) => {
+    Promise.resolve(requestHandler(req, res, next)).catch((err) => next(err));
+  };
+};

package/templates/layers/node/typescript/.env.example

@@ -59,4 +59,6 @@ RATE_LIMIT_MAX=100
 # ==========================
 VAPID_PRIVATE_KEY=
 VAPID_PUBLIC_KEY=
-VAPID_SUBJECT=mailto:noreply@example.com
+VAPID_SUBJECT=mailto:noreply@example.com
+# Google Auth
+GOOGLE_CLIENT_ID=your-google-client-id

package/templates/layers/node/typescript/.eslintrc.cjs

@@ -0,0 +1,28 @@
+module.exports = {
+  env: {
+    node: true,
+    es2022: true,
+  },
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: "latest",
+    sourceType: "module",
+  },
+  plugins: ["@typescript-eslint"],
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+  ],
+  rules: {
+    "@typescript-eslint/no-explicit-any": "error",
+    "no-console": "error",
+  },
+  overrides: [
+    {
+      files: ["src/utils/logger.ts"],
+      rules: {
+        "no-console": "off",
+      },
+    },
+  ],
+};

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

@@ -7,6 +7,13 @@
     "start": "tsx src/index.ts",
     "dev": "tsx watch src/index.ts",
     "build": "tsc",
+    "lint": "eslint . --ext .ts --max-warnings 0",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.{ts,json}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,json}\"",
+    "circular-check": "dpdm --circular --no-warning --no-tree --exit-code circular:1 \"src/**/*.ts\"",
+    "ts-prune": "ts-prune",
+    "ts-purns": "ts-prune",
     "generate:vapid": "node ./src/utils/generateVapidKeys.js"
   },
   "dependencies": {
@@ -26,7 +33,8 @@
     "nodemailer": "^6.9.7",
     "socket.io": "^4.7.2",
     "web-push": "^3.6.6",
-    "expo-server-sdk": "^3.10.0"
+    "expo-server-sdk": "^3.10.0",
+    "google-auth-library": "^9.14.2"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",
@@ -40,9 +48,15 @@
     "@types/node": "^20.9.0",
     "@types/nodemailer": "^6.4.14",
     "@types/web-push": "^3.6.3",
+    "@typescript-eslint/eslint-plugin": "^6.10.0",
+    "@typescript-eslint/parser": "^6.10.0",
+    "dpdm": "^3.14.0",
+    "eslint": "^8.53.0",
     "nodemon": "^3.0.1",
+    "prettier": "^3.4.2",
     "ts-node": "^10.9.1",
+    "ts-prune": "^0.10.3",
     "tsx": "^4.23.1",
     "typescript": "^5.2.2"
   }
-}
+}

package/templates/layers/node/typescript/src/app.ts

@@ -1,4 +1,4 @@
-import express, { Request, Response, NextFunction } from "express";
+import express, { Request, Response } from "express";
 import helmet from "helmet";
 import cors from "cors";
 import compression from "compression";
@@ -7,6 +7,7 @@ import morgan from "morgan";
 import apiRoutes from "./routes/index.js";
 import { notFound, errorHandler } from "./middleware/errorHandler.js";
 import { apiLimiter } from "./middleware/rateLimiter.js";
+import { SuccessResponse } from "./utils/SuccessResponse.js";
 
 const app = express();
 
@@ -27,7 +28,7 @@ app.use(apiLimiter);
 app.use("/api", apiRoutes);
 
 app.get("/api/health", (req: Request, res: Response) => {
-  res.status(200).json({ success: true, message: "API is running" });
+  SuccessResponse(res, 200, "API is running");
 });
 
 app.use(notFound);

package/templates/layers/node/typescript/src/config/db.ts

@@ -6,8 +6,9 @@ const connectDB = async () => {
     const MONGO_URI = process.env.MONGO_URI || "mongodb://localhost:27017/test";
     const conn = await mongoose.connect(MONGO_URI);
     logger.success(`MongoDB connected: ${conn.connection.host}`);
-  } catch (error: any) {
-    logger.error(`MongoDB connection error: ${error.message}`, error);
+  } catch (error: unknown) {
+    const err = error as Error;
+    logger.error(`MongoDB connection error: ${err.message}`, error);
     process.exit(1);
   }
 };

package/templates/layers/node/typescript/src/config/socket.ts

@@ -1,12 +1,13 @@
-import { Server } from "socket.io";
+import { Server as SocketIOServer } from "socket.io";
+import type { Server as HttpServer } from "http";
 import logger from "../utils/logger.js";
 
-let io: Server;
+let io: SocketIOServer;
 
 const userSocketMap: { [key: string]: Set<string> } = {};
 
-const initializeSocket = (server: any) => {
-  io = new Server(server, {
+const initializeSocket = (server: HttpServer) => {
+  io = new SocketIOServer(server, {
     cors: {
       origin: ["http://localhost:5173"],
       credentials: true,