ios – Name API for every merchandise in array after fetching objects from API

What I’ve now could be: the web page masses, the API known as and returns an inventory of things. When the API returns, I need to name the API for every particular person merchandise to request further information. I am caught on this final half.

Here’s what I’ve thus far.

struct MainView: View {
    @Atmosphere(.dismiss) var dismiss
    
    let supply: String
    let sourceId: String
    
    @EnvironmentObject var startupViewModel: StartupViewModel
    
    @StateObject var vm = PlaceViewModel(placeService: PlaceService())
    
    var physique: some View {
        NavigationView {
            ScrollView(showsIndicators: false) {
                VStack(spacing: 0) {
                    VStack(alignment: .main, spacing: 0) {
                        ScrollView(.horizontal, showsIndicators: false) {
                            LazyHStack {
                                ForEach(Array((vm.sights).enumerated()), id: .ingredient.id) { index, place in
                                    PlaceCardView(place: place)
                            }
                        }
                    }
                }
            }
            .job {
                vm.fetchPlace(supply: supply, sourceId: sourceId)
            }
            .onChange(of: vm.place != nil) {
                if let placeId = vm.place?.id {
                    vm.fetchAttractions(placeId: placeId, web page: 1)
                }
            }
        }
        .environmentObject(vm)
    }
}

As you’ll be able to see, when the web page masses I first name fetchPlace(). Then, when vm.place has modified, I name vm.fetchAttractions().

Right here is how these calls are being made for my part mannequin:

class PlaceViewModel: ObservableObject {
    personal var cancellables = Set()
    let placeService: PlaceServiceProtocol
    
    @Revealed var place: Place?
    @Revealed var sights: [Place] = []
    
    init(placeService: PlaceServiceProtocol) {
        self.placeService = placeService
    }
    
    func fetchPlace(supply: String, sourceId: String) {
        placeService.getPlace(supply: supply, sourceId: sourceId)
            .obtain(on: RunLoop.foremost)
            .sink(receiveCompletion: { information in
                print("Acquired:")
                print(information)
        }, receiveValue: {[weak self] information in
            self?.place = information.information?.place
        }).retailer(in: &cancellables)
        print(cancellables)
    }
    
    func fetchAttractions(placeId: Int, web page: Int, completion: ((_ response: [Place]) -> Void)? = nil) {
        placeService.getAttractions(placeId: placeId, web page: web page)
            .obtain(on: RunLoop.foremost)
            .sink(receiveCompletion: { information in
                print("Acquired (information)")
        }, receiveValue: {[weak self] information in
            guard let newAttractions = information.information?.sights else {
                return
            }
            
            if (newAttractions.isEmpty) {
                self?.hasMoreAttractions = false
            }
            
            self?.sights.append(contentsOf: newAttractions)
            
            completion?(newAttractions)
        }).retailer(in: &cancellables)
        print(cancellables)
    }
}

And right here is my community layer (from this tutorial):

protocol PlaceServiceProtocol {
    func getPlace(supply: String, sourceId: String) -> AnyPublisher
    func getAttractions(placeId: Int, web page: Int) -> AnyPublisher
}

class PlaceService: PlaceServiceProtocol {
    let apiClient = URLSessionAPIClient()
    
    func getPlace(supply: String, sourceId: String) -> AnyPublisher {
        return apiClient.request(.getPlace(supply: supply, sourceId: sourceId))
    }
    
    func getAttractions(placeId: Int, web page: Int) -> AnyPublisher {
        return apiClient.request(.getAttractions(placeId: placeId, web page: web page))
    }
}

enum PlaceEndpoint: APIEndpoint {
    case getPlace(supply: String, sourceId: String)
    case getAttractions(placeId: Int, web page: Int)
    
    var path: String {
        swap self {
        case .getPlace:
            return "/place/get"
        case .getAttractions:
            return "/place/sights/get"
        }
    }
    
    var technique: HTTPMethod {
        swap self {
        case .getPlace:
            return .submit
        case .getAttractions:
            return .submit
        }
    }
    
    var headers: [String: String]? {
        swap self {
        case .getPlace:
            return nil
        case .getAttractions:
            return nil
        }
    }
    
    var parameters: [String: Any]? {
        swap self {
        case .getPlace(let supply, let sourceId):
            return ["source": source, "source_id": sourceId]
        case .getAttractions(let placeId, let web page):
            return ["place_id": placeId, "page": page]
        }
    }
}

protocol APIClient {
    associatedtype EndpointType: APIEndpoint
    func request(_ endpoint: EndpointType) -> AnyPublisher
}

class URLSessionAPIClient: APIClient {
    func request(_ endpoint: EndpointType) -> AnyPublisher {
        let url = URL(string: BuildConfiguration.shared.baseURL)!.appendingPathComponent(endpoint.path)
        var request = URLRequest(url: url)
        
        let keychain = KeychainSwift()
        
        request.httpMethod = endpoint.technique.rawValue
        
        request.addValue("utility/json", forHTTPHeaderField: "Content material-Kind")
        request.addValue("utility/json", forHTTPHeaderField: "Settle for")
        
        // Authorization
        request.addValue("Bearer " + (keychain.get("token") ?? ""), forHTTPHeaderField: "Authorization")
        
        do {
            // convert parameters to Knowledge and assign dictionary to httpBody of request
            request.httpBody = strive JSONSerialization.information(withJSONObject: endpoint.parameters ?? [], choices: .prettyPrinted)
        } catch let error {
            print(error.localizedDescription)
        }
        
        endpoint.headers?.forEach { request.addValue($0.worth, forHTTPHeaderField: $0.key) }
        
        return URLSession.shared.dataTaskPublisher(for: request)
            .subscribe(on: DispatchQueue.world(qos: .background))
            .tryMap { information, response -> JSONDecoder.Enter in
                print(response)
                guard let httpResponse = response as? HTTPURLResponse,
                      (200...299).incorporates(httpResponse.statusCode) else {
                    throw APIError.invalidResponse
                }
                return information
            }
            .decode(sort: T.self, decoder: JSONDecoder())
            .eraseToAnyPublisher()
    }
}

After fetchAttractions() known as, I need to name the API once more to fetch further information for every attraction within the checklist.

What’s the easiest way to do that? I’ve tried looping by means of every attraction inside fetchAttractions() nevertheless I skilled lag whereas scrolling.