update retry modifier

Author: dankinsoid

Sources/SwiftAPIClient/Modifiers/RateLimitModifier.swift

@@ -8,30 +8,35 @@ public extension APIClient {
 	///  - id: The identifier to use for rate limiting. Default to the base URL of the request.
 	///  - interval: The interval to wait before repeating the request. Default to 30 seconds.
 	///  - statusCodes: The set of status codes that indicate a rate limit exceeded. Default to `[429]`.
+	///  - methods: The set of HTTP methods to retry. If `nil`, all methods are retried. Default to `nil`.
 	///  - maxRepeatCount: The maximum number of times the request can be repeated. Default to 3.
 	func waitIfRateLimitExceeded<ID: Hashable>(
 		id: @escaping (HTTPRequestComponents) -> ID,
 		interval: TimeInterval = 30,
 		statusCodes: Set<HTTPResponse.Status> = [.tooManyRequests],
+		methods: Set<HTTPRequest.Method>? = nil,
 		maxRepeatCount: Int = 3
 	) -> Self {
-		httpClientMiddleware(RateLimitMiddleware(id: id, interval: interval, statusCodes: statusCodes, maxCount: maxRepeatCount))
+		httpClientMiddleware(RateLimitMiddleware(id: id, interval: interval, statusCodes: statusCodes, methods: methods, maxCount: maxRepeatCount))
 	}
 
 	/// When the rate limit is exceeded, the request will be repeated after the specified interval and all requests with the same base URL will be suspended.
 	/// - Parameters:
 	///  - interval: The interval to wait before repeating the request. Default to 30 seconds.
 	///  - statusCodes: The set of status codes that indicate a rate limit exceeded. Default to `[429]`.
+	///  - methods: The set of HTTP methods to retry. If `nil`, all methods are retried. Default to `nil`.
 	///  - maxRepeatCount: The maximum number of times the request can be repeated. Default to 3.
 	func waitIfRateLimitExceeded(
 		interval: TimeInterval = 30,
 		statusCodes: Set<HTTPResponse.Status> = [.tooManyRequests],
+		methods: Set<HTTPRequest.Method>? = nil,
 		maxRepeatCount: Int = 3
 	) -> Self {
 		waitIfRateLimitExceeded(
 			id: { $0.url?.host ?? UUID().uuidString },
 			interval: interval,
 			statusCodes: statusCodes,
+			methods: methods,
 			maxRepeatCount: maxRepeatCount
 		)
 	}
@@ -42,13 +47,19 @@ private struct RateLimitMiddleware<ID: Hashable>: HTTPClientMiddleware {
 	let id: (HTTPRequestComponents) -> ID
 	let interval: TimeInterval
 	let statusCodes: Set<HTTPResponse.Status>
+	let methods: Set<HTTPRequest.Method>?
 	let maxCount: Int
 
 	func execute<T>(
 		request: HTTPRequestComponents,
 		configs: APIClient.Configs,
 		next: @escaping Next<T>
 	) async throws -> (T, HTTPResponse) {
+		if let methods {
+			guard methods.contains(request.method) else {
+				return try await next(request, configs)
+			}
+		}
 		let id = id(request)
 		await waitForSynchronizedAccess(id: id, of: Void.self)
 		var (res, status) = try await extractStatusCodeEvenFailed {

Sources/SwiftAPIClient/Modifiers/RetryModifier.swift

@@ -5,31 +5,134 @@ import FoundationNetworking
 import HTTPTypes
 
 public extension APIClient {
-
+	
+	/// Retries the request if it fails.
+	/// - Parameters:
+	///   - limit: The maximum number of retries. If `nil`, it will retry indefinitely.
+	///   - interval: The time interval to wait before the next retry. If not provided.
+	///   - condition: A closure that takes the request, the result of the request, and the client configs, and returns a Boolean indicating whether to retry the request. If not provided, it defaults to retrying safe methods (like GET) on error status codes or network errors.
+	/// - Note: Like any modifier, this is order dependent. It takes in account only error from previous modifiers but not the following ones.
+	func retry(
+		when condition: RetryRequestCondition = .requestFailed,
+		limit: Int?,
+		interval: TimeInterval
+	) -> APIClient {
+		retry(when: condition,limit: limit, interval: { _ in interval })
+	}
+	
 	/// Retries the request if it fails.
-	func retry(limit: Int?) -> APIClient {
-		httpClientMiddleware(RetryMiddleware(limit: limit))
+	/// - Parameters:
+	///   - limit: The maximum number of retries. If `nil`, it will retry indefinitely.
+	///   - interval: A closure that takes the current retry count (starting from 0) and returns the time interval to wait before the next retry. If not provided, it defaults to 0 seconds.
+	///   - condition: A closure that takes the request, the result of the request, and the client configs, and returns a Boolean indicating whether to retry the request. If not provided, it defaults to retrying safe methods (like GET) on error status codes or network errors.
+	/// - Note: Like any modifier, this is order dependent. It takes in account only error from previous modifiers but not the following ones.
+	func retry(
+		when condition: RetryRequestCondition = .requestFailed,
+		limit: Int?,
+		interval: @escaping (Int) -> TimeInterval = { _ in 0 }
+	) -> APIClient {
+		httpClientMiddleware(RetryMiddleware(limit: limit, interval: interval, condition: condition))
 	}
 }
 
+/// A condition that determines whether a request should be retried based on the request, the result of the request, and the client configurations.
+public struct RetryRequestCondition {
+	
+	private let condition: (HTTPRequestComponents, Result<HTTPResponse, Error>, APIClient.Configs) -> Bool
+	
+	/// Initializes a new `RetryRequestCondition` with a custom condition closure.
+	/// - Parameters:
+	///   - condition: A closure that takes the request, the result of the request, and the client configs, and returns a Boolean indicating whether to retry the request.
+	public init(
+		_ condition: @escaping (_ request: HTTPRequestComponents, _ result: Result<HTTPResponse, Error>, _ configs: APIClient.Configs) -> Bool
+	) {
+		self.condition = condition
+	}
+
+	/// Determines whether the request should be retried based on the provided condition.
+	/// - Parameters:
+	///   - request: The original HTTP request components.
+	///   - result: The result of the HTTP request, which can be either a successful response or an error.
+	///   - configs: The configurations of the API client.
+	public func shouldRetry(
+		request: HTTPRequestComponents,
+		result: Result<HTTPResponse, Error>,
+		configs: APIClient.Configs
+	) -> Bool {
+		condition(request, result, configs)
+	}
+	
+	/// Combines two `RetryRequestCondition` instances using a logical AND operation.
+	/// The resulting condition will only return `true` if both conditions return `true`.
+	/// - Parameter other: Another `RetryRequestCondition` to combine with.
+	public func and(_ other: RetryRequestCondition) -> RetryRequestCondition {
+		RetryRequestCondition { request, result, configs in
+			self.shouldRetry(request: request, result: result, configs: configs)
+			&& other.shouldRetry(request: request, result: result, configs: configs)
+		}
+	}
+	
+	/// Combines two `RetryRequestCondition` instances using a logical OR operation.
+	/// The resulting condition will return `true` if either condition returns `true`.
+	/// - Parameter other: Another `RetryRequestCondition` to combine with.
+	public func or(_ other: RetryRequestCondition) -> RetryRequestCondition {
+		RetryRequestCondition { request, result, configs in
+			self.shouldRetry(request: request, result: result, configs: configs)
+			|| other.shouldRetry(request: request, result: result, configs: configs)
+		}
+	}
+
+	/// A predefined `RetryRequestCondition` that retries safe HTTP methods (like GET) when the request fails due to error status codes or network errors.
+	public static let requestFailed = RetryRequestCondition { request, result, _ in
+		guard request.method.isSafe else {
+			return false
+		}
+		switch result {
+		case let .success(response):
+			return response.status.kind.isError
+		case let .failure(error):
+			return !(error is CancellationError)
+		}
+	}
+
+	/// A predefined `RetryRequestCondition` that retries the request when the response status code is `429 Too Many Requests`.
+	public static let rateLimitExceeded = RetryRequestCondition.requestFailed.and(
+		RetryRequestCondition { _, response, _ in
+			if case let .success(response) = response {
+				return response.status == .tooManyRequests
+			}
+			return true
+		}
+	)
+}
+
 private struct RetryMiddleware: HTTPClientMiddleware {
 
 	let limit: Int?
+	let interval: (Int) -> TimeInterval
+	let condition: RetryRequestCondition
 
 	func execute<T>(
 		request: HTTPRequestComponents,
 		configs: APIClient.Configs,
 		next: @escaping Next<T>
 	) async throws -> (T, HTTPResponse) {
 		var count = 0
-		func needRetry() -> Bool {
+		func needRetry(_ result: Result<HTTPResponse, Error>) -> Bool {
+			guard condition.shouldRetry(request: request, result: result, configs: configs) else {
+				return false
+			}
 			if let limit {
 				return count <= limit
 			}
 			return true
 		}
 
 		func retry() async throws -> (T, HTTPResponse) {
+			let interval = UInt64(interval(count) * 1_000_000_000)
+			if interval > 0 {
+				try await Task.sleep(nanoseconds: interval)
+			}
 			count += 1
 			return try await next(request, configs)
 		}
@@ -39,12 +142,12 @@ private struct RetryMiddleware: HTTPClientMiddleware {
 		do {
 			(data, response) = try await retry()
 		} catch {
-			if needRetry() {
+			if needRetry(.failure(error)) {
 				return try await retry()
 			}
 			throw error
 		}
-		if response.status.kind.isError, needRetry() {
+		if needRetry(.success(response)) {
 			return try await retry()
 		}
 		return (data, response)

Sources/SwiftAPIClient/Utils/Status+Ext.swift

@@ -7,3 +7,15 @@ extension HTTPResponse.Status.Kind {
 		self == .clientError || self == .serverError || self == .invalid
 	}
 }
+
+extension HTTPRequest.Method {
+	
+	var isSafe: Bool {
+		switch self {
+		case .get, .head, .options, .trace:
+			return true
+		default:
+			return false
+		}
+	}
+}