Interface Injection

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

// Shared dependency interfaces
interface UserRepository {
    findById(id: string): Promise<User | null>;
    save(user: User): Promise<void>;
}
 
interface EventPublisher {
    publish(event: DomainEvent): Promise<void>;
}
 
interface Logger {
    info(message: string): void;
    error(message: string, error?: Error): void;
}
 
// ========================================
// CONSTRUCTOR INJECTION
// Dependencies explicit in constructor
// ========================================
 
class ConstructorInjectedUserService {
    constructor(
        private readonly userRepository: UserRepository,
        private readonly eventPublisher: EventPublisher,
        private readonly logger: Logger
    ) {
        // Object is fully initialized after construction
        // All dependencies are final/readonly
    }
    
    async updateUser(id: string, data: Partial<User>): Promise<User> {
        // All dependencies guaranteed to exist
        this.logger.info(`Updating user ${id}`);
        
        const user = await this.userRepository.findById(id);
        if (!user) throw new UserNotFoundError(id);
        
        const updatedUser = { ...user, ...data };
        await this.userRepository.save(updatedUser);
        await this.eventPublisher.publish(new UserUpdatedEvent(user, updatedUser));
        
        return updatedUser;
    }
}
 
// Usage: Dependencies passed at construction
const service1 = new ConstructorInjectedUserService(
    new PostgresUserRepository(),
    new RabbitMQEventPublisher(),
    new ConsoleLogger()
);
 
// ========================================
// SETTER INJECTION
// Dependencies set via setters after construction
// ========================================
 
class SetterInjectedUserService {
    private userRepository?: UserRepository;
    private eventPublisher?: EventPublisher;
    private logger?: Logger;
    
    // Setter methods for each dependency
    setUserRepository(repo: UserRepository): void {
        this.userRepository = repo;
    }
    
    setEventPublisher(publisher: EventPublisher): void {
        this.eventPublisher = publisher;
    }
    
    setLogger(logger: Logger): void {
        this.logger = logger;
    }
    
    async updateUser(id: string, data: Partial<User>): Promise<User> {
        // Must check for dependencies or use assertions
        if (!this.userRepository || !this.eventPublisher || !this.logger) {
            throw new Error('Dependencies not configured');
        }
        
        this.logger.info(`Updating user ${id}`);
        
        const user = await this.userRepository.findById(id);
        if (!user) throw new UserNotFoundError(id);
        
        const updatedUser = { ...user, ...data };
        await this.userRepository.save(updatedUser);
        await this.eventPublisher.publish(new UserUpdatedEvent(user, updatedUser));
        
        return updatedUser;
    }
}
 
// Usage: Object created, then dependencies set
const service2 = new SetterInjectedUserService();
service2.setUserRepository(new PostgresUserRepository());
service2.setEventPublisher(new RabbitMQEventPublisher());
service2.setLogger(new ConsoleLogger());
 
// ========================================
// INTERFACE INJECTION
// Dependencies define interfaces, class implements them
// ========================================
 
// Injector interfaces (defined by or alongside dependencies)
interface UserRepositoryInjector {
    injectUserRepository(repo: UserRepository): void;
}
 
interface EventPublisherInjector {
    injectEventPublisher(publisher: EventPublisher): void;
}
 
interface LoggerInjector {
    injectLogger(logger: Logger): void;
}
 
class InterfaceInjectedUserService implements
    UserRepositoryInjector,
    EventPublisherInjector,
    LoggerInjector {
    
    private userRepository!: UserRepository;
    private eventPublisher!: EventPublisher;
    private logger!: Logger;
    
    // Implement injector interface methods
    injectUserRepository(repo: UserRepository): void {
        this.userRepository = repo;
    }
    
    injectEventPublisher(publisher: EventPublisher): void {
        this.eventPublisher = publisher;
    }
    
    injectLogger(logger: Logger): void {
        this.logger = logger;
    }
    
    async updateUser(id: string, data: Partial<User>): Promise<User> {
        this.logger.info(`Updating user ${id}`);
        
        const user = await this.userRepository.findById(id);
        if (!user) throw new UserNotFoundError(id);
        
        const updatedUser = { ...user, ...data };
        await this.userRepository.save(updatedUser);
        await this.eventPublisher.publish(new UserUpdatedEvent(user, updatedUser));
        
        return updatedUser;
    }
}
 
