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
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
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284

// ========================================
// FRAMEWORK CORE: Defines injector interfaces
// ========================================
 
namespace WebFramework {
    // Core types
    export interface HttpRequest {
        method: string;
        path: string;
        headers: Record<string, string>;
        body: unknown;
        params: Record<string, string>;
        query: Record<string, string>;
    }
    
    export interface HttpResponse {
        status(code: number): HttpResponse;
        json(data: unknown): void;
        send(body: string): void;
        header(name: string, value: string): HttpResponse;
    }
    
    export interface RequestContext {
        request: HttpRequest;
        response: HttpResponse;
        state: Map<string, unknown>;
    }
    
    // Framework services available for injection
    export interface Logger {
        debug(message: string): void;
        info(message: string): void;
        warn(message: string): void;
        error(message: string, error?: Error): void;
    }
    
    export interface Configuration {
        get<T>(key: string): T | undefined;
        getRequired<T>(key: string): T;
        has(key: string): boolean;
    }
    
    export interface RouteRegistry {
        register(method: string, path: string, handler: RouteHandler): void;
    }
    
    export interface MiddlewareRegistry {
        use(middleware: Middleware): void;
        useFor(pathPattern: string, middleware: Middleware): void;
    }
    
    export type RouteHandler = (ctx: RequestContext) => Promise<void>;
    export type Middleware = (ctx: RequestContext, next: () => Promise<void>) => Promise<void>;
    
    // ========================================
    // INJECTOR INTERFACES
    // User classes implement these to receive services
    // ========================================
    
    export interface LoggerAware {
        setLogger(logger: Logger): void;
    }
    
    export interface ConfigurationAware {
        setConfiguration(config: Configuration): void;
    }
    
    export interface RouteRegistryAware {
        setRouteRegistry(registry: RouteRegistry): void;
    }
    
    export interface MiddlewareRegistryAware {
        setMiddlewareRegistry(registry: MiddlewareRegistry): void;
    }
    
    export interface ContextAware {
        setContext(context: RequestContext): void;
    }
    
    // Detection helpers
    export function isLoggerAware(obj: unknown): obj is LoggerAware {
        return typeof (obj as LoggerAware)?.setLogger === 'function';
    }
    
    export function isConfigurationAware(obj: unknown): obj is ConfigurationAware {
        return typeof (obj as ConfigurationAware)?.setConfiguration === 'function';
    }
    
    export function isRouteRegistryAware(obj: unknown): obj is RouteRegistryAware {
        return typeof (obj as RouteRegistryAware)?.setRouteRegistry === 'function';
    }
    
    export function isMiddlewareRegistryAware(obj: unknown): obj is MiddlewareRegistryAware {
        return typeof (obj as MiddlewareRegistryAware)?.setMiddlewareRegistry === 'function';
    }
    
    export function isContextAware(obj: unknown): obj is ContextAware {
        return typeof (obj as ContextAware)?.setContext === 'function';
    }
}
 
// ========================================
// FRAMEWORK: Extension loader with injection
// ========================================
 
class FrameworkApp {
    private logger: WebFramework.Logger;
    private config: WebFramework.Configuration;
    private routeRegistry: WebFramework.RouteRegistry;
    private middlewareRegistry: WebFramework.MiddlewareRegistry;
    private extensions: object[] = [];
    
    constructor(configPath: string) {
        this.config = Configuration.load(configPath);
        this.logger = new FrameworkLogger(this.config);
        this.routeRegistry = new DefaultRouteRegistry();
        this.middlewareRegistry = new DefaultMiddlewareRegistry();
    }
    
    /**
     * Load an extension (plugin, controller, middleware class)
     * and inject framework services based on implemented interfaces
     */
    loadExtension(extension: object): this {
        console.log(`[Framework] Loading extension: ${extension.constructor.name}`);
        
        this.performInterfaceInjection(extension);
        this.extensions.push(extension);
        
        return this;
    }
    
