Chain of Responsibility Pattern

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

/**
 * HTTP Middleware using Chain of Responsibility
 * 
 * Key characteristics:
 * - Each middleware can modify request/response
 * - Chain can be short-circuited (e.g., auth failure)
 * - Bidirectional flow: before handling AND after response
 */
 
interface HttpRequest {
    method: string;
    path: string;
    headers: Record<string, string>;
    body?: unknown;
    context: Map<string, unknown>;
}
 
interface HttpResponse {
    status: number;
    headers: Record<string, string>;
    body?: unknown;
}
 
type MiddlewareResult = {
    handled: boolean;
    response?: HttpResponse;
};
 
/**
 * Middleware handler with bidirectional processing
 */
abstract class Middleware {
    private next: Middleware | null = null;
 
    setNext(middleware: Middleware): Middleware {
        this.next = middleware;
        return middleware; // Return next for chaining
    }
 
    async handle(request: HttpRequest): Promise<HttpResponse> {
        // Pre-processing (request phase)
        const preResult = await this.preProcess(request);
        if (preResult.handled) {
            return preResult.response!;
        }
 
        // Call next in chain
        let response: HttpResponse;
        if (this.next) {
            response = await this.next.handle(request);
        } else {
            // End of middleware chain - request reaches handler
            response = await this.handleRequest(request);
        }
 
        // Post-processing (response phase)
        return await this.postProcess(request, response);
    }
 
    /**
     * Pre-processing - runs BEFORE downstream middleware/handler.
     * Return handled=true to short-circuit the chain.
     */
    protected async preProcess(request: HttpRequest): Promise<MiddlewareResult> {
        return { handled: false };
    }
 
    /**
     * Post-processing - runs AFTER downstream completes.
     * Can modify the response.
     */
    protected async postProcess(
        request: HttpRequest,
        response: HttpResponse
    ): Promise<HttpResponse> {
        return response;
    }
 
    /**
     * Terminal request handling (if this middleware is the final handler).
     */
    protected async handleRequest(request: HttpRequest): Promise<HttpResponse> {
        return { status: 404, headers: {}, body: { error: 'Not Found' } };
    }
}

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

/**
 * Timing Middleware - measures request processing time
 */
class TimingMiddleware extends Middleware {
    protected async preProcess(request: HttpRequest): Promise<MiddlewareResult> {
        request.context.set('startTime', Date.now());
        return { handled: false };
    }
 
    protected async postProcess(
        request: HttpRequest,
        response: HttpResponse
    ): Promise<HttpResponse> {
        const startTime = request.context.get('startTime') as number;
        const duration = Date.now() - startTime;
        
        // Add timing header
        response.headers['X-Response-Time'] = `${duration}ms`;
        
        // Log slow requests
        if (duration > 1000) {
            console.warn(`Slow request: ${request.method} ${request.path} took ${duration}ms`);
        }
        
        return response;
    }
}
 
/**
 * Authentication Middleware - validates tokens, short-circuits on failure
 */
class AuthMiddleware extends Middleware {
    constructor(private readonly tokenValidator: TokenValidator) {
        super();
    }
 
    protected async preProcess(request: HttpRequest): Promise<MiddlewareResult> {
        // Skip auth for public endpoints
        if (this.isPublicEndpoint(request.path)) {
            return { handled: false };
        }
 
        const authHeader = request.headers['authorization'];
        if (!authHeader) {
            return {
                handled: true,
                response: {
                    status: 401,
                    headers: { 'WWW-Authenticate': 'Bearer' },
                    body: { error: 'Authentication required' },
                },
            };
        }
 
        const token = authHeader.replace('Bearer ', '');
        const user = await this.tokenValidator.validate(token);
        
        if (!user) {
            return {
                handled: true,
                response: {
                    status: 401,
                    headers: {},
                    body: { error: 'Invalid token' },
                },
            };
        }
 
        // Add user to request context for downstream handlers
        request.context.set('user', user);
        return { handled: false };
    }
 
    private isPublicEndpoint(path: string): boolean {
        const publicPaths = ['/health', '/login', '/register', '/public'];
        return publicPaths.some(p => path.startsWith(p));
    }
}
 
/**
 * Rate Limiting Middleware - throttles excessive requests
 */
class RateLimitMiddleware extends Middleware {
    private requestCounts: Map<string, { count: number; resetTime: number }> = new Map();
    
    constructor(
        private readonly limit: number = 100,
        private readonly windowMs: number = 60000
    ) {
        super();
    }
 
