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

// 1. API receives search request
@Get('/hotels/:hotelId/availability')
async searchAvailability(
    @Param('hotelId') hotelId: string,
    @Query() query: SearchQueryDto
): Promise<AvailabilityResponse> {
    // Validate input
    const validatedQuery = this.validateSearchQuery(query);
    
    // 2. SearchService processes request
    const results = await this.searchService.search({
        hotelId: HotelId.from(hotelId),
        checkIn: LocalDate.parse(query.checkIn),
        checkOut: LocalDate.parse(query.checkOut),
        adults: query.adults,
        children: query.children,
        ratePlanCode: query.ratePlanCode,
    });
    
    return this.mapToResponse(results);
}
 
// 3. SearchService implementation
class SearchService {
    async search(query: SearchQuery): Promise<SearchResult[]> {
        const hotel = await this.hotelRepository.findById(query.hotelId);
        
        // Get all room types for this hotel
        const roomTypes = hotel.getRoomTypes()
            .filter(rt => rt.canAccommodate(query.adults, query.children));
        
        const results: SearchResult[] = [];
        
        for (const roomType of roomTypes) {
            // 4. Check availability across all nights
            const availability = await this.availabilityService.checkAvailability(
                hotel.id,
                roomType.id,
                query.checkIn,
                query.checkOut
            );
            
            if (availability.availableRooms > 0) {
                // 5. Calculate pricing
                const pricing = await this.pricingEngine.calculatePricing({
                    hotel,
                    roomType,
                    ratePlan: await this.getRatePlan(query.ratePlanCode),
                    stayDates: new DateRange(query.checkIn, query.checkOut),
                    nights: query.nights,
                    adults: query.adults,
                    children: query.children,
                    promoCode: null,
                    currency: hotel.defaultCurrency,
                    context: this.buildContext(query),
                });
                
                results.push({
                    roomType: roomType.toSummary(),
                    availableRooms: availability.availableRooms,
                    pricing: pricing.toSummary(),
                    cancellationPolicy: pricing.cancellationPolicy.toSummary(),
                });
            }
        }
        
        // Sort by price
        return results.sort((a, b) => 
            a.pricing.total.compareTo(b.pricing.total)
        );
    }
}
 
// Response for our scenario:
{
    "roomTypes": [
        {
            "id": "DELUXE-KING",
            "name": "Deluxe King Room",
            "description": "450 sq ft with city view",
            "maxOccupancy": 3,
            "availableRooms": 5,
            "pricing": {
                "nightlyRates": [
                    { "date": "2024-03-15", "rate": 189.00 },
                    { "date": "2024-03-16", "rate": 219.00 },  // Weekend
                    { "date": "2024-03-17", "rate": 199.00 }
                ],
                "subtotal": 607.00,
                "ratePlanDiscount": -60.70,  // 10% AAA
                "taxes": 72.84,
                "fees": 45.00,  // Resort fee
                "total": 664.14
            },
            "cancellationPolicy": {
                "name": "Flexible 24-Hour",
                "description": "Free cancellation until 24 hours before check-in"
            }
        },
        // ... more room types
    ]
}

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

// 1. API receives booking request
@Post('/bookings')
async createBooking(
    @Body() dto: CreateBookingDto,
    @User() user: AuthenticatedUser
): Promise<BookingResponse> {
    // Validate input
    const validatedInput = this.validateBookingInput(dto);
    
    // 2. BookingService orchestrates the flow
    const result = await this.bookingService.createBooking({
        ...validatedInput,
        userId: user?.id,
    });
    
    return this.mapToResponse(result);
}
 
