Add missing docs and improve exisiting ones,

Add test for network, data & download task.

Author: SwiftyJoeyy

Benchmarks/MyNewBenchmarkTarget/MyNewBenchmarkTarget.swift

@@ -35,22 +35,14 @@ extension ConfigurationValues {
     /// - Warning: If accessed before being explicitly set, this property will trigger a runtime
     /// precondition failure to help catch misconfiguration.
     @Config(forceUnwrapped: true) public internal(set) var tasks: any TasksStorage
+    
+    /// The interceptors that will intercept the request & response.
+    @Config internal var taskInterceptor: any Interceptor = TaskInterceptor()
 }
 
-
 extension Configurable {
     /// Enables or disables request/response logging.
     public func enableLogs(_ enabled: Bool = true) -> Self {
         return configuration(\.logsEnabled, enabled)
     }
-    
-    /// Sets the handler used for managing response caching.
-    public func cacheHandler(_ handler: some ResponseCacheHandler) -> Self {
-        return configuration(\.cacheHandler, handler)
-    }
-    
-    /// Sets the handler for managing HTTP redirections.
-    public func redirectionHandler(_ handler: some RedirectionHandler) -> Self {
-        return configuration(\.redirectionHandler, handler)
-    }
 }

Sources/NetworkingClient/ConfigurationValues.swift

@@ -1,5 +1,5 @@
 //
-//  AuthenticationInterceptor.swift
+//  AuthInterceptor.swift
 //  Networking
 //
 //  Created by Joe Maghzal on 3/5/25.
@@ -8,14 +8,38 @@
 import Foundation
 import NetworkingCore
 