    protected async preProcess(request: HttpRequest): Promise<MiddlewareResult> {
        const clientId = this.getClientId(request);
        const now = Date.now();
        
        let record = this.requestCounts.get(clientId);
        if (!record || now > record.resetTime) {
            record = { count: 0, resetTime: now + this.windowMs };
            this.requestCounts.set(clientId, record);
        }
        
        record.count++;
        
        if (record.count > this.limit) {
            return {
                handled: true,
                response: {
                    status: 429,
                    headers: {
                        'Retry-After': String(Math.ceil((record.resetTime - now) / 1000)),
                        'X-RateLimit-Limit': String(this.limit),
                        'X-RateLimit-Remaining': '0',
                    },
                    body: { error: 'Too many requests' },
                },
            };
        }
 
        return { handled: false };
    }
 
    protected async postProcess(
        request: HttpRequest,
        response: HttpResponse
    ): Promise<HttpResponse> {
        const clientId = this.getClientId(request);
        const record = this.requestCounts.get(clientId);
        
        if (record) {
            response.headers['X-RateLimit-Limit'] = String(this.limit);
            response.headers['X-RateLimit-Remaining'] = String(
                Math.max(0, this.limit - record.count)
            );
        }
        
        return response;
    }
 
    private getClientId(request: HttpRequest): string {
        return request.headers['x-forwarded-for'] || 
               request.headers['x-client-id'] || 
               'anonymous';
    }
}
 
/**
 * CORS Middleware - handles cross-origin requests
 */
class CorsMiddleware extends Middleware {
    constructor(private readonly allowedOrigins: string[]) {
        super();
    }
 
    protected async preProcess(request: HttpRequest): Promise<MiddlewareResult> {
        // Handle preflight requests
        if (request.method === 'OPTIONS') {
            return {
                handled: true,
                response: {
                    status: 204,
                    headers: this.getCorsHeaders(request),
                    body: undefined,
                },
            };
        }
        return { handled: false };
    }
 
    protected async postProcess(
        request: HttpRequest,
        response: HttpResponse
    ): Promise<HttpResponse> {
        // Add CORS headers to all responses
        const corsHeaders = this.getCorsHeaders(request);
        Object.assign(response.headers, corsHeaders);
        return response;
    }
 
    private getCorsHeaders(request: HttpRequest): Record<string, string> {
        const origin = request.headers['origin'];
        const allowedOrigin = this.allowedOrigins.includes(origin) 
            ? origin 
            : this.allowedOrigins[0];
        
        return {
            'Access-Control-Allow-Origin': allowedOrigin,
            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
            'Access-Control-Max-Age': '86400',
        };
    }
}

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

// Building the middleware pipeline
const timing = new TimingMiddleware();
const rateLimit = new RateLimitMiddleware(100, 60000);
const cors = new CorsMiddleware(['https://app.example.com']);
const auth = new AuthMiddleware(new TokenValidator());
const router = new RouterMiddleware(routes); // Final handler
 
// Chain assembly - order matters!
timing
    .setNext(rateLimit)
    .setNext(cors)
    .setNext(auth)
    .setNext(router);
 
// Request processing
async function handleHttp(rawRequest: IncomingMessage): Promise<OutgoingMessage> {
    const request = parseRequest(rawRequest);
    
    // Send through middleware chain
    const response = await timing.handle(request);
    
    return formatResponse(response);
}
 
// Execution flow for authenticated request:
// 1. TimingMiddleware.preProcess → records start time
// 2. RateLimitMiddleware.preProcess → checks rate limit
// 3. CorsMiddleware.preProcess → handles OPTIONS (if preflight)
// 4. AuthMiddleware.preProcess → validates token, adds user
// 5. RouterMiddleware handles request → produces response
// 6. AuthMiddleware.postProcess → (no-op)
// 7. CorsMiddleware.postProcess → adds CORS headers
// 8. RateLimitMiddleware.postProcess → adds rate limit headers
// 9. TimingMiddleware.postProcess → adds timing header

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

/**
 * Validation Chain with configurable behavior:
 * - Fail-fast mode: stop at first error
 * - Aggregate mode: collect all errors
 */
 
interface ValidationError {
    field: string;
    code: string;
    message: string;
}
 
interface ValidationResult {
    valid: boolean;
    errors: ValidationError[];
}
 
interface ValidationContext<T> {
    data: T;
    errors: ValidationError[];
    stopOnFirstError: boolean;
}
 
abstract class Validator<T> {
    private next: Validator<T> | null = null;
 
    setNext(validator: Validator<T>): Validator<T> {
        this.next = validator;
        return validator;
    }
 
