create-express-mongoose-app 1.0.0 → 1.0.2

package/README.md

@@ -1,4 +1,4 @@
-# create-express-mongo-app
+# create-express-mongoose-app
 
 A CLI tool to quickly bootstrap a production-grade Express.js + MongoDB/Mongoose project with TypeScript.
 
@@ -17,13 +17,13 @@ A CLI tool to quickly bootstrap a production-grade Express.js + MongoDB/Mongoose
 ## Installation
 
 ```bash
-npm install -g create-express-mongo-app
+npm install -g create-express-mongoose-app
 ```
 
 Or use npx without installation:
 
 ```bash
-npx create-express-mongo-app
+npx create-express-mongoose-app
 ```
 
 ## Usage
@@ -31,13 +31,13 @@ npx create-express-mongo-app
 Run the CLI:
 
 ```bash
-create-express-mongo-app
+create-express-mongoose-app
 ```
 
 Or with npx:
 
 ```bash
-npx create-express-mongo-app
+npx create-express-mongoose-app
 ```
 
 The CLI will ask for:

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "create-express-mongoose-app",
-  "version": "1.0.0",
+  "version": "1.0.2",
+  "type": "module",
   "description": "CLI tool to create production-grade Express.js with Mongoose starter projects",
   "main": "src/cli.js",
   "bin": {

package/my-test/.env.example

@@ -1,21 +0,0 @@
-# Server Configuration
-NODE_ENV=development
-PORT=3000
-API_PREFIX=/api
-
-# Database Configuration
-MONGODB_URI=mongodb://localhost:27017/express-mongo-starter
-DB_MIN_POOL_SIZE=5
-DB_MAX_POOL_SIZE=10
-
-# Logging Configuration
-LOG_LEVEL=info
-ENABLE_FILE_LOGGING=false
-
-# Security & Rate Limiting
-CORS_ORIGIN=http://localhost:3000
-RATE_LIMIT_WINDOW_MS=900000 
-RATE_LIMIT_MAX_REQUESTS=100
-
-# Request Configuration
-REQUEST_BODY_LIMIT=10kb

package/my-test/README.md

@@ -1,137 +0,0 @@
-# Express MongoDB Starter Template
-
-A production-grade Express.js + MongoDB/Mongoose starter template with TypeScript, comprehensive error handling, Winston logging, Joi validation, and security best practices.
-
-## Features
-
-- ✅ **TypeScript** - Strict mode enabled
-- ✅ **Error Handling** - Centralized error middleware with standardized responses
-- ✅ **Response Handler** - Universal ApiResponseHandler with error/success/info methods
-- ✅ **Logging** - Winston logger with file rotation
-- ✅ **Validation** - Joi schema validation
-- ✅ **Security** - Helmet, CORS, Rate Limiting
-- ✅ **Database** - MongoDB with connection retry logic and graceful shutdown
-- ✅ **Async Handler** - Eliminate try-catch boilerplate
-- ✅ **Health Checks** - /health and /ready endpoints
-
-## Quick Start
-
-1. Clone this repository
-2. Install dependencies:
-
-   ```bash
-   npm install
-   # or
-   yarn install
-   # or
-   pnpm install
-   ```
-
-3. Copy `.env.example` to `.env` and configure:
-
-   ```bash
-   cp .env.example .env
-   ```
-
-4. Start development server:
-
-   ```bash
-   npm run dev
-   ```
-
-5. Build for production:
-   ```bash
-   npm run build
-   npm start
-   ```
-
-## Project Structure
-
-```
-src/
-├── config/           # Configuration files
-│   ├── env.ts        # Environment variables
-│   ├── database.ts   # MongoDB connection
-│   └── winston-logger.ts  # Logger setup
-├── middleware/       # Express middleware
-│   ├── error.middleware.ts
-│   ├── auth.middleware.ts
-│   └── request-id.middleware.ts
-├── modules/          # Feature modules
-│   └── example/      # Example module
-│       ├── example.controller.ts
-│       ├── example.service.ts
-│       ├── example.model.ts
-│       ├── example.route.ts
-│       └── example.validation.ts
-├── utils/            # Utility functions
-│   ├── response.ts   # Response handler
-│   ├── asyncHandler.ts
-│   ├── apiError.ts
-│   └── validationMiddleware.ts
-├── app.ts            # Express app setup
-├── index.ts          # Entry point
-└── generate-module.ts # Module generator CLI
-```
-
-## API Response Format
-
-All endpoints return standardized responses:
-
-```typescript
-// Success Response
-{
-  "status": "success",
-  "data": {...},
-  "message": "Retrieved successfully"
-}
-
-// Error Response
-{
-  "status": "error",
-  "message": "Error message",
-  "errors": {...},
-  "statusCode": 400
-}
-
-// Info Response
-{
-  "status": "info",
-  "message": "Info message",
-  "data": {...}
-}
-```
-
-## Generating New Modules
-
-Generate a new module with all CRUD operations:
-
-```bash
-npm run generate-module <module-name>
-```
-
-This creates:
-
-- Controller
-- Service
-- Model
-- Routes
-- Validation schema
-
-## Environment Variables
-
-See `.env.example` for all available configuration options.
-
-## Error Handling
-
-Errors are automatically caught by the centralized error middleware and formatted consistently. Supports:
-
-- Mongoose validation errors
-- MongoDB duplicate key errors (11000)
-- JWT errors
-- Custom ApiError instances
-- Unhandled exceptions
-
-## License
-
-MIT

package/my-test/package.json

@@ -1,38 +0,0 @@
-{
-  "name": "express-mongo-starter",
-  "version": "1.0.0",
-  "description": "Production-grade Express.js with MongoDB/Mongoose starter template",
-  "main": "dist/index.js",
-  "scripts": {
-    "dev": "ts-node src/index.ts",
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "generate-module": "ts-node src/generate-module.ts"
-  },
-  "dependencies": {
-    "cors": "^2.8.5",
-    "dotenv": "^16.3.1",
-    "express": "^4.18.2",
-    "express-async-errors": "^3.1.1",
-    "express-rate-limit": "^7.1.5",
-    "express-validator": "^7.0.0",
-    "helmet": "^7.1.0",
-    "http-status-codes": "^2.3.0",
-    "joi": "^17.11.0",
-    "mongoose": "^8.1.0",
-    "morgan": "^1.10.0",
-    "uuid": "^13.0.0",
-    "winston": "^3.11.0"
-  },
-  "devDependencies": {
-    "@types/cors": "^2.8.19",
-    "@types/express": "^4.17.21",
-    "@types/morgan": "^1.9.10",
-    "@types/node": "^20.10.6",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.3.3"
-  },
-  "engines": {
-    "node": ">=16.0.0"
-  }
-}

package/my-test/src/app.ts

@@ -1,77 +0,0 @@
-import express, { Express, Request, Response } from "express";
-import helmet from "helmet";
-import cors from "cors";
-import rateLimit from "express-rate-limit";
-import morgan from "morgan";
-import "express-async-errors";
-import { config } from "./config/env";
-import { errorMiddleware } from "./middleware/error.middleware";
-import { requestIdMiddleware } from "./middleware/request-id.middleware";
-import { logger } from "./config/winston-logger";
-import { ApiResponseHandler } from "./utils/response";
-
-export const createApp = (): Express => {
-  const app = express();
-
-  // Security middleware
-  app.use(helmet());
-  app.use(
-    cors({
-      origin: config.corsOrigin,
-      credentials: true,
-    }),
-  );
-
-  // Request ID middleware
-  app.use(requestIdMiddleware);
-
-  // Body parser middleware
-  app.use(express.json({ limit: config.requestBodyLimit }));
-  app.use(
-    express.urlencoded({ limit: config.requestBodyLimit, extended: true }),
-  );
-
-  // Rate limiting
-  const limiter = rateLimit({
-    windowMs: config.rateLimitWindowMs,
-    max: config.rateLimitMaxRequests,
-    message: "Too many requests from this IP, please try again later.",
-  });
-  app.use(limiter);
-
-  // Logging middleware
-  app.use(
-    morgan("combined", {
-      stream: {
-        write: (message) => logger.info(message.trim()),
-      },
-    }),
-  );
-
-  // Health check endpoints
-  app.get("/health", (req: Request, res: Response) => {
-    ApiResponseHandler.success(res, { status: "healthy" }, "Server is running");
-  });
-
-  app.get("/ready", (req: Request, res: Response) => {
-    ApiResponseHandler.success(res, { ready: true }, "Server is ready");
-  });
-
-  // API routes
-  app.use(config.apiPrefix, (req: Request, res: Response) => {
-    ApiResponseHandler.info(res, "API is running", {
-      version: "1.0.0",
-      apiPrefix: config.apiPrefix,
-    });
-  });
-
-  // 404 handler
-  app.use("*", (req: Request, res: Response) => {
-    ApiResponseHandler.error(res, "Route not found", 404);
-  });
-
-  // Error middleware (must be last)
-  app.use(errorMiddleware);
-
-  return app;
-};

package/my-test/src/config/database.ts

@@ -1,54 +0,0 @@
-import mongoose from "mongoose";
-import { config } from "./env";
-import { logger } from "./winston-logger";
-
-export const connectDatabase = async () => {
-  try {
-    const mongoOptions = {
-      minPoolSize: 5,
-      maxPoolSize: 10,
-    };
-
-    await mongoose.connect(config.mongodbUri, mongoOptions);
-
-    logger.info("Database connected successfully");
-
-    mongoose.connection.on("disconnected", () => {
-      logger.warn("Database disconnected");
-    });
-
-    mongoose.connection.on("error", (error) => {
-      logger.error("Database connection error:", error);
-    });
-
-    mongoose.connection.on("reconnected", () => {
-      logger.info("Database reconnected");
-    });
-  } catch (error: any) {
-    logger.error("Failed to connect to database:", error.message);
-    // Retry logic
-    const retryAttempts = 5;
-    for (let i = 1; i <= retryAttempts; i++) {
-      logger.info(`Retrying database connection (${i}/${retryAttempts})...`);
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-      try {
-        await mongoose.connect(config.mongodbUri);
-        logger.info("Database connected successfully on retry");
-        return;
-      } catch (retryError: any) {
-        logger.error(`Retry attempt ${i} failed:`, retryError.message);
-      }
-    }
-    process.exit(1);
-  }
-};
-
-export const disconnectDatabase = async () => {
-  try {
-    await mongoose.disconnect();
-    logger.info("Database disconnected");
-  } catch (error: any) {
-    logger.error("Error disconnecting database:", error.message);
-    process.exit(1);
-  }
-};

package/my-test/src/config/env.ts

@@ -1,42 +0,0 @@
-import dotenv from "dotenv";
-
-dotenv.config();
-
-export interface IConfig {
-  port: number;
-  nodeEnv: string;
-  mongodbUri: string;
-  apiPrefix: string;
-  logLevel: string;
-  corsOrigin: string;
-  rateLimitWindowMs: number;
-  rateLimitMaxRequests: number;
-  requestBodyLimit: string;
-  enableFileLogging: boolean;
-}
-
-export const config: IConfig = {
-  port: parseInt(process.env.PORT || "3000"),
-  nodeEnv: process.env.NODE_ENV || "development",
-  mongodbUri:
-    process.env.MONGODB_URI ||
-    "mongodb://localhost:27017/express-mongo-starter",
-  apiPrefix: process.env.API_PREFIX || "/api",
-  logLevel: process.env.LOG_LEVEL || "info",
-  corsOrigin: process.env.CORS_ORIGIN || "http://localhost:3000",
-  rateLimitWindowMs: parseInt(process.env.RATE_LIMIT_WINDOW_MS || "900000"),
-  rateLimitMaxRequests: parseInt(process.env.RATE_LIMIT_MAX_REQUESTS || "100"),
-  requestBodyLimit: process.env.REQUEST_BODY_LIMIT || "10kb",
-  enableFileLogging: process.env.ENABLE_FILE_LOGGING === "true",
-};
-
-// Validate required environment variables in production
-if (config.nodeEnv === "production") {
-  const requiredVars = ["MONGODB_URI"];
-  const missingVars = requiredVars.filter((v) => !process.env[v]);
-  if (missingVars.length > 0) {
-    throw new Error(
-      `Missing required environment variables: ${missingVars.join(", ")}`,
-    );
-  }
-}

package/my-test/src/config/winston-logger.ts

@@ -1,75 +0,0 @@
-import winston from "winston";
-import path from "path";
-import { config } from "./env";
-
-const logsDir = path.join(process.cwd(), "logs");
-
-const levels = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-};
-
-const colors = {
-  error: "red",
-  warn: "yellow",
-  info: "green",
-  debug: "blue",
-};
-
-winston.addColors(colors);
-
-const format = winston.format.combine(
-  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
-  winston.format.printf(
-    (info) =>
-      `${info.timestamp} [${info.level}]: ${info.message}${info.error ? "\n" + info.error : ""}`,
-  ),
-);
-
-const transports: winston.transport[] = [
-  new winston.transports.Console({
-    format: winston.format.combine(
-      winston.format.colorize({ all: true }),
-      format,
-    ),
-  }),
-];
-
-if (config.nodeEnv === "production" || config.enableFileLogging) {
-  transports.push(
-    new winston.transports.File({
-      filename: path.join(logsDir, "error.log"),
-      level: "error",
-      format,
-      maxsize: 5242880,
-      maxFiles: 5,
-    }),
-    new winston.transports.File({
-      filename: path.join(logsDir, "combined.log"),
-      format,
-      maxsize: 5242880,
-      maxFiles: 5,
-    }),
-  );
-}
-
-export const logger = winston.createLogger({
-  level: config.logLevel || "info",
-  levels,
-  format,
-  transports,
-  exceptionHandlers: [
-    new winston.transports.File({
-      filename: path.join(logsDir, "exceptions.log"),
-    }),
-  ],
-  rejectionHandlers: [
-    new winston.transports.File({
-      filename: path.join(logsDir, "rejections.log"),
-    }),
-  ],
-});
-
-export default logger;

package/my-test/src/index.ts

@@ -1,3 +0,0 @@
-import { startServer } from "./server";
-
-startServer();

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

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

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

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

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