Grid with Map items does not coalesce multiple refreshItem() calls by DataProvider.getId()

[evgeni-uv]

Description

I am using a Grid<HashMap<String, Serializable>>. Each map contains an ID entry, and my custom DataProvider overrides getId() to return that stable ID.

When I call refreshItem(row), then mutate a value inside the same map instance, and call refreshItem(row) again within the same roundtrip, DataCommunicator can accumulate multiple pending updates for the same logical item.

The entries have the same DataProvider.getId() value, but they are not considered equal by the internal updatedData set in the DataCommunicator because hashCode() depends on the map contents. Since updatedData is a HashSet, mutating the map after it has been added changes its equality/hash behavior and allows the same logical item to appear more than once.

This can lead to inconsistent frontend updates: the client may receive multiple updates for the same item ID with different values, so an older state may override a newer one.

Question: Is this expected behavior, or should DataCommunicator deduplicate pending item updates based on DataProvider.getId() instead of relying on the item instance’s equals() / hashCode()?

Expected outcome

Multiple refreshItem() calls for the same logical item, as identified by DataProvider.getId(), should be coalesced within the same roundtrip.

Only the latest state for that item ID should be sent to the client.

Minimal reproducible example

Steps to reproduce

Environment

Vaadin version: 24.9.5

Browsers

No response

[mshabarov]

Thanks for the issue! Could you please provide an example code that shows how do you use Grid<HashMap<...> and that shows how do you define id of the Grid's row. This is a bit unusual case where you use a collection directly for the Grid's row with IDs inside.

[evgeni-uv]

Yes, this example code shows the issue clearly:

When the user clicks multiple times on the refresh button, the cells value changes inconsistently.
(Tested on Vaadin 25.1.0)

@Route
public class MainView extends VerticalLayout {

    private static final String ID_KEY = "id_key";
    private static final String ID_VALUE = "id_value";
    private static final String ID_RANDOM = "id_random";

    Grid<Map<String, Serializable>> grid;
    Map<String, Serializable> singleItem = new HashMap<>(Map.of(ID_KEY, "key1", ID_VALUE, "value1"));

    public MainView() {
        Button button = new Button("Refresh Values", e -> refreshValues());

        grid = new Grid<>();
        grid.setAllRowsVisible(true);

        grid.addColumn(item -> item.get(ID_KEY)).setHeader("Key");
        grid.addColumn(item -> item.get(ID_VALUE)).setHeader("Value");

        MapDataProvider dataProvider = new MapDataProvider(List.of(singleItem));
        grid.setDataProvider(dataProvider);

        add(button, grid);
    }

    private void refreshValues() {
        final Map<String, Serializable> modifiedItem1 = new HashMap<>(singleItem);
        modifiedItem1.put(ID_VALUE, "refreshItem 1");

        final Map<String, Serializable> modifiedItem2 = new HashMap<>(singleItem);
        modifiedItem2.put(ID_VALUE, "refreshItem 2");

        // some random value-change, so hashCode() returns different values on every button click
        modifiedItem1.put(ID_RANDOM, Math.random() * Integer.MAX_VALUE);
        modifiedItem2.put(ID_RANDOM, Math.random() * Integer.MAX_VALUE);

        grid.getDataProvider().refreshItem(modifiedItem1);
        grid.getDataProvider().refreshItem(modifiedItem2);
    }

    private static class MapDataProvider extends ListDataProvider<Map<String, Serializable>> {

        public MapDataProvider(Collection<Map<String, Serializable>> items) {
            super(items);
        }

        @Override
        public Object getId(Map<String, Serializable> item) {
            return item.get(ID_KEY);
        }

    }

}