Merge pull request #409 from appwrite/feat-swift-async-await

Feat swift async await

Author: abnegate

templates/swift/Package.swift.twig

@@ -17,7 +17,7 @@ let package = Package(
         ),
     ],
     dependencies: [
-        .package(url: "https://github.com/swift-server/async-http-client.git", from: "1.0.0"),
+        .package(url: "https://github.com/swift-server/async-http-client.git", from: "1.9.0"),
         .package(url: "https://github.com/apple/swift-nio.git", from: "2.32.0")
     ],
     targets: [

templates/swift/Sources/Client.swift.twig

@@ -21,6 +21,7 @@ open class Client {
     open var headers: [String: String] = [
         "content-type": "",
         "x-sdk-version": "{{spec.title | caseDash}}:{{ language.name | caseLower }}:{{ sdk.version }}"{% if spec.global.defaultHeaders | length > 0 %},{% endif %}
+
 {% for key,header in spec.global.defaultHeaders %}
         "{{key}}": "{{header}}"{% if not loop.last %},{% endif %}
 {% endfor %}
@@ -228,29 +229,17 @@ open class Client {
         headers: [String: String] = [:],
         params: [String: Any?] = [:],
         sink: ((ByteBuffer) -> Void)? = nil,
-        convert: (([String: Any]) -> T)? = nil,
-        completion: ((Result<T, {{ spec.title | caseUcfirst }}Error>) -> Void)? = nil
-    ) {
+        convert: (([String: Any]) -> T)? = nil
+    ) async throws -> T {
         let validParams = params.filter { $0.value != nil }
 
         let queryParameters = method == "GET" && !validParams.isEmpty
             ? "?" + parametersToQueryString(params: validParams)
             : ""
 
-        let targetURL = URL(string: endPoint + path + queryParameters)!
+        var request = HTTPClientRequest(url: endPoint + path + queryParameters)
+        request.method = .RAW(value: method)
 
-        var request: HTTPClient.Request
-        do {
-            request = try HTTPClient.Request(
-                url: targetURL,
-                method: .RAW(value: method)
-            )
-        } catch {
-            completion?(Result.failure({{ spec.title | caseUcfirst }}Error(
-                message: error.localizedDescription
-            )))
-            return
-        }
 
         for (key, value) in self.headers.merging(headers, uniquingKeysWith: { $1 }) {
             request.headers.add(name: key, value: value)
@@ -259,24 +248,16 @@ open class Client {
         request.addDomainCookies()
 
         if "GET" == method {
-            execute(request, convert: convert, completion: completion)
-            return
+            return try await execute(request, convert: convert)
         }
 
-        do {
-            try buildBody(for: &request, with: validParams)
-        } catch let error {
-            completion?(Result.failure({{ spec.title | caseUcfirst}}Error(
-                message: error.localizedDescription
-            )))
-            return
-        }
+        try buildBody(for: &request, with: validParams)
 
-        execute(request, withSink: sink, convert: convert, completion: completion)
+        return try await execute(request, withSink: sink, convert: convert)
     }
 
     private func buildBody(
-        for request: inout HTTPClient.Request,
+        for request: inout HTTPClientRequest,
         with params: [String: Any?]
     ) throws {
         if request.headers["content-type"][0] == "multipart/form-data" {
@@ -287,96 +268,62 @@ open class Client {
     }
 
     private func execute<T>(
-        _ request: HTTPClient.Request,
+        _ request: HTTPClientRequest,
         withSink bufferSink: ((ByteBuffer) -> Void)? = nil,
-        convert: (([String: Any]) -> T)? = nil,
-        completion: ((Result<T, {{ spec.title | caseUcfirst}}Error>) -> Void)? = nil
-    ) {
-        if bufferSink == nil {
-            http.execute(
-                request: request,
-                delegate: ResponseAccumulator(request: request)
-            ).futureResult.whenComplete( { result in
-                complete(with: result)
-            })
-            return
-        }
-
-        http.execute(
-            request: request,
-            delegate: StreamingDelegate(request: request, sink: bufferSink)
-        ).futureResult.whenComplete { result in
-            complete(with: result)
-        }
-
-        func complete(with result: Result<HTTPClient.Response, Swift.Error>) {
-            guard let completion = completion else {
-                return
-            }
-
-            switch result {
-            case .failure(let error): 
-                completion(.failure({{ spec.title | caseUcfirst}}Error(
-                    message: error.localizedDescription
-                )))
-            case .success(var response):
-                switch response.status.code {
-                case 0..<400:
-                    if response.cookies.count > 0 {
-                        UserDefaults.standard.set(
-                            try! response.cookies.toJson(),
-                            forKey: "\(response.host)-cookies"
-                        )
-                    }
-                    switch T.self {
-                    case is Bool.Type:
-                        completion(.success(true as! T))
-                    case is ByteBuffer.Type:
-                        completion(.success(response.body! as! T))
-                    default:
-                        if response.body == nil {
-                            completion(.success(true as! T))
-                            return
-                        }
-                        let dict = try! JSONSerialization
-                            .jsonObject(with: response.body!) as? [String: Any]
-
-                        completion(.success(convert?(dict!) ?? dict! as! T))
-                    }
-                default:
-                    var message = ""
-                    var type = ""
-
-                    if response.body == nil {
-                        completion(.failure({{ spec.title | caseUcfirst }}Error(
-                            message: "Unknown error with status code \(response.status.code)",
-                            code: Int(response.status.code)
-                        )))
-                        return
-                    }
-
-                    do {
-                        let dict = try JSONSerialization
-                            .jsonObject(with: response.body!) as? [String: Any]
-
-                        message = dict?["message"] as? String
-                            ?? response.status.reasonPhrase
-                        
-                        type = dict?["type"] as? String ?? ""
-                    } catch {
-                        message =  response.body!.readString(length: response.body!.readableBytes)!
-                    }
-
-                    let error = {{ spec.title | caseUcfirst }}Error(
-                        message: message,
-                        code: Int(response.status.code),
-                        type: type
+        convert: (([String: Any]) -> T)? = nil
+    ) async throws -> T {
+        func complete(with response: HTTPClientResponse) async throws -> T {
+            switch response.status.code {
+            case 0..<400:
+                if response.headers["Set-Cookie"].count > 0 {
+                    UserDefaults.standard.set(
+                        response.headers["Set-Cookie"],
+                        forKey: URL(string: request.url)!.host! + "-cookies"
                     )
+                }
+                switch T.self {
+                case is Bool.Type:
+                    return true as! T
+                case is ByteBuffer.Type:
+                    return response.body as! T
+                default:
+                    let data = try await response.body.collect(upTo: Int.max)
+                    let dict = try JSONSerialization.jsonObject(with: data) as? [String: Any]
 
-                    completion(.failure(error))
+                    return convert?(dict!) ?? dict! as! T
                 }
+            default:
+                var message = ""
+                var data = try await response.body.collect(upTo: Int.max)
+                
+                do {
+                    let dict = try JSONSerialization.jsonObject(with: data) as? [String: Any]
+
+                    message = dict?["message"] as? String ?? response.status.reasonPhrase
+                } catch {
+                    message =  data.readString(length: data.readableBytes)!
+                }
+
+                throw {{ spec.title | caseUcfirst }}Error(
+                    message: message,
+                    code: Int(response.status.code)
+                )
             }
         }
+
+        if bufferSink == nil {
+            let response = try await http.execute(
+                request, 
+                timeout: .seconds(30)
+            )
+            return try await complete(with: response)
+        }
+
+        let response = try await http.execute(
+            request,
+            timeout: .seconds(30)
+        )
+        return try await complete(with: response)
     }
 
     func chunkedUpload<T>(
@@ -385,60 +332,43 @@ open class Client {
         params: inout [String: Any?],
         paramName: String,
         convert: (([String: Any]) -> T)? = nil,
-        onProgress: ((UploadProgress) -> Void)? = nil,
-        completion: ((Result<T, {{ spec.title | caseUcfirst }}Error>) -> Void)? = nil
-    ) {
+        onProgress: ((UploadProgress) -> Void)? = nil
+    ) async throws -> T {
         let file = params[paramName] as! File
         let size = file.buffer.readableBytes
 
         if size < Client.chunkSize {
-            call(
+            return try await call(
                 method: "POST",
                 path: path,
                 headers: headers,
                 params: params,
-                convert: convert,
-                completion: completion
+                convert: convert
             )
-            return
         }
 
         var input = file.buffer
         var offset = 0
         var result = [String:Any]()
-        let group = DispatchGroup()
 
         while offset < size {
             let slice = input.readSlice(length: Client.chunkSize)
                 ?? input.readSlice(length: Int(size - offset))
-            
+
             params[paramName] = File(
                 name: file.name,
                 buffer: slice!
             )
-            
-            headers["content-range"] = "bytes \(offset)-\(min((offset + Client.chunkSize) - 1, size))/\(size)"
 
-            group.enter()
+            headers["content-range"] = "bytes \(offset)-\(min((offset + Client.chunkSize) - 1, size))/\(size)"
 
-            call(
+            result = try await call(
                 method: "POST",
                 path: path,
                 headers: headers,
                 params: params,
                 convert: { return $0 }
-            ) { response in
-                switch response {
-                case let .success(map):
-                    result = map
-                    group.leave()
-                case let .failure(error):
-                    completion?(.failure(error))
-                    return
-                }
-            }
-            
-            group.wait()
+            )
 
             offset += Client.chunkSize
             headers["x-{{ spec.title | caseLower }}-id"] = result["$id"] as? String
@@ -451,10 +381,9 @@ open class Client {
             ))
         }
 
-        completion?(.success(convert!(result)))
+        return convert!(result)
     }
 
-
     private static func randomBoundary() -> String {
         var string = ""
         for _ in 0..<16 {
@@ -464,16 +393,16 @@ open class Client {
     }
 
     private func buildJSON(
-        _ request: inout HTTPClient.Request,
+        _ request: inout HTTPClientRequest,
         with params: [String: Any?] = [:]
     ) throws {
         let json = try JSONSerialization.data(withJSONObject: params, options: [])
 
-        request.body = .data(json)
+        request.body = .bytes(json)
     }
 
     private func buildMultipart(
-        _ request: inout HTTPClient.Request,
+        _ request: inout HTTPClientRequest,
         with params: [String: Any?] = [:],
         chunked: Bool = false
     ) {
@@ -528,7 +457,7 @@ open class Client {
             request.headers.add(name: "Content-Length", value: bodyBuffer.readableBytes.description)
         }
         request.headers.add(name: "Content-Type", value: "multipart/form-data;boundary=\"\(Client.boundary)\"")
-        request.body = .byteBuffer(bodyBuffer)
+        request.body = .bytes(bodyBuffer)
     }
 
     private func addUserAgentHeader() {

templates/swift/Sources/Extensions/HTTPClientRequest+Cookies.swift.twig

@@ -9,18 +9,19 @@ extension HTTPClient.Request {
     }
 }
 
+extension HTTPClientRequest {
+    public mutating func addDomainCookies() {
+        headers.addDomainCookies(for: URL(string: url)!.host!)
+    }
+}
+
 extension HTTPHeaders {
     public mutating func addDomainCookies(for domain: String) {
-        let cookieJson = UserDefaults.standard.string(forKey: "\(domain)-cookies")
-        let cookies: [HTTPClient.Cookie?]? = try? cookieJson?.fromJson(to: [HTTPClient.Cookie].self)
-            ?? [(try? cookieJson?.fromJson(to: HTTPClient.Cookie.self))]
-
-        var cookiesValue = ""
-        for cookie in cookies ?? [] {
-            if let cookie = cookie {
-                cookiesValue += "\(cookie.name)=\(cookie.value);"
-            }
+        guard let cookies = UserDefaults.standard.stringArray(forKey: "\(domain)-cookies") else {
+            return
         }
-        add(name: "Cookie", value: cookiesValue)
-}
+        for cookie in cookies {
+            add(name: "Cookie", value: cookie)
+        }
+    }
 }