Google Firestore - como obter documentos por vários ids em uma viagem de ida e volta?

Gostaria de saber se é possível obter vários documentos por lista de ids em uma viagem de ida e volta (chamada de rede) para o Firestore.

se você estiver dentro do Node:

https://github.com/googleapis/nodejs-firestore/blob/master/dev/src/index.ts#L701

/**
* Retrieves multiple documents from Firestore.
*
* @param {...DocumentReference} documents - The document references
* to receive.
* @returns {Promise<Array.<DocumentSnapshot>>} A Promise that
* contains an array with the resulting document snapshots.
*
* @example
* let documentRef1 = firestore.doc('col/doc1');
* let documentRef2 = firestore.doc('col/doc2');
*
* firestore.getAll(documentRef1, documentRef2).then(docs => {
*   console.log(`First document: ${JSON.stringify(docs[0])}`);
*   console.log(`Second document: ${JSON.stringify(docs[1])}`);
* });
*/

Isso é especificamente para o SDK do servidor

ATUALIZAÇÃO: "Cloud Firestore [client-side sdk] agora oferece suporte a consultas IN!"

https://firebase.googleblog.com/2019/11/cloud-firestore-now-supports-in-queries.html

myCollection.where(firestore.FieldPath.documentId(), 'in', ["123","456","789"])

Eles acabaram de anunciar essa funcionalidade, https://firebase.googleblog.com/2019/11/cloud-firestore-now-supports-in-queries.html .

Agora você pode usar consultas como, mas lembre-se de que o tamanho da entrada não pode ser maior que 10.

userCollection.where('uid', 'in', ["1231","222","2131"])

Não, no momento não há como agrupar várias solicitações de leitura usando o SDK do Cloud Firestore e, portanto, não há como garantir que você possa ler todos os dados de uma vez.

No entanto, como Frank van Puffelen disse nos comentários acima, isso não significa que buscar 3 documentos será 3x mais lento do que buscar um documento. É melhor realizar suas próprias medições antes de chegar a uma conclusão aqui.

Na prática, você usaria firestore.getAll assim

async getUsers({userIds}) {
    const refs = userIds.map(id => this.firestore.doc(`users/${id}`))
    const users = await this.firestore.getAll(...refs)
    console.log(users.map(doc => doc.data()))
}

ou com sintaxe de promessa

getUsers({userIds}) {
    const refs = userIds.map(id => this.firestore.doc(`users/${id}`))
    this.firestore.getAll(...refs).then(users => console.log(users.map(doc => doc.data())))
}

Você poderia usar uma função como esta:

function getById (path, ids) {
  return firestore.getAll(
    [].concat(ids).map(id => firestore.doc(`${path}/${id}`))
  )
}

Ele pode ser chamado com um único ID:

getById('collection', 'some_id')

ou uma matriz de IDs:

getById('collection', ['some_id', 'some_other_id'])

Certamente, a melhor maneira de fazer isso é implementando a consulta real do Firestore em um Cloud Function. Haveria então apenas uma única chamada de ida e volta do cliente para o Firebase, que parece ser o que você está pedindo.

Você realmente deseja manter toda a sua lógica de acesso a dados como este lado do servidor de qualquer maneira.

Internamente, provavelmente haverá o mesmo número de chamadas para o próprio Firebase, mas todas elas seriam através das interconexões super-rápidas do Google, ao invés da rede externa, e combinadas com o pipelining que Frank van Puffelen explicou, você deve obter um excelente desempenho esta abordagem.

Se estiver usando flutter, você pode fazer o seguinte:

Firestore.instance.collection('your collection name').where(FieldPath.documentId, whereIn:[list containing multiple document IDs]).getDocuments();

Isso retornará um Future contendo o List<DocumentSnapshot>qual você pode iterar conforme achar adequado.

Veja como você faria algo assim em Kotlin com o Android SDK.
Pode não ser necessariamente em uma viagem de ida e volta, mas efetivamente agrupa o resultado e evita muitos retornos de chamada aninhados.

val userIds = listOf("123", "456")
val userTasks = userIds.map { firestore.document("users/${it!!}").get() }

Tasks.whenAllSuccess<DocumentSnapshot>(userTasks).addOnSuccessListener { documentList ->
    //Do what you need to with the document list
}

Observe que buscar documentos específicos é muito melhor do que buscar todos os documentos e filtrar o resultado. Isso ocorre porque o Firestore cobra pelo conjunto de resultados da consulta.

Isso não parece ser possível no Firestore no momento. Não entendo por que a resposta de Alexander é aceita, a solução que ele propõe apenas retorna todos os documentos da coleção "usuários".

Dependendo do que você precisa fazer, você deve tentar duplicar os dados relevantes que você precisa exibir e só solicitar um documento completo quando necessário.

O melhor que você pode fazer é não usar Promise.allcomo seu cliente, então deve esperar pelas .allleituras antes de continuar.

Repita as leituras e deixe-as resolver de forma independente. No lado do cliente, isso provavelmente se resume à interface do usuário com várias imagens do carregador de progresso resolvidas para valores independentemente. No entanto, isso é melhor do que congelar todo o cliente até.all as leituras sejam resolvidas.

Portanto, despeje todos os resultados síncronos na exibição imediatamente e deixe os resultados assíncronos chegarem conforme eles são resolvidos, individualmente. Isso pode parecer uma distinção mesquinha, mas se o seu cliente não tiver conectividade com a Internet (como eu tenho atualmente nesta cafeteria), congelar toda a experiência do cliente por vários segundos provavelmente resultará em uma experiência 'este aplicativo é uma merda'.

Espero que isso ajude você, funciona para mim.

getCartGoodsData(id) {

    const goodsIDs: string[] = [];

    return new Promise((resolve) => {
      this.fs.firestore.collection(`users/${id}/cart`).get()
        .then(querySnapshot => {
          querySnapshot.forEach(doc => {
            goodsIDs.push(doc.id);
          });

          const getDocs = goodsIDs.map((id: string) => {
            return this.fs.firestore.collection('goods').doc(id).get()
              .then((docData) => {
                return docData.data();
              });
          });

          Promise.all(getDocs).then((goods: Goods[]) => {
            resolve(goods);
          });
        });
    });
  }