Fail-Fast Principle

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

// PATTERN 1: Constructor Validation
// Objects are born valid or not at all
class Order {
    private constructor(
        public readonly id: OrderId,
        public readonly customerId: CustomerId,
        public readonly items: ReadonlyArray<OrderItem>,
        public readonly createdAt: Date
    ) {}
    
    static create(
        customerId: CustomerId,
        items: OrderItem[]
    ): Result<Order, OrderCreationError> {
        // Fail fast: reject invalid orders at creation
        if (items.length === 0) {
            return Result.failure(OrderCreationError.emptyOrder());
        }
        
        if (items.length > Order.MAX_ITEMS) {
            return Result.failure(OrderCreationError.tooManyItems(items.length));
        }
        
        // Validate all items
        for (const item of items) {
            if (item.quantity <= 0) {
                return Result.failure(OrderCreationError.invalidQuantity(item));
            }
        }
        
        return Result.success(new Order(
            OrderId.generate(),
            customerId,
            Object.freeze([...items]),
            new Date()
        ));
    }
}
 
// PATTERN 2: Fail-Fast Iterators
// Detect concurrent modification immediately
class FailFastIterator<T> implements Iterator<T> {
    private expectedModCount: number;
    private index = 0;
    
    constructor(
        private readonly collection: FailFastCollection<T>,
        private readonly items: T[]
    ) {
        this.expectedModCount = collection.modCount;
    }
    
    next(): IteratorResult<T> {
        // Check for concurrent modification on every iteration
        if (this.collection.modCount !== this.expectedModCount) {
            throw new ConcurrentModificationError(
                'Collection was modified during iteration'
            );
        }
        
        if (this.index >= this.items.length) {
            return { done: true, value: undefined };
        }
        
        return { done: false, value: this.items[this.index++] };
    }
}
 
// PATTERN 3: Fail-Fast Configuration Loading
class Configuration {
    static load(source: ConfigSource): Configuration {
        const config = source.read();
        
        // Fail-fast: validate ALL configuration at startup
        const errors: string[] = [];
        
        if (!config.databaseUrl) {
            errors.push('DATABASE_URL is required');
        }
        
        if (!config.apiKey) {
            errors.push('API_KEY is required');
        }
        
        if (config.maxConnections !== undefined && config.maxConnections < 1) {
            errors.push('MAX_CONNECTIONS must be positive');
        }
        
        if (config.timeout !== undefined && config.timeout < 0) {
            errors.push('TIMEOUT cannot be negative');
        }
        
        // Fail at startup, not at first use
        if (errors.length > 0) {
            throw new ConfigurationError(
                'Invalid configuration:
' + errors.join('
')
            );
        }
        
        return new Configuration(config);
    }
}
 
// PATTERN 4: Fail-Fast Dependencies
// Verify dependencies at construction, not first use
class OrderService {
    constructor(
        private readonly orderRepo: OrderRepository,
        private readonly paymentGateway: PaymentGateway,
        private readonly eventBus: EventBus
    ) {
        // Fail fast: verify dependencies are valid at construction
        if (!orderRepo) throw new DependencyError('orderRepo is required');
        if (!paymentGateway) throw new DependencyError('paymentGateway is required');
        if (!eventBus) throw new DependencyError('eventBus is required');
        
        // Optional: verify dependencies are actually working
        // (appropriate for critical dependencies)
    }
}

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

// API Boundary: Validate and fail before processing
class OrderController {
    async createOrder(request: HttpRequest): Promise<HttpResponse> {
        // Fail-fast at API boundary
        const parseResult = CreateOrderSchema.safeParse(request.body);
        if (!parseResult.success) {
            // Immediate, specific failure - no partial processing
            return HttpResponse.badRequest({
                code: 'VALIDATION_ERROR',
                errors: parseResult.error.issues.map(issue => ({
                    field: issue.path.join('.'),
                    message: issue.message,
                })),
            });
        }
        
        // Data is now validated - proceed with confidence
        const result = await this.orderService.createOrder(parseResult.data);
        
        return result.match({
            success: order => HttpResponse.created(order),
            failure: error => this.mapDomainError(error),
        });
    }
}
 
// Database Boundary: Use constraints as fail-fast mechanism
// Database schema should enforce invariants
/*
CREATE TABLE orders (
    id UUID PRIMARY KEY,
    customer_id UUID NOT NULL REFERENCES customers(id),
    status VARCHAR(20) NOT NULL CHECK (status IN ('pending', 'confirmed', 'shipped')),
    total_amount DECIMAL(10,2) NOT NULL CHECK (total_amount >= 0),
    item_count INTEGER NOT NULL CHECK (item_count > 0),
    created_at TIMESTAMP NOT NULL DEFAULT NOW()
);
 
-- Fail-fast: unique constraint prevents duplicate orders
CREATE UNIQUE INDEX idx_orders_idempotency 
ON orders(customer_id, idempotency_key);
*/
 