// 3. BookingService implementation
class BookingService {
    async createBooking(input: CreateBookingInput): Promise<BookingResult> {
        // Start transaction for consistency
        return this.transactionManager.run(async (tx) => {
            // 4. Factory creates reservation with all validations
            const reservation = await this.reservationFactory.create({
                hotelId: input.hotelId,
                roomTypeId: input.roomTypeId,
                checkInDate: input.checkInDate,
                checkOutDate: input.checkOutDate,
                adults: input.adults,
                children: input.children,
                childAges: input.childAges,
                roomCount: 1,
                guest: input.guestDetails,
                ratePlanCode: input.ratePlanCode,
                promotionCode: input.promoCode,
                channel: BookingChannel.DIRECT,
                source: 'Website',
                specialRequests: input.specialRequests,
            });
            
            // 5. Process payment
            const paymentResult = await this.paymentService.processPayment({
                reservationId: reservation.id,
                amount: reservation.totalAmount,
                paymentMethod: input.paymentMethod,
                billingDetails: input.billingDetails,
            });
            
            if (!paymentResult.success) {
                // Rollback inventory reservation
                await this.availabilityService.releaseInventory(
                    reservation.hotelId,
                    reservation.roomTypeId,
                    reservation.checkInDate,
                    reservation.checkOutDate,
                    reservation.roomCount,
                    reservation.id
                );
                
                throw new PaymentFailedError(paymentResult.errorMessage);
            }
            
            // 6. Confirm reservation (State transition)
            reservation.recordPayment(paymentResult.paymentId, paymentResult.amount);
            reservation.confirm();  // PENDING → CONFIRMED
            
            // 7. Save reservation
            await this.reservationRepository.save(reservation, tx);
            
            // 8. Publish domain events (outside transaction)
            this.eventBus.publishAll(reservation.domainEvents);
            
            return new BookingResult({
                reservation,
                confirmationNumber: reservation.confirmationNumber,
                paymentConfirmation: paymentResult.confirmationCode,
            });
        });
    }
}
 
// 9. Event handlers react to ReservationConfirmedEvent
class ReservationConfirmedHandler implements EventHandler<ReservationConfirmedEvent> {
    async handle(event: ReservationConfirmedEvent): Promise<void> {
        // Send confirmation email
        await this.emailService.sendConfirmation(
            event.reservationId,
            event.guestEmail
        );
        
        // Update availability on OTAs
        await this.channelManager.syncAvailability(
            event.hotelId,
            event.roomTypeId,
            event.checkInDate,
            event.checkOutDate
        );
        
        // Award loyalty points (if applicable)
        if (event.loyaltyMemberId) {
            await this.loyaltyService.awardBookingPoints(
                event.loyaltyMemberId,
                event.totalAmount
            );
        }
    }
}
 
// Final response:
{
    "confirmationNumber": "GH-NYC-2024031501234",
    "status": "CONFIRMED",
    "guestName": "John Smith",
    "hotel": {
        "name": "Grand Hotel NYC",
        "address": "123 Main St, New York, NY 10001"
    },
    "checkIn": "2024-03-15",
    "checkOut": "2024-03-18",
    "roomType": "Deluxe King Room",
    "guests": { "adults": 2, "children": 0 },
    "pricing": {
        "roomTotal": 546.30,
        "taxes": 72.84,
        "fees": 45.00,
        "grandTotal": 664.14
    },
    "cancellationPolicy": "Free cancellation until March 14, 2024 3:00 PM",
    "payment": {
        "status": "COMPLETED",
        "lastFour": "4242"
    }
}

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

// 1. API receives modification request
@Patch('/bookings/:confirmationNumber')
async modifyBooking(
    @Param('confirmationNumber') confirmationNumber: string,
    @Body() dto: ModifyBookingDto
): Promise<ModificationResponse> {
    const result = await this.bookingService.modifyBooking(
        ConfirmationNumber.from(confirmationNumber),
        dto
    );
    
    return this.mapToResponse(result);
}
 
