create-express-mongoose-app 1.0.0

package/my-test/src/middleware/error.middleware.ts

@@ -0,0 +1,88 @@
+import { Request, Response, NextFunction } from "express";
+import { ApiResponseHandler } from "../utils/response";
+import { ApiError } from "../utils/apiError";
+import { logger } from "../config/winston-logger";
+import { StatusCodes } from "http-status-codes";
+
+export const errorMiddleware = (
+  err: any,
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  const requestId = req.id || "unknown";
+
+  // Handle Mongoose validation errors
+  if (err.name === "ValidationError") {
+    const errors: Record<string, any> = {};
+    Object.keys(err.errors).forEach((key) => {
+      errors[key] = err.errors[key].message;
+    });
+    logger.error(`[${requestId}] Validation Error:`, errors);
+    return ApiResponseHandler.error(
+      res,
+      "Validation failed",
+      StatusCodes.UNPROCESSABLE_ENTITY,
+      errors,
+    );
+  }
+
+  // Handle Mongoose cast errors
+  if (err.name === "CastError") {
+    logger.error(`[${requestId}] Invalid ID format`);
+    return ApiResponseHandler.error(
+      res,
+      "Invalid ID format",
+      StatusCodes.BAD_REQUEST,
+    );
+  }
+
+  // Handle duplicate key errors
+  if (err.code === 11000) {
+    const field = Object.keys(err.keyPattern)[0];
+    logger.error(`[${requestId}] Duplicate key error on field: ${field}`);
+    return ApiResponseHandler.error(
+      res,
+      `${field} already exists`,
+      StatusCodes.CONFLICT,
+    );
+  }
+
+  // Handle JWT errors
+  if (err.name === "JsonWebTokenError") {
+    logger.error(`[${requestId}] JWT Error: ${err.message}`);
+    return ApiResponseHandler.error(
+      res,
+      "Invalid token",
+      StatusCodes.UNAUTHORIZED,
+    );
+  }
+
+  if (err.name === "TokenExpiredError") {
+    logger.error(`[${requestId}] Token Expired`);
+    return ApiResponseHandler.error(
+      res,
+      "Token expired",
+      StatusCodes.UNAUTHORIZED,
+    );
+  }
+
+  // Handle custom ApiError
+  if (err instanceof ApiError) {
+    logger.error(`[${requestId}] ApiError: ${err.message}`, err.errors);
+    return ApiResponseHandler.error(
+      res,
+      err.message,
+      err.statusCode,
+      err.errors,
+    );
+  }
+
+  // Handle unexpected errors
+  logger.error(`[${requestId}] Unexpected Error:`, err.message);
+  return ApiResponseHandler.error(
+    res,
+    "Internal server error",
+    StatusCodes.INTERNAL_SERVER_ERROR,
+  );
+};

package/my-test/src/middleware/request-id.middleware.ts

@@ -0,0 +1,20 @@
+import { Request, Response, NextFunction } from "express";
+import { v4 as uuidv4 } from "uuid";
+
+declare global {
+  namespace Express {
+    interface Request {
+      id?: string;
+    }
+  }
+}
+
+export const requestIdMiddleware = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  req.id = uuidv4();
+  res.setHeader("X-Request-ID", req?.id!);
+  next();
+};

package/my-test/src/modules/example/example.controller.ts

@@ -0,0 +1,45 @@
+import { Request, Response } from "express";
+import { ExampleService } from "./example.service";
+import { ApiResponseHandler } from "../../utils/response";
+import { asyncHandler } from "../../utils/asyncHandler";
+
+const exampleService = new ExampleService();
+
+export const getAllExamples = asyncHandler(
+  async (req: Request, res: Response) => {
+    const examples = await exampleService.findAll();
+    ApiResponseHandler.success(
+      res,
+      examples,
+      "Examples retrieved successfully",
+    );
+  },
+);
+
+export const getExampleById = asyncHandler(
+  async (req: Request, res: Response) => {
+    const example = await exampleService.findById(req.params.id);
+    ApiResponseHandler.success(res, example, "Example retrieved successfully");
+  },
+);
+
+export const createExample = asyncHandler(
+  async (req: Request, res: Response) => {
+    const example = await exampleService.create(req.body);
+    ApiResponseHandler.created(res, example, "Example created successfully");
+  },
+);
+
+export const updateExample = asyncHandler(
+  async (req: Request, res: Response) => {
+    const example = await exampleService.update(req.params.id, req.body);
+    ApiResponseHandler.success(res, example, "Example updated successfully");
+  },
+);
+
+export const deleteExample = asyncHandler(
+  async (req: Request, res: Response) => {
+    await exampleService.delete(req.params.id);
+    ApiResponseHandler.noContent(res);
+  },
+);

