refactor: restructure Authenticating as struct with nested types

- Convert Authenticating from enum namespace to generic struct
- Nest Client, API, and Router types inside Authenticating for cleaner API
- Reuse generic parameters from parent struct in nested types
- Add convenience typealiases for backwards compatibility
- Enable usage pattern: @dependency(Service.self) with service.client and service.router
- Improve type inference and reduce generic parameter duplication

Author: coenttb

Package.swift

@@ -83,6 +83,14 @@ let package = Package(
                 .authenticatingEmailAddress
             ]
         ),
+        .testTarget(
+            name: .authenticating.tests,
+            dependencies: [
+                .authenticating,
+                .dependencies,
+                .product(name: "DependenciesMacros", package: "swift-dependencies")
+            ]
+        ),
     ],
     swiftLanguageModes: [.v6]
 )

Sources/Authenticating/Authenticating API.swift

@@ -43,21 +43,19 @@ extension Authenticating {
     ///     api: MyAPI.getUser(id: "123")
     /// )
     /// ```
-    public struct API<
-        OtherAPI: Equatable & Sendable
-    >: Equatable & Sendable {
+    public struct API: Equatable & Sendable {
         /// The authentication credentials.
         public let auth: Auth
 
         /// The API route or request.
-        public let api: OtherAPI
+        public let api: API
 
         /// Creates a new authenticated API instance.
         ///
         /// - Parameters:
         ///   - auth: The authentication credentials to use.
         ///   - api: The API route or request to authenticate.
-        public init(auth: Auth, api: OtherAPI) {
+        public init(auth: Auth, api: API) {
             self.auth = auth
             self.api = api
         }
@@ -73,13 +71,13 @@ extension Authenticating.API where Auth == BearerAuth {
     ///   - apiKey: The API key to use as the Bearer token.
     ///   - api: The API route or request to authenticate.
     /// - Throws: An error if the API key is invalid.
-    public init(apiKey: String, api: OtherAPI) throws {
+    public init(apiKey: String, api: API) throws {
         self.auth = try .init(token: apiKey)
         self.api = api
     }
 }
 
-extension Authenticating.API {
+extension Authenticating {
     /// A router that combines authentication routing with API routing.
     ///
     /// ``Router`` handles the parsing and printing of authenticated API requests,
@@ -107,16 +105,7 @@ extension Authenticating.API {
     /// )
     /// let request = try router.request(for: api)
     /// ```
-    public struct Router<
-        AuthRouter: ParserPrinter & Sendable,
-        OtherAPIRouter: ParserPrinter & Sendable
-    >: ParserPrinter, Sendable
-    where
-    OtherAPIRouter.Input == URLRequestData,
-    OtherAPIRouter.Output == OtherAPI,
-    AuthRouter.Input == URLRequestData,
-    AuthRouter.Output == Auth
-    {
+    public struct Router: ParserPrinter, Sendable {
 
         /// The base URL for all API requests.
         let baseURL: URL
@@ -125,7 +114,7 @@ extension Authenticating.API {
         let authRouter: AuthRouter
 
         /// The router responsible for handling API routes.
-        let router: OtherAPIRouter
+        let router: APIRouter
 
         /// Creates a new authenticated API router.
         ///
@@ -136,22 +125,22 @@ extension Authenticating.API {
         public init(
             baseURL: URL,
             authRouter: AuthRouter,
-            router: OtherAPIRouter
+            router: APIRouter
         ) {
             self.baseURL = baseURL
             self.authRouter = authRouter
             self.router = router
         }
 
-        /// The router body that combines authentication and API routing.
-        public var body: some URLRouting.Router<Authenticating<Auth>.API<OtherAPI>> {
-            Parse(.memberwise(Authenticating<Auth>.API<OtherAPI>.init)) {
-                authRouter
-                
-                router
-            }
-            .baseURL(self.baseURL.absoluteString)
+    /// The router body that combines authentication and API routing.
+    public var body: some URLRouting.Router<Authenticating.API> {
+        Parse(.memberwise(Authenticating.API.init)) {
+            authRouter
+            
+            router
         }
+        .baseURL(self.baseURL.absoluteString)
     }
 }
+}
 

Sources/Authenticating/Authenticating Client.swift

@@ -54,25 +54,14 @@ extension Authenticating {
     /// The client uses `@dynamicMemberLookup` to provide direct access to the underlying
     /// client's methods and properties, making authenticated requests feel natural.
     @dynamicMemberLookup
-    public struct Client<
-        AuthRouter: ParserPrinter & Sendable,
-        API: Equatable & Sendable,
-        APIRouter: ParserPrinter & Sendable,
-        ClientOutput: Sendable
-    >: Sendable
-    where
-    APIRouter.Input == URLRequestData,
-    APIRouter.Output == API,
-    AuthRouter.Input == URLRequestData,
-    AuthRouter.Output == Auth
-    {
+    public struct Client: Sendable {
 
         private let baseURL: URL
         private let auth: Auth
 
         private let router: APIRouter
         private let buildClient: @Sendable (@escaping @Sendable (API) throws -> URLRequest) -> ClientOutput
-        private let authenticatedRouter: Authenticating<Auth>.API<API>.Router<AuthRouter, APIRouter>
+        private let authenticatedRouter: Router
 
         /// Creates a new authenticated client.
         ///
@@ -93,7 +82,7 @@ extension Authenticating {
             self.auth = auth
             self.router = router
             self.buildClient = buildClient
-            self.authenticatedRouter = Authenticating.API.Router(
+            self.authenticatedRouter = Router(
                 baseURL: baseURL,
                 authRouter: authRouter,
                 router: router
@@ -102,15 +91,15 @@ extension Authenticating {
 
         /// Provides dynamic access to the underlying client's properties and methods.
         ///
-        /// This subscript automatically wraps all API calls with authentication,
-        /// ensuring that every request includes the necessary authentication headers.
+        /// This allows you to access closure properties directly on the authenticated client:
         ///
-        /// - Parameter keyPath: The key path to a property or method on the underlying client.
-        /// - Returns: The value at the specified key path, with authentication automatically applied.
+        /// ```swift
+        /// let response = try await authenticatedClient.send(.getUser(id: "123"))
+        /// ```
         public subscript<T>(dynamicMember keyPath: KeyPath<ClientOutput, T>) -> T {
             @Sendable
             func makeRequest(for api: API) throws -> URLRequest {
-                let data = try authenticatedRouter.print(.init(auth: auth, api: api))
+                let data = try authenticatedRouter.print(Authenticating.API(auth: auth, api: api))
 
                 guard let request = URLRequest(data: data) else {
                     throw Error.requestError
@@ -127,6 +116,37 @@ extension Authenticating {
                 }[keyPath: keyPath]
             }
         }
+        
+        /// Provides access to the underlying client with all authentication automatically applied.
+        ///
+        /// This computed property returns the client instance with authentication headers
+        /// automatically injected into every request. This allows you to call methods
+        /// with proper parameter labels:
+        ///
+        /// ```swift
+        /// // With proper method syntax:
+        /// let response = try await authenticatedClient.client.send(request)
+        /// ```
+        public var client: ClientOutput {
+            @Sendable
+            func makeRequest(for api: API) throws -> URLRequest {
+                let data = try authenticatedRouter.print(Authenticating.API(auth: auth, api: api))
+                
+                guard let request = URLRequest(data: data) else {
+                    throw Error.requestError
+                }
+                
+                return request
+            }
+            
+            return withEscapedDependencies { dependencies in
+                buildClient { api in
+                    try dependencies.yield {
+                        try makeRequest(for: api)
+                    }
+                }
+            }
+        }
     }
 }
 
@@ -143,7 +163,7 @@ public enum Error: Swift.Error {
 
 // MARK: - Bearer Authentication Conveniences
 
-extension Authenticating.Client {
+extension AuthenticatingClient where Auth == BearerAuth {
     /// Creates a new client with Bearer token authentication.
     ///
     /// This convenience initializer is available when using Bearer authentication
@@ -199,7 +219,7 @@ extension Authenticating.Client where APIRouter: TestDependencyKey, APIRouter.Va
 
 // MARK: - Basic Authentication Conveniences
 
-extension Authenticating.Client {
+extension AuthenticatingClient where Auth == BasicAuth {
     /// Creates a new client with Basic authentication.
     ///
     /// This convenience initializer is available when using Basic authentication