    /**
     * Detect and perform interface injection
     */
    private performInterfaceInjection(target: object): void {
        // Inject Logger if LoggerAware
        if (WebFramework.isLoggerAware(target)) {
            console.log(`[Framework] Injecting Logger into ${target.constructor.name}`);
            target.setLogger(this.logger);
        }
        
        // Inject Configuration if ConfigurationAware
        if (WebFramework.isConfigurationAware(target)) {
            console.log(`[Framework] Injecting Configuration into ${target.constructor.name}`);
            target.setConfiguration(this.config);
        }
        
        // Inject RouteRegistry if RouteRegistryAware
        if (WebFramework.isRouteRegistryAware(target)) {
            console.log(`[Framework] Injecting RouteRegistry into ${target.constructor.name}`);
            target.setRouteRegistry(this.routeRegistry);
        }
        
        // Inject MiddlewareRegistry if MiddlewareRegistryAware
        if (WebFramework.isMiddlewareRegistryAware(target)) {
            console.log(`[Framework] Injecting MiddlewareRegistry into ${target.constructor.name}`);
            target.setMiddlewareRegistry(this.middlewareRegistry);
        }
    }
    
    start(port: number): void {
        console.log(`[Framework] Starting on port ${port}`);
        // Start HTTP server...
    }
}
 
// ========================================
// USER CODE: Extensions implementing injector interfaces
// ========================================
 
/**
 * User-defined controller
 * Framework injects services based on implemented interfaces
 */
class UserController implements 
    WebFramework.LoggerAware,
    WebFramework.RouteRegistryAware {
    
    private logger!: WebFramework.Logger;
    private routes!: WebFramework.RouteRegistry;
    
    // Receive logger from framework
    setLogger(logger: WebFramework.Logger): void {
        this.logger = logger;
        this.logger.info('[UserController] Logger injected');
    }
    
    // Receive route registry and register routes
    setRouteRegistry(registry: WebFramework.RouteRegistry): void {
        this.routes = registry;
        this.registerRoutes();
    }
    
    private registerRoutes(): void {
        this.routes.register('GET', '/users', this.listUsers.bind(this));
        this.routes.register('GET', '/users/:id', this.getUser.bind(this));
        this.routes.register('POST', '/users', this.createUser.bind(this));
        this.logger.info('[UserController] Routes registered');
    }
    
    async listUsers(ctx: WebFramework.RequestContext): Promise<void> {
        this.logger.info('Listing users');
        ctx.response.json({ users: [] });
    }
    
    async getUser(ctx: WebFramework.RequestContext): Promise<void> {
        const id = ctx.request.params.id;
        this.logger.info(`Getting user ${id}`);
        ctx.response.json({ id, name: 'Example User' });
    }
    
    async createUser(ctx: WebFramework.RequestContext): Promise<void> {
        this.logger.info('Creating user');
        ctx.response.status(201).json({ id: 'new-id', ...ctx.request.body });
    }
}
 
/**
 * User-defined authentication middleware
 */
class AuthMiddleware implements
    WebFramework.LoggerAware,
    WebFramework.ConfigurationAware,
    WebFramework.MiddlewareRegistryAware {
    
    private logger!: WebFramework.Logger;
    private config!: WebFramework.Configuration;
    private jwtSecret!: string;
    
    setLogger(logger: WebFramework.Logger): void {
        this.logger = logger;
    }
    
    setConfiguration(config: WebFramework.Configuration): void {
        this.config = config;
        this.jwtSecret = config.getRequired<string>('auth.jwtSecret');
    }
    
    setMiddlewareRegistry(registry: WebFramework.MiddlewareRegistry): void {
        // Register for all protected paths
        registry.useFor('/api/*', this.authenticate.bind(this));
        this.logger.info('[AuthMiddleware] Registered for /api/*');
    }
    
    async authenticate(
        ctx: WebFramework.RequestContext,
        next: () => Promise<void>
    ): Promise<void> {
        const token = ctx.request.headers['authorization'];
        
        if (!token) {
            this.logger.warn('Missing authorization header');
            ctx.response.status(401).json({ error: 'Unauthorized' });
            return;
        }
        
        try {
            const payload = this.verifyToken(token);
            ctx.state.set('user', payload);
            await next();
        } catch (error) {
            this.logger.error('Token verification failed', error as Error);
            ctx.response.status(401).json({ error: 'Invalid token' });
        }
    }
    
    private verifyToken(token: string): unknown {
        // JWT verification logic...
        return { userId: '123' };
    }
}
 
// ========================================
// APPLICATION BOOTSTRAP
// ========================================
 
const app = new FrameworkApp('./config.json');
 
// Load user extensions - framework injects based on interfaces
app.loadExtension(new UserController());
app.loadExtension(new AuthMiddleware());
 
app.start(3000);

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
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321

