Handling Transaction Failures

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

/**
 * Classify database exceptions to determine appropriate handling strategy
 */
public class TransactionErrorClassifier {
    
    public ErrorCategory classify(Exception e) {
        if (e instanceof SQLException sqlEx) {
            return classifySqlException(sqlEx);
        }
        if (e instanceof DataAccessException dae) {
            return classifySpringException(dae);
        }
        // Unknown errors default to permanent (fail fast)
        return ErrorCategory.PERMANENT;
    }
    
    private ErrorCategory classifySqlException(SQLException e) {
        String sqlState = e.getSQLState();
        
        if (sqlState == null) {
            return ErrorCategory.PERMANENT;
        }
        
        // Class 40: Transaction Rollback (deadlock, serialization failure)
        if (sqlState.startsWith("40")) {
            return ErrorCategory.TRANSIENT;
        }
        
        // Class 08: Connection Exception
        if (sqlState.startsWith("08")) {
            return ErrorCategory.TRANSIENT;
        }
        
        // Class 23: Integrity Constraint Violation
        if (sqlState.startsWith("23")) {
            return ErrorCategory.CONSTRAINT_VIOLATION;
        }
        
        // Class 53: Insufficient Resources
        if (sqlState.startsWith("53")) {
            return ErrorCategory.RESOURCE_EXHAUSTION;
        }
        
        // Class 57: Operator Intervention (admin shutdown, crash recovery)
        if (sqlState.startsWith("57")) {
            return ErrorCategory.PERMANENT;
        }
        
        // Default to permanent for unknown states
        return ErrorCategory.PERMANENT;
    }
    
    private ErrorCategory classifySpringException(DataAccessException e) {
        // Spring's DataAccessException hierarchy
        if (e instanceof DeadlockLoserDataAccessException) {
            return ErrorCategory.TRANSIENT;
        }
        if (e instanceof CannotAcquireLockException) {
            return ErrorCategory.TRANSIENT;
        }
        if (e instanceof OptimisticLockingFailureException) {
            return ErrorCategory.TRANSIENT;
        }
        if (e instanceof DataIntegrityViolationException) {
            return ErrorCategory.CONSTRAINT_VIOLATION;
        }
        if (e instanceof CannotGetJdbcConnectionException) {
            return ErrorCategory.TRANSIENT;  // Connection pool issues
        }
        return ErrorCategory.PERMANENT;
    }
}
 
public enum ErrorCategory {
    TRANSIENT,              // Retry will likely succeed
    CONSTRAINT_VIOLATION,   // Data is invalid, don't retry
    RESOURCE_EXHAUSTION,    // Back off, then maybe retry
    PERMANENT               // Fail fast, alert
}

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

/**
 * Comprehensive transaction retry implementation
 */
public class TransactionRetryTemplate {
    
    private static final int MAX_RETRIES = 3;
    private static final long BASE_DELAY_MS = 100;
    private static final double JITTER_FACTOR = 0.3;
    
    private final TransactionErrorClassifier classifier = new TransactionErrorClassifier();
    private final Random random = new Random();
    
    /**
     * Execute operation with automatic retry for transient failures
     */
    public <T> T executeWithRetry(Supplier<T> operation, String operationName) {
        int attempt = 0;
        Exception lastException = null;
        
        while (attempt < MAX_RETRIES) {
            try {
                return operation.get();
            } catch (Exception e) {
                lastException = e;
                ErrorCategory category = classifier.classify(e);
                
                if (category != ErrorCategory.TRANSIENT) {
                    // Non-retriable error - fail immediately
                    throw wrapException(e, category, attempt);
                }
                
                attempt++;
                
                if (attempt >= MAX_RETRIES) {
                    logger.warn("Operation '{}' failed after {} attempts", 
                        operationName, attempt);
                    throw new RetryExhaustedException(operationName, lastException);
                }
                
                long delayMs = calculateBackoff(attempt);
                
                logger.info("Transient failure in '{}', attempt {}/{}, retrying in {}ms",
                    operationName, attempt, MAX_RETRIES, delayMs);
                
                sleep(delayMs);
            }
        }
        
        throw new RetryExhaustedException(operationName, lastException);
    }
    
    /**
     * Exponential backoff with jitter
     */
    private long calculateBackoff(int attempt) {
        // Base delay doubles each attempt: 100, 200, 400, 800...
        long exponentialDelay = BASE_DELAY_MS * (1L << (attempt - 1));
        
        // Add random jitter: ± 30%
        double jitter = 1 + (random.nextDouble() - 0.5) * 2 * JITTER_FACTOR;
        
        return (long) (exponentialDelay * jitter);
    }
    
