@imksh/create 1.0.30 → 1.0.32

package/templates/layers/next/typescript/src/store/useAuthStore.ts

@@ -7,6 +7,7 @@ export interface User {
   email: string;
   phone?: string;
   role: string;
+  orgRole?: string;
   avatar?: {
     url?: string;
     publicId?: string;
@@ -15,6 +16,20 @@ export interface User {
   updatedAt?: string;
 }
 
+interface ApiErrorResponse {
+  response?: {
+    data?: {
+      message?: string;
+    };
+  };
+  message?: string;
+}
+
+const getErrorMessage = (err: unknown): string => {
+  const apiErr = err as ApiErrorResponse;
+  return apiErr.response?.data?.message || apiErr.message || "An unexpected error occurred";
+};
+
 export interface AuthState {
   user: User | null;
   loading: boolean;
@@ -39,9 +54,9 @@ export const useAuthStore = create<AuthState>((set) => ({
     try {
       await authService.sendOtp(email);
       return true;
-    } catch (err: any) {
+    } catch (err: unknown) {
       set({
-        error: err.response?.data?.message || err.message,
+        error: getErrorMessage(err),
         loading: false,
       });
       return false;
@@ -62,9 +77,9 @@ export const useAuthStore = create<AuthState>((set) => ({
         loading: false,
       });
       return true;
-    } catch (err: any) {
+    } catch (err: unknown) {
       set({
-        error: err.response?.data?.message || err.message,
+        error: getErrorMessage(err),
         loading: false,
       });
       return false;
@@ -85,9 +100,9 @@ export const useAuthStore = create<AuthState>((set) => ({
         loading: false,
       });
       return true;
-    } catch (err: any) {
+    } catch (err: unknown) {
       set({
-        error: err.response?.data?.message || err.message,
+        error: getErrorMessage(err),
         loading: false,
       });
       return false;
@@ -101,7 +116,7 @@ export const useAuthStore = create<AuthState>((set) => ({
     try {
       const { data } = await authService.getMe();
       set({ user: data.data, isCheckingAuth: false });
-    } catch (err: any) {
+    } catch {
       set({ isCheckingAuth: false });
     } finally {
       set({ isCheckingAuth: false });
@@ -114,9 +129,9 @@ export const useAuthStore = create<AuthState>((set) => ({
       const { data } = await authService.updateMe(updates);
       set({ user: data.data, loading: false });
       return true;
-    } catch (err: any) {
+    } catch (err: unknown) {
       set({
-        error: err.response?.data?.message || err.message,
+        error: getErrorMessage(err),
         loading: false,
       });
       return false;

package/templates/layers/next/typescript/src/store/useUiStore.ts

@@ -1,5 +1,6 @@
 import { create } from "zustand";
 import { ReactNode } from "react";
+import type { BreadcrumbItem } from "../components/common/Breadcrumbs";
 
 export interface UiState {
   open: boolean;
@@ -7,6 +8,8 @@ export interface UiState {
   isMobileMenuOpened: boolean;
   headerTitle: string;
   headerActions: ReactNode;
+  breadcrumbs: BreadcrumbItem[] | null;
+  setBreadcrumbs: (items: BreadcrumbItem[] | null) => void;
   setHeaderTitle: (title: string) => void;
   setHeaderActions: (actions: ReactNode) => void;
   toggleCollapsed: () => void;
@@ -18,6 +21,8 @@ export interface UiState {
   toggleSidebar: () => void;
   openSidebar: () => void;
   close: () => void;
+  modalOpen: boolean;
+  setModalOpen: (open: boolean) => void;
 }
 
 export const useUiStore = create<UiState>((set, get) => ({
@@ -26,6 +31,8 @@ export const useUiStore = create<UiState>((set, get) => ({
   isMobileMenuOpened: false,
   headerTitle: "Dashboard",
   headerActions: null,
+  breadcrumbs: null,
+  setBreadcrumbs: (items) => set({ breadcrumbs: items }),
   setHeaderTitle: (title: string) => set({ headerTitle: title }),
   setHeaderActions: (actions: ReactNode) => set({ headerActions: actions }),
   toggleCollapsed: () => set((state) => ({ collapsed: !state.collapsed })),
@@ -37,7 +44,10 @@ export const useUiStore = create<UiState>((set, get) => ({
     set((state) => ({ isMobileMenuOpened: !state.isMobileMenuOpened }));
   },
 
-  theme: typeof window !== "undefined" ? localStorage.getItem("theme") || "light" : "light",
+  theme:
+    typeof window !== "undefined"
+      ? localStorage.getItem("theme") || "light"
+      : "light",
 
   setTheme: (theme) => {
     if (typeof document !== "undefined") {
@@ -46,20 +56,17 @@ export const useUiStore = create<UiState>((set, get) => ({
     if (typeof window !== "undefined") {
       localStorage.setItem("theme", theme);
     }
-
     set({ theme });
   },
 
   toggleTheme: () => {
     const nextTheme = get().theme === "light" ? "dark" : "light";
-
     if (typeof document !== "undefined") {
       document.documentElement.setAttribute("data-theme", nextTheme);
     }
     if (typeof window !== "undefined") {
       localStorage.setItem("theme", nextTheme);
     }
-
     set({ theme: nextTheme });
   },
 
@@ -77,4 +84,7 @@ export const useUiStore = create<UiState>((set, get) => ({
     set({
       open: false,
     }),
+
+  modalOpen: false,
+  setModalOpen: (open) => set({ modalOpen: open }),
 }));

package/templates/layers/node/javascript/.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/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\"",
     "generate:vapid": "node ./src/utils/generateVapidKeys.js"
   },
   "dependencies": {
@@ -25,9 +30,13 @@
     "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": {
-    "nodemon": "^3.0.1"
+    "dpdm": "^3.14.0",
+    "eslint": "^8.53.0",
+    "nodemon": "^3.0.1",
+    "prettier": "^3.4.2"
   }
-}
+}

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

package/templates/layers/node/javascript/src/controllers/auth.controller.js

@@ -1,181 +1,119 @@
 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";
-
-export const signup = async (req, res, next) => {
-  try {
-    const { name, email, phone, password, otp } = req.body;
-
-    if (!email || !password || !name || !otp) {
-      return next({ status: 400, message: "All fields are required." });
-    }
-
-    const newUser = await authService.signup({ name, email, phone, password, otp });
-    const token = await generateToken(newUser, res);
-    const safeUser = newUser.toObject();
-    delete safeUser.password;
-
-    res
-      .status(201)
-      .json({ message: "Registration Successful", data: safeUser, token });
-  } catch (error) {
-    logger.error("Error in signup controller", error);
-    next(error);
+import { asyncHandler } from "../utils/asyncHandler.js";
+import { SuccessResponse } from "../utils/SuccessResponse.js";
+import { ApiError } from "../utils/ApiError.js";
+
+export const signup = asyncHandler(async (req, res) => {
+  const { name, email, phone, password, otp } = req.body;
+  if (!email || !password || !name || !otp) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
-
-export const login = async (req, res, next) => {
-  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 = user.toObject();
-    delete safeUser.password;
-
-    res
-      .status(200)
-      .json({ message: "Login successfully", data: safeUser, token });
-  } catch (error) {
-    logger.error("Error in login controller", error);
-    next(error);
+  const newUser = await authService.signup({ name, email, phone, password, otp });
+  const token = await generateToken(newUser, res);
+  const safeUser = newUser.toObject();
+  delete safeUser.password;
+  SuccessResponse(res, 201, "Registration Successful", { user: safeUser, token });
+});
+
+export const login = asyncHandler(async (req, res) => {
+  const { email, password } = req.body;
+  if (!email || !password) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
-
-export const logout = async (_req, res, next) => {
-  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);
+  const user = await authService.login({ email, password });
+  const token = await generateToken(user, res);
+  const safeUser = user.toObject();
+  delete safeUser.password;
+  SuccessResponse(res, 200, "Login successfully", { user: safeUser, token });
+});
+
+export const logout = asyncHandler(async (_req, res) => {
+  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, res) => {
+  const safeUser = typeof req.user?.toObject === "function" ? req.user.toObject() : { ...req.user };
+  delete safeUser.password;
+  SuccessResponse(res, 200, "User Authenticated", safeUser);
+});
+
+export const genSignupOtp = asyncHandler(async (req, res) => {
+  const { email } = req.body;
+  if (!email) {
+    throw new ApiError(400, "Email is required.");
   }
-};
-
-export const getMe = async (req, res, next) => {
-  try {
-    const safeUser = req.user.toObject();
-    delete safeUser.password;
-    res.status(200).json({ message: "User Authenticated", data: safeUser });
-  } catch (error) {
-    logger.error("Error in getMe controller", error);
-    next(error);
+  await authService.generateSignupOtp(email);
+  SuccessResponse(res, 200, "Signup Otp sent successfully");
+});
+
+export const genOtp = asyncHandler(async (req, res) => {
+  const { email } = req.body;
+  if (!email) {
+    throw new ApiError(400, "Email is required.");
   }
-};
-
-export const genSignupOtp = async (req, res, next) => {
-  try {
-    const { email } = req.body;
-
-    if (!email) {
-      return next({ status: 400, message: "Email is required." });
-    }
-
-    await authService.generateSignupOtp(email);
-    res.status(200).json({ message: "Signup Otp sent successfully" });
-  } catch (error) {
-    logger.error("Error in genSignupOtp", error);
-    next(error);
+  await authService.generateOtp(email);
+  SuccessResponse(res, 200, "Otp sent successfully");
+});
+
+export const verifyOtp = asyncHandler(async (req, res) => {
+  const { email, otp } = req.body;
+  if (!email || !otp) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
-
-export const genOtp = async (req, res, next) => {
-  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);
+  const user = await authService.verifyOtp({ email, otp });
+  await genOtpToken(user, res);
+  SuccessResponse(res, 200, "Otp verified successfully");
+});
+
+export const resetPassword = asyncHandler(async (req, res) => {
+  const { newPassword } = req.body;
+  const currentUser = req.user;
+  if (!newPassword) {
+    throw new ApiError(400, "All fields are required.");
   }
-};
-
-export const verifyOtp = async (req, res, next) => {
-  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);
+  await authService.resetPassword(currentUser, newPassword);
+  SuccessResponse(res, 200, "Password updated successfully");
+});
+
+export const updateMe = asyncHandler(async (req, res) => {
+  const { name, phone } = req.body;
+  const user = await authService.updateProfile(req.user._id, {
+    name,
+    phone,
+    file: req.file,
+  });
+  const safeUser = user.toObject();
+  delete safeUser.password;
+  SuccessResponse(res, 200, "Profile updated successfully", safeUser);
+});
+
+export const savePushToken = asyncHandler(async (req, res) => {
+  const { token } = req.body;
+  if (!token) {
+    throw new ApiError(400, "Token is required.");
   }
-};
-
-export const resetPassword = async (req, res, next) => {
-  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);
+  await authService.savePushToken(req.user._id, token);
+  SuccessResponse(res, 200, "Push token saved successfully");
+});
+
+export const googleLogin = asyncHandler(async (req, res) => {
+  const { idToken } = req.body;
+  if (!idToken) {
+    throw new ApiError(400, "idToken is required.");
   }
-};
-
-export const updateMe = async (req, res, next) => {
-  try {
-    const { name, phone } = req.body;
-    const user = await authService.updateProfile(req.user._id, {
-      name,
-      phone,
-      file: req.file,
-    });
-    const safeUser = user.toObject();
+  const user = await authService.googleLogin(idToken);
+  const token = await generateToken(user, res);
+  const safeUser = typeof user.toObject === "function" ? user.toObject() : { ...user };
+  if (safeUser.password !== undefined) {
     delete safeUser.password;
-    res.status(200).json({ success: true, data: safeUser });
-  } catch (error) {
-    logger.error("Error updating profile", error);
-    next(error);
-  }
-};
-
-export const savePushToken = async (req, res, next) => {
-  try {
-    const { token } = req.body;
-    if (!token) {
-      return next({ status: 400, message: "Token is required." });
-    }
-    await authService.savePushToken(req.user._id, token);
-    res.status(200).json({ success: true, message: "Push token saved successfully" });
-  } catch (error) {
-    logger.error("Error saving push token", error);
-    next(error);
   }
-};
+  SuccessResponse(res, 200, "Google Login successfully", { user: safeUser, token });
+});

package/templates/layers/node/javascript/src/controllers/push.controller.js

@@ -1,72 +1,65 @@
 import PushSubscription from "../models/pushSubscription.model.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, res, next) => {
-  try {
-    const subscription = req.body;
-    const userId = req.user?._id || req.user?.id; // supports both mongoose and prisma IDs
-    
-    if (!subscription) {
-      return next({ status: 400, message: "Invalid subscription payload" });
-    }
+export const subscribe = asyncHandler(async (req, res) => {
+  const subscription = req.body;
+  const userId = req.user?._id || req.user?.id; // supports both mongoose and prisma IDs
 
-    const isExpo = !!subscription.token;
-    const isWeb = !!(subscription.endpoint && subscription.keys);
+  if (!subscription) {
+    throw new ApiError(400, "Invalid subscription payload");
+  }
 
-    if (!isExpo && !isWeb) {
-      return next({ status: 400, message: "Missing token (EXPO) or endpoint/keys (WEB)" });
-    }
+  const isExpo = !!subscription.token;
+  const isWeb = !!(subscription.endpoint && subscription.keys);
 
-    if (isExpo) {
-      const existingSub = await PushSubscription.findOne({ expoPushToken: subscription.token });
-      if (existingSub) {
-        if (userId && String(existingSub.user) !== String(userId)) {
-          existingSub.user = userId; await existingSub.save();
-        }
-        return res.status(200).json({ success: true, message: "Already subscribed." });
-      }
+  if (!isExpo && !isWeb) {
+    throw new ApiError(400, "Missing token (EXPO) or endpoint/keys (WEB)");
+  }
 
-      await PushSubscription.create({
-        type: "EXPO",
-        expoPushToken: subscription.token,
-        user: userId || undefined
-      });
-    } else {
-      const existingSub = await PushSubscription.findOne({ endpoint: subscription.endpoint });
-      if (existingSub) {
-        if (userId && String(existingSub.user) !== String(userId)) {
-          existingSub.user = userId; await existingSub.save();
-        }
-        return res.status(200).json({ success: true, message: "Already subscribed." });
+  if (isExpo) {
+    const existingSub = await PushSubscription.findOne({ expoPushToken: subscription.token });
+    if (existingSub) {
+      if (userId && String(existingSub.user) !== String(userId)) {
+        existingSub.user = userId;
+        await existingSub.save();
       }
+      return SuccessResponse(res, 200, "Already subscribed.");
+    }
 
-      await PushSubscription.create({
-        type: "WEB",
-        endpoint: subscription.endpoint,
-        keys: subscription.keys,
-        user: userId || undefined
-      });
+    await PushSubscription.create({
+      type: "EXPO",
+      expoPushToken: subscription.token,
+      user: userId || undefined,
+    });
+  } else {
+    const existingSub = await PushSubscription.findOne({ endpoint: subscription.endpoint });
+    if (existingSub) {
+      if (userId && String(existingSub.user) !== String(userId)) {
+        existingSub.user = userId;
+        await existingSub.save();
+      }
+      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 PushSubscription.create({
+      type: "WEB",
+      endpoint: subscription.endpoint,
+      keys: subscription.keys,
+      user: userId || undefined,
+    });
   }
-};
 
-export const unsubscribe = async (req, res, next) => {
-  try {
-    const { endpoint } = req.body;
-    if (!endpoint) {
-      return next({ status: 400, message: "Endpoint required" });
-    }
+  SuccessResponse(res, 201, "Subscription created.");
+});
 
-    await PushSubscription.deleteOne({ endpoint });
-
-    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, res) => {
+  const { endpoint } = req.body;
+  if (!endpoint) {
+    throw new ApiError(400, "Endpoint required");
   }
-};
+
+  await PushSubscription.deleteOne({ endpoint });
+  SuccessResponse(res, 200, "Unsubscribed.");
+});

package/templates/layers/node/javascript/src/controllers/upload.controller.js

@@ -1,26 +1,19 @@
 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";
 
 /**
  * Handle single file uploads to Cloudinary
  */
-export const uploadFile = async (req, res, next) => {
-  try {
-    if (!req.file) {
-      return res.status(400).json({ success: false, message: "No file uploaded" });
-    }
+export const uploadFile = asyncHandler(async (req, res) => {
+  if (!req.file) {
+    throw new ApiError(400, "No file uploaded");
+  }
 
-    const result = await uploadSingleToCloudinary(req.file, {
-      folder: req.body.folder || "general_uploads",
-    });
+  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);
-  }
-};
+  SuccessResponse(res, 200, "File uploaded successfully", result);
+});