// ========================================
// EDITOR CORE: Plugin API with injector interfaces
// ========================================
 
namespace EditorPlugin {
    // Plugin metadata
    export interface PluginManifest {
        id: string;
        name: string;
        version: string;
        description: string;
        author: string;
        activationEvents?: string[];
    }
    
    // Core editor services
    export interface DocumentService {
        getActiveDocument(): Document | undefined;
        openDocument(path: string): Promise<Document>;
        createDocument(content: string): Document;
    }
    
    export interface Document {
        readonly id: string;
        readonly path: string;
        readonly content: string;
        readonly language: string;
        insertText(position: Position, text: string): void;
        deleteRange(start: Position, end: Position): void;
        getText(range?: Range): string;
    }
    
    export interface CommandRegistry {
        registerCommand(id: string, handler: CommandHandler): Disposable;
        executeCommand(id: string, ...args: unknown[]): Promise<unknown>;
    }
    
    export interface MenuRegistry {
        registerMenuItem(location: MenuLocation, item: MenuItem): Disposable;
    }
    
    export interface StatusBar {
        addItem(item: StatusBarItem): Disposable;
    }
    
    export interface Notifications {
        showInfo(message: string): void;
        showWarning(message: string): void;
        showError(message: string): void;
    }
    
    export interface Storage {
        get<T>(key: string): T | undefined;
        set<T>(key: string, value: T): Promise<void>;
        delete(key: string): Promise<void>;
    }
    
    // Disposable pattern for cleanup
    export interface Disposable {
        dispose(): void;
    }
    
    // ========================================
    // INJECTOR INTERFACES FOR PLUGINS
    // ========================================
    
    export interface DocumentServiceInjector {
        injectDocumentService(service: DocumentService): void;
    }
    
    export interface CommandRegistryInjector {
        injectCommandRegistry(registry: CommandRegistry): void;
    }
    
    export interface MenuRegistryInjector {
        injectMenuRegistry(registry: MenuRegistry): void;
    }
    
    export interface StatusBarInjector {
        injectStatusBar(statusBar: StatusBar): void;
    }
    
    export interface NotificationsInjector {
        injectNotifications(notifications: Notifications): void;
    }
    
    export interface StorageInjector {
        injectStorage(storage: Storage): void;
    }
    
    // Plugin lifecycle interface
    export interface Plugin {
        readonly manifest: PluginManifest;
        activate(): void | Promise<void>;
        deactivate(): void | Promise<void>;
    }
}
 
// ========================================
// EDITOR: Plugin loader with interface injection
// ========================================
 
class PluginLoader {
    private documentService: EditorPlugin.DocumentService;
    private commandRegistry: EditorPlugin.CommandRegistry;
    private menuRegistry: EditorPlugin.MenuRegistry;
    private statusBar: EditorPlugin.StatusBar;
    private notifications: EditorPlugin.Notifications;
    private loadedPlugins: Map<string, EditorPlugin.Plugin> = new Map();
    private pluginStorage: Map<string, EditorPlugin.Storage> = new Map();
    
    constructor(editorContext: EditorContext) {
        this.documentService = editorContext.documents;
        this.commandRegistry = editorContext.commands;
        this.menuRegistry = editorContext.menus;
        this.statusBar = editorContext.statusBar;
        this.notifications = editorContext.notifications;
    }
    
    /**
     * Load and activate a plugin
     */
    async loadPlugin(plugin: EditorPlugin.Plugin): Promise<void> {
        const { id, name, version } = plugin.manifest;
        
        console.log(`[Editor] Loading plugin: ${name} v${version}`);
        
        // Perform interface injection before activation
        this.injectServices(plugin, id);
        
        // Activate the plugin
        await plugin.activate();
        
        this.loadedPlugins.set(id, plugin);
        console.log(`[Editor] Plugin activated: ${name}`);
    }
    