    private void sleep(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Interrupted during retry backoff", e);
        }
    }
}
 
/**
 * Spring-based implementation using @Retryable
 */
@Service
public class OrderService {
    
    /**
     * Declarative retry with Spring Retry
     */
    @Retryable(
        value = {DeadlockLoserDataAccessException.class, 
                 OptimisticLockingFailureException.class,
                 CannotAcquireLockException.class},
        maxAttempts = 3,
        backoff = @Backoff(delay = 100, multiplier = 2, maxDelay = 1000)
    )
    @Transactional
    public Order placeOrder(OrderRequest request) {
        // If this fails with a transient error, entire method is retried
        // Note: Transaction is completely new on each retry
        Order order = createOrder(request);
        reserveInventory(order);
        chargePayment(order);
        return order;
    }
    
    /**
     * Recovery method called when all retries exhausted
     */
    @Recover
    public Order placeOrderFallback(RuntimeException e, OrderRequest request) {
        logger.error("Order placement failed after all retries", e);
        metrics.incrementCounter("orders.failed.retry_exhausted");
        throw new OrderPlacementException(
            "Unable to place order. Please try again later.", e
        );
    }
}

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

/**
 * Deadlock-resistant transaction implementation
 */
public class DeadlockAwareTransactionTemplate {
    
    private static final int MAX_DEADLOCK_RETRIES = 5;
    private static final long DEADLOCK_RETRY_DELAY_MS = 50;
    
    /**
     * Execute transaction with deadlock retry
     */
    @Transactional
    public <T> T executeWithDeadlockRetry(TransactionCallback<T> callback) {
        for (int attempt = 1; attempt <= MAX_DEADLOCK_RETRIES; attempt++) {
            try {
                return transactionTemplate.execute(callback);
            } catch (DeadlockLoserDataAccessException e) {
                if (attempt == MAX_DEADLOCK_RETRIES) {
                    logger.error("Deadlock persisted after {} attempts", attempt);
                    throw e;
                }
                
                logger.info("Deadlock detected (attempt {}), retrying...", attempt);
                metrics.incrementCounter("database.deadlocks");
                
                // Brief sleep to let the winner complete
                sleep(DEADLOCK_RETRY_DELAY_MS);
            }
        }
        throw new IllegalStateException("Should not reach here");
    }
    
    /**
     * Prevent deadlocks by locking in consistent order
     */
    @Transactional
    public void transferFunds(UUID fromAccount, UUID toAccount, BigDecimal amount) {
        // CRITICAL: Always lock accounts in a deterministic order (e.g., by ID)
        // This prevents the deadlock where T1 locks A→B while T2 locks B→A
        
        UUID firstLock = fromAccount.compareTo(toAccount) < 0 ? fromAccount : toAccount;
        UUID secondLock = fromAccount.compareTo(toAccount) < 0 ? toAccount : fromAccount;
        
        // Acquire locks in consistent order
        Account first = accountRepository.findByIdForUpdate(firstLock)
            .orElseThrow();
        Account second = accountRepository.findByIdForUpdate(secondLock)
            .orElseThrow();
        
        // Now perform the actual transfer
        Account source = fromAccount.equals(firstLock) ? first : second;
        Account destination = fromAccount.equals(firstLock) ? second : first;
        
        if (source.getBalance().compareTo(amount) < 0) {
            throw new InsufficientFundsException();
        }
        
        source.debit(amount);
        destination.credit(amount);
        
        accountRepository.save(source);
        accountRepository.save(destination);
    }
}
 
/**
 * Alternative: Use NOWAIT to detect potential deadlocks early
 */
@Repository
public class AccountRepository {
    
    @Query("SELECT a FROM Account a WHERE a.id = :id")
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @QueryHints(@QueryHint(name = "javax.persistence.lock.timeout", value = "0"))
    Optional<Account> findByIdWithNoWait(@Param("id") UUID id);
    
    // If lock cannot be acquired immediately, throws exception
    // Prevents waiting that could lead to deadlock
}

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

/**
 * Sophisticated constraint violation handling
 */
@Service
public class UserRegistrationService {
    