    validate(context: ValidationContext<T>): ValidationResult {
        // Run this validator
        const errors = this.doValidate(context.data);
        context.errors.push(...errors);
 
        // Check if we should stop
        if (context.stopOnFirstError && errors.length > 0) {
            return { valid: false, errors: context.errors };
        }
 
        // Continue to next validator
        if (this.next) {
            return this.next.validate(context);
        }
 
        // End of chain - return accumulated result
        return {
            valid: context.errors.length === 0,
            errors: context.errors,
        };
    }
 
    protected abstract doValidate(data: T): ValidationError[];
}
 
/**
 * Factory function to run validation chain
 */
function runValidation<T>(
    data: T,
    chain: Validator<T>,
    stopOnFirstError: boolean = true
): ValidationResult {
    const context: ValidationContext<T> = {
        data,
        errors: [],
        stopOnFirstError,
    };
    return chain.validate(context);
}

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

interface UserRegistration {
    email: string;
    password: string;
    username: string;
    dateOfBirth: string;
    country: string;
}
 
/**
 * Email Validator - checks format and domain
 */
class EmailValidator extends Validator<UserRegistration> {
    private readonly blockedDomains = ['tempmail.com', 'throwaway.com'];
 
    protected doValidate(data: UserRegistration): ValidationError[] {
        const errors: ValidationError[] = [];
        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 
        if (!data.email) {
            errors.push({
                field: 'email',
                code: 'REQUIRED',
                message: 'Email is required',
            });
        } else if (!emailRegex.test(data.email)) {
            errors.push({
                field: 'email',
                code: 'INVALID_FORMAT',
                message: 'Email format is invalid',
            });
        } else {
            const domain = data.email.split('@')[1];
            if (this.blockedDomains.includes(domain)) {
                errors.push({
                    field: 'email',
                    code: 'BLOCKED_DOMAIN',
                    message: 'Temporary email addresses are not allowed',
                });
            }
        }
 
        return errors;
    }
}
 
/**
 * Password Validator - checks strength requirements
 */
class PasswordValidator extends Validator<UserRegistration> {
    protected doValidate(data: UserRegistration): ValidationError[] {
        const errors: ValidationError[] = [];
        const password = data.password || '';
 
        if (password.length < 8) {
            errors.push({
                field: 'password',
                code: 'TOO_SHORT',
                message: 'Password must be at least 8 characters',
            });
        }
 
        if (!/[A-Z]/.test(password)) {
            errors.push({
                field: 'password',
                code: 'NO_UPPERCASE',
                message: 'Password must contain at least one uppercase letter',
            });
        }
 
        if (!/[a-z]/.test(password)) {
            errors.push({
                field: 'password',
                code: 'NO_LOWERCASE',
                message: 'Password must contain at least one lowercase letter',
            });
        }
 
        if (!/[0-9]/.test(password)) {
            errors.push({
                field: 'password',
                code: 'NO_NUMBER',
                message: 'Password must contain at least one number',
            });
        }
 
        if (!/[!@#$%^&*]/.test(password)) {
            errors.push({
                field: 'password',
                code: 'NO_SPECIAL',
                message: 'Password must contain at least one special character',
            });
        }
 
        return errors;
    }
}
 
/**
 * Username Validator - checks format and availability
 */
class UsernameValidator extends Validator<UserRegistration> {
    constructor(private readonly userService: UserService) {
        super();
    }
 
    protected doValidate(data: UserRegistration): ValidationError[] {
        const errors: ValidationError[] = [];
        const username = data.username || '';
 
        if (username.length < 3) {
            errors.push({
                field: 'username',
                code: 'TOO_SHORT',
                message: 'Username must be at least 3 characters',
            });
        } else if (username.length > 20) {
            errors.push({
                field: 'username',
                code: 'TOO_LONG',
                message: 'Username must be at most 20 characters',
            });
        } else if (!/^[a-zA-Z0-9_]+$/.test(username)) {
            errors.push({
                field: 'username',
                code: 'INVALID_CHARACTERS',
                message: 'Username can only contain letters, numbers, and underscores',
            });
        } else if (this.userService.usernameExists(username)) {
            errors.push({
                field: 'username',
                code: 'ALREADY_EXISTS',
                message: 'Username is already taken',
            });
        }
 
        return errors;
    }
}
 
/**
 * Age Validator - checks minimum age requirements
 */
class AgeValidator extends Validator<UserRegistration> {
    constructor(private readonly minimumAge: number = 13) {
        super();
    }
 