    /**
     * Detect and inject services based on implemented interfaces
     */
    private injectServices(plugin: object, pluginId: string): void {
        // DocumentService injection
        if (this.needsDocumentService(plugin)) {
            console.log(`[Editor] Injecting DocumentService into ${pluginId}`);
            plugin.injectDocumentService(this.documentService);
        }
        
        // CommandRegistry injection
        if (this.needsCommandRegistry(plugin)) {
            console.log(`[Editor] Injecting CommandRegistry into ${pluginId}`);
            plugin.injectCommandRegistry(this.commandRegistry);
        }
        
        // MenuRegistry injection
        if (this.needsMenuRegistry(plugin)) {
            console.log(`[Editor] Injecting MenuRegistry into ${pluginId}`);
            plugin.injectMenuRegistry(this.menuRegistry);
        }
        
        // StatusBar injection
        if (this.needsStatusBar(plugin)) {
            console.log(`[Editor] Injecting StatusBar into ${pluginId}`);
            plugin.injectStatusBar(this.statusBar);
        }
        
        // Notifications injection
        if (this.needsNotifications(plugin)) {
            console.log(`[Editor] Injecting Notifications into ${pluginId}`);
            plugin.injectNotifications(this.notifications);
        }
        
        // Storage injection (each plugin gets isolated storage)
        if (this.needsStorage(plugin)) {
            const storage = this.getOrCreatePluginStorage(pluginId);
            console.log(`[Editor] Injecting isolated Storage into ${pluginId}`);
            plugin.injectStorage(storage);
        }
    }
    
    private getOrCreatePluginStorage(pluginId: string): EditorPlugin.Storage {
        if (!this.pluginStorage.has(pluginId)) {
            this.pluginStorage.set(pluginId, new IsolatedPluginStorage(pluginId));
        }
        return this.pluginStorage.get(pluginId)!;
    }
    
    async unloadPlugin(pluginId: string): Promise<void> {
        const plugin = this.loadedPlugins.get(pluginId);
        if (!plugin) return;
        
        console.log(`[Editor] Unloading plugin: ${plugin.manifest.name}`);
        await plugin.deactivate();
        this.loadedPlugins.delete(pluginId);
    }
    
    // Type guards
    private needsDocumentService(obj: unknown): obj is EditorPlugin.DocumentServiceInjector {
        return typeof (obj as EditorPlugin.DocumentServiceInjector)?.injectDocumentService === 'function';
    }
    
    private needsCommandRegistry(obj: unknown): obj is EditorPlugin.CommandRegistryInjector {
        return typeof (obj as EditorPlugin.CommandRegistryInjector)?.injectCommandRegistry === 'function';
    }
    
    private needsMenuRegistry(obj: unknown): obj is EditorPlugin.MenuRegistryInjector {
        return typeof (obj as EditorPlugin.MenuRegistryInjector)?.injectMenuRegistry === 'function';
    }
    
    private needsStatusBar(obj: unknown): obj is EditorPlugin.StatusBarInjector {
        return typeof (obj as EditorPlugin.StatusBarInjector)?.injectStatusBar === 'function';
    }
    
    private needsNotifications(obj: unknown): obj is EditorPlugin.NotificationsInjector {
        return typeof (obj as EditorPlugin.NotificationsInjector)?.injectNotifications === 'function';
    }
    
    private needsStorage(obj: unknown): obj is EditorPlugin.StorageInjector {
        return typeof (obj as EditorPlugin.StorageInjector)?.injectStorage === 'function';
    }
}
 
// ========================================
// PLUGIN EXAMPLE: Word Count Plugin
// ========================================
 
class WordCountPlugin implements
    EditorPlugin.Plugin,
    EditorPlugin.DocumentServiceInjector,
    EditorPlugin.CommandRegistryInjector,
    EditorPlugin.StatusBarInjector,
    EditorPlugin.NotificationsInjector {
    
    readonly manifest: EditorPlugin.PluginManifest = {
        id: 'word-count',
        name: 'Word Count',
        version: '1.0.0',
        description: 'Display word count for the active document',
        author: 'Plugin Developer',
    };
    
    private documents!: EditorPlugin.DocumentService;
    private commands!: EditorPlugin.CommandRegistry;
    private statusBar!: EditorPlugin.StatusBar;
    private notifications!: EditorPlugin.Notifications;
    private disposables: EditorPlugin.Disposable[] = [];
    
    // Interface injection methods
    injectDocumentService(service: EditorPlugin.DocumentService): void {
        this.documents = service;
    }
    
    injectCommandRegistry(registry: EditorPlugin.CommandRegistry): void {
        this.commands = registry;
    }
    
    injectStatusBar(statusBar: EditorPlugin.StatusBar): void {
        this.statusBar = statusBar;
    }
    
    injectNotifications(notifications: EditorPlugin.Notifications): void {
        this.notifications = notifications;
    }
    
    // Lifecycle
    activate(): void {
        console.log('[WordCountPlugin] Activating...');
        
        // Register command
        const cmdDisposable = this.commands.registerCommand(
            'wordCount.showCount',
            this.showWordCount.bind(this)
        );
        this.disposables.push(cmdDisposable);
        
        // Add status bar item
        const statusDisposable = this.statusBar.addItem({
            id: 'word-count-status',
            text: this.getWordCountText(),
            tooltip: 'Word count for current document',
            command: 'wordCount.showCount',
        });
        this.disposables.push(statusDisposable);
        
        this.notifications.showInfo('Word Count plugin activated');
    }
    
    deactivate(): void {
        console.log('[WordCountPlugin] Deactivating...');
        for (const disposable of this.disposables) {
            disposable.dispose();
        }
        this.disposables = [];
    }
    
    private showWordCount(): void {
        const doc = this.documents.getActiveDocument();
        if (!doc) {
            this.notifications.showWarning('No active document');
            return;
        }
        
        const wordCount = this.countWords(doc.content);
        this.notifications.showInfo(`Word count: ${wordCount}`);
    }
    
    private getWordCountText(): string {
        const doc = this.documents.getActiveDocument();
        if (!doc) return 'No document';
        return `Words: ${this.countWords(doc.content)}`;
    }
    
    private countWords(text: string): number {
        return text.split(/\s+/).filter(word => word.length > 0).length;
    }
}
 
