+77

src/Sync/ConflictDetector.php

··· 1 1 + <?php 2 2 + 3 3 + namespace SocialDept\AtpParity\Sync; 4 4 + 5 5 + use Illuminate\Database\Eloquent\Model; 6 6 + use SocialDept\AtpParity\Concerns\SyncsWithAtp; 7 7 + use SocialDept\AtpSchema\Data\Data; 8 8 + 9 9 + /** 10 10 + * Detects conflicts between local and remote record versions. 11 11 + */ 12 12 + class ConflictDetector 13 13 + { 14 14 + /** 15 15 + * Check if there's a conflict between local model and remote record. 16 16 + */ 17 17 + public function hasConflict(Model $model, Data $record, string $cid): bool 18 18 + { 19 19 + // No conflict if model doesn't have local changes 20 20 + if (! $this->modelHasLocalChanges($model)) { 21 21 + return false; 22 22 + } 23 23 + 24 24 + // No conflict if CID matches (same version) 25 25 + if ($this->getCid($model) === $cid) { 26 26 + return false; 27 27 + } 28 28 + 29 29 + return true; 30 30 + } 31 31 + 32 32 + /** 33 33 + * Check if the model has local changes since last sync. 34 34 + */ 35 35 + protected function modelHasLocalChanges(Model $model): bool 36 36 + { 37 37 + // Use trait method if available 38 38 + if ($this->usesTrait($model, SyncsWithAtp::class)) { 39 39 + return $model->hasLocalChanges(); 40 40 + } 41 41 + 42 42 + // Fallback: compare updated_at with a sync timestamp if available 43 43 + $syncedAt = $model->getAttribute('atp_synced_at'); 44 44 + 45 45 + if (! $syncedAt) { 46 46 + return true; 47 47 + } 48 48 + 49 49 + $updatedAt = $model->getAttribute('updated_at'); 50 50 + 51 51 + if (! $updatedAt) { 52 52 + return false; 53 53 + } 54 54 + 55 55 + return $updatedAt > $syncedAt; 56 56 + } 57 57 + 58 58 + /** 59 59 + * Get the CID from a model. 60 60 + */ 61 61 + protected function getCid(Model $model): ?string 62 62 + { 63 63 + $column = config('parity.columns.cid', 'atp_cid'); 64 64 + 65 65 + return $model->getAttribute($column); 66 66 + } 67 67 + 68 68 + /** 69 69 + * Check if a model uses a specific trait. 70 70 + * 71 71 + * @param class-string $trait 72 72 + */ 73 73 + protected function usesTrait(Model $model, string $trait): bool 74 74 + { 75 75 + return in_array($trait, class_uses_recursive($model)); 76 76 + } 77 77 + }

+70

src/Sync/ConflictResolution.php

··· 1 1 + <?php 2 2 + 3 3 + namespace SocialDept\AtpParity\Sync; 4 4 + 5 5 + use Illuminate\Database\Eloquent\Model; 6 6 + 7 7 + /** 8 8 + * Value object representing the result of conflict resolution. 9 9 + */ 10 10 + readonly class ConflictResolution 11 11 + { 12 12 + public function __construct( 13 13 + public bool $resolved, 14 14 + public string $winner, 15 15 + public ?Model $model = null, 16 16 + public ?PendingConflict $pending = null, 17 17 + ) {} 18 18 + 19 19 + /** 20 20 + * Check if the conflict was resolved. 21 21 + */ 22 22 + public function isResolved(): bool 23 23 + { 24 24 + return $this->resolved; 25 25 + } 26 26 + 27 27 + /** 28 28 + * Check if the conflict requires manual resolution. 29 29 + */ 30 30 + public function isPending(): bool 31 31 + { 32 32 + return ! $this->resolved && $this->pending !== null; 33 33 + } 34 34 + 35 35 + /** 36 36 + * Create resolution where remote wins. 37 37 + */ 38 38 + public static function remoteWins(Model $model): self 39 39 + { 40 40 + return new self( 41 41 + resolved: true, 42 42 + winner: 'remote', 43 43 + model: $model, 44 44 + ); 45 45 + } 46 46 + 47 47 + /** 48 48 + * Create resolution where local wins. 49 49 + */ 50 50 + public static function localWins(Model $model): self 51 51 + { 52 52 + return new self( 53 53 + resolved: true, 54 54 + winner: 'local', 55 55 + model: $model, 56 56 + ); 57 57 + } 58 58 + 59 59 + /** 60 60 + * Create pending resolution for manual review. 61 61 + */ 62 62 + public static function pending(PendingConflict $conflict): self 63 63 + { 64 64 + return new self( 65 65 + resolved: false, 66 66 + winner: 'manual', 67 67 + pending: $conflict, 68 68 + ); 69 69 + } 70 70 + }

+118

src/Sync/ConflictResolver.php

··· 1 1 + <?php 2 2 + 3 3 + namespace SocialDept\AtpParity\Sync; 4 4 + 5 5 + use Illuminate\Database\Eloquent\Model; 6 6 + use SocialDept\AtpParity\Contracts\RecordMapper; 7 7 + use SocialDept\AtpParity\Events\ConflictDetected; 8 8 + use SocialDept\AtpSchema\Data\Data; 9 9 + 10 10 + /** 11 11 + * Resolves conflicts between local and remote record versions. 12 12 + */ 13 13 + class ConflictResolver 14 14 + { 15 15 + /** 16 16 + * Resolve a conflict according to the specified strategy. 17 17 + */ 18 18 + public function resolve( 19 19 + Model $model, 20 20 + Data $record, 21 21 + array $meta, 22 22 + RecordMapper $mapper, 23 23 + ConflictStrategy $strategy 24 24 + ): ConflictResolution { 25 25 + return match ($strategy) { 26 26 + ConflictStrategy::RemoteWins => $this->applyRemote($model, $record, $meta, $mapper), 27 27 + ConflictStrategy::LocalWins => $this->keepLocal($model), 28 28 + ConflictStrategy::NewestWins => $this->compareAndApply($model, $record, $meta, $mapper), 29 29 + ConflictStrategy::Manual => $this->flagForReview($model, $record, $meta, $mapper), 30 30 + }; 31 31 + } 32 32 + 33 33 + /** 34 34 + * Apply the remote version, overwriting local changes. 35 35 + */ 36 36 + protected function applyRemote( 37 37 + Model $model, 38 38 + Data $record, 39 39 + array $meta, 40 40 + RecordMapper $mapper 41 41 + ): ConflictResolution { 42 42 + $mapper->updateModel($model, $record, $meta); 43 43 + $model->save(); 44 44 + 45 45 + return ConflictResolution::remoteWins($model); 46 46 + } 47 47 + 48 48 + /** 49 49 + * Keep the local version, ignoring remote changes. 50 50 + */ 51 51 + protected function keepLocal(Model $model): ConflictResolution 52 52 + { 53 53 + return ConflictResolution::localWins($model); 54 54 + } 55 55 + 56 56 + /** 57 57 + * Compare timestamps and apply the newest version. 58 58 + */ 59 59 + protected function compareAndApply( 60 60 + Model $model, 61 61 + Data $record, 62 62 + array $meta, 63 63 + RecordMapper $mapper 64 64 + ): ConflictResolution { 65 65 + $localUpdatedAt = $model->getAttribute('updated_at'); 66 66 + 67 67 + // Try to get remote timestamp from record 68 68 + $remoteCreatedAt = $record->createdAt ?? null; 69 69 + 70 70 + // If we can't compare, default to remote wins 71 71 + if (! $localUpdatedAt || ! $remoteCreatedAt) { 72 72 + return $this->applyRemote($model, $record, $meta, $mapper); 73 73 + } 74 74 + 75 75 + // Compare timestamps 76 76 + if ($localUpdatedAt > $remoteCreatedAt) { 77 77 + return $this->keepLocal($model); 78 78 + } 79 79 + 80 80 + return $this->applyRemote($model, $record, $meta, $mapper); 81 81 + } 82 82 + 83 83 + /** 84 84 + * Flag the conflict for manual review. 85 85 + */ 86 86 + protected function flagForReview( 87 87 + Model $model, 88 88 + Data $record, 89 89 + array $meta, 90 90 + RecordMapper $mapper 91 91 + ): ConflictResolution { 92 92 + // Create a pending conflict record 93 93 + $conflict = PendingConflict::create([ 94 94 + 'model_type' => get_class($model), 95 95 + 'model_id' => $model->getKey(), 96 96 + 'uri' => $meta['uri'] ?? null, 97 97 + 'local_data' => $model->toArray(), 98 98 + 'remote_data' => $this->buildRemoteData($record, $meta, $mapper), 99 99 + 'status' => 'pending', 100 100 + ]); 101 101 + 102 102 + // Dispatch event for notification 103 103 + event(new ConflictDetected($model, $record, $meta, $conflict)); 104 104 + 105 105 + return ConflictResolution::pending($conflict); 106 106 + } 107 107 + 108 108 + /** 109 109 + * Build the remote data array for storage. 110 110 + */ 111 111 + protected function buildRemoteData(Data $record, array $meta, RecordMapper $mapper): array 112 112 + { 113 113 + // Create a temporary model with the remote data 114 114 + $tempModel = $mapper->toModel($record, $meta); 115 115 + 116 116 + return $tempModel->toArray(); 117 117 + } 118 118 + }

+42

src/Sync/ConflictStrategy.php

··· 1 1 + <?php 2 2 + 3 3 + namespace SocialDept\AtpParity\Sync; 4 4 + 5 5 + /** 6 6 + * Strategy for resolving conflicts between local and remote changes. 7 7 + */ 8 8 + enum ConflictStrategy: string 9 9 + { 10 10 + /** 11 11 + * Remote (AT Protocol) is source of truth. 12 12 + * Local changes are overwritten. 13 13 + */ 14 14 + case RemoteWins = 'remote'; 15 15 + 16 16 + /** 17 17 + * Local database is source of truth. 18 18 + * Remote changes are ignored. 19 19 + */ 20 20 + case LocalWins = 'local'; 21 21 + 22 22 + /** 23 23 + * Compare timestamps and use the newest version. 24 24 + */ 25 25 + case NewestWins = 'newest'; 26 26 + 27 27 + /** 28 28 + * Flag conflict for manual review. 29 29 + * Neither version is applied automatically. 30 30 + */ 31 31 + case Manual = 'manual'; 32 32 + 33 33 + /** 34 34 + * Create from config value. 35 35 + */ 36 36 + public static function fromConfig(): self 37 37 + { 38 38 + $strategy = config('parity.conflicts.strategy', 'remote'); 39 39 + 40 40 + return self::tryFrom($strategy) ?? self::RemoteWins; 41 41 + } 42 42 + }

+127

src/Sync/PendingConflict.php

··· 1 1 + <?php 2 2 + 3 3 + namespace SocialDept\AtpParity\Sync; 4 4 + 5 5 + use Illuminate\Database\Eloquent\Model; 6 6 + use Illuminate\Database\Eloquent\Relations\MorphTo; 7 7 + 8 8 + /** 9 9 + * Model for storing pending conflicts requiring manual resolution. 10 10 + */ 11 11 + class PendingConflict extends Model 12 12 + { 13 13 + protected $guarded = []; 14 14 + 15 15 + protected $casts = [ 16 16 + 'local_data' => 'array', 17 17 + 'remote_data' => 'array', 18 18 + 'resolved_at' => 'datetime', 19 19 + ]; 20 20 + 21 21 + /** 22 22 + * Get the table name from config. 23 23 + */ 24 24 + public function getTable(): string 25 25 + { 26 26 + return config('parity.conflicts.table', 'parity_conflicts'); 27 27 + } 28 28 + 29 29 + /** 30 30 + * Get the related model. 31 31 + */ 32 32 + public function model(): MorphTo 33 33 + { 34 34 + return $this->morphTo(); 35 35 + } 36 36 + 37 37 + /** 38 38 + * Check if this conflict is pending. 39 39 + */ 40 40 + public function isPending(): bool 41 41 + { 42 42 + return $this->status === 'pending'; 43 43 + } 44 44 + 45 45 + /** 46 46 + * Check if this conflict has been resolved. 47 47 + */ 48 48 + public function isResolved(): bool 49 49 + { 50 50 + return $this->status === 'resolved'; 51 51 + } 52 52 + 53 53 + /** 54 54 + * Check if this conflict was dismissed. 55 55 + */ 56 56 + public function isDismissed(): bool 57 57 + { 58 58 + return $this->status === 'dismissed'; 59 59 + } 60 60 + 61 61 + /** 62 62 + * Resolve the conflict with the local version. 63 63 + */ 64 64 + public function resolveWithLocal(): void 65 65 + { 66 66 + $this->update([ 67 67 + 'status' => 'resolved', 68 68 + 'resolution' => 'local', 69 69 + 'resolved_at' => now(), 70 70 + ]); 71 71 + } 72 72 + 73 73 + /** 74 74 + * Resolve the conflict with the remote version. 75 75 + */ 76 76 + public function resolveWithRemote(): void 77 77 + { 78 78 + $model = $this->model; 79 79 + 80 80 + if ($model) { 81 81 + $model->fill($this->remote_data); 82 82 + $model->save(); 83 83 + } 84 84 + 85 85 + $this->update([ 86 86 + 'status' => 'resolved', 87 87 + 'resolution' => 'remote', 88 88 + 'resolved_at' => now(), 89 89 + ]); 90 90 + } 91 91 + 92 92 + /** 93 93 + * Dismiss this conflict without resolving. 94 94 + */ 95 95 + public function dismiss(): void 96 96 + { 97 97 + $this->update([ 98 98 + 'status' => 'dismissed', 99 99 + 'resolved_at' => now(), 100 100 + ]); 101 101 + } 102 102 + 103 103 + /** 104 104 + * Scope to pending conflicts. 105 105 + */ 106 106 + public function scopePending($query) 107 107 + { 108 108 + return $query->where('status', 'pending'); 109 109 + } 110 110 + 111 111 + /** 112 112 + * Scope to resolved conflicts. 113 113 + */ 114 114 + public function scopeResolved($query) 115 115 + { 116 116 + return $query->where('status', 'resolved'); 117 117 + } 118 118 + 119 119 + /** 120 120 + * Scope to conflicts for a specific model. 121 121 + */ 122 122 + public function scopeForModel($query, Model $model) 123 123 + { 124 124 + return $query->where('model_type', get_class($model)) 125 125 + ->where('model_id', $model->getKey()); 126 126 + } 127 127 + }