How to Reduce Boilerplate in Cursor-Generated Code

1---
2description: Enforce DRY patterns in REST endpoint generation
3globs: "*.controller.ts,*.route.ts,*.router.ts"
4alwaysApply: true
5---
6
7# DRY Code Rules for REST Endpoints
8- NEVER duplicate error handling logic — use the asyncHandler wrapper
9- NEVER duplicate response formatting — use ApiResponse.success/error
10- NEVER duplicate validation — use validateRequest middleware
11- NEVER inline pagination logic — use the paginate utility
12- ALWAYS import shared utilities from @/lib/
13- ALWAYS use the base controller/router pattern for CRUD endpoints
14- Keep route handlers under 15 lines by delegating to services
15
16## Required Imports:
17```typescript
18import { asyncHandler } from '@/lib/async-handler';
19import { ApiResponse } from '@/lib/api-response';
20import { validateRequest } from '@/middleware/validate';
21import { paginate } from '@/lib/pagination';
22```

1import { Request, Response, NextFunction } from 'express';
2
3export const asyncHandler = (
4  fn: (req: Request, res: Response, next: NextFunction) => Promise<void>
5) =>
6  (req: Request, res: Response, next: NextFunction): void => {
7    Promise.resolve(fn(req, res, next)).catch(next);
8  };
9
10export class ApiResponse<T> {
11  constructor(
12    public success: boolean,
13    public data: T | null,
14    public message: string,
15    public meta?: Record<string, unknown>
16  ) {}
17
18  static ok<T>(data: T, message = 'Success', meta?: Record<string, unknown>) {
19    return new ApiResponse(true, data, message, meta);
20  }
21
22  static created<T>(data: T, message = 'Created') {
23    return new ApiResponse(true, data, message);
24  }
25
26  static error(message: string, meta?: Record<string, unknown>) {
27    return new ApiResponse(false, null, message, meta);
28  }
29}

1@dry-rest.mdc @src/lib/api-response.ts @src/lib/async-handler.ts
2
3Create a complete products API with these endpoints:
4- GET /api/products (list with pagination)
5- GET /api/products/:id (single product)
6- POST /api/products (create with validation)
7- PUT /api/products/:id (update with validation)
8- DELETE /api/products/:id (delete)
9
10Use asyncHandler for every route. Use ApiResponse for all responses.
11Use validateRequest middleware for POST and PUT.
12Keep each handler under 10 lines. Delegate logic to ProductService.

1@dry-rest.mdc @src/routes/
2
3Analyze all route files in this folder. Identify duplicated patterns:
41. Error handling try/catch blocks that could use asyncHandler
52. Response formatting that could use ApiResponse
63. Validation logic that could be extracted to middleware
74. Pagination code that could use a shared utility
8
9For each duplication, show the refactored version using shared utilities.
10Process one route file at a time.

1import { Router } from 'express';
2import { asyncHandler } from '@/lib/async-handler';
3import { ApiResponse } from '@/lib/api-response';
4import { paginate } from '@/lib/pagination';
5
6interface CrudConfig<T> {
7  service: {
8    findAll: (page: number, limit: number) => Promise<{ data: T[]; total: number }>;
9    findById: (id: string) => Promise<T | null>;
10    create: (data: Partial<T>) => Promise<T>;
11    update: (id: string, data: Partial<T>) => Promise<T>;
12    remove: (id: string) => Promise<void>;
13  };
14  validateCreate?: any;
15  validateUpdate?: any;
16}
17
18export const createCrudRouter = <T>(config: CrudConfig<T>): Router => {
19  const router = Router();
20  const { service } = config;
21
22  router.get('/', asyncHandler(async (req, res) => {
23    const { page, limit } = paginate(req.query);
24    const result = await service.findAll(page, limit);
25    res.json(ApiResponse.ok(result.data, 'Success', { total: result.total, page, limit }));
26  }));
27
28  router.get('/:id', asyncHandler(async (req, res) => {
29    const item = await service.findById(req.params.id);
30    if (!item) return res.status(404).json(ApiResponse.error('Not found'));
31    res.json(ApiResponse.ok(item));
32  }));
33
34  router.post('/', asyncHandler(async (req, res) => {
35    const item = await service.create(req.body);
36    res.status(201).json(ApiResponse.created(item));
37  }));
38
39  return router;
40};