1---
2title: Avoid Service Locator Anti-Pattern
3impact: HIGH
4impactDescription: Hides dependencies and breaks testability
5tags: dependency-injection, anti-patterns, testing
6---
7 
8## Avoid Service Locator Anti-Pattern
9 
10Avoid using `ModuleRef.get()` or global containers to resolve dependencies at runtime. This hides dependencies, makes code harder to test, and breaks the benefits of dependency injection. Use constructor injection instead.
11 
12**Incorrect (service locator anti-pattern):**
13 
14```typescript
15// Use ModuleRef to get dependencies dynamically
16@Injectable()
17export class OrdersService {
18  constructor(private moduleRef: ModuleRef) {}
19 
20  async createOrder(dto: CreateOrderDto): Promise<Order> {
21    // Dependencies are hidden - not visible in constructor
22    const usersService = this.moduleRef.get(UsersService);
23    const inventoryService = this.moduleRef.get(InventoryService);
24    const paymentService = this.moduleRef.get(PaymentService);
25 
26    const user = await usersService.findOne(dto.userId);
27    // ... rest of logic
28  }
29}
30 
31// Global singleton container
32class ServiceContainer {
33  private static instance: ServiceContainer;
34  private services = new Map<string, any>();
35 
36  static getInstance(): ServiceContainer {
37    if (!this.instance) {
38      this.instance = new ServiceContainer();
39    }
40    return this.instance;
41  }
42 
43  get<T>(key: string): T {
44    return this.services.get(key);
45  }
46}
47```
48 
49**Correct (constructor injection with explicit dependencies):**
50 
51```typescript
52// Use constructor injection - dependencies are explicit
53@Injectable()
54export class OrdersService {
55  constructor(
56    private usersService: UsersService,
57    private inventoryService: InventoryService,
58    private paymentService: PaymentService,
59  ) {}
60 
61  async createOrder(dto: CreateOrderDto): Promise<Order> {
62    const user = await this.usersService.findOne(dto.userId);
63    const inventory = await this.inventoryService.check(dto.items);
64    // Dependencies are clear and testable
65  }
66}
67 
68// Easy to test with mocks
69describe('OrdersService', () => {
70  let service: OrdersService;
71 
72  beforeEach(async () => {
73    const module = await Test.createTestingModule({
74      providers: [
75        OrdersService,
76        { provide: UsersService, useValue: mockUsersService },
77        { provide: InventoryService, useValue: mockInventoryService },
78        { provide: PaymentService, useValue: mockPaymentService },
79      ],
80    }).compile();
81 
82    service = module.get(OrdersService);
83  });
84});
85 
86// VALID: Factory pattern for dynamic instantiation
87@Injectable()
88export class HandlerFactory {
89  constructor(private moduleRef: ModuleRef) {}
90 
91  getHandler(type: string): Handler {
92    switch (type) {
93      case 'email':
94        return this.moduleRef.get(EmailHandler);
95      case 'sms':
96        return this.moduleRef.get(SmsHandler);
97      default:
98        return this.moduleRef.get(DefaultHandler);
99    }
100  }
101}
102```
103 
104Reference: [NestJS Module Reference](https://docs.nestjs.com/fundamentals/module-ref)
105