// Usage: Container detects interfaces and injects
const service3 = new InterfaceInjectedUserService();
container.injectDependencies(service3); // Container handles injection

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

// ========================================
// CONSTRUCTOR INJECTION: Excellent completeness & immutability
// ========================================
 
class CompleteAndImmutableService {
    // readonly guarantees immutability
    constructor(
        private readonly userRepo: UserRepository,
        private readonly cache: CacheService
    ) {
        // Object is complete - no way to create partially initialized
        // TypeScript enforces all parameters are provided
    }
    
    async getUser(id: string): Promise<User | null> {
        // No null checks needed - construction guarantees completeness
        const cached = await this.cache.get<User>(`user:${id}`);
        if (cached) return cached;
        
        const user = await this.userRepo.findById(id);
        if (user) await this.cache.set(`user:${id}`, user);
        return user;
    }
}
 
// This won't compile - forces completeness
// const broken = new CompleteAndImmutableService(); // Error: Missing arguments
 
// This is the only way - complete from birth
const valid = new CompleteAndImmutableService(
    new PostgresUserRepository(),
    new RedisCache()
);
 
// Cannot modify dependencies - readonly
// valid.userRepo = new MockRepo(); // Error: Cannot assign to readonly
 
// ========================================
// SETTER INJECTION: Poor completeness & immutability
// ========================================
 
class IncompleteAndMutableService {
    private userRepo?: UserRepository;
    private cache?: CacheService;
    
    setUserRepository(repo: UserRepository): void {
        this.userRepo = repo;
    }
    
    setCacheService(cache: CacheService): void {
        this.cache = cache;
    }
    
    async getUser(id: string): Promise<User | null> {
        // Must check or assert - completeness not guaranteed
        if (!this.userRepo || !this.cache) {
            throw new Error('Service not fully configured');
        }
        
        const cached = await this.cache.get<User>(`user:${id}`);
        if (cached) return cached;
        
        const user = await this.userRepo.findById(id);
        if (user) await this.cache.set(`user:${id}`, user);
        return user;
    }
}
 
// Compiles but incomplete - runtime error waiting to happen
const incomplete = new IncompleteAndMutableService();
incomplete.setUserRepository(new PostgresUserRepository());
// Forgot to set cache - will fail at runtime
 
// Dependencies can be swapped - mutable
const mutableService = new IncompleteAndMutableService();
mutableService.setUserRepository(new PostgresUserRepository());
mutableService.setCacheService(new RedisCache());
// Later, some other code does this:
mutableService.setUserRepository(new MockUserRepository()); // Silent replacement!
 
// ========================================
// INTERFACE INJECTION: Moderate completeness & immutability
// ========================================
 
interface UserRepositoryInjector {
    injectUserRepository(repo: UserRepository): void;
}
 
interface CacheInjector {
    injectCache(cache: CacheService): void;
}
 
class InterfaceInjectedService implements UserRepositoryInjector, CacheInjector {
    private userRepo!: UserRepository;
    private cache!: CacheService;
    private injectionComplete = false;
    
    injectUserRepository(repo: UserRepository): void {
        if (this.injectionComplete) {
            throw new Error('Dependencies are immutable after injection complete');
        }
        this.userRepo = repo;
    }
    
    injectCache(cache: CacheService): void {
        if (this.injectionComplete) {
            throw new Error('Dependencies are immutable after injection complete');
        }
        this.cache = cache;
    }
    
    // Container calls this after all injections
    markInjectionComplete(): void {
        if (!this.userRepo || !this.cache) {
            throw new Error('Not all dependencies were injected');
        }
        this.injectionComplete = true;
        Object.freeze(this); // Enforce immutability
    }
    
    async getUser(id: string): Promise<User | null> {
        if (!this.injectionComplete) {
            throw new Error('Service not fully initialized');
        }
        // Safe to use dependencies
        const cached = await this.cache.get<User>(`user:${id}`);
        if (cached) return cached;
        
        const user = await this.userRepo.findById(id);
        if (user) await this.cache.set(`user:${id}`, user);
        return user;
    }
}
 
