exp-node-server 1.1.7 → 2.0.0

package/templates/mongoose/src/app/modules/auth/auth.swagger.ts

@@ -1,214 +0,0 @@
-export const authSwaggerDocs = {
-    "/api/auth/register": {
-        post: {
-            tags: ["Auth"],
-            summary: "Register a new user",
-            description: "Create a new user account with email, number, password, and name.",
-            requestBody: {
-                required: true,
-                content: {
-                    "application/json": {
-                        schema: {
-                            type: "object",
-                            required: ["email", "number", "password", "name"],
-                            properties: {
-                                email: { type: "string", example: "user@example.com" },
-                                number: { type: "string", example: "+1234567890" },
-                                password: { type: "string", example: "secret123" },
-                                name: { type: "string", example: "John Doe" }
-                            }
-                        }
-                    }
-                }
-            },
-            responses: {
-                201: { description: "User registered successfully" },
-                400: { description: "Validation error or user already exists" }
-            }
-        }
-    },
-
-    "/api/auth/login": {
-        post: {
-            tags: ["Auth"],
-            summary: "Login a user",
-            description: "Authenticate user with email and password.",
-            requestBody: {
-                required: true,
-                content: {
-                    "application/json": {
-                        schema: {
-                            type: "object",
-                            required: ["email", "password"],
-                            properties: {
-                                email: { type: "string", example: "user@example.com" },
-                                password: { type: "string", example: "secret123" }
-                            }
-                        }
-                    }
-                }
-            },
-            responses: {
-                200: { description: "User logged in successfully" },
-                401: { description: "Invalid credentials" }
-            }
-        }
-    },
-
-    "/api/auth/me": {
-        get: {
-            tags: ["Auth"],
-            summary: "Get logged-in user's profile",
-            description: "Fetch the authenticated user's profile details.",
-            security: [{ bearerAuth: [] }],
-            responses: {
-                200: { description: "Profile data retrieved successfully" },
-                401: { description: "Unauthorized" }
-            }
-        }
-    },
-
-    "/api/auth/refresh-token": {
-        post: {
-            tags: ["Auth"],
-            summary: "Refresh JWT token",
-            description: "Refresh the access token using a valid refresh token.",
-            responses: {
-                200: { description: "Token refreshed successfully" },
-                401: { description: "Invalid or expired refresh token" }
-            }
-        }
-    },
-
-    "/api/auth/change-password": {
-        post: {
-            tags: ["Auth"],
-            summary: "Change password (authenticated users)",
-            security: [{ bearerAuth: [] }],
-            requestBody: {
-                required: true,
-                content: {
-                    "application/json": {
-                        schema: {
-                            type: "object",
-                            required: ["oldPassword", "newPassword"],
-                            properties: {
-                                oldPassword: { type: "string", example: "oldPass123" },
-                                newPassword: { type: "string", example: "newPass456" }
-                            }
-                        }
-                    }
-                }
-            },
-            responses: {
-                200: { description: "Password changed successfully" },
-                400: { description: "Invalid old password or bad request" }
-            }
-        }
-    },
-
-    "/api/auth/forgot-password": {
-        post: {
-            tags: ["Auth"],
-            summary: "Request password reset",
-            requestBody: {
-                required: true,
-                content: {
-                    "application/json": {
-                        schema: {
-                            type: "object",
-                            required: ["email"],
-                            properties: {
-                                email: { type: "string", example: "user@example.com" }
-                            }
-                        }
-                    }
-                }
-            },
-            responses: {
-                200: { description: "Password reset link sent to email" },
-                404: { description: "User not found" }
-            }
-        }
-    },
-
-    "/api/auth/reset-password": {
-        post: {
-            tags: ["Auth"],
-            summary: "Reset password using token",
-            description: "Reset the user's password using a valid token sent to their email.",
-            requestBody: {
-                required: true,
-                content: {
-                    "application/json": {
-                        schema: {
-                            type: "object",
-                            required: ["token", "email", "newPassword"],
-                            properties: {
-                                token: { type: "string", example: "eyJhbGciOiJIUz..." },
-                                email: { type: "string", example: "user@example.com" },
-                                newPassword: { type: "string", example: "newSecret123" }
-                            }
-                        }
-                    }
-                }
-            },
-            responses: {
-                200: { description: "Password reset successfully" },
-                400: { description: "Invalid or expired token" }
-            }
-        }
-    },
-
-    "/api/auth/verified-account": {
-        post: {
-            tags: ["Auth"],
-            summary: "Verify account using token",
-            description: "Verify a user's email account using a verification token.",
-            requestBody: {
-                required: true,
-                content: {
-                    "application/json": {
-                        schema: {
-                            type: "object",
-                            required: ["token"],
-                            properties: {
-                                token: { type: "string", example: "eyJhbGciOiJIUzI1NiIs..." }
-                            }
-                        }
-                    }
-                }
-            },
-            responses: {
-                200: { description: "Account verified successfully" },
-                400: { description: "Invalid or expired token" }
-            }
-        }
-    },
-
-    "/api/auth/new-verification-link": {
-        post: {
-            tags: ["Auth"],
-            summary: "Request a new verification link",
-            description: "Send a new verification link to the user's email address.",
-            requestBody: {
-                required: true,
-                content: {
-                    "application/json": {
-                        schema: {
-                            type: "object",
-                            required: ["email"],
-                            properties: {
-                                email: { type: "string", example: "user@example.com" }
-                            }
-                        }
-                    }
-                }
-            },
-            responses: {
-                200: { description: "Verification link resent successfully" },
-                404: { description: "User not found or already verified" }
-            }
-        }
-    }
-};