    @Transactional
    public User registerUser(RegistrationRequest request) {
        try {
            User user = new User();
            user.setEmail(request.getEmail());
            user.setUsername(request.getUsername());
            user.setPasswordHash(passwordEncoder.encode(request.getPassword()));
            
            return userRepository.save(user);
            
        } catch (DataIntegrityViolationException e) {
            // Parse the underlying cause to identify which constraint failed
            String message = extractConstraintName(e);
            
            if (message.contains("users_email_key")) {
                throw new RegistrationException(
                    "Email already registered. Please use a different email or log in.",
                    RegistrationErrorCode.EMAIL_TAKEN
                );
            }
            
            if (message.contains("users_username_key")) {
                throw new RegistrationException(
                    "Username already taken. Please choose a different username.",
                    RegistrationErrorCode.USERNAME_TAKEN
                );
            }
            
            // Unknown constraint - log for debugging, return generic message
            logger.error("Unexpected constraint violation during registration", e);
            throw new RegistrationException(
                "Registration failed. Please try again.",
                RegistrationErrorCode.UNKNOWN
            );
        }
    }
    
    private String extractConstraintName(DataIntegrityViolationException e) {
        Throwable cause = e.getCause();
        if (cause instanceof ConstraintViolationException cve) {
            return cve.getConstraintName() != null 
                ? cve.getConstraintName() 
                : cause.getMessage();
        }
        return e.getMessage();
    }
    
    /**
     * Alternative: Check before insert (has race condition but better UX)
     */
    @Transactional
    public ValidationResult validateRegistration(RegistrationRequest request) {
        List<String> errors = new ArrayList<>();
        
        // Pre-check (may have false negatives due to race, but improves UX)
        if (userRepository.existsByEmail(request.getEmail())) {
            errors.add("Email already registered");
        }
        
        if (userRepository.existsByUsername(request.getUsername())) {
            errors.add("Username already taken");
        }
        
        if (!errors.isEmpty()) {
            return ValidationResult.failed(errors);
        }
        
        // Note: Even if pre-checks pass, the actual insert might still fail
        // due to race condition. Handle constraint violation as fallback.
        return ValidationResult.passed();
    }
}
 
/**
 * Handle unique constraint as upsert (insert or update)
 */
@Service
public class SettingsService {
    
    @Transactional
    public UserSettings saveSettings(UUID userId, Map<String, String> settings) {
        for (Map.Entry<String, String> entry : settings.entrySet()) {
            // Use database's upsert capability
            settingsRepository.upsert(userId, entry.getKey(), entry.getValue());
        }
        return settingsRepository.findByUserId(userId);
    }
}
 
@Repository
public interface SettingsRepository extends JpaRepository<Setting, UUID> {
    
    // PostgreSQL upsert using native query
    @Modifying
    @Query(value = 
        "INSERT INTO user_settings (user_id, key, value) " +
        "VALUES (:userId, :key, :value) " +
        "ON CONFLICT (user_id, key) DO UPDATE SET value = :value",
        nativeQuery = true)
    void upsert(
        @Param("userId") UUID userId, 
        @Param("key") String key, 
        @Param("value") String value
    );
}

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

/**
 * Robust connection and timeout handling
 */
@Configuration
public class DataSourceConfiguration {
    
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        
        // Connection pool settings
        config.setMaximumPoolSize(20);
        config.setMinimumIdle(5);
        
        // Connection validation
        config.setConnectionTestQuery("SELECT 1");
        config.setValidationTimeout(5000);  // 5 seconds to validate
        
        // Acquire timeout - fail fast if pool exhausted
        config.setConnectionTimeout(10000);  // 10s to acquire connection
        
        // Idle connections closed after this time
        config.setIdleTimeout(300000);  // 5 minutes
        
        // Connections closed after this time regardless of activity
        config.setMaxLifetime(1800000);  // 30 minutes
        
        // Leak detection
        config.setLeakDetectionThreshold(60000);  // Warn if connection held > 60s
        
        return new HikariDataSource(config);
    }
}
 
@Service
public class RobustDataAccessService {
    
    /**
     * Handle connection acquisition failures
     */
    public Order placeOrderWithConnectionRetry(OrderRequest request) {
        int attempts = 0;
        while (attempts < 3) {
            try {
                return orderService.placeOrder(request);
            } catch (CannotGetJdbcConnectionException e) {
                attempts++;
                logger.warn("Connection pool exhausted, attempt {}/3", attempts);
                
                if (attempts >= 3) {
                    throw new ServiceUnavailableException(
                        "Database temporarily unavailable. Please try again."
                    );
                }
                
                // Back-pressure: wait before retry
                sleep(500 * attempts);
            }
        }
        throw new IllegalStateException("Should not reach here");
    }
    
