dependency-injection

Guidelines for implementing dependency injection patterns, choosing between constructor and property injection, and handling circular dependencies in TypeScript applications

// interfaces/email-service.interface.ts export interface EmailService { sendEmail(to: string, subject: string, body: string): Promise; }

// services/user-notification.service.ts import { injectable, inject } from 'inversify'; import { UserService } from '../interfaces/user-service.interface'; import { EmailService } from '../interfaces/email-service.interface'; import { Logger } from '../interfaces/logger.interface';

@injectable() export class UserNotificationService { constructor( @inject('UserService') private readonly userService: UserService, @inject('EmailService') private readonly emailService: EmailService, @inject('Logger') private readonly logger: Logger ) { // Validate required dependencies if (!userService) throw new Error('UserService is required'); if (!emailService) throw new Error('EmailService is required'); if (!logger) throw new Error('Logger is required'); }

async notifyUser(userId: string, message: string): Promise { const user = await this.userService.findById(userId); await this.emailService.sendEmail(user.email, 'Notification', message); this.logger.info(Notification sent to user ${userId}); } }

</example>

<example type="property-injection">
```typescript
// services/analytics.service.ts
import { injectable, inject, optional } from 'inversify';
import { MetricsCollector } from '../interfaces/metrics-collector.interface';
import { CacheService } from '../interfaces/cache-service.interface';

@injectable()
export class AnalyticsService {
  // Optional dependency via property injection
  @inject('MetricsCollector') @optional()
  private metricsCollector?: MetricsCollector;

  // Required dependency via constructor
  constructor(
    @inject('CacheService') private readonly cacheService: CacheService
  ) {
    if (!cacheService) throw new Error('CacheService is required');
  }

  async trackEvent(event: string, data: any): Promise<void> {
    // Use optional dependency if available
    if (this.metricsCollector) {
      await this.metricsCollector.record(event, data);
    }
    
    // Always use required dependency
    await this.cacheService.set(`event:${event}`, data);
  }
}