1---
2title: Apply Interface Segregation Principle
3impact: HIGH
4impactDescription: Reduces coupling and improves testability by 30-50%
5tags: dependency-injection, interfaces, solid, isp
6---
7 
8## Apply Interface Segregation Principle
9 
10Clients should not be forced to depend on interfaces they don't use. In NestJS, this means keeping interfaces small and focused on specific capabilities rather than creating "fat" interfaces that bundle unrelated methods. When a service only needs to send emails, it shouldn't depend on an interface that also includes SMS, push notifications, and logging. Split large interfaces into role-based ones.
11 
12**Incorrect (fat interface forcing unused dependencies):**
13 
14```typescript
15// Fat interface - forces all consumers to depend on everything
16interface NotificationService {
17  sendEmail(to: string, subject: string, body: string): Promise<void>;
18  sendSms(phone: string, message: string): Promise<void>;
19  sendPush(userId: string, notification: PushPayload): Promise<void>;
20  sendSlack(channel: string, message: string): Promise<void>;
21  logNotification(type: string, payload: any): Promise<void>;
22  getDeliveryStatus(id: string): Promise<DeliveryStatus>;
23  retryFailed(id: string): Promise<void>;
24  scheduleNotification(dto: ScheduleDto): Promise<string>;
25}
26 
27// Consumer only needs email, but must mock everything for tests
28@Injectable()
29export class OrdersService {
30  constructor(
31    private notifications: NotificationService, // Depends on 8 methods, uses 1
32  ) {}
33 
34  async confirmOrder(order: Order): Promise<void> {
35    await this.notifications.sendEmail(
36      order.customer.email,
37      'Order Confirmed',
38      `Your order ${order.id} has been confirmed.`,
39    );
40  }
41}
42 
43// Testing is painful - must mock unused methods
44const mockNotificationService = {
45  sendEmail: jest.fn(),
46  sendSms: jest.fn(),           // Never used, but required
47  sendPush: jest.fn(),          // Never used, but required
48  sendSlack: jest.fn(),         // Never used, but required
49  logNotification: jest.fn(),   // Never used, but required
50  getDeliveryStatus: jest.fn(), // Never used, but required
51  retryFailed: jest.fn(),       // Never used, but required
52  scheduleNotification: jest.fn(), // Never used, but required
53};
54```
55 
56**Correct (segregated interfaces by capability):**
57 
58```typescript
59// Segregated interfaces - each focused on one capability
60interface EmailSender {
61  sendEmail(to: string, subject: string, body: string): Promise<void>;
62}
63 
64interface SmsSender {
65  sendSms(phone: string, message: string): Promise<void>;
66}
67 
68interface PushSender {
69  sendPush(userId: string, notification: PushPayload): Promise<void>;
70}
71 
72interface NotificationLogger {
73  logNotification(type: string, payload: any): Promise<void>;
74}
75 
76interface NotificationScheduler {
77  scheduleNotification(dto: ScheduleDto): Promise<string>;
78}
79 
80// Implementation can implement multiple interfaces
81@Injectable()
82export class NotificationService implements EmailSender, SmsSender, PushSender {
83  async sendEmail(to: string, subject: string, body: string): Promise<void> {
84    // Email implementation
85  }
86 
87  async sendSms(phone: string, message: string): Promise<void> {
88    // SMS implementation
89  }
90 
91  async sendPush(userId: string, notification: PushPayload): Promise<void> {
92    // Push implementation
93  }
94}
95 
96// Or separate implementations
97@Injectable()
98export class SendGridEmailService implements EmailSender {
99  async sendEmail(to: string, subject: string, body: string): Promise<void> {
100    // SendGrid-specific implementation
101  }
102}
103 
104// Consumer depends only on what it needs
105@Injectable()
106export class OrdersService {
107  constructor(
108    @Inject(EMAIL_SENDER) private emailSender: EmailSender, // Minimal dependency
109  ) {}
110 
111  async confirmOrder(order: Order): Promise<void> {
112    await this.emailSender.sendEmail(
113      order.customer.email,
114      'Order Confirmed',
115      `Your order ${order.id} has been confirmed.`,
116    );
117  }
118}
119 
120// Testing is simple - only mock what's used
121const mockEmailSender: EmailSender = {
122  sendEmail: jest.fn(),
123};
124 
125// Module registration with tokens
126export const EMAIL_SENDER = Symbol('EMAIL_SENDER');
127export const SMS_SENDER = Symbol('SMS_SENDER');
128 
129@Module({
130  providers: [
131    { provide: EMAIL_SENDER, useClass: SendGridEmailService },
132    { provide: SMS_SENDER, useClass: TwilioSmsService },
133  ],
134  exports: [EMAIL_SENDER, SMS_SENDER],
135})
136export class NotificationModule {}
137```
138 
139**Combining interfaces when needed:**
140 
141```typescript
142// Sometimes a consumer legitimately needs multiple capabilities
143interface EmailAndSmsSender extends EmailSender, SmsSender {}
144 
145// Or use intersection types
146type MultiChannelSender = EmailSender & SmsSender & PushSender;
147 
148// Consumer that genuinely needs multiple channels
149@Injectable()
150export class AlertService {
151  constructor(
152    @Inject(MULTI_CHANNEL_SENDER)
153    private sender: EmailSender & SmsSender,
154  ) {}
155 
156  async sendCriticalAlert(user: User, message: string): Promise<void> {
157    await Promise.all([
158      this.sender.sendEmail(user.email, 'Critical Alert', message),
159      this.sender.sendSms(user.phone, message),
160    ]);
161  }
162}
163```
164 
165Reference: [Interface Segregation Principle](https://en.wikipedia.org/wiki/Interface_segregation_principle)
166