// 2. BookingService handles modification
class BookingService {
    async modifyBooking(
        confirmationNumber: ConfirmationNumber,
        changes: ModificationInput
    ): Promise<ModificationResult> {
        // Find existing reservation
        const reservation = await this.reservationRepository
            .findByConfirmationNumber(confirmationNumber);
        
        if (!reservation) {
            throw new ReservationNotFoundError(confirmationNumber);
        }
        
        // 3. State pattern validates modification is allowed
        if (!reservation.isModifiable()) {
            throw new ModificationNotAllowedError(
                `Cannot modify reservation in ${reservation.statusName} state`
            );
        }
        
        return this.transactionManager.run(async (tx) => {
            // 4. Analyze date changes
            const dateAnalysis = this.dateAnalyzer.analyze(
                reservation.originalDates,
                new DateRange(
                    changes.newCheckIn ?? reservation.checkInDate,
                    changes.newCheckOut ?? reservation.checkOutDate
                )
            );
            
            // 5. Check availability for new nights
            if (dateAnalysis.addedNights.length > 0) {
                const availability = await this.availabilityService
                    .checkAvailabilityForNights(
                        reservation.hotelId,
                        reservation.roomTypeId,
                        dateAnalysis.addedNights
                    );
                
                if (availability.minAvailable < reservation.roomCount) {
                    throw new InsufficientInventoryError(
                        `Cannot extend - only ${availability.minAvailable} rooms available on ${availability.constrainingDate}`
                    );
                }
            }
            
            // 6. Calculate new pricing
            const repricingResult = await this.repricingService
                .calculateDateModificationPricing(
                    reservation,
                    changes.newCheckIn ?? reservation.checkInDate,
                    changes.newCheckOut ?? reservation.checkOutDate
                );
            
            // 7. Adjust inventory
            await this.availabilityService.adjustInventoryForModification(
                reservation.id,
                reservation.currentDates,
                new DateRange(
                    changes.newCheckIn ?? reservation.checkInDate,
                    changes.newCheckOut ?? reservation.checkOutDate
                ),
                reservation.hotelId,
                reservation.roomTypeId,
                reservation.roomCount
            );
            
            // 8. Apply changes to reservation
            reservation.modifyDates(
                changes.newCheckIn ?? reservation.checkInDate,
                changes.newCheckOut ?? reservation.checkOutDate
            );
            
            reservation.updatePricing(repricingResult);
            
            // 9. Handle payment difference
            if (repricingResult.isAdditionalPaymentRequired) {
                await this.processAdditionalPayment(
                    reservation,
                    repricingResult.difference
                );
            } else if (repricingResult.isRefundDue) {
                await this.processRefund(
                    reservation,
                    repricingResult.difference.abs()
                );
            }
            
            // 10. Save and publish events
            await this.reservationRepository.save(reservation, tx);
            this.eventBus.publishAll(reservation.domainEvents);
            
            return new ModificationResult({
                reservation,
                originalDates: dateAnalysis.originalDates,
                newDates: dateAnalysis.newDates,
                priceDifference: repricingResult.difference,
                newTotal: repricingResult.newTotal,
            });
        });
    }
}
 
// Repricing details for our scenario:
{
    "modification": "DATE_EXTENSION",
    "originalDates": { "checkIn": "2024-03-15", "checkOut": "2024-03-18" },
    "newDates": { "checkIn": "2024-03-15", "checkOut": "2024-03-19" },
    "pricingBreakdown": {
        "unchangedNights": {
            "nights": ["2024-03-15", "2024-03-16", "2024-03-17"],
            "total": 546.30,
            "note": "Original rates preserved"
        },
        "addedNights": {
            "nights": ["2024-03-18"],
            "total": 189.00,
            "note": "Current market rate (Monday)"
        },
        "previousTotal": 664.14,
        "newTotal": 876.89,
        "difference": 212.75,
        "additionalPaymentRequired": true
    }
}

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

// 1. API receives cancellation request
@Delete('/bookings/:confirmationNumber')
async cancelBooking(
    @Param('confirmationNumber') confirmationNumber: string,
    @Body() dto: CancelBookingDto
): Promise<CancellationResponse> {
    const result = await this.bookingService.cancelBooking(
        ConfirmationNumber.from(confirmationNumber),
        dto.reason
    );
    
    return this.mapToResponse(result);
}
 
// 2. BookingService handles cancellation
class BookingService {
    async cancelBooking(
        confirmationNumber: ConfirmationNumber,
        reason: string
    ): Promise<CancellationResult> {
        const reservation = await this.reservationRepository
            .findByConfirmationNumber(confirmationNumber);
        
        if (!reservation) {
            throw new ReservationNotFoundError(confirmationNumber);
        }
        
        // 3. State pattern checks if cancellation is allowed
        if (!reservation.isCancellable()) {
            throw new CancellationNotAllowedError(
                `Cannot cancel reservation in ${reservation.statusName} state`
            );
        }
        
        return this.transactionManager.run(async (tx) => {
            // 4. State.cancel() handles the transition and penalty calculation
            // This delegates to the current state object (ConfirmedState)
            const cancellationResult = reservation.cancel(reason);
            
            // Inside ConfirmedState.cancel():
            // - Calculates hours until check-in: 12 hours
            // - Finds policy tier: 24-hour threshold → 100% penalty
            // - Calculates penalty: $876.89 (full charge)
            // - Processes refund: $0 (paid $876.89, penalty $876.89)
            // - Releases inventory
            // - Transitions to CancelledState
            // - Emits ReservationCancelledEvent
            
            // 5. Save reservation
            await this.reservationRepository.save(reservation, tx);
            
            // 6. Publish events
            this.eventBus.publishAll(reservation.domainEvents);
            
            return cancellationResult;
        });
    }
}
 
