create-express-mongoose-app 1.0.1 → 1.0.2

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

@@ -1,20 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,26 +0,0 @@
-{
-  "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"]
-}