    /**
     * Handle query timeouts with chunking
     */
    @Transactional(timeout = 30)  // 30 second timeout
    public void processLargeBatch(List<Record> records) {
        // If this times out, break into smaller chunks
        for (Record record : records) {
            processRecord(record);
        }
    }
    
    /**
     * Alternative: Process in smaller transactions
     */
    public BatchResult processInChunks(List<Record> records) {
        List<List<Record>> chunks = Lists.partition(records, 100);
        
        int processed = 0;
        List<String> errors = new ArrayList<>();
        
        for (List<Record> chunk : chunks) {
            try {
                // Each chunk is a separate transaction
                processChunk(chunk);  // @Transactional with shorter timeout
                processed += chunk.size();
            } catch (TransactionTimedOutException e) {
                logger.error("Chunk timed out at offset {}", processed);
                errors.add("Timeout at record " + processed);
                // Continue with next chunk or break depending on requirements
            }
        }
        
        return new BatchResult(processed, records.size(), errors);
    }
    
    @Transactional(timeout = 10)  // Smaller timeout per chunk
    public void processChunk(List<Record> records) {
        records.forEach(this::processRecord);
    }
}

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

/**
 * Database circuit breaker implementation
 */
@Service
public class DatabaseCircuitBreaker {
    
    private final AtomicInteger failureCount = new AtomicInteger(0);
    private final AtomicReference<State> state = new AtomicReference<>(State.CLOSED);
    private volatile long lastFailureTime = 0;
    
    private static final int FAILURE_THRESHOLD = 5;
    private static final long OPEN_TIMEOUT_MS = 30000;  // 30 seconds
    
    public <T> T execute(Supplier<T> operation, Supplier<T> fallback) {
        if (state.get() == State.OPEN) {
            if (shouldAttemptReset()) {
                return attemptHalfOpen(operation, fallback);
            }
            return fallback.get();
        }
        
        try {
            T result = operation.get();
            onSuccess();
            return result;
        } catch (Exception e) {
            if (isCircuitBreakerException(e)) {
                onFailure();
            }
            throw e;
        }
    }
    
    private boolean shouldAttemptReset() {
        return System.currentTimeMillis() - lastFailureTime > OPEN_TIMEOUT_MS;
    }
    
    private <T> T attemptHalfOpen(Supplier<T> operation, Supplier<T> fallback) {
        state.set(State.HALF_OPEN);
        try {
            T result = operation.get();
            reset();  // Success! Close the circuit
            return result;
        } catch (Exception e) {
            tripBreaker();  // Still failing, reopen
            return fallback.get();
        }
    }
    
    private void onSuccess() {
        failureCount.set(0);
    }
    
    private void onFailure() {
        int failures = failureCount.incrementAndGet();
        lastFailureTime = System.currentTimeMillis();
        
        if (failures >= FAILURE_THRESHOLD) {
            tripBreaker();
        }
    }
    
    private void tripBreaker() {
        state.set(State.OPEN);
        logger.warn("Circuit breaker OPENED - database failures exceeded threshold");
        alertOps("Database circuit breaker opened");
    }
    
    private void reset() {
        state.set(State.CLOSED);
        failureCount.set(0);
        logger.info("Circuit breaker CLOSED - database recovered");
    }
    
    private boolean isCircuitBreakerException(Exception e) {
        // Only trip for infrastructure failures, not business errors
        return e instanceof CannotGetJdbcConnectionException
            || e instanceof QueryTimeoutException
            || e instanceof DataAccessResourceFailureException;
    }
    
    enum State { CLOSED, OPEN, HALF_OPEN }
}
 
/**
 * Using Resilience4j for production circuit breaker
 */
@Configuration
public class CircuitBreakerConfig {
    
    @Bean
    public CircuitBreakerRegistry circuitBreakerRegistry() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50)  // Open when 50% of calls fail
            .waitDurationInOpenState(Duration.ofSeconds(30))
            .slidingWindowSize(10)  // Evaluate last 10 calls
            .permittedNumberOfCallsInHalfOpenState(3)  // Test with 3 calls
            .recordExceptions(
                CannotGetJdbcConnectionException.class,
                DataAccessResourceFailureException.class
            )
            .build();
        
        return CircuitBreakerRegistry.of(config);
    }
}
 
