@imksh/create 1.0.31 → 1.0.33

package/templates/layers/node/typescript/src/services/auth.service.ts

@@ -1,4 +1,5 @@
-import User from "../models/user.model.js";
+import { OAuth2Client } from "google-auth-library";
+import User, { type IUser } from "../models/user.model.js";
 import Otp from "../models/otp.model.js";
 import bcrypt from "bcrypt";
 import { generateToken } from "../utils/jwt.js";
@@ -6,28 +7,55 @@ import { sendOtpEmail } from "../utils/emailOtp.js";
 import {
   uploadSingleToCloudinary,
   deleteFromCloudinary,
+  type CloudinaryUploadFile,
 } from "../utils/cloudinaryUpload.js";
 import logger from "../utils/logger.js";
+import { ApiError } from "../utils/ApiError.js";
 
-export const signup = async ({ name, email, phone, password, otp }: any) => {
+const googleClient = new OAuth2Client(process.env.GOOGLE_CLIENT_ID || "");
+
+export interface SignupDTO {
+  name: string;
+  email: string;
+  phone?: string;
+  password: string;
+  otp: string;
+}
+
+export interface LoginDTO {
+  email: string;
+  password: string;
+}
+
+export interface VerifyOtpDTO {
+  email: string;
+  otp: string;
+}
+
+export interface UpdateProfileDTO {
+  name?: string;
+  phone?: string;
+  file?: CloudinaryUploadFile;
+}
+
+export interface UserWithSave {
+  password?: string;
+  save: () => Promise<unknown>;
+}
+
+export const signup = async ({ name, email, phone, password, otp }: SignupDTO) => {
   const existingUser = await User.findOne({ email });
   if (existingUser) {
-    const err: any = new Error("User already exists");
-    err.status = 409;
-    throw err;
+    throw new ApiError(409, "User already exists");
   }
 
   const existingOtp = await Otp.findOne({ email });
   if (!existingOtp) {
-    const err: any = new Error("OTP match failed");
-    err.status = 400;
-    throw err;
+    throw new ApiError(400, "OTP match failed");
   }
   const isMatched = await bcrypt.compare(otp, existingOtp.otp);
   if (!isMatched) {
-    const err: any = new Error("OTP match failed");
-    err.status = 400;
-    throw err;
+    throw new ApiError(400, "OTP match failed");
   }
   const salt = await bcrypt.genSalt(10);
   const hashedPassword = await bcrypt.hash(password, salt);
@@ -44,27 +72,23 @@ export const signup = async ({ name, email, phone, password, otp }: any) => {
   await existingOtp.deleteOne(); // delete OTP after successful signup
   return newUser;
 };
-export const login = async ({ email, password }: any) => {
+
+export const login = async ({ email, password }: LoginDTO) => {
   const user = await User.findOne({ email });
   if (!user || !user.password) {
-    const err: any = new Error("Invalid Credentials");
-    err.status = 401;
-    throw err;
+    throw new ApiError(401, "Invalid Credentials");
   }
   const isValid = await bcrypt.compare(password, user.password);
   if (!isValid) {
-    const err: any = new Error("Invalid Credentials");
-    err.status = 401;
-    throw err;
+    throw new ApiError(401, "Invalid Credentials");
   }
   return user;
 };
+
 export const generateSignupOtp = async (email: string) => {
   const user = await User.findOne({ email });
   if (user) {
-    const err: any = new Error("User already exists");
-    err.status = 409;
-    throw err;
+    throw new ApiError(409, "User already exists");
   }
   const existingOtp = await Otp.findOne({ email });
   if (existingOtp) {
@@ -76,12 +100,11 @@ export const generateSignupOtp = async (email: string) => {
   await sendOtpEmail(email, otp);
   return true;
 };
+
 export const generateOtp = async (email: string) => {
   const user = await User.findOne({ email });
   if (!user) {
-    const err: any = new Error("User not found");
-    err.status = 404;
-    throw err;
+    throw new ApiError(404, "User not found");
   }
   const existingOtp = await Otp.findOne({ email });
   if (existingOtp) {
@@ -93,42 +116,37 @@ export const generateOtp = async (email: string) => {
   await sendOtpEmail(email, otp);
   return true;
 };
-export const verifyOtp = async ({ email, otp }: any) => {
+
+export const verifyOtp = async ({ email, otp }: VerifyOtpDTO) => {
   const user = await User.findOne({ email });
   if (!user) {
-    const err: any = new Error("User not found");
-    err.status = 404;
-    throw err;
+    throw new ApiError(404, "User not found");
   }
   const existingOtp = await Otp.findOne({ email });
   if (!existingOtp) {
-    const err: any = new Error("OTP match failed");
-    err.status = 400;
-    throw err;
+    throw new ApiError(400, "OTP match failed");
   }
   const isMatched = await bcrypt.compare(otp, existingOtp.otp);
   if (!isMatched) {
-    const err: any = new Error("OTP match failed");
-    err.status = 400;
-    throw err;
+    throw new ApiError(400, "OTP match failed");
   }
   return user;
 };
-export const resetPassword = async (user: any, newPassword: any) => {
+
+export const resetPassword = async (user: UserWithSave, newPassword: string) => {
   const hashedPassword = await bcrypt.hash(newPassword, 10);
   user.password = hashedPassword;
   await user.save();
   return true;
 };
+
 export const updateProfile = async (
-  userId: any,
-  { name, phone, file }: any,
+  userId: string,
+  { name, phone, file }: UpdateProfileDTO,
 ) => {
   const user = await User.findById(userId);
   if (!user) {
-    const err: any = new Error("User not found");
-    err.status = 404;
-    throw err;
+    throw new ApiError(404, "User not found");
   }
   if (name) user.name = name;
   if (phone) user.phone = phone;
@@ -153,9 +171,7 @@ export const updateProfile = async (
 export const savePushToken = async (userId: string, token: string) => {
   const user = await User.findById(userId);
   if (!user) {
-    const err: any = 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);
@@ -163,3 +179,30 @@ export const savePushToken = async (userId: string, token: string) => {
   }
   return user;
 };
+
+export const googleLogin = async (idToken: string) => {
+  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/typescript/src/types/express.d.ts

@@ -1,10 +1,12 @@
-import { Express } from "express";
+import type { CloudinaryUploadFile } from "../utils/cloudinaryUpload.js";
+
+export {};
 
 declare global {
   namespace Express {
     interface Request {
-      user?: any;
-      file?: any;
+      user?: Record<string, unknown> & { _id?: unknown; id?: unknown; toObject?: () => Record<string, unknown> };
+      file?: CloudinaryUploadFile;
     }
   }
 }

package/templates/layers/node/typescript/src/utils/ApiError.ts

@@ -0,0 +1,25 @@
+export class ApiError extends Error {
+  public statusCode: number;
+  public data: unknown;
+  public success: boolean;
+  public errors: unknown[];
+
+  constructor(
+    statusCode: number,
+    message: string = "Something went wrong",
+    errors: unknown[] = [],
+    stack: string = "",
+  ) {
+    super(message);
+    this.statusCode = statusCode;
+    this.data = null;
+    this.success = false;
+    this.errors = errors;
+
+    if (stack) {
+      this.stack = stack;
+    } else if (typeof (Error as unknown as { captureStackTrace?: (target: object, constructor: unknown) => void }).captureStackTrace === "function") {
+      (Error as unknown as { captureStackTrace: (target: object, constructor: unknown) => void }).captureStackTrace(this, this.constructor);
+    }
+  }
+}

package/templates/layers/node/typescript/src/utils/SuccessResponse.ts

@@ -0,0 +1,17 @@
+import { Response } from "express";
+
+export const SuccessResponse = (
+  res: Response,
+  statusCode: number,
+  message: string = "Success",
+  data: unknown = null,
+  pagination?: unknown,
+) => {
+  return res.status(statusCode).json({
+    success: statusCode < 400,
+    statusCode,
+    message,
+    data,
+    ...(pagination ? { pagination } : {}),
+  });
+};

package/templates/layers/node/typescript/src/utils/apiResponse.ts

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

package/templates/layers/node/typescript/src/utils/asyncHandler.ts

@@ -0,0 +1,13 @@
+import { Request, Response, NextFunction } from "express";
+
+export const asyncHandler = (
+  requestHandler: (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ) => Promise<unknown>,
+) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    Promise.resolve(requestHandler(req, res, next)).catch((err) => next(err));
+  };
+};

package/templates/layers/node/typescript/src/utils/cloudinaryUpload.ts

@@ -1,11 +1,22 @@
 import cloudinary from "../config/cloudinary.js";
 import logger from "./logger.js";
 
-const uploadToCloudinary = async (file: any, options: any = {}) => {
+export interface CloudinaryUploadFile {
+  mimetype?: string;
+  buffer?: Buffer;
+  [key: string]: unknown;
+}
+
+export interface CloudinaryOptions {
+  folder?: string;
+  [key: string]: unknown;
+}
+
+const uploadToCloudinary = async (file: CloudinaryUploadFile, options: CloudinaryOptions = {}) => {
   if (!file?.buffer) {
     throw new Error("Invalid file.");
   }
-  const dataURI = `data:${file.mimetype};base64,${file.buffer.toString("base64")}`;
+  const dataURI = `data:${file.mimetype || "application/octet-stream"};base64,${file.buffer.toString("base64")}`;
   const result = await cloudinary.uploader.upload(dataURI, {
     folder: options.folder || "uploads",
     ...options,
@@ -16,19 +27,19 @@ const uploadToCloudinary = async (file: any, options: any = {}) => {
   };
 };
 
-export const uploadSingleToCloudinary = async (file: any, options: any = {}) => {
+export const uploadSingleToCloudinary = async (file: CloudinaryUploadFile, options: CloudinaryOptions = {}) => {
   try {
     return await uploadToCloudinary(file, options);
-  } catch (error) {
+  } catch (error: unknown) {
     logger.error("Cloudinary Upload Error", error);
     throw new Error("Failed to upload image.");
   }
 };
 
-export const uploadMultipleToCloudinary = async (files: any[] = [], options: any = {}) => {
+export const uploadMultipleToCloudinary = async (files: CloudinaryUploadFile[] = [], options: CloudinaryOptions = {}) => {
   try {
     return await Promise.all(files.map((file) => uploadToCloudinary(file, options)));
-  } catch (error) {
+  } catch (error: unknown) {
     logger.error("Cloudinary Upload Error", error);
     throw new Error("Failed to upload images.");
   }
@@ -37,7 +48,7 @@ export const uploadMultipleToCloudinary = async (files: any[] = [], options: any
 export const deleteFromCloudinary = async (publicId: string) => {
   try {
     return await cloudinary.uploader.destroy(publicId);
-  } catch (error) {
+  } catch (error: unknown) {
     logger.error("Cloudinary Delete Error", error);
     throw new Error("Failed to delete image.");
   }

package/templates/layers/node/typescript/src/utils/expoNotification.ts

@@ -10,7 +10,7 @@ const expo = new Expo();
 export interface PushMessagePayload {
   title: string;
   body: string;
-  data?: Record<string, any>;
+  data?: Record<string, unknown>;
 }
 
 /**

package/templates/layers/node/typescript/src/utils/genOtpToken.ts

@@ -1,7 +1,13 @@
 import jwt from "jsonwebtoken";
 import { Response } from "express";
 
-const genOtpToken = (user: any, res?: Response) => {
+export interface UserOtpTokenPayload {
+  _id?: unknown;
+  id?: unknown;
+  [key: string]: unknown;
+}
+
+const genOtpToken = (user: UserOtpTokenPayload, res?: Response) => {
   const JWT_SECRET = process.env.JWT_SECRET || "fallbacksecret";
   const token = jwt.sign({ id: user._id || user.id }, JWT_SECRET, {
     expiresIn: "10m",

package/templates/layers/node/typescript/src/utils/jwt.ts

@@ -1,7 +1,13 @@
 import jwt from "jsonwebtoken";
 import { Response } from "express";
 
-export const generateToken = (user: any, res?: Response) => {
+export interface UserTokenPayload {
+  _id?: unknown;
+  id?: unknown;
+  [key: string]: unknown;
+}
+
+export const generateToken = (user: UserTokenPayload, res?: Response) => {
   const payload = { id: user._id || user.id };
   const JWT_SECRET = process.env.JWT_SECRET || "fallbacksecret";
   const token = jwt.sign(payload, JWT_SECRET, { expiresIn: "30d" });
@@ -21,7 +27,7 @@ export const verifyToken = (token: string) => {
   try {
     const JWT_SECRET = process.env.JWT_SECRET || "fallbacksecret";
     return jwt.verify(token, JWT_SECRET);
-  } catch (error) {
+  } catch {
     return null;
   }
 };

package/templates/layers/node/typescript/src/utils/logger.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 const colors = {
   reset: "\x1b[0m",
   info: "\x1b[36m", // Cyan
@@ -18,7 +19,7 @@ export const logger = {
   info: (msg: string) => console.log(formatMessage("info", msg)),
   success: (msg: string) => console.log(formatMessage("success", msg)),
   warn: (msg: string) => console.warn(formatMessage("warn", msg)),
-  error: (msg: string, err?: any) => {
+  error: (msg: string, err?: unknown) => {
     console.error(formatMessage("error", msg));
     if (err) console.error(err);
   },

package/templates/layers/node/typescript/src/utils/pushHelper.ts

@@ -1,7 +1,7 @@
 import webpush from "../config/webPush.js";
-import { Expo, ExpoPushMessage, ExpoPushTicket } from "expo-server-sdk";
+import { Expo, ExpoPushMessage } from "expo-server-sdk";
 import logger from "./logger.js";
-import PushSubscription from "../models/pushSubscription.model.js";
+import PushSubscription, { type IPushSubscription } from "../models/pushSubscription.model.js";
 
 const expo = new Expo();
 
@@ -19,7 +19,7 @@ export const sendPushToUser = async (
   url: string = "/",
 ) => {
   try {
-    const subscriptions = await PushSubscription.find({ user: userId });
+    const subscriptions: IPushSubscription[] = await PushSubscription.find({ user: userId });
 
     if (subscriptions.length === 0) return;
 
@@ -30,13 +30,17 @@ export const sendPushToUser = async (
     if (webSubs.length > 0) {
       const payload = JSON.stringify({ title, body, url });
       await Promise.allSettled(
-        webSubs.map(async (sub) => {
+        webSubs.map(async (sub: IPushSubscription) => {
           if (!sub.endpoint || !sub.keys) return;
-          const pushSub = { endpoint: sub.endpoint, keys: sub.keys as any };
+          const pushSub = {
+            endpoint: sub.endpoint,
+            keys: sub.keys as { p256dh: string; auth: string },
+          };
           try {
             await webpush.sendNotification(pushSub, payload);
-          } catch (err: any) {
-            if (err.statusCode === 404 || err.statusCode === 410) {
+          } catch (err: unknown) {
+            const error = err as { statusCode?: number };
+            if (error.statusCode === 404 || error.statusCode === 410) {
               await sub.deleteOne();
             } else {
               logger.error("Web Push Error", err);
@@ -64,12 +68,12 @@ export const sendPushToUser = async (
       for (const chunk of chunks) {
         try {
           await expo.sendPushNotificationsAsync(chunk);
-        } catch (error) {
+        } catch (error: unknown) {
           logger.error("Error sending push notification chunk", error);
         }
       }
     }
-  } catch (error) {
+  } catch (error: unknown) {
     logger.error("Error sending push notification to user", error);
   }
 };

package/templates/layers/node-prisma/javascript/.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/javascript/package.json

@@ -6,6 +6,11 @@
   "scripts": {
     "start": "node src/index.js",
     "dev": "nodemon src/index.js",
+    "lint": "eslint src/**/*.js",
+    "lint:fix": "eslint src/**/*.js --fix",
+    "format": "prettier --write \"src/**/*.{js,json}\"",
+    "format:check": "prettier --check \"src/**/*.{js,json}\"",
+    "circular-check": "dpdm --circular --no-warning --no-tree --exit-code circular:1 \"src/**/*.js\"",
     "db:push": "prisma db push",
     "db:generate": "prisma generate",
     "generate:vapid": "node ./src/utils/generateVapidKeys.js"
@@ -29,10 +34,14 @@
     "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": {
+    "dpdm": "^3.14.0",
+    "eslint": "^8.53.0",
     "nodemon": "^3.0.1",
+    "prettier": "^3.4.2",
     "prisma": "^7.0.0"
   }
-}
+}

package/templates/layers/node-prisma/javascript/src/app.js

@@ -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();
 
@@ -32,7 +33,7 @@ app.use("/api", apiRoutes);
 
 // Example health route
 app.get("/api/health", (req, res) => {
-  res.status(200).json({ success: true, message: "API is running" });
+  SuccessResponse(res, 200, "API is running");
 });
 
 // Error handling middlewares