// 7. Inside ConfirmedState.cancel() - detailed view
class ConfirmedState extends ReservationState {
    cancel(reason: string): CancellationResult {
        // Calculate penalty using CancellationCalculator (Template Method)
        const penalty = this.cancellationCalculator.calculatePenalty(
            this.context,      // reservation
            Instant.now()      // cancellation time
        );
        
        // Calculate refund
        const amountPaid = this.context.totalPaid;
        const refundAmount = amountPaid.subtract(penalty.adjustedPenalty);
        
        const result = new CancellationResult({
            reservationId: this.context.id,
            cancelledAt: Instant.now(),
            penaltyAmount: penalty.adjustedPenalty,
            refundAmount: refundAmount.max(Money.zero()),
            policyApplied: this.context.cancellationPolicy.name,
            reason,
        });
        
        // Release inventory back to available pool
        this.context.releaseInventory();
        
        // Process refund (if any)
        if (refundAmount.isPositive()) {
            this.context.initiateRefund(refundAmount);
        }
        
        // Record status change with history
        this.context.recordStatusChange(
            'CONFIRMED',
            'CANCELLED',
            `Cancelled: ${reason}. Penalty: ${penalty.adjustedPenalty}`
        );
        
        // Transition to terminal state
        this.context.transitionTo(new CancelledState());
        
        // Emit domain event
        this.context.addDomainEvent(new ReservationCancelledEvent(
            this.context.id,
            this.context.confirmationNumber,
            result
        ));
        
        return result;
    }
}
 
// 8. CancellationCalculator (Template Method) - penalty calculation
class StandardCancellationCalculator extends CancellationCalculator {
    protected calculateHoursUntilCheckin(
        reservation: Reservation,
        cancellationTime: Instant
    ): number {
        const checkinInstant = reservation.checkInDate
            .atTime(LocalTime.of(15, 0))  // 3 PM check-in
            .atZone(reservation.hotel.timezone)
            .toInstant();
        
        return cancellationTime.until(checkinInstant, ChronoUnit.HOURS);
        // Returns: 12 hours
    }
    
    protected calculateBasePenalty(
        reservation: Reservation,
        tier: CancellationTier
    ): Money {
        // Tier: { hoursBeforeCheckin: 24, penaltyPercentage: 100 }
        // Since we're at 12 hours (< 24), this tier applies
        
        return reservation.totalAmount.multiply(tier.penaltyPercentage / 100);
        // Returns: $876.89 * 100% = $876.89
    }
}
 
// Response for our scenario:
{
    "confirmationNumber": "GH-NYC-2024031501234",
    "status": "CANCELLED",
    "cancelledAt": "2024-03-15T03:00:00Z",
    "reason": "Change of travel plans",
    "cancellationPolicy": {
        "name": "24-Hour Flexible",
        "tierApplied": "Within 24 hours",
        "penalty": "100% of booking"
    },
    "financial": {
        "originalTotal": 876.89,
        "penaltyAmount": 876.89,
        "refundAmount": 0.00,
        "refundStatus": "NOT_APPLICABLE"
    },
    "inventoryReleased": true
}

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

// ==================== CHECK-IN ====================
 
// 1. Front desk initiates check-in
@Post('/reservations/:confirmationNumber/check-in')
async checkIn(
    @Param('confirmationNumber') confirmationNumber: string,
    @Body() dto: CheckInDto
): Promise<CheckInResponse> {
    return this.frontDeskService.checkIn(
        ConfirmationNumber.from(confirmationNumber),
        dto.assignedRoomNumbers
    );
}
 