// Message Queue Boundary: Validate messages before processing
class OrderEventHandler {
    async handle(message: QueueMessage): Promise<void> {
        // Fail-fast: parse and validate message structure
        let event: OrderEvent;
        try {
            event = OrderEventSchema.parse(JSON.parse(message.body));
        } catch (error) {
            // Invalid message - send to dead letter queue immediately
            // Don't retry messages that will never be valid
            await this.deadLetterQueue.send(message, error);
            return;
        }
        
        // Valid message - process with confidence
        await this.processEvent(event);
    }
}
 
// External Service Boundary: Validate responses immediately
class PaymentGatewayClient {
    async charge(request: ChargeRequest): Promise<Result<Charge, PaymentError>> {
        const response = await this.httpClient.post('/charges', request);
        
        // Fail-fast: validate response matches expected schema
        const parseResult = ChargeResponseSchema.safeParse(response.data);
        if (!parseResult.success) {
            // External service returned unexpected format
            // Log for debugging, fail immediately
            this.logger.error('Invalid payment gateway response', {
                response: response.data,
                errors: parseResult.error,
            });
            
            return Result.failure(
                PaymentError.gatewayError('Unexpected response format')
            );
        }
        
        return Result.success(parseResult.data);
    }
}

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

// Batch processing with error threshold
async function processBatch<T, R>(
    items: T[],
    processor: (item: T) => Promise<R>,
    options: { maxErrorRate: number }
): Promise<BatchResult<R>> {
    const results: R[] = [];
    const errors: Array<{ item: T; error: Error }> = [];
    
    for (const item of items) {
        try {
            results.push(await processor(item));
        } catch (error) {
            errors.push({ item, error: error as Error });
            
            // Fail-fast: if error rate exceeds threshold, abort
            const errorRate = errors.length / (results.length + errors.length);
            if (errorRate > options.maxErrorRate) {
                throw new BatchAbortedError(
                    `Error rate ${(errorRate * 100).toFixed(1)}% exceeds threshold`,
                    { processed: results.length, failed: errors.length, remaining: items.length - results.length - errors.length }
                );
            }
        }
    }
    
    return { results, errors };
}
 
// Graceful degradation for non-critical features
class ProductPage {
    async render(productId: string): Promise<PageContent> {
        // Critical: must succeed or page fails
        const product = await this.productService.getById(productId);
        if (!product) {
            throw new NotFoundError(`Product ${productId} not found`);
        }
        
        // Non-critical: degrade gracefully
        let recommendations: Product[] = [];
        try {
            recommendations = await this.recommendationService
                .getForProduct(productId, { timeout: 200 });
        } catch (error) {
            // Log but don't fail - page works without recommendations
            this.logger.warn('Failed to load recommendations', { productId, error });
        }
        
        return this.template.render({ product, recommendations });
    }
}

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

// Circuit Breaker: Fail-fast with recovery mechanism
class CircuitBreaker<T> {
    private failures = 0;
    private lastFailure?: Date;
    private state: 'closed' | 'open' | 'half-open' = 'closed';
    
    constructor(
        private readonly options: {
            failureThreshold: number;
            resetTimeout: number;
        }
    ) {}
    
    async execute<R>(operation: () => Promise<R>): Promise<R> {
        // Fail-fast when circuit is open
        if (this.state === 'open') {
            if (this.shouldAttemptReset()) {
                this.state = 'half-open';
            } else {
                throw new CircuitOpenError('Circuit breaker is open');
            }
        }
        
        try {
            const result = await operation();
            this.onSuccess();
            return result;
        } catch (error) {
            this.onFailure();
            throw error;
        }
    }
    
    private onSuccess(): void {
        this.failures = 0;
        this.state = 'closed';
    }
    
    private onFailure(): void {
        this.failures++;
        this.lastFailure = new Date();
        
        if (this.failures >= this.options.failureThreshold) {
            this.state = 'open';
        }
    }
    
    private shouldAttemptReset(): boolean {
        if (!this.lastFailure) return true;
        const elapsed = Date.now() - this.lastFailure.getTime();
        return elapsed >= this.options.resetTimeout;
    }
}
 
// Supervisor Pattern: Let it fail, then restart
class ActorSupervisor {
    private restartCount = 0;
    private lastRestart?: Date;
    
    constructor(
        private readonly createActor: () => Actor,
        private readonly strategy: SupervisorStrategy
    ) {}
    
    async supervise(actor: Actor): Promise<void> {
        while (true) {
            try {
                await actor.run();
            } catch (error) {
                // Actor failed - decide on recovery strategy
                const decision = this.strategy.decide(error, this.restartCount);
                
                switch (decision) {
                    case 'restart':
                        this.recordRestart();
                        actor = this.createActor();
                        continue;
                    case 'escalate':
                        throw error; // Let parent supervisor handle
                    case 'stop':
                        return; // Give up
                }
            }
        }
    }
    
    private recordRestart(): void {
        this.restartCount++;
        this.lastRestart = new Date();
    }
}