@Service
public class OrderServiceWithCircuitBreaker {
    
    private final CircuitBreaker circuitBreaker;
    private final CachedOrderService cachedOrderService;
    
    @Autowired
    public OrderServiceWithCircuitBreaker(
            CircuitBreakerRegistry registry,
            CachedOrderService cachedOrderService) {
        this.circuitBreaker = registry.circuitBreaker("database");
        this.cachedOrderService = cachedOrderService;
    }
    
    public Order getOrder(UUID orderId) {
        return circuitBreaker.executeSupplier(() -> 
            orderRepository.findById(orderId).orElseThrow()
        );
    }
    
    // With fallback
    public List<Order> getRecentOrders(UUID customerId) {
        try {
            return circuitBreaker.executeSupplier(() ->
                orderRepository.findRecentByCustomerId(customerId)
            );
        } catch (CallNotPermittedException e) {
            // Circuit is open - use fallback
            return cachedOrderService.getCachedOrders(customerId);
        }
    }
}

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

/**
 * Idempotency key pattern for safe retries
 */
@Service
public class IdempotentOrderService {
    
    private final IdempotencyKeyRepository idempotencyRepo;
    private final OrderRepository orderRepository;
    
    /**
     * Client generates a unique key per logical operation.
     * If key exists, return cached result instead of re-executing.
     */
    @Transactional
    public OrderResult placeOrder(String idempotencyKey, OrderRequest request) {
        // Check if we've already processed this request
        Optional<IdempotencyRecord> existing = 
            idempotencyRepo.findByKey(idempotencyKey);
        
        if (existing.isPresent()) {
            IdempotencyRecord record = existing.get();
            
            if (record.isCompleted()) {
                // Already completed - return cached result
                logger.info("Returning cached result for idempotency key: {}", 
                    idempotencyKey);
                return record.getCachedResult();
            }
            
            if (record.isInProgress()) {
                // Another request is processing - tell client to wait
                throw new ConflictException(
                    "Request in progress. Please retry in a few seconds."
                );
            }
        }
        
        // Mark this key as in-progress
        IdempotencyRecord record = new IdempotencyRecord(
            idempotencyKey, 
            IdempotencyStatus.IN_PROGRESS
        );
        idempotencyRepo.save(record);
        
        try {
            // Execute the actual operation
            Order order = createOrder(request);
            reserveInventory(order);
            
            // Cache the result
            OrderResult result = new OrderResult(order);
            record.setStatus(IdempotencyStatus.COMPLETED);
            record.setCachedResult(result);
            idempotencyRepo.save(record);
            
            return result;
            
        } catch (Exception e) {
            // Mark failed - could retry or leave for investigation
            record.setStatus(IdempotencyStatus.FAILED);
            record.setError(e.getMessage());
            idempotencyRepo.save(record);
            throw e;
        }
    }
    
    /**
     * Alternative: Use natural keys for implicit idempotency
     * Works when operations can be uniquely identified by content
     */
    @Transactional
    public void recordPayment(PaymentNotification notification) {
        String paymentId = notification.getPaymentProviderTransactionId();
        
        // Check if payment already recorded (using unique constraint)
        if (paymentRepository.existsByExternalId(paymentId)) {
            logger.info("Payment {} already recorded, skipping", paymentId);
            return;  // Idempotent - no error, no duplicate
        }
        
        Payment payment = new Payment();
        payment.setExternalId(paymentId);  // Has unique constraint
        payment.setAmount(notification.getAmount());
        payment.setOrderId(notification.getOrderId());
        
        try {
            paymentRepository.save(payment);
        } catch (DataIntegrityViolationException e) {
            // Race condition: another thread saved first
            // This is fine - payment is recorded
            if (e.getMessage().contains("payments_external_id_key")) {
                logger.info("Payment {} recorded by concurrent request", paymentId);
                return;
            }
            throw e;
        }
    }
}
 
/**
 * IdempotencyRecord entity
 */
@Entity
@Table(name = "idempotency_keys")
public class IdempotencyRecord {
    @Id
    @Column(name = "idempotency_key")
    private String key;
    
    @Enumerated(EnumType.STRING)
    private IdempotencyStatus status;
    
    @Column(columnDefinition = "jsonb")
    @Type(JsonType.class)
    private OrderResult cachedResult;
    
    private String error;
    
    @CreationTimestamp
    private Instant createdAt;
    
    // Expire old keys
    @Column(name = "expires_at")
    private Instant expiresAt;
}