Flutter FireStore New Update Method

[Peng-Qian]

Request

add new update method

Why

1. easier to use
2. safer to update (1. Type safe and 2. Firebase team deal and maintain the logic that what should be updated)
3. reduce cost (since it may avoid potential mistake)

How

It is great for adding withConverter() in the new API, and since the Firestore instance know the converter, I think to create another update method to allow user pass old data and new data directly will be much nicer (like current set() method).

It can automatically detect the difference and generate Map<String, dynamic> with FieldValue.delete().

  Future<void> updateData(T oldData, T newData) async {
      // convert oldData and newData to Map<String, dynamic>
      ...
      // get the absent field in newData compare to oldData (the fields that need to delete)
      ...
      // delete un-change data in map
      ...
      // call normal update
      return update(data);
  }

or can firebase expose the converter to allow us adding dart extension to do that

[stargazing-dino]

I'm not sure about this but I think set and update are both 1 write op. Therefore what you can do is make your models implement copyWith and just use that no?

@freezed
class Person with _$Person {
  factory Person({ String? name, int? age }) = _Person;

  // ...
}

final personsRef = FirebaseFirestore.instance.collection('persons').withConverter<Person>(/** */);

void main() async {
  final person = Person('foo', 22);
  final personDoc = personsRef.doc();

  await personDoc.set(person); // 1 write

  // Update person
  await personDoc.set(person.copyWith(age: 33));  // 1 write
}

I think if you want the updating only specific fields behavior you can optionally add SetOptions(merge: true) to .set.

Maybe I'm not fully understanding your intention with updateData however. Let me know

[Peng-Qian]

Thanks for you answer,

Currently I am doing something as above shows, and it is pretty much the same as the second approach that you mentioned.

Personally, I think it is worth to add this new method (or at least to expose the converter to allow us to add a extension for it) since it will not cause breaking changes and it definitely benefits both users(easy to use and maintain) and Firebase itself(reduce transferring data size).

[rrousselGit]

Are you maybe looking for a transaction?

final ref = ...collection('foo').withConverter<Model>();

final newModel = FirebaseFirestore.instance.runTransaction<Model>((transaction) async {
  final previousModel = await transaction.get(ref);
  final updatedValue = previousModel.copyWith(name: 'John');
  transaction.set(updatedValue);
  return updatedValue;
});

[Peng-Qian]

Hi @rrousselGit ,

transactions can do this job but I don't think it a good option for many cases.

the thing I trying to do is that when I update userProfile.address.postcode and delete userProfile.address.city, it will only send the following data to Firebase

{
 'address.postcode' : 'something', 
 'address.city' : FieldValue.delete(),
}

this will ensure only the desired changes be updated and also save some transferring data size.

And this is not required to use transaction but also not safe to update entire model since it may contain some filed should be updated by transaction or others users, such as likes or approved.

All in all, I wanna use the update method and I think it can be much easier to use if Firebase creates a new update method as above or expose the converters.

[rrousselGit]

The problem isn't that this wouldn't be useful, but rather that I don't see how this is possible to implement.

Dart doesn't have a concept of partial class, therefore we cannot pass to update only the properties of our choice and have to send the entire class.

But if we send the entire class, we can't know what to consider as an update and what to ignore. Because even if we assume "if the new value for a property is the same as the old one, skip", then that's not always true.

Since we're dealing with network requests and offline caches, it's very much possible that the local cache is out of sync with the server. So that could be a source of bugs and is probably a bit too magical.

[Peng-Qian]

Maybe I didn't explain well, what I trying to request is just another update method (e.g. updateDifference --- let's name it to distinguish late) on top of the current update method as the following shows.

  Future<void> updateDifference(T oldData, T newData) async {
      // convert oldData and newData to Map<String, dynamic>
      ...
      // get the absent field in newData compare to oldData (the fields that need to delete)
      ...
      // delete un-change data in map
      ...
      // call normal update
      return update(data);
  }

It is achievable since I currently implemented like following way

    await updateCase.when(
      userProfile: (oldUserProfile, newUserProfile) async {
        // get ref
        final reference = ...;
        // get Dto and serialize models
        final oldData = ProfileDto.fromModel(oldUserProfile).toJson(); // Firebase can take this job since it has the converter
        final newData = ProfileDto.fromModel(newUserProfile).toJson(); // Firebase can take this job since it has the converter
        // get difference and generate new Map that contained updated fields or ValueField.delete() 
        final modifiedData = getModifiedData(oldData: oldData, newData: newData); //  Just normal checking go through all entries
        // call Firebase update
        await reference.update(modifiedData);
      },
      post: (oldPost, newPost) async {
        // similar process
        ...
      },
      userContact: (oldUserContact, newUserContact) async {
        // similar process
        ...
      },
    );

If Firebase take the job marked above, the code will be much simple and easy to maintain since Firebase team deal the difference detection

    await updateCase.when(
      userProfile: (oldUserProfile, newUserProfile) async {
        // get ref with converter
        final reference = ...;
        await reference.updateDifference(oldUserProfile, newUserProfile);
      },
      post: (oldPost, newPost) async {
        // get ref with converter
        final reference = ...;
        await reference.updateDifference(oldPost, newPost);
      },
      userContact: (oldUserContact, newUserContact) async {
        // get ref with converter
        final reference = ...;
        await reference.updateDifference(oldUserContact, newUserContact);
      },
    );