    protected doValidate(data: UserRegistration): ValidationError[] {
        const errors: ValidationError[] = [];
        
        const birthDate = new Date(data.dateOfBirth);
        if (isNaN(birthDate.getTime())) {
            errors.push({
                field: 'dateOfBirth',
                code: 'INVALID_DATE',
                message: 'Date of birth is invalid',
            });
        } else {
            const age = this.calculateAge(birthDate);
            if (age < this.minimumAge) {
                errors.push({
                    field: 'dateOfBirth',
                    code: 'UNDER_AGE',
                    message: `You must be at least ${this.minimumAge} years old to register`,
                });
            }
        }
 
        return errors;
    }
 
    private calculateAge(birthDate: Date): number {
        const today = new Date();
        let age = today.getFullYear() - birthDate.getFullYear();
        const monthDiff = today.getMonth() - birthDate.getMonth();
        if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birthDate.getDate())) {
            age--;
        }
        return age;
    }
}

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

// Build validation chain
const emailValidator = new EmailValidator();
const passwordValidator = new PasswordValidator();
const usernameValidator = new UsernameValidator(userService);
const ageValidator = new AgeValidator(13);
 
emailValidator
    .setNext(passwordValidator)
    .setNext(usernameValidator)
    .setNext(ageValidator);
 
// Usage in registration handler
async function registerUser(data: UserRegistration): Promise<RegistrationResponse> {
    // Aggregate mode - collect all errors
    const validationResult = runValidation(data, emailValidator, false);
    
    if (!validationResult.valid) {
        return {
            success: false,
            errors: validationResult.errors,
        };
    }
    
    // Proceed with registration
    const user = await userService.create(data);
    return { success: true, userId: user.id };
}
 
// Example with invalid data
const invalidData: UserRegistration = {
    email: 'invalid-email',
    password: 'weak',
    username: 'ab',
    dateOfBirth: '2015-01-01', // Too young
    country: 'US',
};
 
const result = runValidation(invalidData, emailValidator, false);
// result.errors contains:
// - email: INVALID_FORMAT
// - password: TOO_SHORT, NO_UPPERCASE, NO_NUMBER, NO_SPECIAL
// - username: TOO_SHORT
// - dateOfBirth: UNDER_AGE

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

/**
 * Logging with Chain of Responsibility
 * 
 * Features:
 * - Multiple log destinations (console, file, network)
 * - Level-based filtering per handler
 * - All handlers can process (propagate-through-all strategy)
 */
 
enum LogLevel {
    DEBUG = 0,
    INFO = 1,
    WARN = 2,
    ERROR = 3,
    FATAL = 4,
}
 
interface LogEntry {
    level: LogLevel;
    message: string;
    timestamp: Date;
    context?: Record<string, unknown>;
    error?: Error;
}
 
abstract class LogHandler {
    private next: LogHandler | null = null;
    protected minLevel: LogLevel = LogLevel.DEBUG;
 
    setNext(handler: LogHandler): LogHandler {
        this.next = handler;
        return handler;
    }
 
    setLevel(level: LogLevel): this {
        this.minLevel = level;
        return this;
    }
 
    log(entry: LogEntry): void {
        // Process if level meets threshold
        if (entry.level >= this.minLevel) {
            this.write(entry);
        }
 
        // ALWAYS forward to next (propagate-through-all)
        if (this.next) {
            this.next.log(entry);
        }
    }
 
    protected abstract write(entry: LogEntry): void;
    
    protected formatEntry(entry: LogEntry): string {
        const level = LogLevel[entry.level];
        const time = entry.timestamp.toISOString();
        let message = `[${time}] [${level}] ${entry.message}`;
        
        if (entry.context) {
            message += ` ${JSON.stringify(entry.context)}`;
        }
        
        if (entry.error) {
            message += `
${entry.error.stack}`;
        }
        
        return message;
    }
}
 
/**
 * Console Logger - writes to stdout/stderr
 */
class ConsoleLogHandler extends LogHandler {
    protected write(entry: LogEntry): void {
        const formatted = this.formatEntry(entry);
        
        if (entry.level >= LogLevel.ERROR) {
            console.error(formatted);
        } else {
            console.log(formatted);
        }
    }
}
 
/**
 * File Logger - appends to log file
 */
class FileLogHandler extends LogHandler {
    constructor(private readonly filePath: string) {
        super();
    }
 
    protected write(entry: LogEntry): void {
        const formatted = this.formatEntry(entry) + '
';
        // In real implementation: use async file writing with buffering
        fs.appendFileSync(this.filePath, formatted);
    }
}
 
/**
 * Network Logger - sends to log aggregation service
 */
class NetworkLogHandler extends LogHandler {
    private buffer: LogEntry[] = [];
    private readonly flushInterval: number = 5000;
    private readonly batchSize: number = 100;
 