+/// An interceptor that manages authentication using an ``AuthProvider``.
+///
+/// `AuthInterceptor` applies credentials to outgoing requests and
+/// refreshes them if the response indicates an authentication failure.
+///
+/// It acts as both a ``RequestInterceptor`` and a ``ResponseInterceptor``, enabling:
+/// - Credential injection before the request is sent
+/// - Automatic refresh when an unauthorized (`401`) response is received
+///
+/// Use this type via ``Configurable/authorization(_:)`` to automatically apply and refresh auth.
+///
+/// - Important: Only a single refresh task is executed at a time.
+/// Concurrent requests will wait for the same refresh to complete.
 public actor AuthInterceptor {
+    /// The provider that handles authorization.
     private let provider: any AuthProvider
+    
+    /// The current refresh task.
     private var task: Task<Void, any Error>?
 
+    /// Creates a new interceptor with the given authentication provider.
+    ///
+    /// - Parameter provider: A type conforming to ``AuthProvider``.
     public init(provider: any AuthProvider) {
         self.provider = provider
     }
 
+    /// Refreshes the credentials if not already in progress.
+    ///
+    /// If a refresh is already ongoing, subsequent callers await its result.
+    ///
+    /// - Parameter session: The active session to use for refreshing.
     private func refresh(with session: Session) async throws {
         if let task {
             try await task.value
@@ -30,6 +54,12 @@ public actor AuthInterceptor {
 
 // MARK: - RequestInterceptor
 extension AuthInterceptor: RequestInterceptor {
+    /// Applies the authentication credential to the outgoing request.
+    ///
+    /// If the provider indicates that a refresh is needed,
+    /// this method refreshes the credentials before continuing.
+    ///
+    /// - Returns: A modified request with authentication applied.
     public func intercept(
         _ task: some NetworkingTask,
         request: consuming URLRequest,
@@ -45,6 +75,11 @@ extension AuthInterceptor: RequestInterceptor {
 
 // MARK: - ResponseInterceptor
 extension AuthInterceptor: ResponseInterceptor {
+    /// Intercepts unauthorized responses to trigger a credential refresh.
+    ///
+    /// This only runs if the response is `401 Unauthorized` and the retry count is zero.
+    ///
+    /// - Returns: `.retry` if refresh succeeds; otherwise `.continue` or rethrows on failure.
     public func intercept(
         _ task: some NetworkingTask,
         for session: Session,
@@ -64,7 +99,19 @@ extension AuthInterceptor: ResponseInterceptor {
 }
 
 extension Configurable {
-    /// Sets the handler used to manage request authorization.
+    /// Disables request authorization.
+    ///
+    /// Call this to explicitly disable authentication for a request.
+    public func unauthorized() -> Self {
+        return configuration(\.authInterceptor, nil)
+    }
+    
+    /// Sets the authorization provider used to authorize requests.
+    ///
+    /// The interceptor will apply credentials before sending and refresh them
+    /// automatically if the response is unauthorized.
+    ///
+    /// - Parameter provider: A type conforming to ``AuthProvider``.
     public func authorization(
         _ provider: some AuthProvider
     ) -> Self {

Sources/NetworkingClient/Handlers/AuthInterceptor/AuthInterceptor.swift

@@ -8,10 +8,55 @@
 import Foundation
 import NetworkingCore
 
+/// A type that manages authentication and provides credentials for requests.
+///
+/// Use an ``AuthProvider`` to encapsulate how credentials are created, validated,
+/// and refreshed. You can inject your provider into a request pipeline or session
+/// to automatically apply authentication state.
+///
+/// The provider supplies a ``RequestModifier`` via ``AuthProvider/credential``,
+/// which is attached to requests requiring authentication. When expired,
+/// the system can invoke ``AuthProvider/refresh(with:)`` to update it.
+///
+/// - Important: You are responsible for detecting expiration using ``AuthProvider/requiresRefresh()``
+/// and for updating the internal credential inside `refresh(with:)`.
+///
+/// ```swift
+/// struct TokenAuth: AuthProvider {
+///     var token: String
+///
+///     var credential: some RequestModifier {
+///         HeaderRequestModifier(name: "Authorization", value: "Bearer \(token)")
+///     }
+///
+///     func requiresRefresh() -> Bool { /* check token expiration */ }
+///
+///     func refresh(with session: Session) async throws {
+///         // request new token
+///     }
+/// }
+/// ```
 public protocol AuthProvider: Sendable {
+    /// The type of request modifier that carries authentication information.
     associatedtype Credential: RequestModifier
+    
+    /// The current credential used to modify requests.
+    ///
+    /// Typically this returns a request modifier that injects a token,
+    /// header, or query parameter.
     var credential: Self.Credential {get}
 
+    /// Refreshes the credential by interacting with a backend or store.
+    ///
+    /// This method is called when ``requiresRefresh()`` returns `true`.
+    /// Update any internal state so that the next ``credential`` reflects the new data.
+    ///
+    /// - Parameter session: A `Session` instance for making network requests.
     func refresh(with session: Session) async throws
+    
+    /// Returns a Boolean value indicating whether the credential needs refreshing.
+    ///
+    /// Use this method to determine if the current authentication state is valid.
+    /// If it returns `true`, ``refresh(with:)`` will be called before sending requests.
     func requiresRefresh() -> Bool
 }

Sources/NetworkingClient/Handlers/AuthInterceptor/AuthProvider.swift

@@ -6,14 +6,45 @@
 //
 
 import Foundation
+import NetworkingCore
 
+/// A value that defines how an HTTP redirection should be handled.
+///
+/// Use ``RedirectionBehavior`` to decide whether to follow, ignore,
+/// or modify an HTTP redirect during request execution.
+///
+/// You return one of these cases from a
+/// ``RedirectionHandler/redirect(_:redirectResponse:newRequest:)``
+/// implementation to control how the redirection is processed.
 @frozen public enum RedirectionBehavior: Equatable, Hashable, Sendable {
+    /// Follow the redirection as proposed.
     case redirect
+    
+    /// Ignore the redirection and return the original response.
     case ignore
+    
+    /// Provide a custom request to use instead of the proposed redirect.
+    ///
+    /// Pass `nil` to explicitly cancel the redirect.
     case modified(URLRequest?)
 }
 
+/// A type that handles HTTP redirection behavior.
+///
+/// Conform to ``RedirectionHandler`` to inspect or modify redirect responses
+/// during request execution. You can choose to follow the redirect,
+/// ignore it, or override the new request.
+///
+/// Attach a handler using ``Configurable/redirectionHandler(_:)``.
 public protocol RedirectionHandler: Sendable {
+    /// Evaluates the redirect response and determines the next step.
+    ///
+    /// - Parameters:
+    ///   - task: The networking task in progress.
+    ///   - redirectResponse: The response that triggered the redirect.
+    ///   - newRequest: The new request proposed by the system.
+    ///
+    /// - Returns: A ``RedirectionBehavior`` that indicates how to proceed.
     func redirect(
         _ task: some NetworkingTask,
         redirectResponse: URLResponse,
@@ -22,12 +53,22 @@ public protocol RedirectionHandler: Sendable {
 }
 
 extension RedirectionHandler where Self == DefaultRedirectionHandler {
+    /// A redirection handler that disables all redirections.
+    ///
+    /// This value causes the request to continue without following any redirects.
     public static var none: Self {
         return DefaultRedirectionHandler()
     }
 }
 
+/// A redirection handler that accepts all redirects.
+///
+/// This type always returns ``RedirectionBehavior/redirect``, allowing
+/// the request to follow any proposed redirection without modification.
+///
+/// Use this as a default or baseline implementation.
 public struct DefaultRedirectionHandler: RedirectionHandler {
+    /// Always follows the proposed redirection.
     public func redirect(
         _ task: some NetworkingTask,
         redirectResponse: URLResponse,
@@ -36,3 +77,17 @@ public struct DefaultRedirectionHandler: RedirectionHandler {
         return .redirect
     }
 }
+
+extension Configurable {
+    /// Sets the handler used to manage HTTP redirections.
+    ///
+    /// Use this method to override the default redirection behavior for a request.
+    /// You can ignore, modify, or explicitly cancel redirects based on response metadata.
+    ///
+    /// - Parameter handler: A type conforming to ``RedirectionHandler``.
+    ///
+    /// - Note: Use ``RedirectionHandler/none`` to disable redirects.
+    public func redirectionHandler(_ handler: some RedirectionHandler) -> Self {
+        return configuration(\.redirectionHandler, handler)
+    }
+}