Fix fixes for changes:

- previous fix of AI was bad beacuse it added all changes to database (delta file)

Author: MarcelGeo

server/mergin/sync/models.py

@@ -69,10 +69,12 @@ class ChangeComparisonAction(Enum):
     """Actions to take when comparing two changes"""
 
     REPLACE = "replace"
-    DELETE = "delete"
-    UPDATE = "update"
-    UPDATE_DIFF = "update_diff"
+    UPDATE_METADATA = "update"
+    REPLACE_DIFFS = "update_diff"
     EXCLUDE = "exclude"  # Return None to exclude the file
+    FORCE_UPDATE = (
+        "force_update"  # Force update even if it looks like a delete + create sequence
+    )
 
 
 class Project(db.Model):
@@ -1089,9 +1091,11 @@ def merge_changes(
                 continue
 
             # Compare and merge with previous change for this file
-            can_delete = path in updating_files
+            # If file did not exist before this range (first change was CREATE),
+            # a CREATE+DELETE sequence is transparent — exclude the pair.
+            exclude_delete = path not in updating_files
             new_change = ProjectVersionDelta._compare_changes(
-                result[path], current, can_delete
+                result[path], current, exclude_delete
             )
 
             # Update result (or remove if no change is detected)
@@ -1106,45 +1110,54 @@ def merge_changes(
     def _compare_changes(
         previous: DeltaChangeMerged,
         new: DeltaChangeMerged,
-        prevent_delete_change: bool,
+        exclude_delete: bool,
     ) -> Optional[DeltaChangeMerged]:
         """
         Compare and merge two changes for the same file.
 
         Args:
             previous: Previously accumulated change
             new: New change to compare
-            prevent_delete_change: Whether the change can be deleted when resolving create+delete sequences
+            exclude_delete: If True, a CREATE+DELETE pair is excluded (file was
+                created and deleted within the same range — no net effect).
+                If False, the DELETE is kept (file existed before this range
+                and the client needs to remove it).
 
         Returns:
             Merged change or None if file should be excluded
         """
 
         # Map change type pairs to actions
         action_map = {
-            # create + delete = file is transparent for current changes -> delete it
+            # CREATE + DELETE: if file didn't exist before (exclude_delete=True),
+            # the pair cancels out (EXCLUDE). If it did exist, keep the DELETE
+            # so the client removes its local copy.
             (
                 PushChangeType.CREATE,
                 PushChangeType.DELETE,
-            ): ChangeComparisonAction.DELETE,
+            ): (
+                ChangeComparisonAction.EXCLUDE
+                if exclude_delete
+                else ChangeComparisonAction.REPLACE
+            ),
             # create + update = create with updated info
             (
                 PushChangeType.CREATE,
                 PushChangeType.UPDATE,
-            ): ChangeComparisonAction.UPDATE,
+            ): ChangeComparisonAction.UPDATE_METADATA,
             (
                 PushChangeType.CREATE,
                 PushChangeType.UPDATE_DIFF,
-            ): ChangeComparisonAction.UPDATE,
+            ): ChangeComparisonAction.UPDATE_METADATA,
             (
                 PushChangeType.CREATE,
                 PushChangeType.CREATE,
-            ): ChangeComparisonAction.EXCLUDE,
+            ): ChangeComparisonAction.REPLACE,
             # update + update_diff = update with latest info
             (
                 PushChangeType.UPDATE,
                 PushChangeType.UPDATE_DIFF,
-            ): ChangeComparisonAction.UPDATE,
+            ): ChangeComparisonAction.UPDATE_METADATA,
             (
                 PushChangeType.UPDATE,
                 PushChangeType.UPDATE,
@@ -1161,7 +1174,7 @@ def _compare_changes(
             (
                 PushChangeType.UPDATE_DIFF,
                 PushChangeType.UPDATE_DIFF,
-            ): ChangeComparisonAction.UPDATE_DIFF,
+            ): ChangeComparisonAction.REPLACE_DIFFS,
             (
                 PushChangeType.UPDATE_DIFF,
                 PushChangeType.UPDATE,
@@ -1173,44 +1186,44 @@ def _compare_changes(
             (
                 PushChangeType.UPDATE_DIFF,
                 PushChangeType.CREATE,
-            ): ChangeComparisonAction.EXCLUDE,
+            ): ChangeComparisonAction.REPLACE,
             (
                 PushChangeType.DELETE,
                 PushChangeType.CREATE,
-            ): ChangeComparisonAction.REPLACE,
+            ): ChangeComparisonAction.FORCE_UPDATE,
             # delete + update = invalid sequence
             (
                 PushChangeType.DELETE,
                 PushChangeType.UPDATE,
-            ): ChangeComparisonAction.EXCLUDE,
+            ): ChangeComparisonAction.REPLACE,
             (
                 PushChangeType.DELETE,
                 PushChangeType.UPDATE_DIFF,
             ): ChangeComparisonAction.EXCLUDE,
             (
                 PushChangeType.DELETE,
                 PushChangeType.DELETE,
-            ): ChangeComparisonAction.EXCLUDE,
+            ): ChangeComparisonAction.REPLACE,
         }
 
         action = action_map.get((previous.change, new.change))
+
         result = None
         if action == ChangeComparisonAction.REPLACE:
             result = new
 
