Conflict Resolution

Conflict Resolution System

Version: 0.9.1 Status: Complete Last Updated: 2026-02-03

Overview

The Conflict Resolution System provides comprehensive conflict detection and resolution for offline edits and multi-device synchronization. It supports multiple resolution strategies and handles edge cases gracefully.

Architecture

Components

┌─────────────────────────────────────────────────────────┐
│                  Conflict Resolution                     │
├─────────────────────────────────────────────────────────┤
│                                                           │
│  ┌────────────────────────────────────────────────┐     │
│  │      ConflictResolutionService                 │     │
│  │  - Conflict detection                          │     │
│  │  - Strategy selection                          │     │
│  │  - Conflict resolution                         │     │
│  │  - History tracking                            │     │
│  └────────────────────────────────────────────────┘     │
│                         │                               │
│           ┌─────────────┼─────────────┐                │
│           │             │             │                 │
│  ┌────────▼──────┐ ┌────▼──────┐ ┌──▼────────┐       │
│  │   Settings    │ │   Sync    │ │  Offline  │       │
│  │     Sync      │ │  Service  │ │   Queue   │       │
│  │    Service    │ │           │ │           │       │
│  └───────────────┘ └───────────┘ └───────────┘       │
│                                                         │
│  ┌────────────────────────────────────────────────┐   │
│  │              UI Components                      │   │
│  │  - ConflictDialog                              │   │
│  │  - ConflictHistory                             │   │
│  │  - SyncStatusIndicator                         │   │
│  └────────────────────────────────────────────────┘   │
│                                                         │
└─────────────────────────────────────────────────────────┘

Conflict Types

1. Message Conflicts

Message Edit

Scenario: Same message edited offline by multiple users
Detection: Compare content hash and timestamps
Default Strategy: last-write-wins
Severity: Medium

Message Delete

Scenario: Message deleted while offline edits pending
Detection: Local edit exists but remote is deleted
Default Strategy: manual
Severity: Critical

2. Channel Conflicts

Channel Settings

Scenario: Channel name, description, or permissions changed
Detection: Compare settings version
Default Strategy: server-wins
Severity: Critical

3. Settings Conflicts

User Settings

Scenario: Settings changed on multiple devices
Detection: Compare version numbers
Default Strategy: merge
Severity: Low to High (depends on fields)

Critical Settings Fields:

privacy.onlineStatusVisible
privacy.lastSeenVisible
privacy.profileVisible
notifications.quietHoursEnabled

4. File Conflicts

File Upload

Scenario: Same file uploaded multiple times
Detection: Compare file hash
Default Strategy: last-write-wins
Severity: Low

5. Thread Conflicts

Thread Reply

Scenario: Thread modified while offline
Detection: Compare thread version
Default Strategy: last-write-wins
Severity: Medium

Resolution Strategies

1. Last-Write-Wins (LWW)

// Most recent timestamp wins
const resolution = resolveLastWriteWins(entity)

Use Cases:

Message edits
File uploads
Thread replies
Non-critical updates

Pros:

Simple and deterministic
No user intervention required
Fast resolution

Cons:

May lose data if older change is more important
Doesn't consider semantic meaning

2. Server-Wins

// Server version always wins
const resolution = {
  resolvedData: entity.remoteData,
}

Use Cases:

Permissions and roles
Channel settings
Security-sensitive data
Administrative changes

Pros:

Maintains authority of server
Prevents privilege escalation
Simple to implement

Cons:

Local changes always discarded
May frustrate users

3. Client-Wins

// Local version always wins
const resolution = {
  resolvedData: entity.localData,
}

Use Cases:

User preferences
Draft messages
Temporary data
UI state

Pros:

User's intent preserved
Good for user-specific data

Cons:

May conflict with server state
Not suitable for shared data

4. Merge

// Intelligent merge of both versions
const resolution = mergeObjects(local, remote)

Use Cases:

Settings synchronization
Non-conflicting field updates
Additive changes (arrays, sets)

Pros:

Preserves changes from both sides
Best user experience
Minimal data loss

Cons:

Complex to implement
May produce unexpected results
Some conflicts still need manual resolution

Merge Algorithm:

function mergeObjects(local: object, remote: object): object {
  const merged = {}

  for (const key in { ...local, ...remote }) {
    const localValue = local[key]
    const remoteValue = remote[key]

    // Only one side has value
    if (localValue === undefined) {
      merged[key] = remoteValue
    } else if (remoteValue === undefined) {
      merged[key] = localValue
    }

    // Both have same value
    else if (deepEqual(localValue, remoteValue)) {
      merged[key] = localValue
    }

    // Nested objects - recurse
    else if (isObject(localValue) && isObject(remoteValue)) {
      merged[key] = mergeObjects(localValue, remoteValue)
    }

    // Arrays - union
    else if (isArray(localValue) && isArray(remoteValue)) {
      merged[key] = [...new Set([...localValue, ...remoteValue])]
    }

    // Primitives - remote wins
    else {
      merged[key] = remoteValue
    }
  }

  return merged
}

5. Manual

// User must choose resolution
const resolution = {
  resolvedData: remoteData, // Default
  requiresUserAction: true,
}

Use Cases:

Critical conflicts
Security-sensitive changes
Large differences
Unresolvable conflicts

Pros:

User has full control
No data loss without consent
Transparent process

Cons:

Requires user intervention
Delays synchronization
May be confusing for users

Settings Sync

Settings Categories

