@codeenthusiast09/create-express-app 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeenthusiast09/create-express-app",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "CLI tool to generate production-ready Express TypeScript projects with flexible database options (MongoDB, PostgreSQL with Prisma or Drizzle)",
   "main": "dist/index.js",
   "bin": {

package/templates/boilerplate/{docker/.dockerignore → .dockerignore}

@@ -1,46 +1,56 @@
 # Dependencies
 node_modules
-npm-debug.log
-package-lock.json
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
 
 # Build output
 dist
 build
+*.tsbuildinfo
 
-# Environment files
+# Environment
 .env
-.env.development
-.env.production
-.env.local
-.env.*.local
+.env.*
+!.env.example
 
 # Git
 .git
 .gitignore
+.gitattributes
 
 # IDE
 .vscode
 .idea
 *.swp
 *.swo
+*~
 
 # Testing
 coverage
 .nyc_output
+*.test.ts
+*.spec.ts
+__tests__
+__mocks__
 
 # Documentation
 README.md
+CHANGELOG.md
+LICENSE
 docs
 
-# Docker files
-Dockerfile
-docker-compose.yml
-.dockerignore
-
 # CI/CD
 .github
 .gitlab-ci.yml
+.travis.yml
+
+# Docker
+Dockerfile
+docker-compose.yml
+.dockerignore
 
 # Misc
 .DS_Store
 *.log
+

package/templates/boilerplate/.env.docker

@@ -0,0 +1,7 @@
+NODE_ENV=production
+PORT=3000
+DATABASE_URL=mongodb://mongodb:27017/myapp
+JWT_SECRET=change-this-to-a-secure-random-string-min-32-characters-long
+JWT_EXPIRES_IN=7d
+LOG_LEVEL=info
+CORS_ORIGIN=*

package/templates/boilerplate/.eslintrc.cjs

@@ -1,27 +1,49 @@
 module.exports = {
-  parser: "@typescript-eslint/parser",
+  parser: '@typescript-eslint/parser',
   parserOptions: {
-    project: "tsconfig.json",
+    project: 'tsconfig.json',
     tsconfigRootDir: __dirname,
-    sourceType: "module",
+    sourceType: 'module',
   },
-  plugins: ["@typescript-eslint"],
+  plugins: ['@typescript-eslint'],
   extends: [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "plugin:@typescript-eslint/recommended-requiring-type-checking",
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:@typescript-eslint/recommended-requiring-type-checking',
   ],
   root: true,
   env: {
     node: true,
     jest: true,
   },
-  ignorePatterns: [".eslintrc.js", "dist", "node_modules"],
+  ignorePatterns: ['.eslintrc.js', 'dist', 'node_modules'],
   rules: {
-    "@typescript-eslint/interface-name-prefix": "off",
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/explicit-module-boundary-types": "off",
-    "@typescript-eslint/no-explicit-any": "warn",
-    "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'warn',
+    '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+
+    // Fix for Express async middleware
+    '@typescript-eslint/no-misused-promises': [
+      'error',
+      {
+        checksVoidReturn: false,
+      },
+    ],
+
+    // Additional rules
+    '@typescript-eslint/require-await': 'off',
+    '@typescript-eslint/no-floating-promises': 'warn',
+    '@typescript-eslint/no-unsafe-assignment': 'warn',
+    '@typescript-eslint/no-unsafe-member-access': 'warn',
+    '@typescript-eslint/no-unsafe-call': 'warn',
+    '@typescript-eslint/no-unsafe-return': 'warn',
+    '@typescript-eslint/no-unsafe-argument': 'warn',
+
+    // Code quality
+    'no-console': ['warn', { allow: ['warn', 'error'] }],
+    'prefer-const': 'error',
+    'no-var': 'error',
   },
 };

package/templates/boilerplate/docker-compose.yml

@@ -0,0 +1,86 @@
+version: '3.8'
+
+services:
+  # MongoDB Service (Development - No Auth)
+  mongodb:
+    image: mongo:7
+    container_name: express-mongodb
+    restart: unless-stopped
+    ports:
+      - '27017:27017'
+    volumes:
+      - mongodb_data:/data/db
+    networks:
+      - app-network
+    healthcheck:
+      test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017/test --quiet
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  # PostgreSQL Service (Uncomment if needed)
+  # postgres:
+  #   image: postgres:16-alpine
+  #   container_name: express-postgres
+  #   restart: unless-stopped
+  #   ports:
+  #     - '5432:5432'
+  #   environment:
+  #     POSTGRES_USER: ${DB_USER:-postgres}
+  #     POSTGRES_PASSWORD: ${DB_PASSWORD:-postgres}
+  #     POSTGRES_DB: ${DB_NAME:-myapp}
+  #   volumes:
+  #     - postgres_data:/var/lib/postgresql/data
+  #   networks:
+  #     - app-network
+  #   healthcheck:
+  #     test: ["CMD-SHELL", "pg_isready -U postgres"]
+  #     interval: 10s
+  #     timeout: 5s
+  #     retries: 5
+
+  # Application Service
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: production
+    container_name: express-app
+    restart: unless-stopped
+    ports:
+      - '${PORT:-3000}:${PORT:-3000}'
+    environment:
+      NODE_ENV: ${NODE_ENV:-production}
+      PORT: ${PORT:-3000}
+      DATABASE_URL: ${DATABASE_URL:-mongodb://mongodb:27017/myapp}
+      JWT_SECRET: ${JWT_SECRET:?JWT_SECRET is required}
+      JWT_EXPIRES_IN: ${JWT_EXPIRES_IN:-7d}
+      LOG_LEVEL: ${LOG_LEVEL:-info}
+      CORS_ORIGIN: ${CORS_ORIGIN:-*}
+    depends_on:
+      mongodb:
+        condition: service_healthy
+      # postgres:
+      #   condition: service_healthy
+    networks:
+      - app-network
+    healthcheck:
+      test:
+        [
+          'CMD',
+          'node',
+          '-e',
+          "require('http').get('http://localhost:${PORT:-3000}/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))",
+        ]
+      interval: 30s
+      timeout: 3s
+      retries: 3
+      start_period: 40s
+
+networks:
+  app-network:
+    driver: bridge
+
+volumes:
+  mongodb_data:
+  # postgres_data:

package/templates/boilerplate/package.json

@@ -28,9 +28,12 @@
   "license": "MIT",
   "dependencies": {
     "bcryptjs": "^2.4.3",
+    "compression": "^1.7.4",
     "cors": "^2.8.5",
     "dotenv": "^16.4.5",
     "express": "^4.18.2",
+    "express-rate-limit": "^7.1.5",
+    "helmet": "^7.1.0",
     "jsonwebtoken": "^9.0.2",
     "pino": "^8.19.0",
     "pino-http": "^9.0.0",
@@ -39,6 +42,7 @@
   },
   "devDependencies": {
     "@types/bcryptjs": "^2.4.6",
+    "@types/compression": "^1.7.5",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.12",

package/templates/boilerplate/src/common/middleware/error.middleware.ts

@@ -1,4 +1,6 @@
-import { Request, Response, NextFunction } from 'express';
+import { Request, Response, NextFunction, RequestHandler } from 'express';
+import { ParamsDictionary } from 'express-serve-static-core';
+import { ParsedQs } from 'qs';
 import { ZodError } from 'zod';
 import { logger } from '@/common/utils/logger';
 import { config } from '@/config';
@@ -39,18 +41,23 @@ interface MongoError extends Error {
  * Catches all errors and sends appropriate responses.
  * MUST be registered LAST in middleware chain.
  */
-export const errorHandler = (err: Error, req: Request, res: Response, _next: NextFunction) => {
+export const errorHandler = (
+  err: Error,
+  req: Request,
+  res: Response,
+  _next: NextFunction,
+): void => {
   // Log the error
   logger.error({ err, req: { method: req.method, url: req.url } });
 
   // Handle custom AppError
   if (err instanceof AppError) {
-    // Client errors (4xx)
     if (err.statusCode < 500) {
-      return ResponseHelper.fail(res, err.code, err.message, err.statusCode);
+      ResponseHelper.fail(res, err.code, err.message, err.statusCode);
+      return;
     }
-    // Server errors (5xx)
-    return ResponseHelper.error(res, err.code, err.message, err.statusCode, err);
+    ResponseHelper.error(res, err.code, err.message, err.statusCode, err);
+    return;
   }
 
   // Handle Zod validation errors
@@ -60,32 +67,38 @@ export const errorHandler = (err: Error, req: Request, res: Response, _next: Nex
       message: error.message,
       code: error.code,
     }));
-    return ResponseHelper.validationError(res, details);
+    ResponseHelper.validationError(res, details);
+    return;
   }
 
   // Handle JWT errors
   if (err.name === 'JsonWebTokenError') {
-    return ResponseHelper.unauthorized(res, 'Invalid token');
+    ResponseHelper.unauthorized(res, 'Invalid token');
+    return;
   }
   if (err.name === 'TokenExpiredError') {
-    return ResponseHelper.unauthorized(res, 'Token expired');
+    ResponseHelper.unauthorized(res, 'Token expired');
+    return;
   }
 
   // Handle Mongoose errors
   if (err.name === 'ValidationError') {
-    return ResponseHelper.badRequest(res, 'Validation failed');
+    ResponseHelper.badRequest(res, 'Validation failed');
+    return;
   }
   if (err.name === 'CastError') {
-    return ResponseHelper.badRequest(res, 'Invalid ID format');
+    ResponseHelper.badRequest(res, 'Invalid ID format');
+    return;
   }
   const mongoError = err as MongoError;
   if (mongoError.code === 11000) {
     const field = mongoError.keyPattern ? Object.keys(mongoError.keyPattern)[0] : 'field';
-    return ResponseHelper.conflict(res, `Duplicate value for ${field ?? 'unknown field'}`);
+    ResponseHelper.conflict(res, `Duplicate value for ${field ?? 'unknown field'}`);
+    return;
   }
 
   // Default: Unknown error
-  return ResponseHelper.internalError(
+  ResponseHelper.internalError(
     res,
     config.nodeEnv === 'development' ? err.message : 'An unexpected error occurred',
     err,
@@ -93,20 +106,41 @@ export const errorHandler = (err: Error, req: Request, res: Response, _next: Nex
 };
 
 /**
- * Async Handler Wrapper
+ * Async Handler Wrapper with Generic Type Support
  *
  * Wraps async route handlers to catch errors automatically.
+ * Supports typed Request parameters for type-safe controllers.
  *
- * Usage:
- *   router.get('/users', asyncHandler(async (req, res) => {
- *     const users = await userService.findAll();
- *     ResponseHelper.success(res, users);
- *   }));
+ * @example
+ * // Simple usage
+ * router.get('/users', asyncHandler(async (req, res) => {
+ *   const users = await userService.findAll();
+ *   ResponseHelper.success(res, users);
+ * }));
+ *
+ * @example
+ * // With typed params
+ * router.get('/users/:id', asyncHandler<IdParam>(async (req, res) => {
+ *   const { id } = req.params; // TypeScript knows this is string
+ *   const user = await userService.findById(id);
+ *   ResponseHelper.success(res, user);
+ * }));
  */
-export const asyncHandler = (
-  fn: (req: Request, res: Response, next: NextFunction) => Promise<void>,
-) => {
-  return (req: Request, res: Response, next: NextFunction) => {
+export const asyncHandler = <
+  P = ParamsDictionary,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ResBody = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ReqBody = any,
+  ReqQuery = ParsedQs,
+>(
+  fn: (
+    req: Request<P, ResBody, ReqBody, ReqQuery>,
+    res: Response<ResBody>,
+    next: NextFunction,
+  ) => Promise<void>,
+): RequestHandler<P, ResBody, ReqBody, ReqQuery> => {
+  return (req, res, next): void => {
     Promise.resolve(fn(req, res, next)).catch(next);
   };
 };
@@ -116,6 +150,6 @@ export const asyncHandler = (
  *
  * Register BEFORE error handler.
  */
-export const notFoundHandler = (req: Request, res: Response) => {
-  return ResponseHelper.notFound(res, `Route ${req.method} ${req.url} not found`);
+export const notFoundHandler = (req: Request, res: Response): void => {
+  ResponseHelper.notFound(res, `Route ${req.method} ${req.url} not found`);
 };

package/templates/boilerplate/src/common/middleware/validation.middleware.ts

@@ -8,8 +8,8 @@ import { ErrorDetail } from '@/types/response.types';
  *
  * Validates request body, query, or params against Zod schema.
  *
- * Usage:
- *   router.post('/users', validate({ body: createUserSchema }), createUser);
+ * @example
+ * router.post('/users', validate({ body: createUserSchema }), createUser);
  */
 interface ValidationSchemas {
   body?: AnyZodObject;
@@ -18,7 +18,7 @@ interface ValidationSchemas {
 }
 
 export const validate = (schemas: ValidationSchemas) => {
-  return async (req: Request, res: Response, next: NextFunction) => {
+  return async (req: Request, res: Response, next: NextFunction): Promise<void> => {
     try {
       if (schemas.body) {
         req.body = await schemas.body.parseAsync(req.body);
@@ -32,7 +32,7 @@ export const validate = (schemas: ValidationSchemas) => {
         req.params = await schemas.params.parseAsync(req.params);
       }
 
-      return next();
+      next();
     } catch (error) {
       if (error instanceof ZodError) {
         const details: ErrorDetail[] = error.errors.map((err) => ({
@@ -41,10 +41,11 @@ export const validate = (schemas: ValidationSchemas) => {
           code: err.code,
         }));
 
-        return ResponseHelper.validationError(res, details);
+        ResponseHelper.validationError(res, details);
+        return;
       }
 
-      return next(error);
+      next(error);
     }
   };
 };

package/templates/boilerplate/src/common/utils/http-logger.ts

@@ -24,7 +24,7 @@ export const httpLogger = pinoHttp({
     req: (req: Request) => ({
       method: req.method,
       url: req.url,
-      userId: req.user?.id,
+      // Add userId here when you implement authentication
     }),
     res: (res: Response) => ({
       statusCode: res.statusCode,

package/templates/boilerplate/src/common/utils/response-helper.ts

@@ -16,14 +16,15 @@ export class ResponseHelper {
   /**
    * Success Response (2xx)
    */
-  static success<T>(res: Response, data: T, message = 'Success', statusCode = 200): Response {
+  static success<T>(res: Response, data: T, message = 'Success', statusCode = 200): void {
     const response = {
       success: true,
       data,
       message,
       timestamp: new Date().toISOString(),
     } satisfies ApiSuccessResponse<T>;
-    return res.status(statusCode).json(response);
+
+    res.status(statusCode).json(response);
   }
 
   /**
@@ -36,7 +37,7 @@ export class ResponseHelper {
     message: string,
     statusCode = 400,
     details?: ErrorDetail[],
-  ): Response {
+  ): void {
     const response = {
       success: false,
       error: {
@@ -46,7 +47,8 @@ export class ResponseHelper {
       },
       timestamp: new Date().toISOString(),
     } satisfies ApiFailResponse;
-    return res.status(statusCode).json(response);
+
+    res.status(statusCode).json(response);
   }
 
   /**
@@ -59,18 +61,18 @@ export class ResponseHelper {
     message: string,
     statusCode = 500,
     error?: Error,
-  ): Response {
+  ): void {
     const response = {
       success: false,
       error: {
         code,
         message,
-        // Only include stack trace in development
         stack: config.nodeEnv === 'development' ? error?.stack : undefined,
       },
       timestamp: new Date().toISOString(),
     } satisfies ApiErrorResponse;
-    return res.status(statusCode).json(response);
+
+    res.status(statusCode).json(response);
   }
 
   // ========== Convenience Methods ==========
@@ -78,63 +80,63 @@ export class ResponseHelper {
   /**
    * 201 Created
    */
-  static created<T>(res: Response, data: T, message = 'Resource created') {
-    return ResponseHelper.success(res, data, message, 201);
+  static created<T>(res: Response, data: T, message = 'Resource created'): void {
+    ResponseHelper.success(res, data, message, 201);
   }
 
   /**
    * 204 No Content
    */
-  static noContent(res: Response) {
-    return res.status(204).send();
+  static noContent(res: Response): void {
+    res.status(204).send();
   }
 
   /**
    * 400 Bad Request (with validation errors)
    */
-  static badRequest(res: Response, message: string, details?: ErrorDetail[]) {
-    return ResponseHelper.fail(res, 'BAD_REQUEST', message, 400, details);
+  static badRequest(res: Response, message: string, details?: ErrorDetail[]): void {
+    ResponseHelper.fail(res, 'BAD_REQUEST', message, 400, details);
   }
 
   /**
    * 401 Unauthorized
    */
-  static unauthorized(res: Response, message = 'Authentication required') {
-    return ResponseHelper.fail(res, 'UNAUTHORIZED', message, 401);
+  static unauthorized(res: Response, message = 'Authentication required'): void {
+    ResponseHelper.fail(res, 'UNAUTHORIZED', message, 401);
   }
 
   /**
    * 403 Forbidden
    */
-  static forbidden(res: Response, message = 'Access denied') {
-    return ResponseHelper.fail(res, 'FORBIDDEN', message, 403);
+  static forbidden(res: Response, message = 'Access denied'): void {
+    ResponseHelper.fail(res, 'FORBIDDEN', message, 403);
   }
 
   /**
    * 404 Not Found
    */
-  static notFound(res: Response, message = 'Resource not found') {
-    return ResponseHelper.fail(res, 'NOT_FOUND', message, 404);
+  static notFound(res: Response, message = 'Resource not found'): void {
+    ResponseHelper.fail(res, 'NOT_FOUND', message, 404);
   }
 
   /**
    * 409 Conflict
    */
-  static conflict(res: Response, message: string) {
-    return ResponseHelper.fail(res, 'CONFLICT', message, 409);
+  static conflict(res: Response, message: string): void {
+    ResponseHelper.fail(res, 'CONFLICT', message, 409);
   }
 
   /**
    * 422 Unprocessable Entity (validation errors)
    */
-  static validationError(res: Response, details: ErrorDetail[]) {
-    return ResponseHelper.fail(res, 'VALIDATION_ERROR', 'Validation failed', 422, details);
+  static validationError(res: Response, details: ErrorDetail[]): void {
+    ResponseHelper.fail(res, 'VALIDATION_ERROR', 'Validation failed', 422, details);
   }
 
   /**
    * 500 Internal Server Error
    */
-  static internalError(res: Response, message = 'Internal server error', error?: Error) {
-    return ResponseHelper.error(res, 'INTERNAL_SERVER_ERROR', message, 500, error);
+  static internalError(res: Response, message = 'Internal server error', error?: Error): void {
+    ResponseHelper.error(res, 'INTERNAL_SERVER_ERROR', message, 500, error);
   }
 }

package/templates/boilerplate/src/database/mongoose.connection.ts

@@ -6,20 +6,37 @@ import { logger } from '@/common/utils/logger';
  * MongoDB Connection (Mongoose)
  */
 
+const MAX_RETRIES = 5;
+const RETRY_DELAY = 5000;
+
 export const connectDatabase = async (): Promise<void> => {
-  try {
-    const options: mongoose.ConnectOptions = {
-      maxPoolSize: 10,
-      minPoolSize: 2,
-      serverSelectionTimeoutMS: 5000,
-      socketTimeoutMS: 45000,
-    };
-
-    await mongoose.connect(config.database.url, options);
-    logger.info('󰆼 MongoDB connected successfully');
-  } catch (error) {
-    logger.error('󱙀 MongoDB connection error:', error);
-    process.exit(1);
+  const options: mongoose.ConnectOptions = {
+    maxPoolSize: 10,
+    minPoolSize: 2,
+    serverSelectionTimeoutMS: 5000,
+    socketTimeoutMS: 45000,
+  };
+
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      await mongoose.connect(config.database.url, options);
+
+      logger.info('󰆼 MongoDB connected successfully');
+
+      return;
+    } catch (error) {
+      logger.error(`󰆼 MongoDB connection attempt ${attempt}/${MAX_RETRIES} failed:`, error);
+
+      if (attempt < MAX_RETRIES) {
+        logger.info(`󰆼 Retrying in ${RETRY_DELAY}ms...`);
+
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY));
+      } else {
+        logger.error('󱙀 Failed to connect to MongoDB after maximum retries');
+
+        throw error;
+      }
+    }
   }
 };
 
@@ -44,13 +61,3 @@ mongoose.connection.on('disconnected', () => {
 mongoose.connection.on('error', (error) => {
   logger.error('󱙀 MongoDB connection error:', error);
 });
-
-// Graceful shutdown
-const gracefulShutdown = async (signal: string) => {
-  logger.info(`󰆼 ${signal} received. Closing MongoDB connection...`);
-  await disconnectDatabase();
-  process.exit(0);
-};
-
-process.on('SIGINT', () => void gracefulShutdown('SIGINT'));
-process.on('SIGTERM', () => void gracefulShutdown('SIGTERM'));

package/templates/boilerplate/src/server.ts

@@ -1,20 +1,23 @@
 import { config } from './config';
 import express, { Application } from 'express';
 import cors from 'cors';
+import helmet from 'helmet';
+import compression from 'compression';
+// import rateLimit from 'express-rate-limit';
 import { logger } from './common/utils/logger';
 import { httpLogger } from './common/utils/http-logger';
 import { errorHandler, notFoundHandler } from './common/middleware/error.middleware';
-import { connectDatabase } from './database';
+import { connectDatabase, disconnectDatabase } from './database';
 
 /**
  * Express Application Setup
  */
-
 const app: Application = express();
 
 /**
- * Middleware
+ * Security Middleware
  */
+app.use(helmet()); // Security headers
 app.use(
   cors({
     origin: config.cors.origin,
@@ -22,12 +25,36 @@ app.use(
   }),
 );
 
+/**
+ * Performance Middleware
+ */
+app.use(compression()); // Compress responses
+
+/**
+ * Rate Limiting (Applied to API routes only)
+ * Comment it out to use it 👇🏽 and the import 👆🏽
+ */
+// const limiter = rateLimit({
+//   windowMs: 15 * 60 * 1000, // 15 minutes
+//   max: 100, // Limit each IP to 100 requests per window
+//   message: 'Too many requests from this IP, please try again later.',
+//   standardHeaders: true, // Return rate limit info in `RateLimit-*` headers
+//   legacyHeaders: false, // Disable `X-RateLimit-*` headers
+// });
+
+/**
+ * Body Parsing Middleware
+ */
 app.use(express.json({ limit: '10mb' }));
 app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+
+/**
+ * Logging Middleware
+ */
 app.use(httpLogger);
 
 /**
- * Health Check Endpoint
+ * Health Check Endpoint (No rate limiting)
  */
 app.get('/health', (_req, res) => {
   res.json({
@@ -43,17 +70,19 @@ app.get('/health', (_req, res) => {
  */
 app.get('/', (_req, res) => {
   res.json({
-    message: 'Hello World!',
+    message: 'Express TypeScript API',
     version: '1.0.0',
+    documentation: '/api/docs', // Add when you implement API docs
   });
 });
 
 /**
  * API Routes
  *
+ * Apply rate limiting to all API routes
  * Add your routes here:
- * app.use('/api/users', userRoutes);
- * app.use('/api/posts', postRoutes);
+ *   app.use('/api/users', limiter, userRoutes);
+ *   app.use('/api/posts', limiter, postRoutes);
  */
 
 /**
@@ -67,10 +96,11 @@ app.use(errorHandler);
  */
 const startServer = async (): Promise<void> => {
   try {
+    // Connect to database with retry logic
     await connectDatabase();
 
     const PORT = config.port;
-    app.listen(PORT, () => {
+    const server = app.listen(PORT, () => {
       if (config.nodeEnv === 'development') {
         logger.info(`
 ╔════════════════════════════════════════╗
@@ -80,41 +110,62 @@ const startServer = async (): Promise<void> => {
 ╚════════════════════════════════════════╝
         `);
       } else {
-        // Production: Simple, JSON-friendly message
         logger.info({
-          message: 'Server is running',
+          message: 'Server started successfully',
           port: PORT,
           environment: config.nodeEnv,
-          url: `http://localhost:${PORT}`,
         });
       }
     });
+
+    // Graceful shutdown
+    const gracefulShutdown = async (signal: string) => {
+      logger.info(`${signal} received. Starting graceful shutdown...`);
+
+      // Stop accepting new requests
+      server.close(async () => {
+        logger.info('HTTP server closed');
+
+        try {
+          // Close database connections
+          await disconnectDatabase();
+          logger.info('Database disconnected');
+          process.exit(0);
+        } catch (error) {
+          logger.error('Error during graceful shutdown:', error);
+          process.exit(1);
+        }
+      });
+
+      // Force shutdown after 10 seconds
+      setTimeout(() => {
+        logger.error('Forced shutdown after timeout');
+        process.exit(1);
+      }, 10000);
+    };
+
+    process.on('SIGINT', () => void gracefulShutdown('SIGINT'));
+    process.on('SIGTERM', () => void gracefulShutdown('SIGTERM'));
   } catch (error) {
     logger.error('Failed to start server:', error);
     process.exit(1);
   }
 };
 
-// Graceful shutdown
-const gracefulShutdown = (signal: string) => {
-  logger.info(`${signal} received. Starting graceful shutdown...`);
-  process.exit(0);
-};
-
-process.on('SIGINT', () => gracefulShutdown('SIGINT'));
-process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+// Unhandled errors
 process.on('unhandledRejection', (reason: Error) => {
   logger.error('Unhandled Promise Rejection:', reason);
   process.exit(1);
 });
+
 process.on('uncaughtException', (error: Error) => {
   logger.error('Uncaught Exception:', error);
   process.exit(1);
 });
 
+// Start the server
 startServer().catch((error) => {
   logger.error('Failed to start server:', error);
-
   process.exit(1);
 });
 

package/templates/boilerplate/docker/docker-compose.yml

@@ -1,68 +0,0 @@
-version: '3.8'
-
-services:
-  # MongoDB Service
-  mongodb:
-    image: mongo:7
-    container_name: express-mongodb
-    restart: unless-stopped
-    ports:
-      - '27017:27017'
-    environment:
-      MONGO_INITDB_ROOT_USERNAME: admin
-      MONGO_INITDB_ROOT_PASSWORD: password123
-      MONGO_INITDB_DATABASE: myapp
-    volumes:
-      - mongodb_data:/data/db
-    networks:
-      - app-network
-
-  # PostgreSQL Service (uncomment if using PostgreSQL)
-  # postgres:
-  #   image: postgres:16-alpine
-  #   container_name: express-postgres
-  #   restart: unless-stopped
-  #   ports:
-  #     - '5432:5432'
-  #   environment:
-  #     POSTGRES_USER: postgres
-  #     POSTGRES_PASSWORD: password123
-  #     POSTGRES_DB: myapp
-  #   volumes:
-  #     - postgres_data:/var/lib/postgresql/data
-  #   networks:
-  #     - app-network
-
-  # Application Service
-  app:
-    build:
-      context: .
-      dockerfile: Dockerfile
-      target: production
-    container_name: express-app
-    restart: unless-stopped
-    ports:
-      - '3000:3000'
-    environment:
-      NODE_ENV: production
-      PORT: 3000
-      # MongoDB connection
-      DATABASE_URL: mongodb://admin:password123@mongodb:27017/myapp?authSource=admin
-      # PostgreSQL connection (uncomment if using PostgreSQL)
-      # DATABASE_URL: postgresql://postgres:password123@postgres:5432/myapp
-      JWT_SECRET: your-super-secret-jwt-key-change-this-in-production-min-32-chars
-      JWT_EXPIRES_IN: 7d
-      LOG_LEVEL: info
-    depends_on:
-      - mongodb
-      # - postgres  # Uncomment if using PostgreSQL
-    networks:
-      - app-network
-
-networks:
-  app-network:
-    driver: bridge
-
-volumes:
-  mongodb_data:
-  # postgres_data:  # Uncomment if using PostgreSQL