// ========================================
// LOADING THE PLUGIN
// ========================================
const loader = new PluginLoader(editorContext);
await loader.loadPlugin(new WordCountPlugin());

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
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315

// ========================================
// Lifecycle interfaces
// ========================================
 
interface InitializingBean {
    /**
     * Called after all dependencies are injected
     */
    afterPropertiesSet(): void | Promise<void>;
}
 
interface DisposableBean {
    /**
     * Called before the bean is destroyed
     */
    destroy(): void | Promise<void>;
}
 
interface Lifecycle {
    /**
     * Start the component
     */
    start(): void | Promise<void>;
    
    /**
     * Stop the component
     */
    stop(): void | Promise<void>;
    
    /**
     * Is the component running?
     */
    isRunning(): boolean;
}
 
interface RefreshAware {
    /**
     * Called when the container is refreshed
     */
    onRefresh(): void | Promise<void>;
}
 
// ========================================
// Container with lifecycle management
// ========================================
 
class LifecycleAwareContainer {
    private beans: Map<string, object> = new Map();
    private beanOrder: string[] = []; // Track creation order for destruction
    private started = false;
    
    // ... dependency registration and injection code ...
    
    /**
     * Register and initialize a bean
     */
    async registerBean(name: string, bean: object): Promise<void> {
        console.log(`[Container] Registering bean: ${name}`);
        
        // Perform interface injection first
        this.injectDependencies(bean);
        
        // Call InitializingBean callback after injection
        if (this.isInitializingBean(bean)) {
            console.log(`[Container] Calling afterPropertiesSet on ${name}`);
            await bean.afterPropertiesSet();
        }
        
        this.beans.set(name, bean);
        this.beanOrder.push(name);
        
        // If container is already started, start this bean too
        if (this.started && this.isLifecycle(bean)) {
            await bean.start();
        }
    }
    
    /**
     * Start all Lifecycle beans
     */
    async start(): Promise<void> {
        console.log('[Container] Starting all lifecycle beans...');
        
        for (const name of this.beanOrder) {
            const bean = this.beans.get(name)!;
            if (this.isLifecycle(bean) && !bean.isRunning()) {
                console.log(`[Container] Starting: ${name}`);
                await bean.start();
            }
        }
        
        this.started = true;
        console.log('[Container] All lifecycle beans started');
    }
    
    /**
     * Stop all Lifecycle beans (reverse order)
     */
    async stop(): Promise<void> {
        console.log('[Container] Stopping all lifecycle beans...');
        
        // Stop in reverse order
        for (const name of [...this.beanOrder].reverse()) {
            const bean = this.beans.get(name)!;
            if (this.isLifecycle(bean) && bean.isRunning()) {
                console.log(`[Container] Stopping: ${name}`);
                await bean.stop();
            }
        }
        
        this.started = false;
        console.log('[Container] All lifecycle beans stopped');
    }
    
