To efficiently handle this task, I make use of batched writes in my Firestore database implementation. Here's an example:

const jobSkillsRef = db.collection('job_skills').where('job_id', '==', post.job_id);
let batch = firestore.batch();

jobSkillsRef.get()
  .then(snapshot => {
    snapshot.docs.forEach(doc => {
      batch.delete(doc.ref);
    });
    return batch.commit();
  })

Alternatively, with ES6 async/await syntax:

const jobSkills = await store
  .collection('job_skills')
  .where('job_id', '==', post.job_id)
  .get();

const batch = store.batch();

jobSkills.forEach(doc => {
  batch.delete(doc.ref);
});

await batch.commit();

//This code snippet demonstrates how to locate and remove a document from firestore

const document = await this.noteRef.where('userId', '==', userId).get();
document.forEach(item => {
    item.ref.delete();
    console.log(`Document deleted: ${item.id}`);
});

One crucial element in Frank's response that resolved my issues was utilizing the .ref within doc.ref.delete()

Initially, I only had doc.delete(), which resulted in a "not a function" error. Now, after making this adjustment, my code appears like this and functions flawlessly:

let firestore = firebase.firestore();
let collectionReference = fs.collection(<your collection here>);

collectionReference.where("name", "==", name)
.get()
.then(querySnapshot => {
  querySnapshot.forEach((doc) => {
    doc.ref.delete().then(() => {
      console.log("Document successfully deleted!");
    }).catch(function(error) {
      console.error("Error removing document: ", error);
    });
  });
})
.catch(function(error) {
  console.log("Error getting documents: ", error);
});

give this a shot, assuming you already have the id

export const removeFile = (id) => {
return (dispatch) => {
    firebase.firestore()
    .collection("documents")
    .doc(id)
    .delete()
}

}

New possibility:

db.collection("cities").doc("DC").delete().then(function() {
    console.log("Document deleted successfully!");
}).catch(function(error) {
    console.error("Error while removing document: ", error);
});

To tackle this issue, I implemented a system where each document is assigned a uniqueID. By querying based on this field, I was able to retrieve the documentID of the specific document and utilize it for deletion. Here is how I accomplished this:

(Written in Swift)

func removeFriendRequest(request: Request) {
    DispatchQueue.global().async {
        self.db.collection("requests")
            .whereField("uniqueID", isEqualTo: request.uniqueID)
            .getDocuments { querySnapshot, error in
                if let e = error {
                    print("An error occurred while fetching the document: \(e)")
                } else {
                    self.db.collection("requests")
                        .document(querySnapshot!.documents.first!.documentID)
                        .delete() { err in
                            if let e = err {
                                print("An error occurred while deleting the document: \(e)")
                            } else {
                                print("Document successfully deleted!")
                            }
                        }
                }
            }
    }
}

Although there may be room for improvement in the code, this method worked well for me. Hopefully, it proves useful for others facing a similar challenge in the future!

Utilizing await/async can simplify the process:

exports.delete = functions.https.onRequest(async (req, res) => {
try {
    var jobskill_ref = db.collection('job_skills').where('job_id','==',post.job_id).get();
    jobskill_ref.forEach((doc) => {
      doc.ref.delete();
    });
  } catch (error) {
    return res.json({
      status: 'error', msg: 'Error while deleting', data: error,
    });
  }
});

The need to get(), loop, and then delete() each document individually may seem cumbersome compared to executing a single SQL-style query for deletion. Despite this, Google has set the current approach as the standard.

If you find yourself utilizing Cloud Firestore from the Client side, there's a convenient solution for generating unique keys by using packages/modules like uuid. This allows you to create an ID and then assign it to the document before saving it in Firestore along with a reference on the stored object.

For instance: Suppose you wish to store a person object in Firestore; initially, you can utilize uuid to create an ID for that individual as demonstrated below.

const uuid = require('uuid') 

const person = { name: "Jane Doe", age: 25}
const id = uuid() // generates a unique string ID
const personWithId = {person, id} 

export const saveToFirestore = async (person) => {
  await db.collection("people").doc(id).set(personWithId);
};

// To delete, retrieve the stored ID related to the object and execute the following firestore query

export const removeFromFirestore = async (id) => {
  await db.collection("people").doc(id).delete();
};

This method can be beneficial for those working with Firestore on the Client side.