SwiftUI - Publish Background Thread Not Allowed - on code that does not update ui

Question

New to swiftui and don't understand why the JSONDecoder() line in the first code throws

[SwiftUI] Publishing changes from background threads is not allowed; make sure to publish values from the main thread (via operators like receive(on:)) on model updates.

This to me is not updating ui so why is this showing?

 do {
    // pass the request type, bearer token, and email / password ( which are sent as POST body params )
    let request = L.getRequest(requestType:"POST", token: token, email: self.username, password: self.psw)

    L.fetchData(from: request) { result in
        switch result {
        case .success(let data):
            // covert the binary data to a swift dictionary
            do {
                let response = try JSONDecoder().decode(WpJson.self, from: data)
                for (key, title) in response.allowedReadings {
                    let vimeoId = Int( key )!
                    let vimeoUri = self.buildVimeoUri(vimeoId: key)
                    self.addReadingEntity(vimeoUri: vimeoUri, vimeoId: vimeoId, title: title)
                }
                self.writeToKeychain(jwt:response.jwt, displayName: response.displayName)
                readings = self.fetchReadings()
            }
            catch {
                self.error = error.localizedDescription
            }
        case .failure(let error):
            self.error = error.localizedDescription
        }
    }
}

I tried wrapping a main queue around the do-catch in the L.fetchData(from: request) { result in but this did not help

DispatchQueue.main.async { [weak self] in 

Here is the Login protocol, again without any ui work:

import Foundation
import SwiftUI

struct Login: Endpoint {
    var url: URL?
    init(url: URL?) {
        self.url = url
    }
}

protocol Endpoint {
    var url: URL? { get set }
    init(url: URL?)
}

extension Endpoint {
    func getRequestUrl() -> URLRequest {
        guard let requestUrl = url else { fatalError() }
        // Prepare URL Request Object
        return URLRequest(url: requestUrl)
    }
    
    func getRequest(requestType:String="POST", token:String, email:String="", password:String="") -> URLRequest {
        var request = self.getRequestUrl()
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.addValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
        
        if ( "" != email && "" != password && requestType == "POST") {
            let parameters:[String:String?] =  [
                "email": email,
                "password": password
            ]
            
            // Run the request
            do {
                // pass dictionary to nsdata object and set it as request body
                request.httpBody = try JSONSerialization.data(withJSONObject: parameters, options: .prettyPrinted)
            } catch let error {
                print(error.localizedDescription)
            }
        }
        return request;
    }
    
    func fetchData(from request: URLRequest, completion: @escaping (Result<Data, NetworkError>) -> Void) {
        
         URLSession.shared.dataTask(with: request) { data, response, error in
            if let data = data {
                completion(.success(data))
           } else if error != nil {
                // any sort of network failure
                completion(.failure(.requestFailed))
           } else {
                // this ought not to be possible, yet here we are
                completion(.failure(.unknown))
           }
        }.resume()
    }
}

extension URLSession {
    func dataTask(with request: URLRequest, completionHandler: @escaping (Result<(Data, HTTPURLResponse), Error>) -> Void) -> URLSessionDataTask {
        return dataTask(with: request, completionHandler: { (data, urlResponse, error) in
            if let error = error {
                completionHandler(.failure(error))
            } else if let data = data, let urlResponse = urlResponse as? HTTPURLResponse {
                completionHandler(.success((data, urlResponse)))
            }
        })
    }
}

Do you have any idea on how to fix this?

Answer 1

Wrap it right in place of assignment

        catch {
            DispatchQueue.main.async {
             self.error = error.localizedDescription
            }
        }
    case .failure(let error):
       DispatchQueue.main.async {
          self.error = error.localizedDescription
       }
    }