@codeenthusiast09/create-express-app 1.0.0

package/templates/boilerplate/scripts/generate-module.cjs

@@ -0,0 +1,397 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Module Generator
+ *
+ * Creates a new module with all necessary files:
+ * - controller.ts
+ * - service.ts
+ * - routes.ts
+ * - validation.ts
+ * - repository.interface.ts
+ * - repository.ts
+ *
+ * Usage: npm run generate:module <module-name>
+ * Example: npm run generate:module hazard-matrix
+ */
+
+// Get module name from command line
+const moduleName = process.argv[2];
+
+if (!moduleName) {
+  console.error('❌ Error: Please provide a module name');
+  console.log('Usage: npm run generate:module <module-name>');
+  console.log('Example: npm run generate:module hazard-matrix');
+  process.exit(1);
+}
+
+// Validate module name (allow lowercase letters, hyphens, and underscores)
+if (!/^[a-z][a-z0-9-_]*$/.test(moduleName)) {
+  console.error(
+    '❌ Error: Module name must start with a lowercase letter and contain only lowercase letters, numbers, hyphens, and underscores',
+  );
+  console.log('Valid examples: users, user-profiles, hazard-matrix');
+  process.exit(1);
+}
+
+/**
+ * Convert kebab-case or snake_case to PascalCase
+ * Examples:
+ *   hazard-matrix -> HazardMatrix
+ *   user_profiles -> UserProfiles
+ *   users -> Users
+ */
+function toPascalCase(str) {
+  return str
+    .split(/[-_]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join('');
+}
+
+/**
+ * Convert kebab-case or snake_case to camelCase
+ * Examples:
+ *   hazard-matrix -> hazardMatrix
+ *   user_profiles -> userProfiles
+ *   users -> users
+ */
+function toCamelCase(str) {
+  const parts = str.split(/[-_]/);
+  return (
+    parts[0] +
+    parts
+      .slice(1)
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join('')
+  );
+}
+
+// Generate names
+const ModuleName = toPascalCase(moduleName); // HazardMatrix (for class names, schemas)
+const moduleNameCamel = toCamelCase(moduleName); // hazardMatrix (for variable names)
+const modulePath = path.join(process.cwd(), 'src', 'modules', moduleName); // hazard-matrix (keep original)
+
+// Check if module already exists
+if (fs.existsSync(modulePath)) {
+  console.error(`❌ Error: Module "${moduleName}" already exists!`);
+  process.exit(1);
+}
+
+// Create module directory
+console.log(`📁 Creating module: ${moduleName}...`);
+fs.mkdirSync(modulePath, { recursive: true });
+
+// File templates
+const templates = {
+  // Controller
+  'controller.ts': `import { Request, Response } from 'express';
+import { ${moduleNameCamel}Service } from './${moduleName}.service';
+import { ResponseHelper } from '@/common/utils/response-helper';
+import { asyncHandler } from '@/common/middleware/error.middleware';
+
+/**
+ * ${ModuleName} Controller
+ */
+export class ${ModuleName}Controller {
+  /**
+   * Create ${moduleName}
+   */
+  create = asyncHandler(async (req: Request, res: Response) => {
+    const data = await ${moduleNameCamel}Service.create(req.body);
+    ResponseHelper.created(res, data, '${ModuleName} created successfully');
+  });
+
+  /**
+   * Get all ${moduleName}
+   */
+  getAll = asyncHandler(async (_req: Request, res: Response) => {
+    const data = await ${moduleNameCamel}Service.findAll();
+    ResponseHelper.success(res, data, '${ModuleName} retrieved successfully');
+  });
+
+  /**
+   * Get ${moduleName} by ID
+   */
+  getById = asyncHandler(async (req: Request, res: Response) => {
+    const id = req.params.id;
+    if (!id) {
+      ResponseHelper.badRequest(res, 'ID is required');
+      return;
+    }
+    const data = await ${moduleNameCamel}Service.findById(id);
+    ResponseHelper.success(res, data, '${ModuleName} retrieved successfully');
+  });
+ 
+  /**
+   * Update ${moduleName}
+   */
+  update = asyncHandler(async (req: Request, res: Response) => {
+    const id = req.params.id;
+    if (!id) {
+      ResponseHelper.badRequest(res, 'ID is required');
+      return;
+    }
+    const data = await ${moduleNameCamel}Service.update(id, req.body);
+    ResponseHelper.success(res, data, '${ModuleName} updated successfully');
+  });
+
+  /**
+   * Delete ${moduleName}
+   */
+  delete = asyncHandler(async (req: Request, res: Response) => {
+    const id = req.params.id;
+    if (!id) {
+      ResponseHelper.badRequest(res, 'ID is required');
+      return;
+    }
+    await ${moduleNameCamel}Service.delete(id);
+    ResponseHelper.noContent(res);
+  });
+}
+
+export const ${moduleNameCamel}Controller = new ${ModuleName}Controller();
+`,
+
+  // Service
+  'service.ts': `import { ${moduleNameCamel}Repository } from './${moduleName}.repository';
+import { AppError } from '@/common/middleware/error.middleware';
+
+/**
+ * ${ModuleName} Service
+ * 
+ * Business logic for ${moduleName} operations.
+ */
+class ${ModuleName}Service {
+  /**
+   * Find all ${moduleName}
+   */
+  async findAll() {
+    return await ${moduleNameCamel}Repository.findAll();
+  }
+
+  /**
+   * Find ${moduleName} by ID
+   */
+  async findById(id: string) {
+    const data = await ${moduleNameCamel}Repository.findById(id);
+    if (!data) {
+      throw new AppError('${ModuleName} not found', 404, '${ModuleName.toUpperCase().replace(/-/g, '_')}_NOT_FOUND');
+    }
+    return data;
+  }
+
+  /**
+   * Create ${moduleName}
+   */
+  async create(data: any) {
+    return await ${moduleNameCamel}Repository.create(data);
+  }
+
+  /**
+   * Update ${moduleName}
+   */
+  async update(id: string, data: any) {
+    const updated = await ${moduleNameCamel}Repository.update(id, data);
+    if (!updated) {
+      throw new AppError('${ModuleName} not found', 404, '${ModuleName.toUpperCase().replace(/-/g, '_')}_NOT_FOUND');
+    }
+    return updated;
+  }
+
+  /**
+   * Delete ${moduleName}
+   */
+  async delete(id: string) {
+    const deleted = await ${moduleNameCamel}Repository.delete(id);
+    if (!deleted) {
+      throw new AppError('${ModuleName} not found', 404, '${ModuleName.toUpperCase().replace(/-/g, '_')}_NOT_FOUND');
+    }
+  }
+}
+
+export const ${moduleNameCamel}Service = new ${ModuleName}Service();
+`,
+
+  // Routes
+  'routes.ts': `import { Router } from 'express';
+import { ${moduleNameCamel}Controller } from './${moduleName}.controller';
+import { validate } from '@/common/middleware/validation.middleware';
+import { create${ModuleName}Schema, update${ModuleName}Schema, idParamSchema } from './${moduleName}.validation';
+
+/**
+ * ${ModuleName} Routes
+ */
+const router = Router();
+
+router.get('/', ${moduleNameCamel}Controller.getAll);
+router.get('/:id', validate({ params: idParamSchema }), ${moduleNameCamel}Controller.getById);
+router.post('/', validate({ body: create${ModuleName}Schema }), ${moduleNameCamel}Controller.create);
+router.patch('/:id', validate({ params: idParamSchema, body: update${ModuleName}Schema }), ${moduleNameCamel}Controller.update);
+router.delete('/:id', validate({ params: idParamSchema }), ${moduleNameCamel}Controller.delete);
+
+export default router;
+`,
+
+  // Validation
+  'validation.ts': `import { z } from 'zod';
+
+/**
+ * ${ModuleName} Validation Schemas
+ */
+
+export const create${ModuleName}Schema = z.object({
+  name: z.string().min(1, 'Name is required'),
+  // Add more fields as needed
+});
+
+export const update${ModuleName}Schema = z.object({
+  name: z.string().min(1).optional(),
+  // Add more fields as needed
+});
+
+export const idParamSchema = z.object({
+  id: z.string().min(1, 'ID is required'),
+});
+
+export type Create${ModuleName}Input = z.infer<typeof create${ModuleName}Schema>;
+export type Update${ModuleName}Input = z.infer<typeof update${ModuleName}Schema>;
+`,
+
+  // Repository Interface
+  'repository.interface.ts': `/**
+ * ${ModuleName} Repository Interface
+ */
+
+export interface I${ModuleName}Repository {
+  findAll(): Promise<any[]>;
+  findById(id: string): Promise<any | null>;
+  create(data: any): Promise<any>;
+  update(id: string, data: any): Promise<any | null>;
+  delete(id: string): Promise<boolean>;
+}
+`,
+
+  // Repository Implementation
+  'repository.ts': `import { I${ModuleName}Repository } from './${moduleName}.repository.interface';
+
+/**
+ * ${ModuleName} Repository
+ * 
+ * TODO: Implement based on your database choice:
+ * - For Mongoose: Import and use Mongoose model
+ * - For Prisma: Import and use Prisma client
+ * - For Drizzle: Import and use Drizzle db instance
+ */
+class ${ModuleName}Repository implements I${ModuleName}Repository {
+  async findAll() {
+    // TODO: Implement database query
+    return [];
+  }
+
+  async findById(_id: string) {
+    // TODO: Implement database query
+    return null;
+  }
+
+  async create(data: any) {
+    // TODO: Implement database insertion
+    return data;
+  }
+
+  async update(_id: string, _data: any) {
+    // TODO: Implement database update
+    return null;
+  }
+
+  async delete(_id: string) {
+    // TODO: Implement database deletion
+    return false;
+  }
+}
+
+export const ${moduleNameCamel}Repository = new ${ModuleName}Repository();
+`,
+};
+
+// Generate files
+Object.entries(templates).forEach(([filename, content]) => {
+  const filePath = path.join(modulePath, `${moduleName}.${filename}`);
+  fs.writeFileSync(filePath, content);
+  console.log(`✓ Created ${moduleName}.${filename}`);
+});
+
+// ========== Auto-register routes ==========
+console.log();
+console.log('📝 Registering routes in server.ts...');
+
+try {
+  const serverPath = path.join(process.cwd(), 'src', 'server.ts');
+  let serverContent = fs.readFileSync(serverPath, 'utf-8');
+
+  // 1. Add import statement at the top (after other imports)
+  const importStatement = `import ${moduleNameCamel}Routes from './modules/${moduleName}/${moduleName}.routes';`;
+
+  // Find the last import statement
+  const lastImportIndex = serverContent.lastIndexOf('import ');
+  const endOfLastImport = serverContent.indexOf('\n', lastImportIndex);
+
+  // Insert the new import after the last import
+  serverContent =
+    serverContent.slice(0, endOfLastImport + 1) +
+    importStatement +
+    '\n' +
+    serverContent.slice(endOfLastImport + 1);
+
+  // 2. Add route registration before error handlers
+  const routeRegistration = `\n/**\n * ${ModuleName} Routes\n */\napp.use('/api/${moduleName}', ${moduleNameCamel}Routes);\n`;
+
+  // Find the "Error Handling" comment (this should be before error handlers)
+  const errorHandlingComment = '/**\n * Error Handling (must be last)\n */';
+  const errorHandlingIndex = serverContent.indexOf(errorHandlingComment);
+
+  if (errorHandlingIndex === -1) {
+    // Fallback: insert before the first app.use with error handler
+    const notFoundHandlerIndex = serverContent.indexOf('app.use(notFoundHandler)');
+    if (notFoundHandlerIndex !== -1) {
+      serverContent =
+        serverContent.slice(0, notFoundHandlerIndex) +
+        routeRegistration +
+        serverContent.slice(notFoundHandlerIndex);
+    } else {
+      console.warn(
+        '⚠️  Could not find error handler location. You may need to manually register the routes.',
+      );
+    }
+  } else {
+    // Insert before the error handling comment
+    serverContent =
+      serverContent.slice(0, errorHandlingIndex) +
+      routeRegistration +
+      serverContent.slice(errorHandlingIndex);
+  }
+
+  // Write the updated content back
+  fs.writeFileSync(serverPath, serverContent);
+  console.log(`✓ Routes registered in server.ts`);
+  console.log(`  - Import: ${importStatement}`);
+  console.log(`  - Route: app.use('/api/${moduleName}', ${moduleNameCamel}Routes)`);
+} catch (error) {
+  console.error('⚠️  Error auto-registering routes:', error.message);
+  console.log('   Please manually add the following to src/server.ts:');
+  console.log(
+    `   import ${moduleNameCamel}Routes from './modules/${moduleName}/${moduleName}.routes';`,
+  );
+  console.log(`   app.use('/api/${moduleName}', ${moduleNameCamel}Routes);`);
+}
+
+console.log();
+console.log(`✅ Module "${moduleName}" created successfully!`);
+console.log();
+console.log('📝 Next steps:');
+console.log(`1. Implement database operations in ${moduleName}.repository.ts`);
+console.log(`2. Update validation schemas in ${moduleName}.validation.ts`);
+console.log(`3. Start coding! Routes are already registered at /api/${moduleName}`);
+console.log();

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

@@ -0,0 +1,121 @@
+import { Request, Response, NextFunction } from 'express';
+import { ZodError } from 'zod';
+import { logger } from '@/common/utils/logger';
+import { config } from '@/config';
+import { ResponseHelper } from '@/common/utils/response-helper';
+import { ErrorDetail } from '@/types/response.types';
+
+/**
+ * Custom Application Error
+ *
+ * Throw this for expected errors:
+ *   throw new AppError('User not found', 404);
+ */
+export class AppError extends Error {
+  constructor(
+    public message: string,
+    public statusCode: number = 500,
+    public code: string = 'APP_ERROR',
+    public isOperational: boolean = true,
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+/**
+ * MongoDB Duplicate Key Error Interface
+ */
+interface MongoError extends Error {
+  code?: number;
+  keyPattern?: Record<string, number>;
+  keyValue?: Record<string, unknown>;
+}
+
+/**
+ * Global Error Handler
+ *
+ * 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) => {
+  // 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);
+    }
+    // Server errors (5xx)
+    return ResponseHelper.error(res, err.code, err.message, err.statusCode, err);
+  }
+
+  // Handle Zod validation errors
+  if (err instanceof ZodError) {
+    const details: ErrorDetail[] = err.errors.map((error) => ({
+      field: error.path.join('.'),
+      message: error.message,
+      code: error.code,
+    }));
+    return ResponseHelper.validationError(res, details);
+  }
+
+  // Handle JWT errors
+  if (err.name === 'JsonWebTokenError') {
+    return ResponseHelper.unauthorized(res, 'Invalid token');
+  }
+  if (err.name === 'TokenExpiredError') {
+    return ResponseHelper.unauthorized(res, 'Token expired');
+  }
+
+  // Handle Mongoose errors
+  if (err.name === 'ValidationError') {
+    return ResponseHelper.badRequest(res, 'Validation failed');
+  }
+  if (err.name === 'CastError') {
+    return ResponseHelper.badRequest(res, 'Invalid ID format');
+  }
+  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'}`);
+  }
+
+  // Default: Unknown error
+  return ResponseHelper.internalError(
+    res,
+    config.nodeEnv === 'development' ? err.message : 'An unexpected error occurred',
+    err,
+  );
+};
+
+/**
+ * Async Handler Wrapper
+ *
+ * Wraps async route handlers to catch errors automatically.
+ *
+ * Usage:
+ *   router.get('/users', asyncHandler(async (req, res) => {
+ *     const users = await userService.findAll();
+ *     ResponseHelper.success(res, users);
+ *   }));
+ */
+export const asyncHandler = (
+  fn: (req: Request, res: Response, next: NextFunction) => Promise<void>,
+) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+};
+
+/**
+ * 404 Not Found Handler
+ *
+ * Register BEFORE error handler.
+ */
+export const notFoundHandler = (req: Request, res: Response) => {
+  return ResponseHelper.notFound(res, `Route ${req.method} ${req.url} not found`);
+};

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

@@ -0,0 +1,50 @@
+import { Request, Response, NextFunction } from 'express';
+import { AnyZodObject, ZodError } from 'zod';
+import { ResponseHelper } from '@/common/utils/response-helper';
+import { ErrorDetail } from '@/types/response.types';
+
+/**
+ * Validation Middleware
+ *
+ * Validates request body, query, or params against Zod schema.
+ *
+ * Usage:
+ *   router.post('/users', validate({ body: createUserSchema }), createUser);
+ */
+interface ValidationSchemas {
+  body?: AnyZodObject;
+  query?: AnyZodObject;
+  params?: AnyZodObject;
+}
+
+export const validate = (schemas: ValidationSchemas) => {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      if (schemas.body) {
+        req.body = await schemas.body.parseAsync(req.body);
+      }
+
+      if (schemas.query) {
+        req.query = await schemas.query.parseAsync(req.query);
+      }
+
+      if (schemas.params) {
+        req.params = await schemas.params.parseAsync(req.params);
+      }
+
+      return next();
+    } catch (error) {
+      if (error instanceof ZodError) {
+        const details: ErrorDetail[] = error.errors.map((err) => ({
+          field: err.path.join('.'),
+          message: err.message,
+          code: err.code,
+        }));
+
+        return ResponseHelper.validationError(res, details);
+      }
+
+      return next(error);
+    }
+  };
+};

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

