Add Swift SDK generation and release checks

.gitmodules

@@ -22,3 +22,7 @@
 [submodule "submodules/dart"]
 	path = submodules/dart
 	url = ../Aspose.BarCode-Cloud-SDK-for-Dart
+[submodule "submodules/swift"]
+	path = submodules/swift
+	url = ../Aspose.BarCode-Cloud-SDK-for-Swift
+	branch = main

Makefile

@@ -62,3 +62,7 @@ php:
 .PHONY: python
 python:
 	cd codegen && ./generate-python.bash
+
+.PHONY: swift
+swift:
+	cd codegen && ./generate-swift.bash

codegen/Templates/swift/AsposeBarcodeCloudClient.mustache

@@ -0,0 +1,133 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public typealias AsposeBarcodeCloudTokenFetcher = @Sendable (
+    AsposeBarcodeCloudConfiguration,
+    @escaping @Sendable (Result<String, AsposeBarcodeCloudClientError>) -> Void
+) -> Void
+
+public final class AsposeBarcodeCloudClient: @unchecked Sendable {
+    public let configuration: AsposeBarcodeCloudConfiguration
+    public let apiConfiguration: AsposeBarcodeCloudAPIConfiguration
+    private let authInterceptor: BarcodeAuthInterceptor
+
+    public init(
+        configuration: AsposeBarcodeCloudConfiguration,
+        tokenFetcher: AsposeBarcodeCloudTokenFetcher? = nil
+    ) {
+        self.configuration = configuration
+        let fetcher = tokenFetcher ?? AsposeBarcodeCloudClient.defaultTokenFetcher
+
+        let apiConfig = AsposeBarcodeCloudAPIConfiguration(
+            basePath: configuration.host,
+            customHeaders: [
+                "x-aspose-client": configuration.sdkName,
+                "x-aspose-client-version": configuration.sdkVersion,
+            ]
+        )
+        let interceptor = BarcodeAuthInterceptor(
+            configuration: configuration,
+            tokenFetcher: fetcher
+        )
+        apiConfig.interceptor = interceptor
+
+        self.apiConfiguration = apiConfig
+        self.authInterceptor = interceptor
+    }
+
+    public convenience init(
+        clientId: String,
+        clientSecret: String,
+        host: String = AsposeBarcodeCloudConfiguration.defaultHost,
+        tokenURL: String = AsposeBarcodeCloudConfiguration.defaultTokenURL
+    ) {
+        self.init(configuration: AsposeBarcodeCloudConfiguration(
+            clientId: clientId,
+            clientSecret: clientSecret,
+            host: host,
+            tokenURL: tokenURL
+        ))
+    }
+
+    public convenience init(
+        accessToken: String,
+        host: String = AsposeBarcodeCloudConfiguration.defaultHost
+    ) {
+        self.init(configuration: AsposeBarcodeCloudConfiguration(
+            accessToken: accessToken,
+            host: host
+        ))
+    }
+
+    public func authorize(completion: @escaping @Sendable (Result<String, AsposeBarcodeCloudClientError>) -> Void) {
+        authInterceptor.ensureToken(completion: completion)
+    }
+
+    @discardableResult
+    public func authorize() async throws -> String {
+        try await withCheckedThrowingContinuation { continuation in
+            authorize { result in
+                switch result {
+                case let .success(token):
+                    continuation.resume(returning: token)
+                case let .failure(error):
+                    continuation.resume(throwing: error)
+                }
+            }
+        }
+    }
+
+    private struct TokenResponse: Decodable {
+        let accessToken: String?
+
+        enum CodingKeys: String, CodingKey {
+            case accessToken = "access_token"
+        }
+    }
+
+    private static func defaultTokenFetcher(
+        configuration: AsposeBarcodeCloudConfiguration,
+        completion: @escaping @Sendable (Result<String, AsposeBarcodeCloudClientError>) -> Void
+    ) {
+        let request: URLRequest
+        do {
+            request = try configuration.makeTokenRequest()
+        } catch let error as AsposeBarcodeCloudClientError {
+            completion(.failure(error))
+            return
+        } catch {
+            completion(.failure(.transportError(error)))
+            return
+        }
+
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                completion(.failure(.transportError(error)))
+                return
+            }
+
+            guard let httpResponse = response as? HTTPURLResponse else {
+                completion(.failure(.invalidTokenResponse))
+                return
+            }
+
+            guard 200..<300 ~= httpResponse.statusCode else {
+                let body = data.flatMap { String(data: $0, encoding: .utf8) }
+                completion(.failure(.tokenRequestFailed(statusCode: httpResponse.statusCode, body: body)))
+                return
+            }
+
+            guard let data = data,
+                  let tokenResponse = try? JSONDecoder().decode(TokenResponse.self, from: data),
+                  let accessToken = tokenResponse.accessToken,
+                  !accessToken.isEmpty else {
+                completion(.failure(.invalidTokenResponse))
+                return
+            }
+
+            completion(.success(accessToken))
+        }.resume()
+    }
+}