// With a well-implemented container:
class InjectionContainer {
    wire(target: object): void {
        if (this.isUserRepositoryInjector(target)) {
            target.injectUserRepository(this.resolveUserRepository());
        }
        if (this.isCacheInjector(target)) {
            target.injectCache(this.resolveCache());
        }
        // Mark complete after all injections
        if ('markInjectionComplete' in target) {
            (target as InterfaceInjectedService).markInjectionComplete();
        }
    }
    
    // Type guards and resolution...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

// ========================================
// TEST SETUP FOR CONSTRUCTOR INJECTION
// Cleanest testing experience
// ========================================
 
describe('ConstructorInjectedUserService', () => {
    let service: ConstructorInjectedUserService;
    let mockUserRepo: jest.Mocked<UserRepository>;
    let mockEventPublisher: jest.Mocked<EventPublisher>;
    let mockLogger: jest.Mocked<Logger>;
    
    beforeEach(() => {
        // Create mocks
        mockUserRepo = {
            findById: jest.fn(),
            save: jest.fn(),
        };
        mockEventPublisher = {
            publish: jest.fn(),
        };
        mockLogger = {
            info: jest.fn(),
            error: jest.fn(),
        };
        
        // Single clean instantiation with all dependencies
        service = new ConstructorInjectedUserService(
            mockUserRepo,
            mockEventPublisher,
            mockLogger
        );
    });
    
    it('should update user successfully', async () => {
        const existingUser = { id: '1', name: 'John', email: 'john@example.com' };
        mockUserRepo.findById.mockResolvedValue(existingUser);
        mockUserRepo.save.mockResolvedValue();
        mockEventPublisher.publish.mockResolvedValue();
        
        const result = await service.updateUser('1', { name: 'Jane' });
        
        expect(result.name).toBe('Jane');
        expect(mockUserRepo.save).toHaveBeenCalled();
        expect(mockEventPublisher.publish).toHaveBeenCalledWith(
            expect.any(UserUpdatedEvent)
        );
    });
});
 
// ========================================
// TEST SETUP FOR SETTER INJECTION
// More flexible but risky
// ========================================
 
describe('SetterInjectedUserService', () => {
    let service: SetterInjectedUserService;
    let mockUserRepo: jest.Mocked<UserRepository>;
    let mockEventPublisher: jest.Mocked<EventPublisher>;
    let mockLogger: jest.Mocked<Logger>;
    
    beforeEach(() => {
        // Create mocks
        mockUserRepo = {
            findById: jest.fn(),
            save: jest.fn(),
        };
        mockEventPublisher = {
            publish: jest.fn(),
        };
        mockLogger = {
            info: jest.fn(),
            error: jest.fn(),
        };
        
        // Create service and set dependencies
        service = new SetterInjectedUserService();
        service.setUserRepository(mockUserRepo);
        service.setEventPublisher(mockEventPublisher);
        service.setLogger(mockLogger);
    });
    
    it('should update user successfully', async () => {
        const existingUser = { id: '1', name: 'John', email: 'john@example.com' };
        mockUserRepo.findById.mockResolvedValue(existingUser);
        mockUserRepo.save.mockResolvedValue();
        mockEventPublisher.publish.mockResolvedValue();
        
        const result = await service.updateUser('1', { name: 'Jane' });
        
        expect(result.name).toBe('Jane');
    });
    
    // Setter injection allows testing partial configuration
    it('can test with only some dependencies (if the method allows)', async () => {
        // Create fresh service with only needed dependencies
        const partialService = new SetterInjectedUserService();
        partialService.setLogger(mockLogger);
        
        // This would throw because userRepo is not set
        // But you can test methods that don't need all dependencies
        // (if such methods exist)
    });
    
    // Risk: Forgetting to set a dependency
    it('fails if dependencies are not set', async () => {
        const incompleteService = new SetterInjectedUserService();
        // Forgot to set dependencies
        
        await expect(incompleteService.updateUser('1', {}))
            .rejects.toThrow('Dependencies not configured');
    });
});
 
// ========================================
// TEST SETUP FOR INTERFACE INJECTION
// More setup but mirrors production
// ========================================
 
describe('InterfaceInjectedUserService', () => {
    let service: InterfaceInjectedUserService;
    let mockUserRepo: jest.Mocked<UserRepository>;
    let mockEventPublisher: jest.Mocked<EventPublisher>;
    let mockLogger: jest.Mocked<Logger>;
    
    beforeEach(() => {
        // Create mocks
        mockUserRepo = { findById: jest.fn(), save: jest.fn() };
        mockEventPublisher = { publish: jest.fn() };
        mockLogger = { info: jest.fn(), error: jest.fn() };
        
        // Create service
        service = new InterfaceInjectedUserService();
        
        // Perform interface injection manually
        service.injectUserRepository(mockUserRepo);
        service.injectEventPublisher(mockEventPublisher);
        service.injectLogger(mockLogger);
    });
    
    it('should update user successfully', async () => {
        const existingUser = { id: '1', name: 'John', email: 'john@example.com' };
        mockUserRepo.findById.mockResolvedValue(existingUser);
        mockUserRepo.save.mockResolvedValue();
        mockEventPublisher.publish.mockResolvedValue();
        
        const result = await service.updateUser('1', { name: 'Jane' });
        
        expect(result.name).toBe('Jane');
    });
});
 
// Alternative: Use a test container for interface injection
describe('InterfaceInjectedUserService with TestContainer', () => {
    let container: TestContainer;
    
    beforeEach(() => {
        container = new TestContainer()
            .registerMock(UserRepository, { findById: jest.fn(), save: jest.fn() })
            .registerMock(EventPublisher, { publish: jest.fn() })
            .registerMock(Logger, { info: jest.fn(), error: jest.fn() });
    });
    
    it('should update user successfully', async () => {
        const service = container.create(InterfaceInjectedUserService);
        
        container.getMock<UserRepository>(UserRepository).findById
            .mockResolvedValue({ id: '1', name: 'John', email: 'john@example.com' });
        
        const result = await service.updateUser('1', { name: 'Jane' });
        
        expect(result.name).toBe('Jane');
    });
});
 
// ========================================
// Test container for interface injection
// ========================================
 
class TestContainer {
    private mocks: Map<object, object> = new Map();
    