@@ -0,0 +1,24 @@
+import pinoHttp from 'pino-http';
+import { Request, Response } from 'express';
+import { logger } from './logger';
+
+export const httpLogger = pinoHttp({
+  logger,
+
+  customLogLevel: (_req, res, err) => {
+    if (res.statusCode >= 500 || err) return 'error';
+    if (res.statusCode >= 400) return 'warn';
+    return 'info';
+  },
+
+  serializers: {
+    req: (req: Request) => ({
+      method: req.method,
+      url: req.url,
+      userId: req.user?.id,
+    }),
+    res: (res: Response) => ({
+      statusCode: res.statusCode,
+    }),
+  },
+});

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

@@ -0,0 +1,34 @@
+import pino from 'pino';
+import { config } from '@/config';
+
+/**
+ * Application Logger
+ *
+ * Usage:
+ *   logger.info('User created', { userId: 123 });
+ *   logger.error('Failed to connect', { error });
+ *   logger.debug('Cache hit', { key: 'user:123' });
+ */
+export const logger = pino({
+  level: config.logging.level,
+
+  // Pretty print in development, JSON in production
+  transport:
+    config.nodeEnv === 'development'
+      ? {
+          target: 'pino-pretty',
+          options: {
+            colorize: true,
+            translateTime: 'HH:MM:ss Z',
+            ignore: 'pid,hostname',
+          },
+        }
+      : undefined,
+
+  // Add environment to every log
+  // base: {
+  //   env: config.nodeEnv,
+  // },
+
+  timestamp: pino.stdTimeFunctions.isoTime,
+});