Create helpful extensions to the generated types.

Add swiftly user agent middleware

Restrict the generator to only the swiftly portion of the API

Author: cmcgee1024

Sources/Swiftly/SelfUpdate.swift

@@ -31,45 +31,38 @@ internal struct SelfUpdate: SwiftlyCommand {
         SwiftlyCore.print("Checking for swiftly updates...")
 
         let swiftlyRelease = try await SwiftlyCore.httpClient.getCurrentSwiftlyRelease()
-        guard let releaseVersion = try? SwiftlyVersion(parsing: swiftlyRelease.version) else {
-            throw SwiftlyError(message: "Invalid swiftly version reported: \(swiftlyRelease.version)")
-        }
 
-        guard releaseVersion > SwiftlyCore.version else {
+        guard try swiftlyRelease.swiftlyVersion > SwiftlyCore.version else {
             SwiftlyCore.print("Already up to date.")
             return SwiftlyCore.version
         }
 
         var downloadURL: Foundation.URL?
         for platform in swiftlyRelease.platforms {
 #if os(macOS)
-            guard platform.platform.value1 == .darwin else {
+            guard platform.isDarwin else {
                 continue
             }
 #elseif os(Linux)
-            guard platform.platform.value1 == .linux else {
+            guard platform.isLinux else {
                 continue
             }
 #endif
 
 #if arch(x86_64)
-            guard let url = URL(string: platform.x8664) else {
-                throw SwiftlyError(message: "The swiftly release URL is not valid: \(platform.x8664)")
-            }
-            downloadURL = url
+            downloadURL = try platform.x86_64URL
 #elseif arch(arm64)
-            guard let url = URL(string: platform.arm64) else {
-                throw SwiftlyError(message: "The swiftly release URL is not valid: \(platform.arm64)")
-            }
-            downloadURL = url
+            downloadURL = try platform.arm64URL
 #endif
         }
 
         guard let downloadURL else {
-            throw SwiftlyError(message: "No matching platform was found in swiftly release.")
+            throw SwiftlyError(message: "The newest release of swiftly is incompatible with your current OS and/or processor architecture.")
         }
 
-        SwiftlyCore.print("A new version is available: \(releaseVersion)")
+        let version = try swiftlyRelease.swiftlyVersion
+
+        SwiftlyCore.print("A new version is available: \(version)")
 
         let tmpFile = Swiftly.currentPlatform.getTempFilePath()
         FileManager.default.createFile(atPath: tmpFile.path, contents: nil)
@@ -79,7 +72,7 @@ internal struct SelfUpdate: SwiftlyCommand {
 
         let animation = PercentProgressAnimation(
             stream: stdoutStream,
-            header: "Downloading swiftly \(releaseVersion)"
+            header: "Downloading swiftly \(version)"
         )
         do {
             try await SwiftlyCore.httpClient.downloadFile(
@@ -105,7 +98,7 @@ internal struct SelfUpdate: SwiftlyCommand {
         try await Swiftly.currentPlatform.verifySignature(httpClient: SwiftlyCore.httpClient, archiveDownloadURL: downloadURL, archive: tmpFile, verbose: verbose)
         try Swiftly.currentPlatform.extractSwiftlyAndInstall(from: tmpFile)
 
-        SwiftlyCore.print("Successfully updated swiftly to \(releaseVersion) (was \(SwiftlyCore.version))")
-        return releaseVersion
+        SwiftlyCore.print("Successfully updated swiftly to \(version) (was \(SwiftlyCore.version))")
+        return version
     }
 }

Sources/SwiftlyCore/HTTPClient.swift

@@ -1,17 +1,75 @@
 import _StringProcessing
 import AsyncHTTPClient
 import Foundation
+import HTTPTypes
 import NIO
 import NIOFoundationCompat
 import NIOHTTP1
 import OpenAPIAsyncHTTPClient
 import OpenAPIRuntime
 
+extension Components.Schemas.SwiftlyRelease {
+    public var swiftlyVersion: SwiftlyVersion {
+        get throws {
+            guard let releaseVersion = try? SwiftlyVersion(parsing: self.version) else {
+                throw SwiftlyError(message: "Invalid swiftly version reported: \(self.version)")
+            }
+
+            return releaseVersion
+        }
+    }
+}
+
+extension Components.Schemas.SwiftlyReleasePlatformArtifacts {
+    public var isDarwin: Bool {
+        self.platform.value1 == .darwin
+    }
+
+    public var isLinux: Bool {
+        self.platform.value1 == .linux
+    }
+
+    public var x86_64URL: URL {
+        get throws {
+            guard let url = URL(string: self.x8664) else {
+                throw SwiftlyError(message: "The swiftly x86_64 URL is invalid: \(self.x8664)")
+            }
+
+            return url
+        }
+    }
+
+    public var arm64URL: URL {
+        get throws {
+            guard let url = URL(string: self.arm64) else {
+                throw SwiftlyError(message: "The swiftly arm64 URL is invalid: \(self.arm64)")
+            }
+
+            return url
+        }
+    }
+}
+
 public protocol HTTPRequestExecutor {
     func execute(_ request: HTTPClientRequest, timeout: TimeAmount) async throws -> HTTPClientResponse
     func getCurrentSwiftlyRelease() async throws -> Components.Schemas.SwiftlyRelease
 }
 
+internal struct SwiftlyUserAgentMiddleware: ClientMiddleware {
+    package func intercept(
+        _ request: HTTPRequest,
+        body: HTTPBody?,
+        baseURL: URL,
+        operationID _: String,
+        next: (HTTPRequest, HTTPBody?, URL) async throws -> (HTTPResponse, HTTPBody?)
+    ) async throws -> (HTTPResponse, HTTPBody?) {
+        var request = request
+        // Adds the `Authorization` header field with the provided value.
+        request.headerFields[.userAgent] = "swiftly/\(SwiftlyCore.version)"
+        return try await next(request, body, baseURL)
+    }
+}
+
 /// An `HTTPRequestExecutor` backed by the shared `HTTPClient`.
 internal class HTTPRequestExecutorImpl: HTTPRequestExecutor {
     let httpClient: HTTPClient
@@ -59,11 +117,12 @@ internal class HTTPRequestExecutorImpl: HTTPRequestExecutor {
 
     public func getCurrentSwiftlyRelease() async throws -> Components.Schemas.SwiftlyRelease {
         let config = AsyncHTTPClientTransport.Configuration(client: self.httpClient, timeout: .seconds(30))
+        let swiftlyUserAgent = SwiftlyUserAgentMiddleware()
 
-        // FIXME: use a middleware that adds the swiftly user agent header (problem is how to do this with async http client)
         let client = Client(
             serverURL: URL(string: "https://swift.org/api")!,
-            transport: AsyncHTTPClientTransport(configuration: config)
+            transport: AsyncHTTPClientTransport(configuration: config),
+            middlewares: [swiftlyUserAgent]
         )
 
         let response = try await client.getCurrentSwiftlyRelease()

Sources/SwiftlyCore/openapi-generator-config.yaml

@@ -3,3 +3,5 @@ generate:
   - client
 namingStrategy: idiomatic
 accessModifier: public
+filter:
+  tags: ["Swiftly"]