fix: address PR review comments

- Remove redundant EndsAt assignment in types/types.go (res is already a copy of o)
- Fix overlap check to handle equal StartsAt timestamps using !Before instead of After
- Replace isUpdate check with more specific isResolving check that only allows
  merging when an alert is being resolved (endsAt set and old alert doesn't have
  it, or new endsAt is earlier than old endsAt), preventing arbitrary updates
  based solely on UpdatedAt timestamp

Fixes review comments from #4717

Signed-off-by: Andrew Leng <work@Andrews-MacBook-Air.local>

Author: tennisleng

provider/mem/mem.go

@@ -243,16 +243,20 @@ func (a *Alerts) Put(alerts ...*types.Alert) error {
 			existing = true
 
 			// Merge alerts if there is an overlap in activity range, or if
-			// the new alert is updating the existing alert (e.g., setting endsAt
-			// to resolve it, or updating annotations/labels).
-			hasOverlap := (alert.EndsAt.After(old.StartsAt) && alert.EndsAt.Before(old.EndsAt)) ||
-				(alert.StartsAt.After(old.StartsAt) && alert.StartsAt.Before(old.EndsAt))
+			// the new alert is resolving the existing alert.
+			// Overlap check: check if alert's time range overlaps with old's time range.
+			// Handle equal timestamps as overlapping (use !Before instead of After).
+			// An alert with zero EndsAt is considered active indefinitely.
+			hasOverlap := (!old.EndsAt.IsZero() && !alert.EndsAt.Before(old.StartsAt) && alert.EndsAt.Before(old.EndsAt)) ||
+				(!alert.StartsAt.Before(old.StartsAt) && (old.EndsAt.IsZero() || alert.StartsAt.Before(old.EndsAt)))
 
-			// Also merge if updating an existing alert (same fingerprint) to allow
-			// updates like setting endsAt to resolve an alert, even without overlap.
-			isUpdate := !alert.UpdatedAt.Before(old.UpdatedAt)
+			// Merge if the new alert is resolving the old alert (setting endsAt to resolve it).
+			// This handles the case where an alert is resolved via API without time overlap.
+			// An alert is being resolved if it has endsAt set and the old alert doesn't,
+			// or if the new endsAt is earlier than the old endsAt.
+			isResolving := !alert.EndsAt.IsZero() && (old.EndsAt.IsZero() || alert.EndsAt.Before(old.EndsAt))
 
-			if hasOverlap || isUpdate {
+			if hasOverlap || isResolving {
 				alert = old.Merge(alert)
 			}
 		}

types/types.go

@@ -455,7 +455,7 @@ func (a *Alert) Merge(o *Alert) *Alert {
 	if o.Resolved() {
 		// If the new alert is resolved, use its EndsAt timestamp.
 		// This handles the case where an alert is being resolved via API.
-		res.EndsAt = o.EndsAt
+		// Note: res.EndsAt is already o.EndsAt since res := *o above.
 		// The latest explicit resolved timestamp wins if both alerts are effectively resolved.
 		if a.Resolved() && a.EndsAt.After(o.EndsAt) {
 			res.EndsAt = a.EndsAt