    constructor(private readonly endpoint: string) {
        super();
        // Flush periodically
        setInterval(() => this.flush(), this.flushInterval);
    }
 
    protected write(entry: LogEntry): void {
        this.buffer.push(entry);
        
        if (this.buffer.length >= this.batchSize) {
            this.flush();
        }
    }
 
    private async flush(): Promise<void> {
        if (this.buffer.length === 0) return;
        
        const batch = this.buffer;
        this.buffer = [];
        
        try {
            await fetch(this.endpoint, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(batch),
            });
        } catch (error) {
            // Re-add failed entries (with limit to prevent memory issues)
            if (this.buffer.length < 1000) {
                this.buffer.unshift(...batch);
            }
        }
    }
}
 
/**
 * Alert Logger - sends alerts for critical logs
 */
class AlertLogHandler extends LogHandler {
    constructor(private readonly alertService: AlertService) {
        super();
        this.minLevel = LogLevel.ERROR; // Only alert on errors
    }
 
    protected write(entry: LogEntry): void {
        const severity = entry.level === LogLevel.FATAL ? 'critical' : 'high';
        
        this.alertService.sendAlert({
            title: `[${LogLevel[entry.level]}] ${entry.message}`,
            severity,
            context: entry.context,
            error: entry.error?.stack,
        });
    }
}

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

// Build logging chain for production
const consoleLogger = new ConsoleLogHandler().setLevel(LogLevel.INFO);
const fileLogger = new FileLogHandler('/var/log/app.log').setLevel(LogLevel.DEBUG);
const networkLogger = new NetworkLogHandler('https://logs.example.com/ingest').setLevel(LogLevel.INFO);
const alertLogger = new AlertLogHandler(alertService).setLevel(LogLevel.ERROR);
 
// Chain: all logs flow through all handlers (each filters by level)
consoleLogger
    .setNext(fileLogger)
    .setNext(networkLogger)
    .setNext(alertLogger);
 
// Logger facade
class Logger {
    constructor(private readonly chain: LogHandler) {}
 
    debug(message: string, context?: Record<string, unknown>): void {
        this.chain.log({ level: LogLevel.DEBUG, message, timestamp: new Date(), context });
    }
 
    info(message: string, context?: Record<string, unknown>): void {
        this.chain.log({ level: LogLevel.INFO, message, timestamp: new Date(), context });
    }
 
    warn(message: string, context?: Record<string, unknown>): void {
        this.chain.log({ level: LogLevel.WARN, message, timestamp: new Date(), context });
    }
 
    error(message: string, error?: Error, context?: Record<string, unknown>): void {
        this.chain.log({ level: LogLevel.ERROR, message, timestamp: new Date(), context, error });
    }
 
    fatal(message: string, error?: Error, context?: Record<string, unknown>): void {
        this.chain.log({ level: LogLevel.FATAL, message, timestamp: new Date(), context, error });
    }
}
 
// Usage
const logger = new Logger(consoleLogger);
 
logger.info('Application started', { version: '1.0.0' });
// → Console: INFO log
// → File: INFO log
// → Network: INFO log
// → Alert: (skipped - level < ERROR)
 
logger.error('Database connection failed', new Error('Connection refused'), { host: 'db.example.com' });
// → Console: ERROR log
// → File: ERROR log
// → Network: ERROR log
// → Alert: Alert sent!

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

/**
 * UI Event Handling with Chain of Responsibility
 * 
 * Implements:
 * - Event bubbling (child → parent)
 * - Event capturing (parent → child)
 * - Stop propagation
 */
 
interface UIEvent {
    type: 'click' | 'key' | 'focus' | 'submit' | 'custom';
    target: UIComponent;
    data?: unknown;
    stopped: boolean;
    timestamp: Date;
}
 
abstract class UIComponent {
    private parent: UIComponent | null = null;
    private children: UIComponent[] = [];
    private eventHandlers: Map<string, ((event: UIEvent) => void)[]> = new Map();
 
    constructor(public readonly id: string) {}
 
    addChild(child: UIComponent): void {
        child.parent = this;
        this.children.push(child);
    }
 
    removeChild(child: UIComponent): void {
        const index = this.children.indexOf(child);
        if (index !== -1) {
            child.parent = null;
            this.children.splice(index, 1);
        }
    }
 
    /**
     * Register an event handler
     */
    on(eventType: string, handler: (event: UIEvent) => void): void {
        if (!this.eventHandlers.has(eventType)) {
            this.eventHandlers.set(eventType, []);
        }
        this.eventHandlers.get(eventType)!.push(handler);
    }
 