// 2. FrontDeskService handles check-in
class FrontDeskService {
    async checkIn(
        confirmationNumber: ConfirmationNumber,
        roomNumbers: RoomNumber[]
    ): Promise<CheckInResult> {
        const reservation = await this.reservationRepository
            .findByConfirmationNumber(confirmationNumber);
        
        if (!reservation) {
            throw new ReservationNotFoundError(confirmationNumber);
        }
        
        return this.transactionManager.run(async (tx) => {
            // 3. Find and validate rooms
            const rooms: Room[] = [];
            for (const roomNumber of roomNumbers) {
                const room = await this.roomRepository.findByNumber(
                    reservation.hotelId,
                    roomNumber
                );
                
                if (!room) {
                    throw new RoomNotFoundError(roomNumber);
                }
                
                // Validate room type matches
                if (!room.roomTypeId.equals(reservation.roomTypeId)) {
                    throw new RoomTypeMismatchError(
                        `Room ${roomNumber} is not a ${reservation.roomTypeName}`
                    );
                }
                
                // Validate room is available
                if (!room.canBeAssigned()) {
                    throw new RoomNotAvailableError(
                        `Room ${roomNumber} is ${room.status}`
                    );
                }
                
                rooms.push(room);
            }
            
            // 4. Assign rooms (Room entity updates)
            for (const room of rooms) {
                room.assignToReservation(
                    reservation.id,
                    reservation.primaryGuestId
                );
                await this.roomRepository.save(room, tx);
            }
            
            // 5. Check in reservation (State transition)
            reservation.checkIn(rooms.map(r => r.id));
            
            // ConfirmedState.checkIn() does:
            // - Validates room count matches reservation
            // - Sets assignedRoomIds
            // - Sets checkedInAt timestamp
            // - Transitions to CheckedInState
            // - Records status change in history
            // - Emits GuestCheckedInEvent
            
            // 6. Save reservation
            await this.reservationRepository.save(reservation, tx);
            
            // 7. Publish events
            this.eventBus.publishAll(reservation.domainEvents);
            
            return new CheckInResult({
                reservation,
                assignedRooms: rooms.map(r => r.toSummary()),
                keyCardsIssued: rooms.length,
            });
        });
    }
}
 
// ==================== DURING STAY ====================
 
// 8. Post incidental charges
@Post('/reservations/:confirmationNumber/charges')
async postCharge(
    @Param('confirmationNumber') confirmationNumber: string,
    @Body() dto: PostChargeDto
): Promise<ChargeResponse> {
    const reservation = await this.reservationRepository
        .findByConfirmationNumber(confirmationNumber);
    
    // Only CHECKED_IN reservations can have charges posted
    if (reservation.statusName !== 'CHECKED_IN') {
        throw new InvalidStateError(
            'Can only post charges for checked-in guests'
        );
    }
    
    const charge = new IncidentalCharge({
        type: dto.chargeType,  // MINIBAR, ROOM_SERVICE, SPA, etc.
        description: dto.description,
        amount: Money.of(dto.amount, dto.currency),
        postedAt: Instant.now(),
        postedBy: dto.staffId,
    });
    
    reservation.addCharge(charge);
    await this.reservationRepository.save(reservation);
    
    return this.mapToResponse(charge);
}
 
// ==================== CHECK-OUT ====================
 
// 9. Front desk initiates check-out
@Post('/reservations/:confirmationNumber/check-out')
async checkOut(
    @Param('confirmationNumber') confirmationNumber: string
): Promise<CheckOutResponse> {
    return this.frontDeskService.checkOut(
        ConfirmationNumber.from(confirmationNumber)
    );
}
 
