1---
2title: Single Responsibility for Services
3impact: CRITICAL
4impactDescription: "40%+ improvement in testability"
5tags: architecture, services, single-responsibility
6---
7 
8## Single Responsibility for Services
9 
10Each service should have a single, well-defined responsibility. Avoid "god services" that handle multiple unrelated concerns. If a service name includes "And" or handles more than one domain concept, it likely violates single responsibility. This reduces complexity and improves testability by 40%+.
11 
12**Incorrect (god service anti-pattern):**
13 
14```typescript
15// God service anti-pattern
16@Injectable()
17export class UserAndOrderService {
18  constructor(
19    private userRepo: UserRepository,
20    private orderRepo: OrderRepository,
21    private mailer: MailService,
22    private payment: PaymentService,
23  ) {}
24 
25  async createUser(dto: CreateUserDto) {
26    const user = await this.userRepo.save(dto);
27    await this.mailer.sendWelcome(user);
28    return user;
29  }
30 
31  async createOrder(userId: string, dto: CreateOrderDto) {
32    const order = await this.orderRepo.save({ userId, ...dto });
33    await this.payment.charge(order);
34    await this.mailer.sendOrderConfirmation(order);
35    return order;
36  }
37 
38  async calculateOrderStats(userId: string) {
39    // Stats logic mixed in
40  }
41 
42  async validatePayment(orderId: string) {
43    // Payment logic mixed in
44  }
45}
46```
47 
48**Correct (focused services with single responsibility):**
49 
50```typescript
51// Focused services with single responsibility
52@Injectable()
53export class UsersService {
54  constructor(private userRepo: UserRepository) {}
55 
56  async create(dto: CreateUserDto): Promise<User> {
57    return this.userRepo.save(dto);
58  }
59 
60  async findById(id: string): Promise<User> {
61    return this.userRepo.findOneOrFail({ where: { id } });
62  }
63}
64 
65@Injectable()
66export class OrdersService {
67  constructor(private orderRepo: OrderRepository) {}
68 
69  async create(userId: string, dto: CreateOrderDto): Promise<Order> {
70    return this.orderRepo.save({ userId, ...dto });
71  }
72 
73  async findByUser(userId: string): Promise<Order[]> {
74    return this.orderRepo.find({ where: { userId } });
75  }
76}
77 
78@Injectable()
79export class OrderStatsService {
80  constructor(private orderRepo: OrderRepository) {}
81 
82  async calculateForUser(userId: string): Promise<OrderStats> {
83    // Focused stats calculation
84  }
85}
86 
87// Orchestration in controller or dedicated orchestrator
88@Controller('orders')
89export class OrdersController {
90  constructor(
91    private orders: OrdersService,
92    private payment: PaymentService,
93    private notifications: NotificationService,
94  ) {}
95 
96  @Post()
97  async create(@CurrentUser() user: User, @Body() dto: CreateOrderDto) {
98    const order = await this.orders.create(user.id, dto);
99    await this.payment.charge(order);
100    await this.notifications.sendOrderConfirmation(order);
101    return order;
102  }
103}
104```
105 
106Reference: [NestJS Providers](https://docs.nestjs.com/providers)
107