    /**
     * Destroy all beans (cleanup)
     */
    async destroy(): Promise<void> {
        console.log('[Container] Destroying all beans...');
        
        // Stop first if running
        if (this.started) {
            await this.stop();
        }
        
        // Destroy in reverse order
        for (const name of [...this.beanOrder].reverse()) {
            const bean = this.beans.get(name)!;
            if (this.isDisposableBean(bean)) {
                console.log(`[Container] Destroying: ${name}`);
                await bean.destroy();
            }
        }
        
        this.beans.clear();
        this.beanOrder = [];
        console.log('[Container] All beans destroyed');
    }
    
    /**
     * Refresh the container (reload configuration, etc.)
     */
    async refresh(): Promise<void> {
        console.log('[Container] Refreshing...');
        
        // Reload configuration
        await this.reloadConfiguration();
        
        // Notify RefreshAware beans
        for (const [name, bean] of this.beans) {
            if (this.isRefreshAware(bean)) {
                console.log(`[Container] Notifying refresh: ${name}`);
                await bean.onRefresh();
            }
        }
        
        console.log('[Container] Refresh complete');
    }
    
    // Type guards
    private isInitializingBean(obj: unknown): obj is InitializingBean {
        return typeof (obj as InitializingBean)?.afterPropertiesSet === 'function';
    }
    
    private isDisposableBean(obj: unknown): obj is DisposableBean {
        return typeof (obj as DisposableBean)?.destroy === 'function';
    }
    
    private isLifecycle(obj: unknown): obj is Lifecycle {
        return typeof (obj as Lifecycle)?.start === 'function' &&
               typeof (obj as Lifecycle)?.stop === 'function' &&
               typeof (obj as Lifecycle)?.isRunning === 'function';
    }
    
    private isRefreshAware(obj: unknown): obj is RefreshAware {
        return typeof (obj as RefreshAware)?.onRefresh === 'function';
    }
    
    private injectDependencies(bean: object): void {
        // ... interface injection logic ...
    }
    
    private async reloadConfiguration(): Promise<void> {
        // ... reload config ...
    }
}
 
// ========================================
// Example: Database Connection Pool with full lifecycle
// ========================================
 
class DatabaseConnectionPool implements
    LoggerInjector,
    ConfigurationInjector,
    InitializingBean,
    DisposableBean,
    Lifecycle,
    RefreshAware {
    
    private logger!: Logger;
    private config!: Configuration;
    private pool: Connection[] = [];
    private running = false;
    private poolSize = 10;
    
    // Interface injection
    injectLogger(logger: Logger): void {
        this.logger = logger;
    }
    
    injectConfiguration(config: Configuration): void {
        this.config = config;
    }
    
    // Called after all dependencies are injected
    async afterPropertiesSet(): Promise<void> {
        this.logger.info('[Pool] Initializing after dependencies set');
        this.poolSize = this.config.get<number>('database.poolSize') ?? 10;
        this.logger.info(`[Pool] Pool size configured to ${this.poolSize}`);
    }
    
    // Lifecycle: start
    async start(): Promise<void> {
        this.logger.info('[Pool] Starting - creating connections');
        
        const connectionString = this.config.getRequired<string>('database.url');
        
        for (let i = 0; i < this.poolSize; i++) {
            const conn = await this.createConnection(connectionString);
            this.pool.push(conn);
        }
        
        this.running = true;
        this.logger.info(`[Pool] Started with ${this.poolSize} connections`);
    }
    
    // Lifecycle: stop
    async stop(): Promise<void> {
        this.logger.info('[Pool] Stopping - closing connections');
        
        for (const conn of this.pool) {
            await conn.close();
        }
        
        this.pool = [];
        this.running = false;
        this.logger.info('[Pool] Stopped');
    }
    
    isRunning(): boolean {
        return this.running;
    }
    
    // Called on configuration refresh
    async onRefresh(): Promise<void> {
        const newPoolSize = this.config.get<number>('database.poolSize') ?? 10;
        
        if (newPoolSize !== this.poolSize) {
            this.logger.info(`[Pool] Pool size changed: ${this.poolSize} -> ${newPoolSize}`);
            this.poolSize = newPoolSize;
            
            if (this.running) {
                // Adjust pool size at runtime
                await this.resizePool(newPoolSize);
            }
        }
    }
    
    // Called on container shutdown
    async destroy(): Promise<void> {
        this.logger.info('[Pool] Destroying');
        if (this.running) {
            await this.stop();
        }
        // Additional cleanup...
    }
    
    // Public API
    async getConnection(): Promise<Connection> {
        if (!this.running) {
            throw new Error('Pool not running');
        }
        // ... connection acquisition logic ...
    }
    
    private async createConnection(connStr: string): Promise<Connection> {
        // ... create connection ...
    }
    
    private async resizePool(newSize: number): Promise<void> {
        // ... resize pool logic ...
    }
}
 