    /**
     * Trigger an event - it bubbles up through the chain
     */
    triggerEvent(event: UIEvent): void {
        // Handle at this component
        this.handleEvent(event);
 
        // Bubble up to parent (unless stopped)
        if (!event.stopped && this.parent) {
            this.parent.triggerEvent(event);
        }
    }
 
    private handleEvent(event: UIEvent): void {
        const handlers = this.eventHandlers.get(event.type);
        if (handlers) {
            for (const handler of handlers) {
                handler(event);
                if (event.stopped) break;
            }
        }
    }
 
    /**
     * Find a child component by ID
     */
    findById(id: string): UIComponent | null {
        if (this.id === id) return this;
        for (const child of this.children) {
            const found = child.findById(id);
            if (found) return found;
        }
        return null;
    }
}
 
/**
 * Concrete UI Components
 */
class Window extends UIComponent {
    constructor() {
        super('window');
        // Window handles unhandled events
        this.on('click', (event) => {
            console.log(`Window received click (from ${event.target.id})`);
        });
        this.on('key', (event) => {
            const keyData = event.data as { key: string };
            if (keyData.key === 'Escape') {
                console.log('Window handling Escape - closing dialogs');
                event.stopped = true;
            }
        });
    }
}
 
class Panel extends UIComponent {
    constructor(id: string) {
        super(id);
    }
}
 
class Button extends UIComponent {
    constructor(id: string, private readonly label: string) {
        super(id);
    }
 
    click(): void {
        const event: UIEvent = {
            type: 'click',
            target: this,
            stopped: false,
            timestamp: new Date(),
        };
        this.triggerEvent(event);
    }
}
 
class TextField extends UIComponent {
    private value: string = '';
 
    constructor(id: string) {
        super(id);
    }
 
    focus(): void {
        const event: UIEvent = {
            type: 'focus',
            target: this,
            stopped: false,
            timestamp: new Date(),
        };
        this.triggerEvent(event);
    }
 
    keyPress(key: string): void {
        const event: UIEvent = {
            type: 'key',
            target: this,
            data: { key },
            stopped: false,
            timestamp: new Date(),
        };
        this.triggerEvent(event);
    }
}

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

// Build component hierarchy
const window = new Window();
const mainPanel = new Panel('main-panel');
const toolbar = new Panel('toolbar');
const saveButton = new Button('save-btn', 'Save');
const searchField = new TextField('search-field');
 
window.addChild(mainPanel);
mainPanel.addChild(toolbar);
toolbar.addChild(saveButton);
toolbar.addChild(searchField);
 
// Component hierarchy:
// Window
//   └─ MainPanel
//        └─ Toolbar
//             ├─ SaveButton
//             └─ SearchField
 
// Register handlers at different levels
saveButton.on('click', (event) => {
    console.log('Save button clicked - saving document');
    event.stopped = true; // Stop propagation
});
 
toolbar.on('click', (event) => {
    console.log('Toolbar received click');
    // This won't run for saveButton clicks (stopped above)
});
 
mainPanel.on('focus', (event) => {
    console.log(`Focus entered panel from ${event.target.id}`);
});
 
// Trigger events
saveButton.click();
// Output: "Save button clicked - saving document"
// (propagation stopped - toolbar/window don't receive)
 
searchField.focus();
// Output: "Focus entered panel from search-field"
// (bubbles through toolbar → mainPanel)
 
searchField.keyPress('Escape');
// Output: "Window handling Escape - closing dialogs"
// (bubbles all the way to window, which handles Escape)

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

/**
 * Enterprise Expense Approval System
 * 
 * Features:
 * - Multi-level approval based on amount and category
 * - Audit trail for compliance
 * - SLA tracking for escalation
 * - Policy validation
 */
 
interface ExpenseRequest {
    id: string;
    amount: number;
    currency: string;
    category: 'TRAVEL' | 'EQUIPMENT' | 'SOFTWARE' | 'CONTRACTOR' | 'OTHER';
    description: string;
    requester: Employee;
    attachments: string[];
    submittedAt: Date;
    metadata: Record<string, unknown>;
}
 
interface Employee {
    id: string;
    name: string;
    department: string;
    level: number; // 1=IC, 2=Manager, 3=Director, 4=VP, 5=C-Suite
    managerId: string | null;
}
 
interface ApprovalDecision {
    approver: Employee;
    decision: 'APPROVED' | 'REJECTED' | 'ESCALATED' | 'PENDING';
    comments?: string;
    conditions?: string[];
    decidedAt: Date;
}
 
interface ApprovalResult {
    request: ExpenseRequest;
    decisions: ApprovalDecision[];
    finalStatus: 'APPROVED' | 'REJECTED' | 'PENDING';
    totalProcessingTime: number;
}
 
