Removing an array item from Firestore not working when array contains date

The problem is, as you noted, the Date field. And it's a problem because Firestore does not preserve the native Date object when it's stored in the database--they are converted into date objects native to Firestore. And the go-between these two data types is a token system. For example, when you write a date to Firestore from a Swift client, you actually send the database a token which is then redeemed by the server when it arrives which then creates the Firestore date object in the database. Conversely, when you read a date from Firestore on a Swift client, you actually receive a token which is then redeemed by the client which you then can convert into a Swift Date object. Therefore, the definition of "now" is not the same on the client as it is on the server, there is a discrepancy.

That said, in order to remove a specific item from a Firestore array, you must recreate that exact item to give to FieldValue.arrayRemove(), which as you can now imagine is tricky with dates. Unlike Swift, you cannot remove items from Firestore arrays by index. Therefore, if you want to keep your data architecture as is (because there is a workaround I will explain below), the safest way is to get the item itself from the server and pass that into FieldValue.arrayRemove(). You can do this with a regular read and then execute the remove in the completion handler or you can perform it atomically (safer) in a transaction.

let db = Firestore.firestore()

db.runTransaction { (trans, errorPointer) -> Any? in
    let doc: DocumentSnapshot
    let docRef = db.document("test/def")
    
    // get the document
    do {
        try doc = trans.getDocument(docRef)
    } catch let error as NSError {
        errorPointer?.pointee = error
        return nil
    }
    
    // get the items from the document
    if let items = doc.get("items") as? [[String: Any]] {
        
        // find the element to delete
        if let toDelete = items.first(where: { (element) -> Bool in
            
            // the predicate for finding the element
            if let number = element["number"] as? Int,
               number == 385 {
                return true
            } else {
                return false
            }
        }) {
            // element found, remove it
            docRef.updateData([
                "items": FieldValue.arrayRemove([toDelete])
            ])
        }
    } else {
        // array itself not found
        print("items not found")
    }
    return nil // you can return things out of transactions but not needed here so return nil
} completion: { (_, error) in
    if let error = error {
        print(error)
    } else {
        print("transaction done")
    }
}

The workaround I mentioned earlier is to bypass the token system altogether. And the simplest way to do that is to express time as an integer, using the Unix timestamp. This way, the date is stored as an integer in the database which is almost how you'd expect it to be stored anyway. This makes locating array elements that contain dates simpler because time on the client is now equal to time on the server. This is not the case with tokens because the actual date that is stored in the database, for example, is when the token is redeemed and not when it was created.

You can extend Date to conveniently convert dates to timestamps and extend Int to conveniently convert timestamps to dates:

typealias UnixTimestamp = Int

extension Date {
    var unixTimestamp: UnixTimestamp {
        return UnixTimestamp(self.timeIntervalSince1970 * 1_000) // millisecond precision
    }
}

extension UnixTimestamp {
    var dateObject: Date {
        return Date(timeIntervalSince1970: TimeInterval(self / 1_000)) // must take a millisecond-precision unix timestamp
    }
}

One last thing is that in my example, I located the element to delete by its number field (I used your data), which I assumed to be a unique identifier. I don't know the nature of these elements and how they are uniquely identified so consider the filter predicate in my code to be purely an assumption.