@imksh/create 1.0.30 → 1.0.32

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

@@ -1,155 +1,178 @@
+import { OAuth2Client } from "google-auth-library";
 import bcrypt from "bcrypt";
 import { prisma } from "../config/db.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";
+
+const googleClient = new OAuth2Client(process.env.GOOGLE_CLIENT_ID || "");
+
 export const signup = async ({ name, email, phone, password }) => {
-    const existingUser = await prisma.user.findUnique({
-      where: { email },
-    });
-    if (existingUser) {
-      const err = new Error("User already exists");
-      err.status = 409;
-      throw err;
-    }
+  const existingUser = await prisma.user.findUnique({
+    where: { email },
+  });
+  if (existingUser) {
+    throw new ApiError(409, "User already exists");
+  }
 
-    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 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 prisma.user.create({
-      data: {
-        name,
-        email: email.toLowerCase(),
-        phone,
-        password: hashedPassword,
-        avatarUrl: photoURL,
-        avatarPublicId: "",
-      },
-    });
+  const newUser = await prisma.user.create({
+    data: {
+      name,
+      email: email.toLowerCase(),
+      phone,
+      password: hashedPassword,
+      avatarUrl: photoURL,
+      avatarPublicId: "",
+    },
+  });
 
-    return newUser;
-  }
-export const login = async ({ email, password }) => {
-    const user = await prisma.user.findUnique({
-      where: { email },
-    });
-    if (!user) {
-      const err = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
+  return newUser;
+};
 
-    const isValid = await bcrypt.compare(password, user.password);
-    if (!isValid) {
-      const err = new Error("Invalid Credentials");
-      err.status = 401;
-      throw err;
-    }
+export const login = async ({ email, password }) => {
+  const user = await prisma.user.findUnique({
+    where: { email },
+  });
+  if (!user) {
+    throw new ApiError(404, "User not found");
+  }
 
-    return user;
+  const isValid = await bcrypt.compare(password, user.password);
+  if (!isValid) {
+    throw new ApiError(401, "Invalid Credentials");
   }
+
+  return user;
+};
+
 export const generateOtp = async (email) => {
-    const user = await prisma.user.findUnique({
-      where: { email },
-    });
-    if (!user) {
-      const err = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
+  const user = await prisma.user.findUnique({
+    where: { email },
+  });
+  if (!user) {
+    throw new ApiError(404, "User not found");
+  }
 
-    const existingOtp = await prisma.otp.findUnique({
+  const existingOtp = await prisma.otp.findUnique({
+    where: { email },
+  });
+  if (existingOtp) {
+    await prisma.otp.delete({
       where: { email },
     });
-    if (existingOtp) {
-      await prisma.otp.delete({
-        where: { email },
-      });
-    }
+  }
 
-    const otp = Math.floor(100000 + Math.random() * 900000).toString();
-    const hashedOtp = await bcrypt.hash(otp, 10);
+  const otp = Math.floor(100000 + Math.random() * 900000).toString();
+  const hashedOtp = await bcrypt.hash(otp, 10);
 
-    await prisma.otp.create({
-      data: {
-        email,
-        otp: hashedOtp,
-      },
-    });
+  await prisma.otp.create({
+    data: {
+      email,
+      otp: hashedOtp,
+    },
+  });
 
-    await sendOtpEmail(email, otp);
-    return true;
-  }
-export const verifyOtp = async ({ email, otp }) => {
-    const user = await prisma.user.findUnique({
-      where: { email },
-    });
-    if (!user) {
-      const err = new Error("User not found");
-      err.status = 404;
-      throw err;
-    }
+  await sendOtpEmail(email, otp);
+  return true;
+};
 
-    const existingOtp = await prisma.otp.findUnique({
-      where: { email },
-    });
-    if (!existingOtp) {
-      const err = new Error("OTP match failed");
-      err.status = 400;
-      throw err;
-    }
+export const verifyOtp = async ({ email, otp }) => {
+  const user = await prisma.user.findUnique({
+    where: { email },
+  });
+  if (!user) {
+    throw new ApiError(404, "User not found");
+  }
 
-    const isMatched = await bcrypt.compare(otp, existingOtp.otp);
-    if (!isMatched) {
-      const err = new Error("OTP match failed");
-      err.status = 400;
-      throw err;
-    }
+  const existingOtp = await prisma.otp.findUnique({
+    where: { email },
+  });
+  if (!existingOtp) {
+    throw new ApiError(400, "OTP match failed");
+  }
 
-    return user;
+  const isMatched = await bcrypt.compare(otp, existingOtp.otp);
+  if (!isMatched) {
+    throw new ApiError(400, "OTP match failed");
   }
+
+  return user;
+};
+
 export const resetPassword = async (user, newPassword) => {
-    const hashedPassword = await bcrypt.hash(newPassword, 10);
-    await prisma.user.update({
-      where: { id: user.id },
-      data: { password: hashedPassword },
-    });
-    return true;
-  }
+  const hashedPassword = await bcrypt.hash(newPassword, 10);
+  await prisma.user.update({
+    where: { id: user.id },
+    data: { password: hashedPassword },
+  });
+  return true;
+};
+
 export const updateProfile = async (userId, { name, phone, file }) => {
-    const user = await prisma.user.findUnique({
-      where: { id: userId },
+  const user = await prisma.user.findUnique({
+    where: { id: userId },
+  });
+  if (!user) {
+    throw new ApiError(404, "User not found");
+  }
+
+  const updateData = {};
+  if (name) updateData.name = name;
+  if (phone) updateData.phone = phone;
+
+  if (file) {
+    const uploadResult = await uploadSingleToCloudinary(file, {
+      folder: "codelab/avatars",
     });
-    if (!user) {
-      const err = new Error("User not found");
-      err.status = 404;
-      throw err;
+
+    if (user.avatarPublicId) {
+      await deleteFromCloudinary(user.avatarPublicId).catch((err) =>
+        logger.error("Old avatar delete error", err)
+      );
     }
 
-    const updateData = {};
-    if (name) updateData.name = name;
-    if (phone) updateData.phone = phone;
+    updateData.avatarUrl = uploadResult.url;
+    updateData.avatarPublicId = uploadResult.publicId;
+  }
 
-    if (file) {
-      const uploadResult = await uploadSingleToCloudinary(file, {
-        folder: "codelab/avatars",
-      });
+  const updatedUser = await prisma.user.update({
+    where: { id: userId },
+    data: updateData,
+  });
+
+  return updatedUser;
+};
+
+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");
+  }
 
-      if (user.avatarPublicId) {
-        await deleteFromCloudinary(user.avatarPublicId).catch((err) =>
-          logger.error("Old avatar delete error", err)
-        );
+  let user = await prisma.user.findUnique({ where: { email } });
+  if (!user) {
+    user = await prisma.user.create({
+      data: {
+        name: name || "User",
+        email: email.toLowerCase(),
+        password: "",
+        avatarUrl: picture || `https://placehold.co/600x400?text=${name?.charAt(0).toUpperCase() || 'U'}`,
+        avatarPublicId: "",
       }
-
-      updateData.avatarUrl = uploadResult.url;
-      updateData.avatarPublicId = uploadResult.publicId;
-    }
-
-    const updatedUser = await prisma.user.update({
-      where: { id: userId },
-      data: updateData,
     });
-
-    return updatedUser;
   }
+  return user;
+};

package/templates/layers/node-prisma/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-prisma/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-prisma/javascript/src/utils/apiResponse.js

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

package/templates/layers/node-prisma/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-prisma/typescript/.env.example

@@ -60,4 +60,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-prisma/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-prisma/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",
     "db:push": "prisma db push",
     "db:generate": "prisma generate",
     "generate:vapid": "node ./src/utils/generateVapidKeys.js"
@@ -30,7 +37,8 @@
     "web-push": "^3.6.6",
     "pg": "^8.11.3",
     "@prisma/adapter-pg": "^7.0.0",
-    "expo-server-sdk": "^3.10.0"
+    "expo-server-sdk": "^3.10.0",
+    "google-auth-library": "^9.14.2"
   },
   "devDependencies": {
     "@types/bcrypt": "^5.0.2",
@@ -41,12 +49,18 @@
     "@types/jsonwebtoken": "^9.0.5",
     "@types/morgan": "^1.9.9",
     "@types/multer": "^1.4.11",
+    "@types/node": "^20.9.0",
     "@types/nodemailer": "^6.4.14",
+    "@types/pg": "^8.11.0",
     "@types/web-push": "^3.6.3",
-    "@types/node": "^20.9.0",
+    "@typescript-eslint/eslint-plugin": "^6.10.0",
+    "@typescript-eslint/parser": "^6.10.0",
+    "dpdm": "^3.14.0",
+    "eslint": "^8.53.0",
+    "prettier": "^3.4.2",
     "prisma": "^7.0.0",
+    "ts-prune": "^0.10.3",
     "tsx": "^4.23.1",
-    "typescript": "^5.2.2",
-    "@types/pg": "^8.11.0"
+    "typescript": "^5.2.2"
   }
-}
+}

package/templates/layers/node-prisma/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-prisma/typescript/src/config/prisma.ts

@@ -15,8 +15,9 @@ const connectDB = async () => {
   try {
     await prisma.$connect();
     logger.success("Prisma Database connected successfully");
-  } catch (error: any) {
-    logger.error(`Prisma Database connection failed: ${error.message}`, error);
+  } catch (error: unknown) {
+    const err = error as Error;
+    logger.error(`Prisma Database connection failed: ${err.message}`, error);
     process.exit(1);
   }
 };

package/templates/layers/node-prisma/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,