codegen/Templates/swift/AsposeBarcodeCloudClientError.mustache

@@ -0,0 +1,27 @@
+import Foundation
+
+public enum AsposeBarcodeCloudClientError: Error, CustomStringConvertible, @unchecked Sendable {
+    case missingCredentials
+    case invalidTokenURL(String)
+    case invalidTokenResponse
+    case tokenRequestFailed(statusCode: Int, body: String?)
+    case transportError(Error)
+
+    public var description: String {
+        switch self {
+        case .missingCredentials:
+            return "Access token or clientId/clientSecret are required"
+        case let .invalidTokenURL(url):
+            return "Invalid token URL: \(url)"
+        case .invalidTokenResponse:
+            return "Token response does not contain access_token"
+        case let .tokenRequestFailed(statusCode, body):
+            if let body = body, !body.isEmpty {
+                return "Token request failed with status \(statusCode): \(body)"
+            }
+            return "Token request failed with status \(statusCode)"
+        case let .transportError(error):
+            return error.localizedDescription
+        }
+    }
+}

codegen/Templates/swift/AsposeBarcodeCloudConfiguration.mustache

@@ -0,0 +1,65 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public final class AsposeBarcodeCloudConfiguration: @unchecked Sendable {
+    public static let defaultHost = "https://api.aspose.cloud/v4.0"
+    public static let defaultTokenURL = "https://id.aspose.cloud/connect/token"
+    public static let defaultSdkName = "swift sdk"
+    public static let defaultSdkVersion = "{{packageVersion}}"
+
+    public var host: String
+    public var tokenURL: String
+    public var accessToken: String?
+    public var clientId: String?
+    public var clientSecret: String?
+    public var sdkName: String
+    public var sdkVersion: String
+    public var timeoutInterval: TimeInterval
+
+    public init(
+        accessToken: String? = nil,
+        clientId: String? = nil,
+        clientSecret: String? = nil,
+        host: String = AsposeBarcodeCloudConfiguration.defaultHost,
+        tokenURL: String = AsposeBarcodeCloudConfiguration.defaultTokenURL,
+        sdkName: String = AsposeBarcodeCloudConfiguration.defaultSdkName,
+        sdkVersion: String = AsposeBarcodeCloudConfiguration.defaultSdkVersion,
+        timeoutInterval: TimeInterval = 300
+    ) {
+        self.accessToken = accessToken
+        self.clientId = clientId
+        self.clientSecret = clientSecret
+        self.host = host
+        self.tokenURL = tokenURL
+        self.sdkName = sdkName
+        self.sdkVersion = sdkVersion
+        self.timeoutInterval = timeoutInterval
+    }
+
+    public func makeTokenRequest() throws -> URLRequest {
+        guard let clientId = clientId, !clientId.isEmpty,
+              let clientSecret = clientSecret, !clientSecret.isEmpty else {
+            throw AsposeBarcodeCloudClientError.missingCredentials
+        }
+
+        guard let url = URL(string: tokenURL) else {
+            throw AsposeBarcodeCloudClientError.invalidTokenURL(tokenURL)
+        }
+
+        var components = URLComponents()
+        components.queryItems = [
+            URLQueryItem(name: "grant_type", value: "client_credentials"),
+            URLQueryItem(name: "client_id", value: clientId),
+            URLQueryItem(name: "client_secret", value: clientSecret),
+        ]
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.timeoutInterval = timeoutInterval
+        request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+        request.httpBody = components.percentEncodedQuery?.data(using: .utf8)
+        return request
+    }
+}