package/templates/mongoose/src/app/modules/auth/auth.validation.ts

@@ -1,37 +0,0 @@
-import { z } from "zod";
-
-// Zod schema matching TAccount / authSchema
-const register_validation = z.object({
-    email: z.string({ message: "Email is required" }).email(),
-    password: z.string({ message: "Password is required" }),
-    name: z.string({ message: "Name is required" })
-});
-
-const login_validation = z.object({
-    email: z.string({ message: "Email is required" }),
-    password: z.string({ message: "Email is required" })
-})
-
-const changePassword = z.object({
-    oldPassword: z.string({ message: "Old Password is required" }),
-    newPassword: z.string({ message: "New Password is required" })
-})
-
-const forgotPassword = z.object({ email: z.string({ message: "Email is required" }) })
-const resetPassword = z.object({
-    token: z.string(),
-    newPassword: z.string(),
-    email: z.string()
-})
-const verified_account = z.object({
-    token: z.string({ message: "Token is Required!!" })
-})
-
-export const auth_validation = {
-    register_validation,
-    login_validation,
-    changePassword,
-    forgotPassword,
-    resetPassword,
-    verified_account
-}

package/templates/mongoose/src/app/modules/user/user.controller.ts

@@ -1,17 +0,0 @@
-import catchAsync from "../../utils/catch_async";
-import manageResponse from "../../utils/manage_response";
-import { user_services } from "./user.service";
-
-const update_profile = catchAsync(async (req, res) => {
-  const result = await user_services.update_profile_into_db(req);
-  manageResponse(res, {
-    success: true,
-    statusCode: 200,
-    message: "Profile update successful.",
-    data: result,
-  });
-});
-
-export const user_controllers = {
-  update_profile,
-};

package/templates/mongoose/src/app/modules/user/user.interface.ts

@@ -1,15 +0,0 @@
-import { Types } from "mongoose"
-
-export type TUser = {
-    name: string,
-    photo?: string,
-    address?: {
-        location?: string,
-        city?: string,
-        state?: string,
-        postCode?: string,
-        country?: string,
-        timeZone?: string
-    },
-    accountId?: Types.ObjectId
-}