// ========================================
// Application bootstrap
// ========================================
 
const container = new LifecycleAwareContainer();
 
// Register beans
await container.registerBean('logger', new ConsoleLogger());
await container.registerBean('config', new FileConfiguration('./config.json'));
await container.registerBean('dbPool', new DatabaseConnectionPool());
 
// Start all lifecycle beans
await container.start();
 
// Run application...
 
// On shutdown
process.on('SIGTERM', async () => {
    await container.destroy();
    process.exit(0);
});

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
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274

// ========================================
// Cross-cutting concern interfaces
// ========================================
 
// Logging concern
interface LoggingAware {
    setLogger(logger: Logger): void;
}
 
// Metrics concern
interface MetricsAware {
    setMetrics(metrics: MetricsCollector): void;
}
 
// Transaction concern
interface TransactionAware {
    setTransactionManager(manager: TransactionManager): void;
}
 
// Security context concern
interface SecurityContextAware {
    setSecurityContext(context: SecurityContext): void;
}
 
// Distributed tracing concern
interface TracingAware {
    setTracer(tracer: DistributedTracer): void;
}
 
// Error handling concern
interface ErrorHandlerAware {
    setErrorHandler(handler: ErrorHandler): void;
}
 
// ========================================
// Concern implementations
// ========================================
 
interface Logger {
    debug(message: string, context?: object): void;
    info(message: string, context?: object): void;
    warn(message: string, context?: object): void;
    error(message: string, error?: Error, context?: object): void;
}
 
interface MetricsCollector {
    incrementCounter(name: string, labels?: Record<string, string>): void;
    recordHistogram(name: string, value: number, labels?: Record<string, string>): void;
    recordGauge(name: string, value: number, labels?: Record<string, string>): void;
}
 
interface TransactionManager {
    begin(): Transaction;
    runInTransaction<T>(fn: () => Promise<T>): Promise<T>;
}
 
interface SecurityContext {
    getCurrentUser(): User | undefined;
    hasPermission(permission: string): boolean;
    isAuthenticated(): boolean;
}
 
interface DistributedTracer {
    startSpan(name: string): Span;
    getCurrentSpan(): Span | undefined;
    injectContext(headers: Record<string, string>): void;
}
 
interface ErrorHandler {
    handle(error: Error, context?: object): void;
    captureException(error: Error): void;
}
 
// ========================================
// Cross-cutting concern container
// ========================================
 
class CrossCuttingConcernInjector {
    private logger: Logger;
    private metrics: MetricsCollector;
    private transactionManager: TransactionManager;
    private securityContext: SecurityContext;
    private tracer: DistributedTracer;
    private errorHandler: ErrorHandler;
    
    constructor(concerns: {
        logger: Logger;
        metrics: MetricsCollector;
        transactionManager: TransactionManager;
        securityContext: SecurityContext;
        tracer: DistributedTracer;
        errorHandler: ErrorHandler;
    }) {
        this.logger = concerns.logger;
        this.metrics = concerns.metrics;
        this.transactionManager = concerns.transactionManager;
        this.securityContext = concerns.securityContext;
        this.tracer = concerns.tracer;
        this.errorHandler = concerns.errorHandler;
    }
    
    /**
     * Inject all applicable cross-cutting concerns into a target
     */
    injectConcerns(target: object): void {
        const injected: string[] = [];
        
        if (this.isLoggingAware(target)) {
            target.setLogger(this.logger);
            injected.push('Logger');
        }
        
        if (this.isMetricsAware(target)) {
            target.setMetrics(this.metrics);
            injected.push('Metrics');
        }
        
        if (this.isTransactionAware(target)) {
            target.setTransactionManager(this.transactionManager);
            injected.push('TransactionManager');
        }
        
        if (this.isSecurityContextAware(target)) {
            target.setSecurityContext(this.securityContext);
            injected.push('SecurityContext');
        }
        
        if (this.isTracingAware(target)) {
            target.setTracer(this.tracer);
            injected.push('Tracer');
        }
        
        if (this.isErrorHandlerAware(target)) {
            target.setErrorHandler(this.errorHandler);
            injected.push('ErrorHandler');
        }
        
        if (injected.length > 0) {
            this.logger.debug(`Injected concerns into ${target.constructor.name}`, { 
                concerns: injected 
            });
        }
    }
    