codegen/Templates/swift/BarcodeAuthInterceptor.mustache

@@ -0,0 +1,115 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+final class BarcodeAuthInterceptor: OpenAPIInterceptor, @unchecked Sendable {
+    private let configuration: AsposeBarcodeCloudConfiguration
+    private let tokenFetcher: AsposeBarcodeCloudTokenFetcher
+    private let state: OpenAPIMutex<State>
+
+    private struct State {
+        var token: String?
+        var inFlightFetch: Bool
+        var pendingWaiters: [@Sendable (Result<String, AsposeBarcodeCloudClientError>) -> Void]
+    }
+
+    init(
+        configuration: AsposeBarcodeCloudConfiguration,
+        tokenFetcher: @escaping AsposeBarcodeCloudTokenFetcher
+    ) {
+        self.configuration = configuration
+        self.tokenFetcher = tokenFetcher
+        let initialToken = configuration.accessToken.flatMap { $0.isEmpty ? nil : $0 }
+        self.state = OpenAPIMutex(State(
+            token: initialToken,
+            inFlightFetch: false,
+            pendingWaiters: []
+        ))
+    }
+
+    func intercept<T>(
+        urlRequest: URLRequest,
+        urlSession: URLSessionProtocol,
+        requestBuilder: RequestBuilder<T>,
+        completion: @Sendable @escaping (Result<URLRequest, any Error>) -> Void
+    ) {
+        guard requestBuilder.requiresAuthentication else {
+            completion(.success(urlRequest))
+            return
+        }
+
+        ensureToken { result in
+            switch result {
+            case let .success(token):
+                var modified = urlRequest
+                modified.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+                completion(.success(modified))
+            case let .failure(error):
+                completion(.failure(error))
+            }
+        }
+    }
+
+    func retry<T>(
+        urlRequest: URLRequest,
+        urlSession: URLSessionProtocol,
+        requestBuilder: RequestBuilder<T>,
+        data: Data?,
+        response: URLResponse?,
+        error: any Error,
+        completion: @Sendable @escaping (OpenAPIInterceptorRetry) -> Void
+    ) {
+        completion(.dontRetry)
+    }
+
+    func ensureToken(completion: @escaping @Sendable (Result<String, AsposeBarcodeCloudClientError>) -> Void) {
+        enum Action {
+            case immediate(Result<String, AsposeBarcodeCloudClientError>)
+            case wait
+            case startFetch
+        }
+
+        var action: Action = .wait
+        state.withValue { state in
+            if let token = state.token, !token.isEmpty {
+                action = .immediate(.success(token))
+                return
+            }
+            state.pendingWaiters.append(completion)
+            if state.inFlightFetch {
+                action = .wait
+            } else {
+                state.inFlightFetch = true
+                action = .startFetch
+            }
+        }
+
+        switch action {
+        case let .immediate(result):
+            completion(result)
+        case .wait:
+            break
+        case .startFetch:
+            tokenFetcher(configuration) { [weak self] result in
+                self?.deliverToken(result)
+            }
+        }
+    }
+
+    private func deliverToken(_ result: Result<String, AsposeBarcodeCloudClientError>) {
+        var waiters: [@Sendable (Result<String, AsposeBarcodeCloudClientError>) -> Void] = []
+        state.withValue { state in
+            state.inFlightFetch = false
+            if case let .success(token) = result {
+                state.token = token
+                self.configuration.accessToken = token
+            }
+            waiters = state.pendingWaiters
+            state.pendingWaiters.removeAll()
+        }
+        for waiter in waiters {
+            waiter(result)
+        }
+    }
+}