Dans rxjs, comment chaîner le mappage à travers des tableaux de données reçues de différentes API?

J'appelle une API et je reçois un tableau de résultats, je vérifie la pagination et s'il existe plus de pages, j'appelle la page suivante, répète jusqu'à ce qu'il n'y ait plus de pages.

Pour chaque tableau de résultats, j'appelle un autre point de terminaison et je fais exactement la même chose: je reçois un tableau de résultats, vérifie une autre page et appelle à nouveau le point de terminaison. Lavez, rincez et répétez.

Par exemple:

Je veux saisir une liste de pays qui pourraient être une réponse paginée, puis pour chaque pays, je veux saisir une liste de villes, qui pourrait également être paginé. Et pour chaque ville, j'exécute un ensemble de transformations puis je stocke dans une base de données.

J'ai déjà essayé ceci, mais je suis resté bloqué:

// grabCountries stays the same as above, but the rest is as follows:

const grabCities = (country) =>
  Observable.create(async (observer) => {
    const url = `http://api.com/${country}/cities`
      let cursor = url
      do {
       const results = fetch(cursor)

       // results = {
       //     data: [
       //         'Montreal', 'Toronto',
       //         'Paris', 'Marseilles',
       //         'Barcelona', 'Madrid'
       //     ],
       //     next: '89ghjg98nd8g8sdfg98gs9h868hfoig'
       // }

       results.data.forEach(city => {
         observer.next(city)
       })

    cursor = results.next ? `${url}/${results.next}` : undefined

    } while (cursor)
})

const multiCaster = new Subject()

grabCountries.subscribe(multiCaster)
multiCaster.pipe(map((country) => {
    grabCities(country).pipe(map(saveCityToDB)).subscribe()
})).subscribe()
multiCaster.pipe(map(saveCountryToDB)).subscribe()

J'ai essayé quelques approches:

Faire un sujet (parfois je 'll faudra faire une base traitée en parallèle sur les résultats de' grabCountries '. Par exemple, je peux vouloir stocker les pays dans une base de données en parallèle avec la saisie des villes.)

const intermediateSubject = new Subject()

intermediateSubject.subscribe(storeCountriesInDatabase)
intermediateSubject.subscribe(getCities)

J'ai aussi essayé le piping et le mapping, mais il semble que ce soit fondamentalement la même chose.

En écrivant ceci, j'ai pensé à cette solution et elle semble fonctionner correctement, j'aimerais juste savoir si Je rend cela trop compliqué. Il peut y avoir des cas où je dois faire plus que quelques appels d'API d'affilée. (Imagine, Countries => States => Cities => Boulangeries => Avis => Commentaires => Réponses) Donc, cette étrange cartographie sur un autre modèle de rappel d'observateur pourrait devenir désagréable.

C'est donc ce que j'ai maintenant en gros:

const grabCountries = Observable.create(async (observer) => {
    const url = 'http://api.com/countries'
    let cursor = url
    do {

        const results = fetch(cursor)

        // results = { 
        //   data: [ 'Canada', 'France', 'Spain' ],
        //   next: '47asd8f76358df8f4058898fd8fab'
        // }

        results.data.forEach(country => { observer.next(country) })

        cursor = results.next ? `${url}/${results.next}` : undefined

    } while(cursor)

})


const getCities = {
    next: (country) => {
        const url = 'http://api.com/cities'
        let cursor = url
        do {

            const results = fetch(cursor)

            // results = {
            //     data: [ 
            //         'Montreal', 'Toronto', 
            //         'Paris', 'Marseilles', 
            //         'Barcelona', 'Madrid' 
            //     ],
            //     next: '89ghjg98nd8g8sdfg98gs9h868hfoig'
            // }

            results.data.forEach(city => { 
                `**** What do I do here?? ****` 
            })

            cursor = results.next ? `${url}/${results.next}` : undefined

        } while(cursor)
    }
}

tl; dr - J'appelle une API qui reçoit un ensemble de résultats paginés dans un tableau et je dois mapper chaque élément et appeler une autre API qui en reçoit une autre ensemble paginé de résultats, chaque ensemble également dans un tableau.

Est-ce que l'imbrication d'une observable dans une autre et la cartographie des résultats via 'callApiForCountries.pipe (map (forEachCountryCallApiForCities))' la meilleure méthode ou en avez-vous d'autres recommandations?