REQUIREMENT:
"A customer can place an order containing multiple products. 
 Each order must have a shipping address and payment method.
 The system should track order status from placement to delivery."
 
NOUN EXTRACTION:
- Customer     → Entity: Customer class
- Order        → Entity: Order class  
- Products     → Entity: Product class
- Shipping Address → Value Object or Entity: Address class
- Payment Method   → Entity: PaymentMethod class
- Order Status     → Enum or State: OrderStatus
 
RELATIONSHIPS IDENTIFIED:
- Customer HAS-MANY Orders
- Order HAS-MANY Products (through OrderItem)
- Order HAS-ONE ShippingAddress
- Order HAS-ONE PaymentMethod
- Order HAS-ONE OrderStatus (with state transitions)

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

REQUIREMENT:
"Customers can add products to their cart, update quantities,
 and proceed to checkout. The system calculates shipping costs
 based on destination and applies available discounts."
 
VERB EXTRACTION → METHODS:
- "add products"        → Cart.addItem(product, quantity)
- "update quantities"   → Cart.updateItemQuantity(productId, quantity)
- "proceed to checkout" → CheckoutService.initiateCheckout(cart)
- "calculates shipping" → ShippingCalculator.calculate(destination, items)
- "applies discounts"   → DiscountEngine.apply(cart, customerProfile)
 
METHOD SIGNATURES REFINED:
interface Cart {
    addItem(product: Product, quantity: number): void;
    updateItemQuantity(productId: string, quantity: number): void;
    removeItem(productId: string): void;
    getTotal(): Money;
    getItems(): ReadonlyArray<CartItem>;
}
 
interface CheckoutService {
    initiateCheckout(cart: Cart): CheckoutSession;
    completeCheckout(session: CheckoutSession, payment: PaymentDetails): Order;
    cancelCheckout(sessionId: string): void;
}

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

// Password value object prevents accidental exposure
class Password {
    private readonly value: string;
    
    constructor(plaintext: string) {
        this.value = plaintext;
    }
    
    // Deliberately omit getValue() - force hashing instead
    
    // Never expose in logs or serialization
    toString(): string {
        return "[REDACTED]";
    }
    
    toJSON(): string {
        return "[REDACTED]";
    }
    
    // The only way to use the password
    hash(hasher: IPasswordHasher): HashedPassword {
        return hasher.hash(this.value);
    }
    
    verify(hasher: IPasswordHasher, hash: HashedPassword): boolean {
        return hasher.verify(this.value, hash);
    }
}
 
// Interface allows algorithm substitution
interface IPasswordHasher {
    hash(password: string): HashedPassword;
    verify(password: string, hash: HashedPassword): boolean;
}
 
// Concrete implementation can be swapped
class BCryptHasher implements IPasswordHasher {
    hash(password: string): HashedPassword {
        // BCrypt implementation
    }
    verify(password: string, hash: HashedPassword): boolean {
        // BCrypt verification
    }
}

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

// Without edge case consideration
class NaiveOrderService {
    placeOrder(customerId: string, items: Product[]): Order {
        // Just creates the order - what could go wrong?
        return new Order(customerId, items);
    }
}
 
// With deliberate edge case design
class RobustOrderService {
    placeOrder(customerId: string, items: Product[]): OrderResult {
        // Edge case: no customer
        const customer = this.customerRepository.find(customerId);
        if (!customer) {
            return OrderResult.failure("Customer not found");
        }
        
        // Edge case: empty order
        if (items.length === 0) {
            return OrderResult.failure("Cannot place empty order");
        }
        
        // Edge case: customer account suspended
        if (customer.isSuspended) {
            return OrderResult.failure("Account suspended");
        }
        
        // Edge case: items no longer available
        const unavailable = items.filter(item => !item.isAvailable());
        if (unavailable.length > 0) {
            return OrderResult.failure("Some items unavailable", unavailable);
        }
        
        // Edge case: exceeds order limit
        if (items.length > this.config.maxItemsPerOrder) {
            return OrderResult.failure(
                `Maximum ${this.config.maxItemsPerOrder} items per order`
            );
        }
        
        // Happy path
        const order = this.createOrder(customer, items);
        return OrderResult.success(order);
    }
}
 
// Result type makes edge cases explicit in the API
type OrderResult = 
    | { success: true; order: Order }
    | { success: false; error: string; details?: any };