grpc workaround2

workaroundrepository.swift

import Foundation
import Combine
import Resolver

class RESTFirestoreGalleryCollectionRepository: BaseCollectionRepository, GalleryCollectionRepository, ObservableObject {
    let objectsPath: String = "objects"
    let collectionsPath: String = "collections"
    
    private static let imageProcessingQueue = DispatchQueue(label: "image-processing")
    private var cancellables = Set<AnyCancellable>()
    
    override init() {
        super.init()
    }
    
    func asyncLoadCollection(_ id: String) -> AnyPublisher<Collection, Error> {
        
        guard let url = URL(string: "https://firestore.googleapis.com/v1/projects/YOUR_PROJECT/databases/(default)/documents/collections/\(id)") else {
            return Empty(completeImmediately: true)
                .eraseToAnyPublisher()
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = "GET"
        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
        request.addValue("application/json", forHTTPHeaderField: "Accept")
        
        return URLSession.shared.dataTaskPublisher(for: request)
            .map { $0.data }
            .decode(type: grpcCollection?.self, decoder: JSONDecoder())
            .map {
                $0?.collection
            }
            .subscribe(on: DispatchQueue.global(qos: .background))
            .flatMap { collection -> AnyPublisher<Collection, Error> in
                guard let collection = collection else {
                    return Empty(completeImmediately: true)
                        .eraseToAnyPublisher()
                }
                return self.asyncLoadObjects(for: collection)
            }
            .eraseToAnyPublisher()
    }
    
    private func asyncLoadObjects(for collection: Collection) -> AnyPublisher<Collection, Error> {
        let objectIds = collection.objectIds.map { "{\"stringValue\":\"\($0)\"}" }.joined(separator: ",")
        
        let compoundquery = """
            {"structuredQuery":{"from":[{"collectionId":"objects"}],"where":{"fieldFilter":{"field":{"fieldPath":"id"},"op":"IN","value":{"arrayValue":{"values":[\(objectIds)]}}}}}}
        """
        
        guard let url = URL(string: "https://firestore.googleapis.com/v1/projects/YOUR_PROJECT/databases/(default)/documents:runQuery") else {
            return Empty(completeImmediately: true)
                .eraseToAnyPublisher()
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.httpBody = compoundquery.data(using: .utf8)
        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
        request.addValue("application/json", forHTTPHeaderField: "Accept")
        
        return URLSession.shared.dataTaskPublisher(for: request)
            .map { $0.data }
            .decode(type: [grpcObjectResult].self, decoder: JSONDecoder())
            .map { $0.map { $0.document.object } }
            .subscribe(on: DispatchQueue.global(qos: .background))
            .flatMap { objects -> AnyPublisher<Collection, Error> in
                let updatedCollection = Collection(id: collection.id,
                                                   owner: collection.owner,
                                                   coverImage: collection.coverImage,
                                                   name: collection.name,
                                                   shortDescription: collection.shortDescription,
                                                   longDescription: collection.longDescription,
                                                   objectIds: collection.objectIds,
                                                   objects: objects)
                return Just(updatedCollection)
                    .setFailureType(to: Error.self)
                    .eraseToAnyPublisher()
            }
            .eraseToAnyPublisher()
    }
}