// 10. FrontDeskService handles check-out
class FrontDeskService {
    async checkOut(
        confirmationNumber: ConfirmationNumber
    ): Promise<CheckOutResult> {
        const reservation = await this.reservationRepository
            .findByConfirmationNumber(confirmationNumber);
        
        return this.transactionManager.run(async (tx) => {
            // 11. Check for outstanding balance
            const balance = reservation.outstandingBalance;
            
            if (balance.isPositive()) {
                // Attempt to charge card on file
                const paymentResult = await this.paymentService.chargeBalance(
                    reservation.id,
                    balance
                );
                
                if (!paymentResult.success) {
                    throw new OutstandingBalanceError(
                        `Cannot check out. Balance: ${balance}. ` +
                                        `Payment failed: ${paymentResult.errorMessage}`
                    );
                }
                
                reservation.recordPayment(
                    paymentResult.paymentId,
                    paymentResult.amount
                );
            }
            
            // 12. Check out reservation (State transition)
            reservation.checkOut();
            
            // CheckedInState.checkOut() does:
            // - Validates no outstanding balance
            // - Sets checkedOutAt timestamp
            // - Transitions to CheckedOutState
            // - Emits GuestCheckedOutEvent
            
            // 13. Release rooms (Room entity updates)
            for (const roomId of reservation.assignedRoomIds) {
                const room = await this.roomRepository.findById(roomId);
                room.release();  // Status → NEEDS_CLEANING
                await this.roomRepository.save(room, tx);
            }
            
            // 14. Record stay for guest history and loyalty
            const guest = await this.guestRepository.findById(
                reservation.primaryGuestId
            );
            guest.recordStay(
                LocalDate.now(),
                reservation.totalCharged
            );
            guest.awardPoints(
                this.loyaltyCalculator.calculatePoints(reservation),
                'Completed stay'
            );
            await this.guestRepository.save(guest, tx);
            
            // 15. Save reservation
            await this.reservationRepository.save(reservation, tx);
            
            // 16. Publish events
            this.eventBus.publishAll(reservation.domainEvents);
            
            return new CheckOutResult({
                reservation,
                finalBill: reservation.getFinalBill(),
                loyaltyPointsEarned: guest.lastPointsAwarded,
            });
        });
    }
}
 
// 17. Housekeeping service reacts to room release
class RoomReleasedHandler implements EventHandler<GuestCheckedOutEvent> {
    async handle(event: GuestCheckedOutEvent): Promise<void> {
        for (const roomId of event.roomIds) {
            // Create housekeeping task
            await this.housekeepingService.createCleaningTask(roomId);
        }
    }
}

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

// Comprehensive error handling in BookingService
class BookingService {
    async createBooking(input: CreateBookingInput): Promise<BookingResult> {
        // Wrap in transaction with error handling
        try {
            return await this.transactionManager.run(async (tx) => {
                // ... booking logic
            });
        } catch (error) {
            // Log full error for debugging
            this.logger.error('Booking failed', {
                input,
                error: error.message,
                stack: error.stack,
            });
            
            // Map to user-friendly errors
            if (error instanceof InsufficientInventoryError) {
                throw new BookingError(
                    'SOLD_OUT',
                    'Sorry, this room type is no longer available. Please choose different dates or room type.',
                    { retryable: false }
                );
            }
            
            if (error instanceof PaymentFailedError) {
                throw new BookingError(
                    'PAYMENT_FAILED',
                    error.message,
                    { retryable: true, retryAction: 'UPDATE_PAYMENT' }
                );
            }
            
            if (error instanceof InvalidDateRangeError) {
                throw new BookingError(
                    'INVALID_DATES',
                    error.message,
                    { retryable: false }
                );
            }
            
            // Unexpected errors - don't expose internal details
            throw new BookingError(
                'SYSTEM_ERROR',
                'An unexpected error occurred. Please try again.',
                { retryable: true }
            );
        }
    }
}
 
// Race condition protection - optimistic locking
class AvailabilityService {
    async reserveInventory(/* params */): Promise<void> {
        const MAX_RETRIES = 3;
        
        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
            try {
                await this.lockManager.withLock(lockKey, async () => {
                    // Re-check availability with lock held
                    const current = await this.checkAvailability(/* params */);
                    
                    if (current.availableRooms < roomCount) {
                        throw new InsufficientInventoryError(/*...*/);
                    }
                    
                    // Reserve with optimistic locking
                    await this.inventoryRepository.atomicReserve(/* params */);
                });
                
                return; // Success
                
            } catch (error) {
                if (error instanceof ConcurrentModificationError && attempt < MAX_RETRIES) {
                    // Another booking happened simultaneously - retry
                    this.logger.warn(`Concurrent modification on attempt ${attempt}, retrying`);
                    await this.delay(100 * attempt);  // Exponential backoff
                    continue;
                }
                throw error;
            }
        }
    }
}