package/templates/mongoose/src/app/modules/user/user.route.ts

@@ -1,20 +0,0 @@
-import { NextFunction, Request, Response, Router } from "express";
-import { user_controllers } from "./user.controller";
-import uploader from "../../middlewares/uploader";
-import { user_validations } from "./user.validation";
-import auth from "../../middlewares/auth";
-
-const userRoute = Router()
-
-userRoute.patch(
-    "/update-profile",
-    auth("ADMIN","USER"),
-    uploader.single("image"),
-    (req: Request, res: Response, next: NextFunction) => {
-        req.body = user_validations.update_user.parse(JSON.parse(req?.body?.data))
-        user_controllers.update_profile(req, res, next)
-    },
-)
-
-
-export default userRoute;

package/templates/mongoose/src/app/modules/user/user.schema.ts

@@ -1,22 +0,0 @@
-import { model, Schema } from "mongoose";
-import { TUser } from "./user.interface";
-
-const user_schema = new Schema<TUser>({
-    name: { type: String, required: true },
-    photo: { type: String, required: false },
-    accountId: { type: String, required: false, ref: "account" },
-    address: {
-        location: { type: String },
-        city: { type: String },
-        state: { type: String },
-        postCode: { type: String },
-        country: { type: String },
-        timeZone: { type: String }
-    }
-}, {
-    versionKey: false,
-    timestamps: true
-})
-
-
-export const User_Model = model("user", user_schema)

package/templates/mongoose/src/app/modules/user/user.service.ts

@@ -1,22 +0,0 @@
-import { Request } from "express"
-import uploadCloud from "../../utils/cloudinary";
-import { User_Model } from "./user.schema";
-import { Account_Model } from "../auth/auth.schema";
-
-const update_profile_into_db = async (req: Request) => {
-    // upload file and get link
-    if (req.file) {
-        const uploadedImage = await uploadCloud(req.file);
-        req.body.photo = uploadedImage?.secure_url;
-    };
-
-    const isExistUser = await Account_Model.findOne({ email: req?.user?.email }).lean()
-    const result = await User_Model.findOneAndUpdate({ accountId: isExistUser!._id }, req?.body)
-    return result
-}
-
-
-
-export const user_services = {
-    update_profile_into_db
-}

package/templates/mongoose/src/app/modules/user/user.swagger.ts