interface UserSettings {
  theme: ThemeSettings // CLIENT_WINS
  notifications: NotificationSettings // MERGE
  privacy: PrivacySettings // SERVER_WINS
  accessibility: AccessibilitySettings // CLIENT_WINS
  locale: LocaleSettings // CLIENT_WINS
  keyboardShortcuts: KeyboardShortcutSettings // CLIENT_WINS
}

Merge Rules

Privacy Settings (Server Wins)

merged.privacy = remote.privacy

Reason: Security-sensitive, prevent privilege escalation

Notification Settings (Merge)

merged.notifications = {
  ...remote.notifications,
  ...local.notifications,
  quietHoursEnabled: local.quietHoursEnabled || remote.quietHoursEnabled,
}

Reason: Most restrictive notification settings win

Theme Settings (Client Wins)

merged.theme = local.theme

Reason: User preference, device-specific

Locale Settings (Client Wins)

merged.locale = local.locale

Reason: Device-specific, regional preferences

Conflict Detection Algorithm

function detectSettingsConflict(
  local: UserSettings,
  remote: UserSettings,
  localVersion: number,
  remoteVersion: number
): ConflictDetectionResult {
  // Version mismatch
  if (localVersion !== remoteVersion) {
    const severity = calculateSeverity(local, remote)
    return {
      hasConflict: true,
      severity,
      suggestedStrategy: severity === 'critical' ? 'manual' : 'merge',
    }
  }

  // Content mismatch
  if (JSON.stringify(local) !== JSON.stringify(remote)) {
    return {
      hasConflict: true,
      severity: 'low',
      suggestedStrategy: 'merge',
    }
  }

  // No conflict
  return { hasConflict: false, severity: 'low' }
}

Critical Conflict Detection

function hasCriticalSettingsConflict(local: UserSettings, remote: UserSettings): boolean {
  const criticalFields = [
    'privacy.onlineStatusVisible',
    'privacy.profileVisible',
    'privacy.lastSeenVisible',
  ]

  for (const field of criticalFields) {
    const [category, key] = field.split('.')
    if (local[category][key] !== remote[category][key]) {
      return true
    }
  }

  return false
}

Edge Cases

1. Concurrent Edits

Scenario: Two users edit the same message simultaneously while offline

Solution:

Detect conflict using timestamps
Apply last-write-wins strategy
Notify both users of conflict
Show conflict in history

2. Network Interruption During Sync

Scenario: Connection lost while syncing settings

Solution:

Transaction-based sync
Rollback on failure
Retry with exponential backoff
Local changes preserved
Sync status: error

3. Partial Sync

Scenario: Some settings synced, others failed

Solution:

Atomic sync per category
Track which categories synced
Retry failed categories
Show partial sync status

4. Invalid Settings Data

Scenario: Settings contain invalid values (schema mismatch)

Solution:

Validate settings before sync
Fallback to defaults for invalid fields
Log validation errors
Notify user of reset fields

function validateSettings(settings: unknown): UserSettings {
  const validated = { ...DEFAULT_USER_SETTINGS }

  for (const category in settings) {
    if (isValidCategory(category)) {
      try {
        validated[category] = validateCategory(category, settings[category])
      } catch (error) {
        console.error(`Invalid ${category} settings:`, error)
        // Keep default for invalid category
      }
    }
  }

  return validated
}

5. Settings Schema Version Mismatch

Scenario: App updated, new settings fields added

Solution:

Store schema version in settings metadata
Migrate old settings to new schema
Preserve unknown fields for backward compatibility

interface SettingsMetadata {
  schemaVersion: number
  lastSyncedAt: string
  lastSyncedDevice: string
}

function migrateSettings(
  settings: UserSettings,
  fromVersion: number,
  toVersion: number
): UserSettings {
  let migrated = { ...settings }

  for (let v = fromVersion; v < toVersion; v++) {
    migrated = migrations[v](migrated)
  }

  return migrated
}

6. Multiple Devices Syncing Simultaneously

Scenario: User has 3 devices, all sync at same time

Solution:

Use optimistic locking (version numbers)
First sync wins, others conflict
Retry with merged settings
Exponential backoff to prevent thundering herd

async function syncWithRetry(settings: UserSettings, maxRetries = 3): Promise<void> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      await syncSettings(settings)
      return
    } catch (error) {
      if (isVersionConflict(error)) {
        // Fetch latest, merge, retry
        const latest = await fetchLatestSettings()
        settings = mergeSettings(settings, latest)
        await delay(Math.pow(2, i) * 1000) // Exponential backoff
      } else {
        throw error
      }
    }
  }

  throw new Error('Max retries exceeded')
}

UI Components

ConflictDialog

Shows conflict details and allows user to choose resolution.

<ConflictDialog
  open={showConflict}
  onClose={() => setShowConflict(false)}
  conflict={detection}
  onResolve={(strategy, customData) => {
    resolveConflict(detection, strategy, customData)
  }}
  allowCustomResolution={true}
/>

Features:

Side-by-side diff view
Timestamp comparison
Version display
Strategy selection
Critical conflict warnings

ConflictHistory

Displays history of resolved conflicts.

<ConflictHistory filterType="user:settings" limit={50} showClearButton={true} />

Features:

Chronological list
Filter by type
View details
Resolution strategy badges
Clear history option

SyncStatusIndicator

Shows current sync status.

<SyncStatusIndicator
  status={syncStatus}
  lastSyncTimestamp={lastSync}
  conflictCount={conflicts.length}
  onSync={() => triggerSync()}
  variant="full"
  showConflicts={true}
/>

Features:

Status icon with color
Last sync time
Conflict count badge
Manual sync button
Multiple display variants

API Reference