/**
 * Abstract Approval Handler with audit and SLA support
 */
abstract class ApprovalHandler {
    private next: ApprovalHandler | null = null;
    
    constructor(
        protected readonly auditLog: AuditLog,
        protected readonly slaConfig: { maxHours: number }
    ) {}
 
    setNext(handler: ApprovalHandler): ApprovalHandler {
        this.next = handler;
        return handler;
    }
 
    async process(
        request: ExpenseRequest, 
        decisions: ApprovalDecision[]
    ): Promise<ApprovalResult> {
        const startTime = Date.now();
 
        // Log entry
        await this.auditLog.log({
            action: 'APPROVAL_STARTED',
            handler: this.constructor.name,
            requestId: request.id,
            timestamp: new Date(),
        });
 
        // Check if this handler should process
        const shouldProcess = await this.shouldHandle(request);
        
        if (shouldProcess) {
            const decision = await this.makeDecision(request);
            decisions.push(decision);
 
            // Log decision
            await this.auditLog.log({
                action: 'DECISION_MADE',
                handler: this.constructor.name,
                requestId: request.id,
                decision: decision.decision,
                timestamp: new Date(),
            });
 
            // If rejected or approved and no further approval needed
            if (decision.decision === 'REJECTED') {
                return this.createResult(request, decisions, 'REJECTED', startTime);
            }
            
            if (decision.decision === 'APPROVED' && !this.requiresFurtherApproval(request)) {
                return this.createResult(request, decisions, 'APPROVED', startTime);
            }
        }
 
        // Forward to next handler
        if (this.next) {
            return this.next.process(request, decisions);
        }
 
        // End of chain - determine final status
        const finalStatus = this.determineFinalStatus(decisions);
        return this.createResult(request, decisions, finalStatus, startTime);
    }
 
    protected abstract shouldHandle(request: ExpenseRequest): Promise<boolean>;
    protected abstract makeDecision(request: ExpenseRequest): Promise<ApprovalDecision>;
    
    protected requiresFurtherApproval(request: ExpenseRequest): boolean {
        return false; // Override if needed
    }
 
    private determineFinalStatus(decisions: ApprovalDecision[]): 'APPROVED' | 'REJECTED' | 'PENDING' {
        if (decisions.some(d => d.decision === 'REJECTED')) return 'REJECTED';
        if (decisions.every(d => d.decision === 'APPROVED')) return 'APPROVED';
        return 'PENDING';
    }
 
    private createResult(
        request: ExpenseRequest,
        decisions: ApprovalDecision[],
        status: 'APPROVED' | 'REJECTED' | 'PENDING',
        startTime: number
    ): ApprovalResult {
        return {
            request,
            decisions,
            finalStatus: status,
            totalProcessingTime: Date.now() - startTime,
        };
    }
}
 
/**
 * Policy Validation Handler - first in chain
 */
class PolicyValidationHandler extends ApprovalHandler {
    constructor(
        private readonly policyService: PolicyService,
        auditLog: AuditLog
    ) {
        super(auditLog, { maxHours: 1 });
    }
 
    protected async shouldHandle(): Promise<boolean> {
        return true; // Always validate policy
    }
 
    protected async makeDecision(request: ExpenseRequest): Promise<ApprovalDecision> {
        const violations = await this.policyService.checkViolations(request);
        
        if (violations.length > 0) {
            return {
                approver: { id: 'SYSTEM', name: 'Policy Engine' } as Employee,
                decision: 'REJECTED',
                comments: `Policy violations: ${violations.join(', ')}`,
                decidedAt: new Date(),
            };
        }
 
        return {
            approver: { id: 'SYSTEM', name: 'Policy Engine' } as Employee,
            decision: 'APPROVED',
            comments: 'Passed policy validation',
            decidedAt: new Date(),
        };
    }
 
    protected requiresFurtherApproval(): boolean {
        return true; // Policy is just the first check
    }
}
 
/**
 * Manager Approval Handler
 */
class ManagerApprovalHandler extends ApprovalHandler {
    constructor(
        private readonly employeeService: EmployeeService,
        private readonly approvalLimit: number,
        auditLog: AuditLog
    ) {
        super(auditLog, { maxHours: 24 });
    }
 
    protected async shouldHandle(request: ExpenseRequest): Promise<boolean> {
        return request.amount <= this.approvalLimit;
    }
 
    protected async makeDecision(request: ExpenseRequest): Promise<ApprovalDecision> {
        const manager = await this.employeeService.getManager(request.requester.id);
        
        // In real system, this would wait for manager's actual decision
        // Here we simulate auto-approval for demonstration
        return {
            approver: manager,
            decision: 'APPROVED',
            comments: 'Approved by direct manager',
            decidedAt: new Date(),
        };
    }
}
 
