Add DeepL translation integration

Changelog-Added: DeepL translation integration
Closes: #522

damus/Util/Translator.swift

@@ -0,0 +1,127 @@
+//
+//  Translator.swift
+//  damus
+//
+//  Created by Terry Yiu on 2/4/23.
+//
+
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public struct Translator {
+    private let userSettingsStore: UserSettingsStore
+    private let session = URLSession.shared
+    private let encoder = JSONEncoder()
+    private let decoder = JSONDecoder()
+
+    init(_ userSettingsStore: UserSettingsStore) {
+        self.userSettingsStore = userSettingsStore
+    }
+
+    public func translate(_ text: String, from sourceLanguage: String, to targetLanguage: String) async throws -> String? {
+        switch userSettingsStore.translation_service {
+        case .libretranslate:
+            return try await translateWithLibreTranslate(text, from: sourceLanguage, to: targetLanguage)
+        case .deepl:
+            return try await translateWithDeepL(text, from: sourceLanguage, to: targetLanguage)
+        case .none:
+            return text
+        }
+    }
+
+    private func translateWithLibreTranslate(_ text: String, from sourceLanguage: String, to targetLanguage: String) async throws -> String? {
+        let url = try makeURL(userSettingsStore.libretranslate_url, path: "/translate")
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+
+        struct RequestBody: Encodable {
+            let q: String
+            let source: String
+            let target: String
+            let api_key: String?
+        }
+        let body = RequestBody(q: text, source: sourceLanguage, target: targetLanguage, api_key: userSettingsStore.libretranslate_api_key)
+        request.httpBody = try encoder.encode(body)
+
+        struct Response: Decodable {
+            let translatedText: String
+        }
+        let response: Response = try await decodedData(for: request)
+        return response.translatedText
+    }
+
+    private func translateWithDeepL(_ text: String, from sourceLanguage: String, to targetLanguage: String) async throws -> String? {
+        if userSettingsStore.deepl_api_key == "" {
+            return nil
+        }
+
+        let url = try makeURL(userSettingsStore.deepl_plan.model.url, path: "/v2/translate")
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("DeepL-Auth-Key \(userSettingsStore.deepl_api_key)", forHTTPHeaderField: "Authorization")
+
+        struct RequestBody: Encodable {
+            let text: [String]
+            let source_lang: String
+            let target_lang: String
+        }
+        let body = RequestBody(text: [text], source_lang: sourceLanguage.uppercased(), target_lang: targetLanguage.uppercased())
+        request.httpBody = try encoder.encode(body)
+
+        struct Response: Decodable {
+            let translations: [DeepLTranslations]
+        }
+        struct DeepLTranslations: Decodable {
+            let detected_source_language: String
+            let text: String
+        }
+
+        let response: Response = try await decodedData(for: request)
+        return response.translations.map { $0.text }.joined(separator: " ")
+    }
+
+    private func makeURL(_ baseUrl: String, path: String) throws -> URL {
+        guard var components = URLComponents(string: baseUrl) else {
+            throw URLError(.badURL)
+        }
+        components.path = path
+        guard let url = components.url else {
+            throw URLError(.badURL)
+        }
+        return url
+    }
+
+    private func decodedData<Output: Decodable>(for request: URLRequest) async throws -> Output {
+        let data = try await session.data(for: request)
+        let result = try decoder.decode(Output.self, from: data)
+        return result
+    }
+}
+
+private extension URLSession {
+    func data(for request: URLRequest) async throws -> Data {
+        var task: URLSessionDataTask?
+        let onCancel = { task?.cancel() }
+        return try await withTaskCancellationHandler(
+            operation: {
+                try await withCheckedThrowingContinuation { continuation in
+                    task = dataTask(with: request) { data, _, error in
+                        guard let data = data else {
+                            let error = error ?? URLError(.badServerResponse)
+                            return continuation.resume(throwing: error)
+                        }
+                        continuation.resume(returning: data)
+                    }
+                    task?.resume()
+                }
+            },
+            onCancel: { onCancel() }
+        )
+    }
+}