    registerMock<T>(type: new (...args: any[]) => T, mock: Partial<T>): this {
        this.mocks.set(type, mock);
        return this;
    }
    
    getMock<T>(type: new (...args: any[]) => T): jest.Mocked<T> {
        return this.mocks.get(type) as jest.Mocked<T>;
    }
    
    create<T extends object>(ctor: new () => T): T {
        const instance = new ctor();
        
        // Perform interface injection
        if ('injectUserRepository' in instance) {
            (instance as any).injectUserRepository(this.mocks.get(UserRepository));
        }
        if ('injectEventPublisher' in instance) {
            (instance as any).injectEventPublisher(this.mocks.get(EventPublisher));
        }
        if ('injectLogger' in instance) {
            (instance as any).injectLogger(this.mocks.get(Logger));
        }
        
        return instance;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

// ========================================
// Decision tree for choosing injection type
// ========================================
 
type InjectionType = 'constructor' | 'setter' | 'interface';
 
interface InjectionDecisionContext {
    // Dependency characteristics
    isRequired: boolean;
    isImmutable: boolean;
    isFrameworkService: boolean;
    
    // Class characteristics
    youControlConstruction: boolean;
    hasLegacyNoArgConstructorRequirement: boolean;
    isFrameworkExtension: boolean;
    isPlugin: boolean;
    
    // Architecture characteristics
    needsDiscoveryBasedWiring: boolean;
    hasCircularDependencies: boolean;
    dependencyControlsLifecycle: boolean;
}
 
function chooseInjectionType(context: InjectionDecisionContext): InjectionType {
    // Framework extensions and plugins → Interface Injection
    if (context.isFrameworkExtension || context.isPlugin) {
        return 'interface';
    }
    
    // Discovery-based wiring or dependency-controlled lifecycle → Interface
    if (context.needsDiscoveryBasedWiring || context.dependencyControlsLifecycle) {
        return 'interface';
    }
    
    // Circular dependencies or optional dependencies → Setter
    if (context.hasCircularDependencies || !context.isRequired) {
        return 'setter';
    }
    
    // Legacy no-arg constructor requirement → Setter
    if (context.hasLegacyNoArgConstructorRequirement) {
        return 'setter';
    }
    
    // You control construction and want required/immutable → Constructor
    if (context.youControlConstruction && context.isRequired && context.isImmutable) {
        return 'constructor';
    }
    
    // Default to constructor for most application code
    return 'constructor';
}
 
// ========================================
// Real-world decision examples
// ========================================
 
// Example 1: Standard application service
const orderServiceDecision = chooseInjectionType({
    isRequired: true,
    isImmutable: true,
    isFrameworkService: false,
    youControlConstruction: true,
    hasLegacyNoArgConstructorRequirement: false,
    isFrameworkExtension: false,
    isPlugin: false,
    needsDiscoveryBasedWiring: false,
    hasCircularDependencies: false,
    dependencyControlsLifecycle: false,
});
// Result: 'constructor'
 
// Example 2: Optional email notifier
const emailNotifierDecision = chooseInjectionType({
    isRequired: false,  // Optional!
    isImmutable: false,
    isFrameworkService: false,
    youControlConstruction: true,
    hasLegacyNoArgConstructorRequirement: false,
    isFrameworkExtension: false,
    isPlugin: false,
    needsDiscoveryBasedWiring: false,
    hasCircularDependencies: false,
    dependencyControlsLifecycle: false,
});
// Result: 'setter'
 
// Example 3: Framework plugin
const pluginDecision = chooseInjectionType({
    isRequired: true,
    isImmutable: true,
    isFrameworkService: true,
    youControlConstruction: false,
    hasLegacyNoArgConstructorRequirement: false,
    isFrameworkExtension: true,
    isPlugin: true,
    needsDiscoveryBasedWiring: true,
    hasCircularDependencies: false,
    dependencyControlsLifecycle: true,
});
// Result: 'interface'
 
// Example 4: Hibernate entity (no-arg constructor required)
const entityDecision = chooseInjectionType({
    isRequired: true,
    isImmutable: false,
    isFrameworkService: false,
    youControlConstruction: false,
    hasLegacyNoArgConstructorRequirement: true,  // ORM requirement!
    isFrameworkExtension: false,
    isPlugin: false,
    needsDiscoveryBasedWiring: false,
    hasCircularDependencies: false,
    dependencyControlsLifecycle: false,
});
// Result: 'setter'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218

// ========================================
// Pattern 1: Constructor + Setter
// Required via constructor, optional via setter
// ========================================
 
class HybridPaymentService {
    // Required dependencies - constructor injected
    constructor(
        private readonly paymentGateway: PaymentGateway,
        private readonly transactionLog: TransactionLog
    ) {}
    
    // Optional dependencies - setter injected
    private fraudChecker?: FraudChecker;
    private notifier?: NotificationService;
    
    setFraudChecker(checker: FraudChecker): void {
        this.fraudChecker = checker;
    }
    
    setNotifier(notifier: NotificationService): void {
        this.notifier = notifier;
    }
    
    async processPayment(payment: Payment): Promise<PaymentResult> {
        // Required dependencies always available
        await this.transactionLog.begin(payment);
        
        // Optional fraud check if configured
        if (this.fraudChecker) {
            const fraudRisk = await this.fraudChecker.assess(payment);
            if (fraudRisk > 0.8) {
                await this.transactionLog.flag(payment, 'FRAUD_SUSPECTED');
                throw new FraudDetectedError();
            }
        }
        
        const result = await this.paymentGateway.charge(payment);
        await this.transactionLog.commit(payment, result);
        
        // Optional notification if configured
        if (this.notifier) {
            await this.notifier.sendPaymentConfirmation(payment, result);
        }
        
        return result;
    }
}
 
// Usage
const service = new HybridPaymentService(
    new StripeGateway(),
    new PostgresTransactionLog()
);
// Optional: add fraud checking in production
if (process.env.NODE_ENV === 'production') {
    service.setFraudChecker(new MLFraudChecker());
}
service.setNotifier(new EmailNotifier());
 
// ========================================
// Pattern 2: Constructor + Interface
// Core deps via constructor, framework services via interface
// ========================================
 
interface LoggerAware {
    setLogger(logger: Logger): void;
}
 
interface MetricsAware {
    setMetrics(metrics: MetricsCollector): void;
}
 
class FrameworkIntegratedOrderService implements LoggerAware, MetricsAware {
    // Core business dependencies - constructor injected
    constructor(
        private readonly orderRepo: OrderRepository,
        private readonly inventoryService: InventoryService,
        private readonly pricingEngine: PricingEngine
    ) {}
    
    // Framework/infrastructure deps - interface injected
    private logger?: Logger;
    private metrics?: MetricsCollector;
    
    setLogger(logger: Logger): void {
        this.logger = logger;
    }
    
    setMetrics(metrics: MetricsCollector): void {
        this.metrics = metrics;
    }
    
    async createOrder(request: OrderRequest): Promise<Order> {
        this.logger?.info('Creating order', { customerId: request.customerId });
        const startTime = Date.now();
        
        try {
            // Core business logic uses constructor-injected dependencies
            const items = await this.inventoryService.reserveItems(request.items);
            const pricing = await this.pricingEngine.calculate(items, request.discounts);
            const order = await this.orderRepo.create({
                customerId: request.customerId,
                items,
                total: pricing.total,
            });
            
            this.metrics?.incrementCounter('orders.created');
            this.metrics?.recordHistogram('orders.duration_ms', Date.now() - startTime);
            this.logger?.info('Order created', { orderId: order.id });
            
            return order;
        } catch (error) {
            this.metrics?.incrementCounter('orders.failed');
            this.logger?.error('Order creation failed', error as Error);
            throw error;
        }
    }
}
 
// Usage: Constructor injection for business deps
const orderService = new FrameworkIntegratedOrderService(
    new PostgresOrderRepository(),
    new InventoryService(),
    new DynamicPricingEngine()
);
 
// Framework container adds infrastructure via interface injection
frameworkContainer.wire(orderService);
 
// ========================================
// Pattern 3: Interface + Lifecycle
// Interface injection with lifecycle callbacks
// ========================================
 
interface Initializable {
    initialize(): Promise<void>;
}
 
interface Destroyable {
    destroy(): Promise<void>;
}
 
class DatabaseQueueProcessor implements
    DatabaseConnectionInjector,
    MessageQueueInjector,
    LoggerInjector,
    Initializable,
    Destroyable {
    
    private db!: DatabaseConnection;
    private queue!: MessageQueue;
    private logger!: Logger;
    private processing = false;
    
    // Interface injection for all dependencies
    injectDatabaseConnection(db: DatabaseConnection): void {
        this.db = db;
    }
    
    injectMessageQueue(queue: MessageQueue): void {
        this.queue = queue;
    }
    
    injectLogger(logger: Logger): void {
        this.logger = logger;
    }
    
    // Lifecycle: called after all injections
    async initialize(): Promise<void> {
        this.logger.info('Initializing queue processor');
        await this.db.connect();
        await this.queue.subscribe('orders', this.processMessage.bind(this));
        this.processing = true;
        this.logger.info('Queue processor initialized and listening');
    }
    
    // Lifecycle: called before shutdown
    async destroy(): Promise<void> {
        this.logger.info('Shutting down queue processor');
        this.processing = false;
        await this.queue.unsubscribe('orders');
        await this.db.disconnect();
        this.logger.info('Queue processor shut down');
    }
    
    private async processMessage(message: Message): Promise<void> {
        if (!this.processing) return;
        
        this.logger.info('Processing message', { messageId: message.id });
        // Process with database...
    }
}
 
// Container handles injection + lifecycle
class LifecycleContainer {
    async create<T extends object>(ctor: new () => T): Promise<T> {
        const instance = new ctor();
        
        // Perform interface injection
        this.injectDependencies(instance);
        
        // Call lifecycle hook
        if (this.isInitializable(instance)) {
            await instance.initialize();
        }
        
        return instance;
    }
    
    async destroy<T extends object>(instance: T): Promise<void> {
        if (this.isDestroyable(instance)) {
            await instance.destroy();
        }
    }
    
    // ... injection and type guard methods
}