/**
 * Director Approval Handler
 */
class DirectorApprovalHandler extends ApprovalHandler {
    constructor(
        private readonly employeeService: EmployeeService,
        private readonly minAmount: number,
        private readonly maxAmount: number,
        auditLog: AuditLog
    ) {
        super(auditLog, { maxHours: 48 });
    }
 
    protected async shouldHandle(request: ExpenseRequest): Promise<boolean> {
        return request.amount > this.minAmount && request.amount <= this.maxAmount;
    }
 
    protected async makeDecision(request: ExpenseRequest): Promise<ApprovalDecision> {
        const director = await this.employeeService.getDepartmentDirector(
            request.requester.department
        );
        
        return {
            approver: director,
            decision: 'APPROVED',
            comments: 'Approved by department director',
            conditions: ['Requires receipt within 30 days'],
            decidedAt: new Date(),
        };
    }
}
 
/**
 * Finance Review Handler - for large expenses
 */
class FinanceReviewHandler extends ApprovalHandler {
    constructor(
        private readonly threshold: number,
        auditLog: AuditLog
    ) {
        super(auditLog, { maxHours: 72 });
    }
 
    protected async shouldHandle(request: ExpenseRequest): Promise<boolean> {
        return request.amount > this.threshold;
    }
 
    protected async makeDecision(request: ExpenseRequest): Promise<ApprovalDecision> {
        // Finance review includes budget check
        return {
            approver: { id: 'FINANCE', name: 'Finance Department' } as Employee,
            decision: 'APPROVED',
            comments: 'Budget verified and approved by Finance',
            decidedAt: new Date(),
        };
    }
}

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

// Build approval chain
function createApprovalWorkflow(
    policyService: PolicyService,
    employeeService: EmployeeService,
    auditLog: AuditLog
): ApprovalHandler {
    const policy = new PolicyValidationHandler(policyService, auditLog);
    const manager = new ManagerApprovalHandler(employeeService, 5000, auditLog);
    const director = new DirectorApprovalHandler(employeeService, 5000, 25000, auditLog);
    const finance = new FinanceReviewHandler(25000, auditLog);
 
    policy
        .setNext(manager)
        .setNext(director)
        .setNext(finance);
 
    return policy;
}
 
// Usage
const workflow = createApprovalWorkflow(policyService, employeeService, auditLog);
 
async function submitExpense(request: ExpenseRequest): Promise<ApprovalResult> {
    console.log(`Processing expense request ${request.id} for ${request.amount} ${request.currency}`);
    
    const result = await workflow.process(request, []);
    
    console.log(`Request ${request.id}: ${result.finalStatus}`);
    console.log(`Decisions: ${result.decisions.length}`);
    result.decisions.forEach(d => {
        console.log(`  - ${d.approver.name}: ${d.decision}`);
    });
    
    return result;
}
 
// Example: Small expense (≤$5000) - Manager handles
await submitExpense({
    id: 'EXP-001',
    amount: 500,
    currency: 'USD',
    category: 'TRAVEL',
    description: 'Client meeting transportation',
    requester: employee,
    attachments: [],
    submittedAt: new Date(),
    metadata: {},
});
// Flow: Policy ✓ → Manager ✓ → Done
 
// Example: Large expense (>$25000) - Full chain
await submitExpense({
    id: 'EXP-002',
    amount: 50000,
    currency: 'USD',
    category: 'EQUIPMENT',
    description: 'Server infrastructure upgrade',
    requester: employee,
    attachments: ['quote.pdf'],
    submittedAt: new Date(),
    metadata: {},
});
// Flow: Policy ✓ → Manager (skipped) → Director (skipped) → Finance ✓ → Done

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

// ❌ BAD: Handler knows about other handlers
class BadHandler extends AbstractHandler<Request, Response> {
    handle(request: Request): Response | null {
        if (this.shouldHandle(request)) {
            return this.processRequest(request);
        }
        
        // Anti-pattern: Handler knows specific successor
        if (request.type === 'SPECIAL') {
            // Skip to SpecialHandler directly - breaks chain independence!
            const specialHandler = new SpecialHandler();
            return specialHandler.handle(request);
        }
        
        return this.forward(request);
    }
}
 
// ✅ GOOD: Handler is independent
class GoodHandler extends AbstractHandler<Request, Response> {
    handle(request: Request): Response | null {
        if (this.shouldHandle(request)) {
            return this.processRequest(request);
        }
        return this.forward(request); // Always use chain
    }
}