v17/migrations - delegate tracking out of core.

uSync.BackOffice/Services/SyncService.cs

@@ -1,8 +1,5 @@
 using Microsoft.Extensions.Logging;
 
-using Org.BouncyCastle.Asn1.Ocsp;
-using Org.BouncyCastle.Tls;
-
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -26,6 +23,7 @@
 using uSync.BackOffice.SyncHandlers.Models;
 using uSync.Core;
 using uSync.Core.Extensions;
+using uSync.Core.Notifications;
 using uSync.Core.Serialization;
 
 namespace uSync.BackOffice;
@@ -297,6 +295,9 @@ public bool CleanExportFolder(string folder)
         {
             if (_syncFileService.DirectoryExists(folder))
                 _syncFileService.CleanFolder(folder);
+
+            // tell the migrations table to clean itself too. 
+            _eventAggregator.Publish(new SyncExportCleanNotification());
         }
         catch (Exception ex)
         {

uSync.Core/DataTypes/ConfigurationSerializerCollectionBuilder.cs

@@ -18,6 +18,7 @@ public ConfigurationSerializerCollection(Func<IEnumerable<IConfigurationSerializ
     {
     }
 
+    [Obsolete("Use GetSerializers instead to get all serializers for an editor alias, getting only the first is not recommended. will be removed in v19")]
     public IConfigurationSerializer? GetSerializer(string editorAlias)
         => this.FirstOrDefault(x => x.IsSerializer(editorAlias));
 
@@ -39,4 +40,19 @@ public IEnumerable<IConfigurationSerializer> GetSerializers(string editorAlias)
         }
         return null;
     }
+
+    /// <summary>
+    ///  tells serializers that care about it that this is a rename 
+    /// </summary>
+    /// <param name="oldEditorAlias"></param>
+    /// <param name="newEditorAlias"></param>
+    public async Task TrackRenamedEditorAsync(string oldEditorAlias, string newEditorAlias) {
+
+        foreach(var serializer in GetSerializers(oldEditorAlias))
+        {
+            if (serializer is IConfigurationTrackingSerializer trackingSerializer)
+                await trackingSerializer.TrackRenamedEditorAsync(oldEditorAlias, newEditorAlias);
+        }
+
+    }
 }

uSync.Core/DataTypes/IConfigurationSerializer.cs

@@ -35,3 +35,8 @@ Task<IDictionary<string, object>> GetConfigurationImportAsync(string name, IDict
     bool IsSerializer(string propertyName)
         => Editors.InvariantContains(propertyName);
 }
+
+public interface IConfigurationTrackingSerializer : IConfigurationSerializer
+{
+    Task TrackRenamedEditorAsync(string oldEditorAlias, string newEditorAlias);
+}

uSync.Core/Mapping/ISyncMapper.cs

@@ -9,6 +9,9 @@ public interface ISyncMapper
     string Name { get; }
     string[] Editors { get; }
 
+    bool IsMapper(string editorAlias) 
+        => Editors.Contains(editorAlias, StringComparer.OrdinalIgnoreCase);
+
     bool IsMapper(PropertyType propertyType);
 
     Task<string?> GetExportValueAsync(object value, string editorAlias);

uSync.Core/Mapping/SyncValueMapperBase.cs

@@ -28,6 +28,9 @@ public SyncValueMapperBase(IEntityService entityService)
 
     public abstract string[] Editors { get; }
 
+    public virtual bool IsMapper(string editorAlias)
+        => Editors.InvariantContains(editorAlias);
+
     public virtual bool IsMapper(PropertyType propertyType)
         => Editors.InvariantContains(propertyType.PropertyEditorAlias);
 

uSync.Core/Mapping/SyncValueMapperCollection.cs

@@ -6,29 +6,31 @@
 
 using uSync.Core.Cache;
 using uSync.Core.Extensions;