package/my-test/src/modules/example/example.model.ts

@@ -0,0 +1,31 @@
+import mongoose, { Schema, Document } from "mongoose";
+
+export interface IExample extends Document {
+  name: string;
+  description?: string;
+  isActive: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+const ExampleSchema = new Schema(
+  {
+    name: {
+      type: String,
+      required: [true, "Name is required"],
+      trim: true,
+      unique: true,
+    },
+    description: {
+      type: String,
+      trim: true,
+    },
+    isActive: {
+      type: Boolean,
+      default: true,
+    },
+  },
+  { timestamps: true },
+);
+
+export default mongoose.model<IExample>("Example", ExampleSchema);

package/my-test/src/modules/example/example.route.ts

@@ -0,0 +1,20 @@
+import { Router } from "express";
+import {
+  getAllExamples,
+  getExampleById,
+  createExample,
+  updateExample,
+  deleteExample,
+} from "./example.controller";
+import { validateWithJoi } from "../../utils/validationMiddleware";
+import { createExampleSchema, updateExampleSchema } from "./example.validation";
+
+const router = Router();
+
+router.get("/", getAllExamples);
+router.get("/:id", getExampleById);
+router.post("/", validateWithJoi(createExampleSchema), createExample);
+router.put("/:id", validateWithJoi(updateExampleSchema), updateExample);
+router.delete("/:id", deleteExample);
+
+export default router;

package/my-test/src/modules/example/example.service.ts

@@ -0,0 +1,92 @@
+import { StatusCodes } from "http-status-codes";
+import { ApiError } from "../../utils/apiError";
+import Example, { IExample } from "./example.model";
+
+export class ExampleService {
+  async findAll() {
+    try {
+      return await Example.find({ isActive: true })
+        .sort({ createdAt: -1 })
+        .lean();
+    } catch (error: any) {
+      throw ApiError.internal("Failed to retrieve examples");
+    }
+  }
+
+  async findById(id: string): Promise<IExample> {
+    try {
+      const example = await Example.findById(id);
+      if (!example) {
+        throw ApiError.notFound("Example not found");
+      }
+      return example;
+    } catch (error: any) {
+      if (error instanceof ApiError) throw error;
+      if (error.kind === "ObjectId") {
+        throw ApiError.badRequest("Invalid ID format");
+      }
+      throw ApiError.internal("Failed to retrieve example");
+    }
+  }
+
+  async create(data: Partial<IExample>): Promise<IExample> {
+    try {
+      const example = new Example(data);
+      return await example.save();
+    } catch (error: any) {
+      if (error.name === "ValidationError") {
+        const messages = Object.values(error.errors)
+          .map((err: any) => err.message)
+          .join(", ");
+        throw ApiError.unprocessable(messages);
+      }
+      if (error.code === 11000) {
+        const field = Object.keys(error.keyPattern)[0];
+        throw ApiError.conflict(`${field} already exists`);
+      }
+      throw ApiError.internal("Failed to create example");
+    }
+  }
+
+  async update(id: string, data: Partial<IExample>): Promise<IExample> {
+    try {
+      const example = await Example.findByIdAndUpdate(id, data, {
+        new: true,
+        runValidators: true,
+      });
+
+      if (!example) {
+        throw ApiError.notFound("Example not found");
+      }
+
+      return example;
+    } catch (error: any) {
+      if (error instanceof ApiError) throw error;
+      if (error.kind === "ObjectId") {
+        throw ApiError.badRequest("Invalid ID format");
+      }
+      if (error.name === "ValidationError") {
+        const messages = Object.values(error.errors)
+          .map((err: any) => err.message)
+          .join(", ");
+        throw ApiError.unprocessable(messages);
+      }
+      throw ApiError.internal("Failed to update example");
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    try {
+      const result = await Example.findByIdAndDelete(id);
+      if (!result) {
+        throw ApiError.notFound("Example not found");
+      }
+    } catch (error: any) {
+      if (error instanceof ApiError) throw error;
+      if (error.kind === "ObjectId") {
+        throw ApiError.badRequest("Invalid ID format");
+      }
+      throw ApiError.internal("Failed to delete example");
+    }
+  }
+}

package/my-test/src/modules/example/example.validation.ts

@@ -0,0 +1,16 @@
+import Joi from "joi";
+
+export const createExampleSchema = Joi.object({
+  name: Joi.string().required().trim().messages({
+    "string.empty": "Name is required",
+    "any.required": "Name is required",
+  }),
+  description: Joi.string().optional().trim(),
+  isActive: Joi.boolean().optional().default(true),
+});
+
+export const updateExampleSchema = Joi.object({
+  name: Joi.string().optional().trim(),
+  description: Joi.string().optional().trim(),
+  isActive: Joi.boolean().optional(),
+});

package/my-test/src/server.ts

@@ -0,0 +1,57 @@
+import http from "http";
+import { createApp } from "./app";
+import { config } from "./config/env";
+import { connectDatabase, disconnectDatabase } from "./config/database";
+import { logger } from "./config/winston-logger";
+
+let server: http.Server;
+
+export const startServer = async () => {
+  try {
+    // Connect to database
+    await connectDatabase();
+
+    // Create Express app
+    const app = createApp();
+
+    // Start server
+    server = http.createServer(app);
+    server.listen(config.port, () => {
+      logger.info(
+        `Server running on port ${config.port} in ${config.nodeEnv} mode`,
+      );
+    });
+
+    // Graceful shutdown handlers
+    const shutdown = async (signal: string) => {
+      logger.info(`${signal} received, starting graceful shutdown...`);
+
+      const shutdownTimeout = setTimeout(() => {
+        logger.error("Graceful shutdown timeout, forcing exit");
+        process.exit(1);
+      }, 10000);
+
+      server.close(async () => {
+        clearTimeout(shutdownTimeout);
+        await disconnectDatabase();
+        logger.info("Server closed gracefully");
+        process.exit(0);
+      });
+    };
+
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+    process.on("SIGINT", () => shutdown("SIGINT"));
+
+    process.on("unhandledRejection", (reason, promise) => {
+      logger.error("Unhandled Rejection at:", promise, "reason:", reason);
+    });
+
+    process.on("uncaughtException", (error) => {
+      logger.error("Uncaught Exception:", error);
+      process.exit(1);
+    });
+  } catch (error: any) {
+    logger.error("Failed to start server:", error.message);
+    process.exit(1);
+  }
+};

package/my-test/src/utils/apiError.ts

@@ -0,0 +1,63 @@
+import { StatusCodes } from "http-status-codes";
+
+export class ApiError extends Error {
+  statusCode: number;
+  isOperational: boolean;
+  errors?: Record<string, any> | string[];
+
+  constructor(
+    statusCode: number,
+    message: string,
+    isOperational: boolean = true,
+    errors?: Record<string, any> | string[],
+  ) {
+    super(message);
+    Object.setPrototypeOf(this, ApiError.prototype);
+    this.statusCode = statusCode;
+    this.isOperational = isOperational;
+    this.errors = errors;
+  }
+
+  static badRequest(
+    message: string,
+    errors?: Record<string, any> | string[],
+  ): ApiError {
+    return new ApiError(StatusCodes.BAD_REQUEST, message, true, errors);
+  }
+
+  static unauthorized(message: string = "Unauthorized"): ApiError {
+    return new ApiError(StatusCodes.UNAUTHORIZED, message);
+  }
+
+  static forbidden(message: string = "Forbidden"): ApiError {
+    return new ApiError(StatusCodes.FORBIDDEN, message);
+  }
+
+  static notFound(message: string = "Not found"): ApiError {
+    return new ApiError(StatusCodes.NOT_FOUND, message);
+  }
+
+  static conflict(message: string = "Conflict"): ApiError {
+    return new ApiError(StatusCodes.CONFLICT, message);
+  }
+
+  static unprocessable(
+    message: string = "Unprocessable entity",
+    errors?: Record<string, any>,
+  ): ApiError {
+    return new ApiError(
+      StatusCodes.UNPROCESSABLE_ENTITY,
+      message,
+      true,
+      errors,
+    );
+  }
+
+  static internal(message: string = "Internal server error"): ApiError {
+    return new ApiError(StatusCodes.INTERNAL_SERVER_ERROR, message, false);
+  }
+
+  static serviceUnavailable(message: string = "Service unavailable"): ApiError {
+    return new ApiError(StatusCodes.SERVICE_UNAVAILABLE, message, false);
+  }
+}

package/my-test/src/utils/asyncHandler.ts

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

package/my-test/src/utils/response.ts

@@ -0,0 +1,102 @@
+import { Response } from "express";
+import { StatusCodes } from "http-status-codes";
+
+interface IApiResponse<T> {
+  status: "success" | "error" | "info";
+  data?: T;
+  message?: string;
+  errors?: Record<string, any>;
+  statusCode?: number;
+}
+
+export class ApiResponseHandler {
+  static success<T>(
+    res: Response,
+    data: T,
+    message: string = "Success",
+    statusCode: number = StatusCodes.OK,
+  ): Response {
+    return res.status(statusCode).json({
+      status: "success",
+      data,
+      message,
+    } as IApiResponse<T>);
+  }
+
+  static created<T>(
+    res: Response,
+    data: T,
+    message: string = "Resource created successfully",
+  ): Response {
+    return res.status(StatusCodes.CREATED).json({
+      status: "success",
+      data,
+      message,
+    } as IApiResponse<T>);
+  }
+
+  static error(
+    res: Response,
+    message: string,
+    statusCode: number = StatusCodes.BAD_REQUEST,
+    errors?: Record<string, any> | string[],
+  ): Response {
+    return res.status(statusCode).json({
+      status: "error",
+      message,
+      errors,
+      statusCode,
+    } as IApiResponse<null>);
+  }
+
+  static info<T>(
+    res: Response,
+    message: string,
+    data?: T,
+    statusCode: number = StatusCodes.OK,
+  ): Response {
+    return res.status(statusCode).json({
+      status: "info",
+      message,
+      data,
+    } as IApiResponse<T>);
+  }
+
+  static noContent(res: Response): Response {
+    return res.status(StatusCodes.NO_CONTENT).send();
+  }
+
+  static paginated<T>(
+    res: Response,
+    data: T[],
+    total: number,
+    page: number,
+    limit: number,
+    message: string = "Retrieved successfully",
+  ): Response {
+    return res.status(StatusCodes.OK).json({
+      status: "success",
+      data,
+      message,
+      pagination: {
+        total,
+        page,
+        limit,
+        pages: Math.ceil(total / limit),
+      },
+    });
+  }
+
+  static buildResponse<T>(
+    data: T,
+    message: string,
+    statusCode: number = StatusCodes.OK,
+  ): IApiResponse<T> {
+    return {
+      status: "success",
+      data,
+      message,
+      statusCode,
+    };
+  }
+}

package/my-test/src/utils/validationMiddleware.ts

@@ -0,0 +1,32 @@
+import { Request, Response, NextFunction } from "express";
+import { Schema } from "joi";
+import { ApiError } from "./apiError";
+import { StatusCodes } from "http-status-codes";
+
+export const validateWithJoi = (schema: Schema) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const { error, value } = schema.validate(req.body, {
+      abortEarly: false,
+      stripUnknown: true,
+    });
+
+    if (error) {
+      const errors: Record<string, any> = {};
+      error.details.forEach((detail) => {
+        errors[detail.path.join(".")] = detail.message;
+      });
+
+      return next(
+        new ApiError(
+          StatusCodes.UNPROCESSABLE_ENTITY,
+          "Validation failed",
+          true,
+          errors,
+        ),
+      );
+    }
+
+    req.body = value;
+    next();
+  };
+};

package/my-test/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "paths": {
+      "@/*": ["./*"],
+      "@modules/*": ["./modules/*"],
+      "@config/*": ["./config/*"],
+      "@middleware/*": ["./middleware/*"],
+      "@utils/*": ["./utils/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}