@@ -1,75 +0,0 @@
-export const userSwaggerDocs = {
-    "/api/user/update-profile": {
-        patch: {
-            tags: ["User"],
-            summary: "Update user profile",
-            description:
-                "Updates the authenticated user's profile information, including optional profile image upload. Accessible by both ADMIN and USER roles.",
-            security: [{ bearerAuth: [] }],
-            requestBody: {
-                required: true,
-                content: {
-                    "multipart/form-data": {
-                        schema: {
-                            type: "object",
-                            properties: {
-                                image: {
-                                    type: "string",
-                                    format: "binary",
-                                    description: "Optional profile image file",
-                                },
-                                data: {
-                                    type: "string",
-                                    description:
-                                        "JSON string containing user profile update data (validated by `user_validations.update_user`)",
-                                    example: JSON.stringify({
-                                        name: "John Doe",
-                                        email: "john.doe@example.com",
-                                        phone: "+8801787654321",
-                                        address: "Dhaka, Bangladesh",
-                                    }),
-                                },
-                            },
-                            required: ["data"],
-                        },
-                    },
-                },
-            },
-            responses: {
-                200: {
-                    description: "User profile updated successfully",
-                    content: {
-                        "application/json": {
-                            schema: {
-                                type: "object",
-                                properties: {
-                                    message: { type: "string", example: "Profile updated successfully" },
-                                    data: {
-                                        type: "object",
-                                        properties: {
-                                            id: { type: "string", example: "64b2e1b9d1234f0012ab5678" },
-                                            name: { type: "string", example: "John Doe" },
-                                            email: { type: "string", example: "john.doe@example.com" },
-                                            phone: { type: "string", example: "+8801787654321" },
-                                            image: {
-                                                type: "string",
-                                                example: "/uploads/users/profile_64b2e1b9.png",
-                                            },
-                                            role: { type: "string", example: "USER" },
-                                            updatedAt: {
-                                                type: "string",
-                                                example: "2025-10-10T10:00:00Z",
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                400: { description: "Bad Request — Validation failed or invalid JSON format" },
-                401: { description: "Unauthorized — must be logged in as ADMIN or USER" },
-            },
-        },
-    },
-};

package/templates/mongoose/src/app/modules/user/user.validation.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-
-const update_user = z.object({
-    name: z.string().optional(),
-    photo: z.string().optional(),
-    address: z.object({
-        location: z.string().optional(),
-        city: z.string().optional(),
-        state: z.string().optional(),
-        postCode: z.string().optional(),
-        country: z.string().optional(),
-        timeZone: z.string().optional(),
-    }).optional()
-})
-
-export const user_validations = {
-    update_user
-}

package/templates/mongoose/src/app/types/index.d.ts

@@ -1,12 +0,0 @@
-import { TJwtUser } from "../modules/auth/auth.interface";
-import { JwtPayloadType } from "../utils/JWT";
-
-
-
-declare global {
-    namespace Express {
-        interface Request {
-            user?: JwtPayloadType;
-        }
-    }
-}

package/templates/mongoose/src/app/utils/isAccountExist.ts

@@ -1,31 +0,0 @@
-import { Account_Model } from "../modules/auth/auth.schema";
-import { AppError } from "./app_error";
-
-export const isAccountExist = async (email: string, populateField?: string) => {
-  let isExistAccount;
-  if (populateField) {
-    isExistAccount = await Account_Model.findOne({ email }).populate(
-      populateField,
-    );
-  } else {
-    isExistAccount = await Account_Model.findOne({ email });
-  }
-  // check account
-  if (!isExistAccount) {
-    throw new AppError("Account not found!!", 404);
-  }
-  if (isExistAccount.isDeleted) {
-    throw new AppError("Account deleted !!", 403);
-  }
-  if (isExistAccount.accountStatus == "INACTIVE") {
-    throw new AppError(
-      "Account is temporary suspend, contact us on support !!",
-      403,
-    );
-  }
-  if (isExistAccount.accountStatus == "SUSPENDED") {
-    throw new AppError("Account is suspended !!", 403);
-  }
-
-  return isExistAccount;
-};

package/templates/prisma/src/app/types/index.d.ts

@@ -1,12 +0,0 @@
-import { TJwtUser } from "../modules/auth/auth.interface";
-import { JwtPayloadType } from "../utils/JWT";
-
-
-
-declare global {
-    namespace Express {
-        interface Request {
-            user?: JwtPayloadType;
-        }
-    }
-}

package/templates/prisma/src/app/utils/otpGenerator.ts

@@ -1,29 +0,0 @@
-export const otpGenerator = (): string => {
-  const upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  const lower = "abcdefghijklmnopqrstuvwxyz";
-  const numbers = "0123456789";
-  const symbols = "@#$%&*!?";
-
-  const allChars = upper + lower + numbers + symbols;
-
-  let otp = "";
-
-  // Ensure at least one character from each set
-  otp += upper[Math.floor(Math.random() * upper.length)];
-  otp += lower[Math.floor(Math.random() * lower.length)];
-  otp += numbers[Math.floor(Math.random() * numbers.length)];
-  otp += symbols[Math.floor(Math.random() * symbols.length)];
-
-  // Fill the rest randomly
-  for (let i = otp.length; i < 6; i++) {
-    otp += allChars[Math.floor(Math.random() * allChars.length)];
-  }
-
-  // Shuffle to remove predictable order
-  otp = otp
-    .split("")
-    .sort(() => Math.random() - 0.5)
-    .join("");
-
-  return otp;
-};