-using uSync.Core.Migrations;
+using uSync.Core.Mapping.Tracking;
+using uSync.Core.Tracking;
 
 namespace uSync.Core.Mapping;
 
 public class SyncValueMapperCollection
         : BuilderCollectionBase<ISyncMapper>
 {
-    private readonly ConcurrentDictionary<string, string> _customMappings = new(StringComparer.InvariantCultureIgnoreCase);
-    private readonly ISyncMigratedDataService _migratedDataService;
+    private readonly SyncMapperTrackerCollection _mapperTrackers;
 
+    private readonly ConcurrentDictionary<string, string> _customMappings = new(StringComparer.InvariantCultureIgnoreCase);
+
     public SyncEntityCache EntityCache { get; private set; }
 
     public SyncValueMapperCollection(
         SyncEntityCache entityCache,
         Func<IEnumerable<ISyncMapper>> items,
-        ISyncMigratedDataService migratedDataService)
+        SyncMapperTrackerCollection mapperTrackers)
         : base(items)
     {
         EntityCache = entityCache;
 
         // todo, load these from config. 
         _customMappings = [];
-        _migratedDataService = migratedDataService;
+        _mapperTrackers = mapperTrackers;
     }
 
     /// <summary>
@@ -37,21 +39,17 @@ public SyncValueMapperCollection(
     public IEnumerable<ISyncMapper> GetSyncMappers(string editorAlias)
     {
         var mappedAlias = GetMapperAlias(editorAlias);
-        return this.Where(x => x.Editors.InvariantContains(mappedAlias));
+        return this.Where(m => m.IsMapper(mappedAlias));
     }
 
     /// <summary>
-    ///  will get any mappers and any mappers associated with the editor alias that have been migrated (if any) 
+    ///  will get any mappers and any mappers that are tracked for the editor alias, this is important because
     ///  this allows us to support old mappers for a property editor, even if the property editor alias has changed.
     /// </summary>
     public async Task<IEnumerable<ISyncMapper>> GetImportingSyncMappers(string editorAlias)
     {
-        var mappers = new List<ISyncMapper>();
-        var importingAlias = await _migratedDataService.GetAsync(editorAlias);
-        if (importingAlias is not null)
-            mappers.AddRange(this.Where(x => x.Editors.InvariantContains(importingAlias.Orginal)));
-
-        return [.. mappers, ..GetSyncMappers(editorAlias)];
+        var mappers = await _mapperTrackers.GetMappersAsync(editorAlias);
+        return [.. mappers, .. GetSyncMappers(editorAlias)];
     }
 
     /// <summary>

uSync.Core/Mapping/Tracking/ISyncMapperTracker.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace uSync.Core.Mapping.Tracking;
+
+/// <summary>
+///  tracking for when editors might change. 
+/// </summary>
+/// <remarks>
+///  A tracker mapper can return additional ISyncMappers for an editor Alias
+///  typically we do this when migrations has tracked that a new editorAlias 
+///  was once an a different editor alias.
+/// </remarks>
+public interface ISyncMapperTracker
+{
+    Task<IEnumerable<ISyncMapper>> GetTrackingMappers(string editorAlias);
+}

uSync.Core/Mapping/Tracking/SyncMapperTrackerCollection.cs

@@ -0,0 +1,26 @@
+using Umbraco.Cms.Core.Composing;
+
+namespace uSync.Core.Mapping.Tracking;
+
+public class SyncMapperTrackerCollection
+    : BuilderCollectionBase<ISyncMapperTracker>
+{
+    public SyncMapperTrackerCollection(Func<IEnumerable<ISyncMapperTracker>> items)
+        : base(items)
+    { }
+
+    public async Task<IEnumerable<ISyncMapper>> GetMappersAsync(string editorAlias)
+    {
+        if (this.Count == 0) return Enumerable.Empty<ISyncMapper>();
+
+        var tasks = this.Select(x => x.GetTrackingMappers(editorAlias));
+        var results = await Task.WhenAll(tasks);
+        return results.SelectMany(x => x);
+    }
+}
+
+public class SyncMapperTrackerCollectionBuilder
+    : LazyCollectionBuilderBase<SyncMapperTrackerCollectionBuilder, SyncMapperTrackerCollection, ISyncMapperTracker>
+{
+    protected override SyncMapperTrackerCollectionBuilder This => this;
+}