@imksh/create 1.0.31 → 1.0.33

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

@@ -1,19 +1,46 @@
+import { OAuth2Client } from "google-auth-library";
 import bcrypt from "bcrypt";
 import { prisma } from "../config/prisma.js";
 import { sendOtpEmail } from "../utils/emailOtp.js";
 import {
   uploadSingleToCloudinary,
   deleteFromCloudinary,
+  type CloudinaryUploadFile,
 } from "../utils/cloudinaryUpload.js";
 import logger from "../utils/logger.js";
-export const signup = async ({ name, email, phone, password }: any) => {
+import { ApiError } from "../utils/ApiError.js";
+
+const googleClient = new OAuth2Client(process.env.GOOGLE_CLIENT_ID || "");
+
+export interface SignupDTO {
+  name: string;
+  email: string;
+  phone?: string;
+  password: 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 const signup = async ({ name, email, phone, password }: SignupDTO) => {
   const existingUser = await prisma.user.findUnique({
     where: { email },
   });
   if (existingUser) {
-    const err: any = new Error("User already exists");
-    err.status = 409;
-    throw err;
+    throw new ApiError(409, "User already exists");
   }
 
   const salt = await bcrypt.genSalt(10);
@@ -33,33 +60,29 @@ export const signup = async ({ name, email, phone, password }: any) => {
 
   return newUser;
 };
-export const login = async ({ email, password }: any) => {
+
+export const login = async ({ email, password }: LoginDTO) => {
   const user = await prisma.user.findUnique({
     where: { email },
   });
   if (!user) {
-    const err: any = new Error("User not found");
-    err.status = 404;
-    throw err;
+    throw new ApiError(404, "User not found");
   }
 
   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 generateOtp = async (email: string) => {
   const user = await prisma.user.findUnique({
     where: { 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 prisma.otp.findUnique({
@@ -84,35 +107,31 @@ 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 prisma.user.findUnique({
     where: { 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 prisma.otp.findUnique({
     where: { 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: { id: string }, newPassword: string) => {
   const hashedPassword = await bcrypt.hash(newPassword, 10);
   await prisma.user.update({
     where: { id: user.id },
@@ -120,20 +139,24 @@ export const resetPassword = async (user: any, newPassword: any) => {
   });
   return true;
 };
+
 export const updateProfile = async (
-  userId: any,
-  { name, phone, file }: any,
+  userId: string,
+  { name, phone, file }: UpdateProfileDTO,
 ) => {
   const user = await prisma.user.findUnique({
     where: { id: userId },
   });
   if (!user) {
-    const err: any = new Error("User not found");
-    err.status = 404;
-    throw err;
+    throw new ApiError(404, "User not found");
   }
 
-  const updateData: any = {};
+  const updateData: {
+    name?: string;
+    phone?: string;
+    avatarUrl?: string;
+    avatarPublicId?: string;
+  } = {};
   if (name) updateData.name = name;
   if (phone) updateData.phone = phone;
 
@@ -159,3 +182,32 @@ export const updateProfile = async (
 
   return updatedUser;
 };
+
+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 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: "",
+      }
+    });
+  }
+  return user;
+};

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

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

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

@@ -1,5 +1,5 @@
 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 { prisma } from "../config/prisma.js";
 
@@ -34,11 +34,15 @@ export const sendPushToUser = async (
       await Promise.allSettled(
         webSubs.map(async (sub) => {
           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 unknown 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 prisma.pushSubscription.delete({ where: { id: sub.id } }).catch(() => {});
             } else {
               logger.error("Web Push Error", err);
@@ -66,12 +70,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/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,7 +34,10 @@
     "web-push": "^3.6.6"
   },
   "devDependencies": {
+    "dpdm": "^3.14.0",
+    "eslint": "^8.53.0",
     "nodemon": "^3.0.1",
+    "prettier": "^3.4.2",
     "prisma": "^5.6.0"
   }
 }

package/templates/layers/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"
@@ -38,10 +45,16 @@
     "@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/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": "^5.6.0",
+    "ts-prune": "^0.10.3",
     "tsx": "^4.23.1",
     "typescript": "^5.2.2"
   }

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

@@ -7,8 +7,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/react/javascript/package.json

@@ -7,6 +7,10 @@
     "dev": "vite",
     "build": "vite build",
     "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0",
+    "lint:fix": "eslint . --ext js,jsx --fix",
+    "format": "prettier --write \"src/**/*.{js,jsx,css,json}\"",
+    "format:check": "prettier --check \"src/**/*.{js,jsx,css,json}\"",
+    "circular-check": "dpdm --circular --no-warning --no-tree --exit-code circular:1 \"src/**/*.{js,jsx}\"",
     "preview": "vite preview"
   },
   "dependencies": {
@@ -29,10 +33,12 @@
     "@types/react": "^18.2.37",
     "@types/react-dom": "^18.2.15",
     "@vitejs/plugin-react": "^4.2.0",
+    "dpdm": "^3.14.0",
     "eslint": "^8.53.0",
     "eslint-plugin-react": "^7.33.2",
     "eslint-plugin-react-hooks": "^4.6.0",
     "eslint-plugin-react-refresh": "^0.4.4",
+    "prettier": "^3.4.2",
     "vite": "^5.0.0"
   }
 }

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

@@ -0,0 +1,20 @@
+module.exports = {
+  root: true,
+  env: { browser: true, es2020: true },
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:react-hooks/recommended",
+  ],
+  ignorePatterns: ["dist", ".eslintrc.cjs"],
+  parser: "@typescript-eslint/parser",
+  plugins: ["react-refresh", "@typescript-eslint"],
+  rules: {
+    "@typescript-eslint/no-explicit-any": "error",
+    "no-console": "error",
+    "react-refresh/only-export-components": [
+      "warn",
+      { allowConstantExport: true },
+    ],
+  },
+};

package/templates/layers/react/typescript/package.json

@@ -7,6 +7,12 @@
     "dev": "vite",
     "build": "tsc && vite build",
     "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
+    "lint:fix": "eslint . --ext ts,tsx --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx,css,json}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,tsx,css,json}\"",
+    "circular-check": "dpdm --circular --no-warning --no-tree --exit-code circular:1 \"src/**/*.{ts,tsx}\"",
+    "ts-prune": "ts-prune",
+    "ts-purns": "ts-prune",
     "preview": "vite preview"
   },
   "dependencies": {
@@ -31,11 +37,14 @@
     "@typescript-eslint/eslint-plugin": "^6.10.0",
     "@typescript-eslint/parser": "^6.10.0",
     "@vitejs/plugin-react": "^4.2.0",
+    "dpdm": "^3.14.0",
     "eslint": "^8.53.0",
+    "eslint-plugin-react": "^7.33.2",
     "eslint-plugin-react-hooks": "^4.6.0",
     "eslint-plugin-react-refresh": "^0.4.4",
+    "prettier": "^3.4.2",
+    "ts-prune": "^0.10.3",
     "typescript": "^5.2.2",
-    "vite": "^5.0.0",
-    "eslint-plugin-react": "^7.33.2"
+    "vite": "^5.0.0"
   }
 }

package/templates/layers/react/typescript/src/components/common/Table.tsx

@@ -1,14 +1,14 @@
 import React, { useEffect, useRef } from "react";
 import { Pagination } from "./Pagination";
 
-export interface TableColumn<T = any> {
+export interface TableColumn<T = Record<string, unknown>> {
   header: React.ReactNode | string;
   accessor?: keyof T | string;
-  render?: (value: any, row: T, index: number) => React.ReactNode;
+  render?: (value: unknown, row: T, index: number) => React.ReactNode;
   headerClass?: string;
 }
 
-interface TableProps<T = any> {
+interface TableProps<T = Record<string, unknown>> {
   columns: TableColumn<T>[];
   data: T[];
   loading?: boolean;
@@ -23,7 +23,7 @@ interface TableProps<T = any> {
   header?: React.ReactNode; // custom header content to render above the table
 }
 
-const Table = <T extends Record<string, any>>({
+const Table = <T extends Record<string, unknown>>({
   columns = [],
   data = [],
   loading = false,

package/templates/layers/react/typescript/src/components/ui/Sidebar.tsx

@@ -89,7 +89,7 @@ const Sidebar = () => {
             >
               {navigation
                 .filter((item) => {
-                  const orgRole = (user as any)?.orgRole;
+                  const orgRole = user?.orgRole;
                   const isUserAdmin =
                     user?.role === "ADMIN" ||
                     orgRole === "OWNER" ||

package/templates/layers/react/typescript/src/main.tsx

@@ -8,17 +8,17 @@ if ("serviceWorker" in navigator) {
   window.addEventListener("load", () => {
     navigator.serviceWorker
       .register("/sw.js")
-      .then((reg) =>
-        console.log("Service Worker registered successfully:", reg.scope),
-      )
-      .catch((err) => console.log("Service Worker registration failed:", err));
+      .catch(() => {});
   });
 }
 
-ReactDOM.createRoot(document.getElementById("root")).render(
-  <React.StrictMode>
-    <BrowserRouter>
-      <App />
-    </BrowserRouter>
-  </React.StrictMode>,
-);
+const rootElement = document.getElementById("root");
+if (rootElement) {
+  ReactDOM.createRoot(rootElement).render(
+    <React.StrictMode>
+      <BrowserRouter>
+        <App />
+      </BrowserRouter>
+    </React.StrictMode>,
+  );
+}

package/templates/layers/react/typescript/src/services/authService.ts

@@ -12,7 +12,7 @@ export const authService = {
 
   getMe: () => api.get("/auth/me"),
 
-  updateMe: (data: any) => api.put("/auth/me", data),
+  updateMe: (data: FormData | Record<string, unknown>) => api.put("/auth/me", data),
 
   logout: () =>
     api.post("/auth/logout"),