    // Type guards
    private isLoggingAware(obj: unknown): obj is LoggingAware {
        return typeof (obj as LoggingAware)?.setLogger === 'function';
    }
    
    private isMetricsAware(obj: unknown): obj is MetricsAware {
        return typeof (obj as MetricsAware)?.setMetrics === 'function';
    }
    
    private isTransactionAware(obj: unknown): obj is TransactionAware {
        return typeof (obj as TransactionAware)?.setTransactionManager === 'function';
    }
    
    private isSecurityContextAware(obj: unknown): obj is SecurityContextAware {
        return typeof (obj as SecurityContextAware)?.setSecurityContext === 'function';
    }
    
    private isTracingAware(obj: unknown): obj is TracingAware {
        return typeof (obj as TracingAware)?.setTracer === 'function';
    }
    
    private isErrorHandlerAware(obj: unknown): obj is ErrorHandlerAware {
        return typeof (obj as ErrorHandlerAware)?.setErrorHandler === 'function';
    }
}
 
// ========================================
// Service using multiple cross-cutting concerns
// ========================================
 
class PaymentService implements
    LoggingAware,
    MetricsAware,
    TransactionAware,
    SecurityContextAware,
    TracingAware,
    ErrorHandlerAware {
    
    private logger!: Logger;
    private metrics!: MetricsCollector;
    private transactions!: TransactionManager;
    private security!: SecurityContext;
    private tracer!: DistributedTracer;
    private errorHandler!: ErrorHandler;
    
    // Cross-cutting concern injection methods
    setLogger(logger: Logger): void { this.logger = logger; }
    setMetrics(metrics: MetricsCollector): void { this.metrics = metrics; }
    setTransactionManager(manager: TransactionManager): void { this.transactions = manager; }
    setSecurityContext(context: SecurityContext): void { this.security = context; }
    setTracer(tracer: DistributedTracer): void { this.tracer = tracer; }
    setErrorHandler(handler: ErrorHandler): void { this.errorHandler = handler; }
    
    async processPayment(paymentRequest: PaymentRequest): Promise<PaymentResult> {
        // Start distributed trace
        const span = this.tracer.startSpan('processPayment');
        
        // Check security
        if (!this.security.hasPermission('payment:process')) {
            this.logger.warn('Payment attempt without permission', { 
                userId: this.security.getCurrentUser()?.id 
            });
            span.setError(new Error('Unauthorized'));
            throw new UnauthorizedError('permission:payment:process');
        }
        
        // Record metrics
        this.metrics.incrementCounter('payment_attempts', { 
            currency: paymentRequest.currency 
        });
        
        const startTime = Date.now();
        
        try {
            // Run in transaction
            const result = await this.transactions.runInTransaction(async () => {
                this.logger.info('Processing payment', { 
                    amount: paymentRequest.amount,
                    currency: paymentRequest.currency,
                });
                
                // ... payment processing logic ...
                
                return { success: true, transactionId: 'txn-123' };
            });
            
            // Record success metrics
            const duration = Date.now() - startTime;
            this.metrics.recordHistogram('payment_duration_ms', duration);
            this.metrics.incrementCounter('payment_success');
            
            this.logger.info('Payment processed successfully', { 
                transactionId: result.transactionId 
            });
            
            span.finish();
            return result;
            
        } catch (error) {
            // Handle error with error handler
            this.errorHandler.captureException(error as Error);
            
            this.metrics.incrementCounter('payment_failures');
            this.logger.error('Payment processing failed', error as Error);
            
            span.setError(error);
            span.finish();
            
            throw error;
        }
    }
}
 
// ========================================
// Application bootstrap
// ========================================
 
const concerns = new CrossCuttingConcernInjector({
    logger: new StructuredLogger(),
    metrics: new PrometheusMetrics(),
    transactionManager: new PostgresTransactionManager(),
    securityContext: requestScopedSecurityContext,
    tracer: new JaegerTracer(),
    errorHandler: new SentryErrorHandler(),
});
 
const paymentService = new PaymentService();
concerns.injectConcerns(paymentService);
 
// PaymentService now has all cross-cutting concerns available