ref.child ('route'). update Duplicate queries

Hello @Nery Ortez first, thank you very much for answering, giving a bit of retro to the points you indicate ...

Previous revisions are no problem because in Firebase I eliminated all the Cloud Functions to focus on this problem so this code is the only one I have.

Turning to the recommendation and testing the code you send me now the code is in an infinite loop which only stops when you mark a timeout.

Google's documentation indicates that the Promise is used to control an asynchronous call and the structure you send me see it correctly.

Any ideas why this is happening?

Previous reviews:

Now, I see that you have two problems with your function:

About using Promises

As you can read in the documentation , asynchronous functions should return null , an object or a promise ( Promise ). That way the server knows when the function is over.

Even if with the previous points you have fixed your problem, I strongly recommend that you return a promise in your function. I'll explain:

In your case, with the penultimate line of code return event.eventId; denotes that your function has ended ... But beware! The next call is asynchronous:

chats_bg.on('value', function(snapshot2) // Buscar valores en la Base de Datos
{
// ... No se ejecuta inmediatamente. Se espera a que la Base de Datos responda.
});

Which means that the end of the function will be reached before the above is executed.

As proof of this, in your log you can see that the termination message finished with status: 'ok' , but still logs are still displayed.

What happens is:

About writing /chats/broadcast_groups

Agree to the documentation if you use ref.on('value', ...) the callback will trigger for each change in the reference:

  

This method starts when the listener is attached and again every time the data changes (including secondary ones).

Something like this is happening:

To avoid this you must read the data only once using the once() method. Take into account that once() , unlike on() , returns a Promise with the data read.

The following code should fix both problems:

exports.DeleteUserCirculo = functions.database.ref('/users/{pushId}').onUpdate((snapshot, event) => {

  var after = snapshot.after.val();
  var cambio = after.status;
  console.log("El usuario con ID: ", after.id, "se le aplicará la regla ", after.status);


  var chats_bg = admin.database().ref('chats/broadcast_group');

  // Devolvemos una promesa que se resuelva cuando se termine la
  // actualizacion del broadcast.
  return chats_bg.once('value').then((snapshot2) => {
    let broad = snapshot2.val();
    let promesas = []; // Un array para guardar todas las promesas

    for (let c in broad) {
      console.log("esta es la vuelta", c);

      if (broad[c].type == 'broadcast_group' && broad[c].creatorUserId == after.id) {
        console.log("esta es la vuelta dentro del if", c);
        promesas.push(actualizatatusbroadcast(broad[c].id, cambio));
        // 'actualizatatusbroadcast' devuelve un Promise, guardamos todas las promesas
        // en un array para que se resuelvan juntas.
      }
    }

    return Promise.all(promesas);
    // Promise.all espera a que todas las promesas se cumplan para resolverse
  });
});

function actualizatatusbroadcast(broad, cambio) {
  const ref = admin.database().ref();
  // retornamos el Promise que se devuelve con 'update'
  return ref.child('chats/broadcast_group/' + broad).update(
    {
      status: cambio
    }
  );
}

We use the promise returned by once() to return the internal promises.

With the above, the server will not stop the promise until the update promises are resolved (or until the timeout is reached).

The previous code should be self-explanatory, but if you still have doubts, check the documentation that I linked you above.