-        elif action == ChangeComparisonAction.DELETE:
-            # if change is create + delete, we can just remove the change from accumulated changes
-            # only if this action is allowed (file existed before)
-            if prevent_delete_change:
-                result = new
+        elif action == ChangeComparisonAction.FORCE_UPDATE:
+            # handle force update case, when previous change was delete and new change is create - just revert to update with new metadata
+            new.change = PushChangeType.UPDATE
+            result = new
 
-        elif action == ChangeComparisonAction.UPDATE:
+        elif action == ChangeComparisonAction.UPDATE_METADATA:
             # handle update case, when previous change was create - just revert to create with new metadata
             new.change = previous.change
             new.diffs = []
             result = new
 
-        elif action == ChangeComparisonAction.UPDATE_DIFF:
+        elif action == ChangeComparisonAction.REPLACE_DIFFS:
             new.diffs = (previous.diffs or []) + (new.diffs or [])
             result = new
 
@@ -1270,14 +1283,11 @@ def create_checkpoint(
         for delta in delta_range:
             changes.extend(DeltaChangeSchema(many=True).load(delta.changes))
 
-        # Compute merged result only to decide which FileDiff checkpoints to create.
-        # The raw (unmerged) changes are what gets stored — pre-merging would collapse
-        # DELETE+CREATE sequences into a single CREATE, losing the DELETE. When the
-        # outer merge_changes in get_delta_changes later combines adjacent checkpoints,
-        # that missing DELETE causes can_delete to be False, making CREATE+DELETE or
-        # CREATE+CREATE sequences produce EXCLUDE instead of DELETE or CREATE.
+        # Merge changes for compact storage and FileDiff checkpoint decisions.
+        merged_changes = cls.merge_changes(changes)
+
         merged_delta_items: List[DeltaChange] = [
-            d.to_data_delta() for d in cls.merge_changes(changes)
+            d.to_data_delta() for d in merged_changes
         ]
 
         # Pre-fetch data for all versioned files to create FileDiff checkpoints where it makes sense
@@ -1330,7 +1340,7 @@ def create_checkpoint(
             project_id=project_id,
             version=checkpoint.end,
             rank=checkpoint.rank,
-            changes=DeltaChangeSchema(many=True).dump(changes),
+            changes=DeltaChangeSchema(many=True).dump(merged_delta_items),
         )
         db.session.add(checkpoint_delta)
         db.session.commit()

server/mergin/tests/test_public_api_v2.py

@@ -568,20 +568,20 @@ def test_delta_cross_checkpoint_recreate_then_delete(client):
 
     Root cause: create_checkpoint pre-merges DELETE+CREATE to CREATE in chunk A,
     losing the DELETE. The outer merge then sees CREATE (chunk A) + DELETE (chunk B).
-    Because the stored CREATE did not populate updating_files, can_delete=False,
+    Because the stored CREATE did not populate updating_files, exclude_delete=True,
     so CREATE+DELETE maps to EXCLUDE rather than DELETE — the file is never
     removed from the client even though it no longer exists on the server.
 
     Setup:
-        v1–v4:  base.gpkg exists (client at v4 has the file, can_delete should be True)
+        v1–v4:  base.gpkg exists (client at v4 has the file, exclude_delete should be False)
         v5–v8:  base.gpkg DELETED at v5, RE-CREATED at v6
                 → rank-1 stores [CREATE(v6)] after pre-merging DELETE+CREATE
         v9–v12: base.gpkg DELETED at v9 (permanently gone)
                 → rank-1 stores [DELETE(v9)]
 
     get_delta_changes(4, 12) loads [CREATE(v6), DELETE(v9)]. The stored CREATE
-    from chunk A did not set can_delete, so the outer merge treats it as a fresh
-    creation. CREATE+DELETE with can_delete=False → EXCLUDE → returns [].
+    from chunk A did not set updating_files, so exclude_delete=True and
+    CREATE+DELETE → EXCLUDE → returns [].
 
     Expected: [DELETE] so the client removes the stale local copy of base.gpkg.
     """
@@ -617,7 +617,7 @@ def test_delta_cross_checkpoint_recreate_then_delete(client):
     assert base_gpkg is not None, (
         "base.gpkg missing from delta — cross-checkpoint pre-merge bug: "
         "DELETE(v5)+CREATE(v6) was collapsed to CREATE inside checkpoint(v5-v8), "
-        "then CREATE(v6)+DELETE(v9) hit CREATE+DELETE with can_delete=False→EXCLUDE "
+        "then CREATE(v6)+DELETE(v9) hit CREATE+DELETE with exclude_delete=True→EXCLUDE "
         "in the outer merge, so client is never told to remove the file"
     )
     assert base_gpkg.change == PushChangeType.DELETE
@@ -654,15 +654,15 @@ def test_project_version_delta_changes(client, diff_project: Project):
     # delete + create version
     delta = diff_project.get_delta_changes(1, 3)
     assert len(delta) == 1
-    assert delta[0].change == PushChangeType.CREATE
+    assert delta[0].change == PushChangeType.UPDATE
     # file was created in v3
     assert delta[0].version == 3
     assert delta[0].checksum == deltas[3].changes[0]["checksum"]
 
     # get_delta with update diff
     delta = diff_project.get_delta_changes(1, 4)
     assert len(delta) == 1
-    assert delta[0].change == PushChangeType.CREATE
+    assert delta[0].change == PushChangeType.UPDATE
     assert ProjectVersionDelta.query.filter_by(rank=1).count() == 0
 
     # create rank 1 checkpoint for v4