Creates method to create the relations based on the property editor's returned reference but have discovered a gotcha for relations, so next step is to resolve that.

src/Umbraco.Core/Constants-Conventions.cs

@@ -309,32 +309,52 @@ namespace Umbraco.Core
             public static class RelationTypes
             {
                 /// <summary>
-                /// ContentType name for default relation type "Relate Document On Copy".
+                /// Name for default relation type "Related Media".
+                /// </summary>
+                public const string RelatedMediaName = "Related Media";
+
+                /// <summary>
+                /// Alias for default relation type "Related Media"
+                /// </summary>
+                public const string RelatedMediaAlias = "umbMedia";
+
+                /// <summary>
+                /// Name for default relation type "Related Document".
+                /// </summary>
+                public const string RelatedDocumentName = "Related Document";
+
+                /// <summary>
+                /// Alias for default relation type "Related Document"
+                /// </summary>
+                public const string RelatedDocumentAlias = "umbDocument";
+
+                /// <summary>
+                /// Name for default relation type "Relate Document On Copy".
                 /// </summary>
                 public const string RelateDocumentOnCopyName = "Relate Document On Copy";
 
                 /// <summary>
-                /// ContentType alias for default relation type "Relate Document On Copy".
+                /// Alias for default relation type "Relate Document On Copy".
                 /// </summary>
                 public const string RelateDocumentOnCopyAlias = "relateDocumentOnCopy";
 
                 /// <summary>
-                /// ContentType name for default relation type "Relate Parent Document On Delete".
+                /// Name for default relation type "Relate Parent Document On Delete".
                 /// </summary>
                 public const string RelateParentDocumentOnDeleteName = "Relate Parent Document On Delete";
 
                 /// <summary>
-                /// ContentType alias for default relation type "Relate Parent Document On Delete".
+                /// Alias for default relation type "Relate Parent Document On Delete".
                 /// </summary>
                 public const string RelateParentDocumentOnDeleteAlias = "relateParentDocumentOnDelete";
 
                 /// <summary>
-                /// ContentType name for default relation type "Relate Parent Media Folder On Delete".
+                /// Name for default relation type "Relate Parent Media Folder On Delete".
                 /// </summary>
                 public const string RelateParentMediaFolderOnDeleteName = "Relate Parent Media Folder On Delete";
 
                 /// <summary>
-                /// ContentType alias for default relation type "Relate Parent Media Folder On Delete".
+                /// Alias for default relation type "Relate Parent Media Folder On Delete".
                 /// </summary>
                 public const string RelateParentMediaFolderOnDeleteAlias = "relateParentMediaFolderOnDelete";
             }

src/Umbraco.Core/Migrations/Install/DatabaseDataCreator.cs

@@ -318,6 +318,16 @@ namespace Umbraco.Core.Migrations.Install
             relationType = new RelationTypeDto { Id = 3, Alias = Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias, ChildObjectType = Constants.ObjectTypes.Media, ParentObjectType = Constants.ObjectTypes.Media, Dual = false, Name = Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName };
             relationType.UniqueId = (relationType.Alias + "____" + relationType.Name).ToGuid();
             _database.Insert(Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
+
+            //TODO: We need to decide if we are going to change the relations APIs since it's pretty crappy that we have to explicitly define all relation type object type combinations...
+
+            relationType = new RelationTypeDto { Id = 4, Alias = Constants.Conventions.RelationTypes.RelatedMediaAlias, ChildObjectType = Constants.ObjectTypes.Media, ParentObjectType = Constants.ObjectTypes.Document, Dual = false, Name = Constants.Conventions.RelationTypes.RelatedMediaName };
+            relationType.UniqueId = (relationType.Alias + "____" + relationType.Name).ToGuid();
+            _database.Insert(Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
+
+            relationType = new RelationTypeDto { Id = 4, Alias = Constants.Conventions.RelationTypes.RelatedDocumentAlias, ChildObjectType = Constants.ObjectTypes.Document, ParentObjectType = Constants.ObjectTypes.Document, Dual = false, Name = Constants.Conventions.RelationTypes.RelatedDocumentName };
+            relationType.UniqueId = (relationType.Alias + "____" + relationType.Name).ToGuid();
+            _database.Insert(Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
         }
 
         private void CreateKeyValueData()

src/Umbraco.Core/Models/Editors/ContentPropertyFile.cs

@@ -1,5 +1,6 @@
 namespace Umbraco.Core.Models.Editors
 {
+
     /// <summary>
     /// Represents an uploaded file for a property.
     /// </summary>

src/Umbraco.Core/Models/Editors/UmbracoEntityReference.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Models.Editors
+{
+    /// <summary>
+    /// Used to track reference to other entities in a property value
+    /// </summary>
+    public struct UmbracoEntityReference : IEquatable<UmbracoEntityReference>
+    {
+        private static readonly UmbracoEntityReference _empty = new UmbracoEntityReference(Udi.UnknownTypeUdi.Instance, string.Empty);
+
+        public UmbracoEntityReference(Udi udi, string relationTypeAlias)
+        {
+            Udi = udi ?? throw new ArgumentNullException(nameof(udi));
+            RelationTypeAlias = relationTypeAlias ?? throw new ArgumentNullException(nameof(relationTypeAlias));
+        }
+
+        public static UmbracoEntityReference Empty() => _empty;
+
+        public static bool IsEmpty(UmbracoEntityReference reference) => reference == Empty();
+
+        public Udi Udi { get; }
+        public string RelationTypeAlias { get; }
+
+        public override bool Equals(object obj)
+        {
+            return obj is UmbracoEntityReference reference && Equals(reference);
+        }
+
+        public bool Equals(UmbracoEntityReference other)
+        {
+            return EqualityComparer<Udi>.Default.Equals(Udi, other.Udi) &&
+                   RelationTypeAlias == other.RelationTypeAlias;
+        }
+
+        public override int GetHashCode()
+        {
+            var hashCode = -487348478;
+            hashCode = hashCode * -1521134295 + EqualityComparer<Udi>.Default.GetHashCode(Udi);
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(RelationTypeAlias);
+            return hashCode;
+        }
+
+        public static bool operator ==(UmbracoEntityReference left, UmbracoEntityReference right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(UmbracoEntityReference left, UmbracoEntityReference right)
+        {
+            return !(left == right);
+        }
+    }
+}

src/Umbraco.Core/Persistence/Repositories/IRelationRepository.cs

@@ -4,6 +4,13 @@ namespace Umbraco.Core.Persistence.Repositories
 {
     public interface IRelationRepository : IReadWriteQueryRepository<int, IRelation>
     {
-
+        /// <summary>
+        /// Deletes all relations for a parent for any specified relation type alias
+        /// </summary>
+        /// <param name="parentId"></param>
+        /// <param name="relationTypeAliases">
+        /// A list of relation types to match for deletion, if none are specified then all relations for this parent id are deleted
+        /// </param>
+        void DeleteByParent(int parentId, params string[] relationTypeAliases);
     }
 }

src/Umbraco.Core/Persistence/Repositories/Implement/ContentRepositoryBase.cs

@@ -9,6 +9,7 @@ using Umbraco.Core.Composing;
 using Umbraco.Core.Events;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
+using Umbraco.Core.Models.Editors;
 using Umbraco.Core.Models.Entities;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.Dtos;
@@ -47,12 +48,13 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
         ///     Lazy property value collection - must be lazy because we have a circular dependency since some property editors require services, yet these services require property editors
         /// </param>
         protected ContentRepositoryBase(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger,
-            ILanguageRepository languageRepository, IRelationRepository relationRepository,
+            ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
             Lazy<PropertyEditorCollection> propertyEditors)
             : base(scopeAccessor, cache, logger)
         {
             LanguageRepository = languageRepository;
             RelationRepository = relationRepository;
+            RelationTypeRepository = relationTypeRepository;
             _propertyEditors = propertyEditors;
         }
 
@@ -60,6 +62,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
         protected ILanguageRepository LanguageRepository { get; }
         protected IRelationRepository RelationRepository { get; }
+        protected IRelationTypeRepository RelationTypeRepository { get; }
 
         protected PropertyEditorCollection PropertyEditors => _propertyEditors.Value;
 
@@ -818,7 +821,62 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
 
         protected void PersistRelations(TEntity entity)
         {
-            //foreach(var p in entity.)
+            var trackedRelations = new List<UmbracoEntityReference>();
+
+            foreach (var p in entity.Properties)
+            {
+                if (!PropertyEditors.TryGet(p.PropertyType.PropertyEditorAlias, out var editor)) continue;
+                if (!(editor is IDataValueReference reference)) continue;
+
+                //TODO: Support variants/segments! This is not required for this initial prototype which is why there is a check here
+                if (!p.PropertyType.VariesByNothing()) continue;
+
+                var val = p.GetValue(); // get the invariant value
+                var refs = reference.GetReferences(val);
+                trackedRelations.AddRange(refs);
+            }
+
+            if (trackedRelations.Count == 0) return;
+
+            //First delete all relations for this entity
+            var relationTypes = trackedRelations.Select(x => x.RelationTypeAlias).ToArray();
+            RelationRepository.DeleteByParent(entity.Id, relationTypes);
+
+            var udiToGuids = trackedRelations.Select(x => x.Udi as GuidUdi)
+                .ToDictionary(x => (Udi)x, x => x.Guid);
+
+            //lookup in the DB all INT ids for the GUIDs and chuck into a dictionary
+            var keyToIds = Database.Fetch<NodeIdKey>(Sql().Select<NodeDto>(x => x.NodeId, x => x.UniqueId).From<NodeDto>().WhereIn<NodeDto>(x => x.UniqueId, udiToGuids.Values))
+                .ToDictionary(x => x.UniqueId, x => x.NodeId);
+
+            var allRelationTypes = RelationTypeRepository.GetMany(Array.Empty<int>())
+                .ToDictionary(x => x.Alias, x => x);
+
+            foreach(var rel in trackedRelations)
+            {
+                if (!allRelationTypes.TryGetValue(rel.RelationTypeAlias, out var relationType))
+                    throw new InvalidOperationException($"The relation type {rel.RelationTypeAlias} does not exist");
+
+                if (!udiToGuids.TryGetValue(rel.Udi, out var guid))
+                    continue; // This shouldn't happen!
+
+                if (!keyToIds.TryGetValue(guid, out var id))
+                    continue; // This shouldn't happen!
+                
+                //Create new relation
+                //TODO: This is N+1, we could do this all in one operation, just need a new method on the relations repo
+                RelationRepository.Save(new Relation(entity.Id, id, relationType));
+            }
+
+        }
+
+        private class NodeIdKey
+        {
+            [Column("id")]
+            public int NodeId { get; set; }
+
+            [Column("uniqueId")]
+            public Guid UniqueId { get; set; }
         }
     }
 }

src/Umbraco.Core/Persistence/Repositories/Implement/DocumentBlueprintRepository.cs

@@ -19,9 +19,9 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
     internal class DocumentBlueprintRepository : DocumentRepository, IDocumentBlueprintRepository
     {
         public DocumentBlueprintRepository(IScopeAccessor scopeAccessor, AppCaches appCaches, ILogger logger,
-            IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository,
+            IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
             Lazy<PropertyEditorCollection> propertyEditorCollection)
-            : base(scopeAccessor, appCaches, logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, propertyEditorCollection)
+            : base(scopeAccessor, appCaches, logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditorCollection)
         {
         }
 

src/Umbraco.Core/Persistence/Repositories/Implement/DocumentRepository.cs

@@ -45,9 +45,9 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
         ///     Lazy property value collection - must be lazy because we have a circular dependency since some property editors require services, yet these services require property editors
         /// </param>
         public DocumentRepository(IScopeAccessor scopeAccessor, AppCaches appCaches, ILogger logger,
-            IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository,
+            IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
             Lazy<PropertyEditorCollection> propertyEditors)
-            : base(scopeAccessor, appCaches, logger, languageRepository, relationRepository, propertyEditors)
+            : base(scopeAccessor, appCaches, logger, languageRepository, relationRepository, relationTypeRepository, propertyEditors)
         {
             _contentTypeRepository = contentTypeRepository ?? throw new ArgumentNullException(nameof(contentTypeRepository));
             _templateRepository = templateRepository ?? throw new ArgumentNullException(nameof(templateRepository));

src/Umbraco.Core/Persistence/Repositories/Implement/MediaRepository.cs

@@ -28,9 +28,9 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
         private readonly ITagRepository _tagRepository;
         private readonly MediaByGuidReadRepository _mediaByGuidReadRepository;
 
-        public MediaRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository,
+        public MediaRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
             Lazy<PropertyEditorCollection> propertyEditorCollection)
-            : base(scopeAccessor, cache, logger, languageRepository, relationRepository, propertyEditorCollection)
+            : base(scopeAccessor, cache, logger, languageRepository, relationRepository, relationTypeRepository, propertyEditorCollection)
         {
             _mediaTypeRepository = mediaTypeRepository ?? throw new ArgumentNullException(nameof(mediaTypeRepository));
             _tagRepository = tagRepository ?? throw new ArgumentNullException(nameof(tagRepository));

src/Umbraco.Core/Persistence/Repositories/Implement/MemberRepository.cs

@@ -27,9 +27,9 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
         private readonly IMemberGroupRepository _memberGroupRepository;
 
         public MemberRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger,
-            IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository,
+            IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
             Lazy<PropertyEditorCollection> propertyEditors)
-            : base(scopeAccessor, cache, logger, languageRepository, relationRepository, propertyEditors)
+            : base(scopeAccessor, cache, logger, languageRepository, relationRepository, relationTypeRepository, propertyEditors)
         {
             _memberTypeRepository = memberTypeRepository ?? throw new ArgumentNullException(nameof(memberTypeRepository));
             _tagRepository = tagRepository ?? throw new ArgumentNullException(nameof(tagRepository));

src/Umbraco.Core/Persistence/Repositories/Implement/RelationRepository.cs

@@ -9,6 +9,7 @@ using Umbraco.Core.Models.Entities;
 using Umbraco.Core.Persistence.Dtos;
 using Umbraco.Core.Persistence.Factories;
 using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Persistence.SqlSyntax;
 using Umbraco.Core.Scoping;
 
 namespace Umbraco.Core.Persistence.Repositories.Implement
@@ -157,5 +158,20 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
         }
 
         #endregion
+
+        public void DeleteByParent(int parentId, params string[] relationTypeAliases)
+        {
+            var subQuery = Sql().Select<RelationDto>(x => x.Id)
+                .From<RelationDto>()
+                .InnerJoin<RelationTypeDto>().On<RelationDto, RelationTypeDto>(x => x.RelationType, x => x.Id)
+                .Where<RelationDto>(x => x.ParentId == parentId);
+
+            if (relationTypeAliases.Length > 0)
+            {
+                subQuery.WhereIn<RelationTypeDto>(x => x.Alias, relationTypeAliases);
+            }
+
+            Database.Execute(Sql().Delete<RelationDto>().WhereIn<RelationDto>(x => x.Id, subQuery));
+        }
     }
 }

src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProviderExtensions.cs

@@ -35,6 +35,8 @@ namespace Umbraco.Core.Persistence.SqlSyntax
         /// </remarks>
         public static Sql GetDeleteSubquery(this ISqlSyntaxProvider sqlProvider, string tableName, string columnName, Sql subQuery, WhereInType whereInType = WhereInType.In)
         {
+            //TODO: This is no longer necessary since this used to be a specific requirement for MySql!
+            // Now we can do a Delete<T> + sub query, see RelationRepository.DeleteByParent for example
 
             return
                 new Sql(string.Format(

src/Umbraco.Core/PropertyEditors/IDataValueReference.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using Umbraco.Core.Models.Editors;
 
 namespace Umbraco.Core.PropertyEditors
 {
@@ -12,6 +13,6 @@ namespace Umbraco.Core.PropertyEditors
         /// </summary>
         /// <param name="value"></param>
         /// <returns></returns>
-        IEnumerable<Udi> GetReferences(object value);
+        IEnumerable<UmbracoEntityReference> GetReferences(object value);
     }
 }

src/Umbraco.Core/Services/IRelationService.cs

@@ -47,7 +47,7 @@ namespace Umbraco.Core.Services
         /// </summary>
         /// <param name="relationType"><see cref="RelationType"/> to retrieve Relations for</param>
         /// <returns>An enumerable list of <see cref="Relation"/> objects</returns>
-        IEnumerable<IRelation> GetAllRelationsByRelationType(RelationType relationType);
+        IEnumerable<IRelation> GetAllRelationsByRelationType(IRelationType relationType);
 
         /// <summary>
         /// Gets all <see cref="Relation"/> objects by their <see cref="RelationType"/>'s Id

src/Umbraco.Core/Services/Implement/RelationService.cs

@@ -96,7 +96,7 @@ namespace Umbraco.Core.Services.Implement
         /// </summary>
         /// <param name="relationType"><see cref="RelationType"/> to retrieve Relations for</param>
         /// <returns>An enumerable list of <see cref="Relation"/> objects</returns>
-        public IEnumerable<IRelation> GetAllRelationsByRelationType(RelationType relationType)
+        public IEnumerable<IRelation> GetAllRelationsByRelationType(IRelationType relationType)
         {
             return GetAllRelationsByRelationType(relationType.Id);
         }
@@ -642,6 +642,8 @@ namespace Umbraco.Core.Services.Implement
                 var query = Query<IRelation>().Where(x => x.RelationTypeId == relationType.Id);
                 relations.AddRange(_relationRepository.Get(query).ToList());
 
+                //TODO: N+1, we should be able to do this in a single call
+
                 foreach (var relation in relations)
                     _relationRepository.Delete(relation);
 

src/Umbraco.Core/Udi.cs

@@ -368,7 +368,7 @@ namespace Umbraco.Core
             return (udi1 == udi2) == false;
         }
 
-        private class UnknownTypeUdi : Udi
+        internal class UnknownTypeUdi : Udi
         {
             private UnknownTypeUdi()
                 : base("unknown", "umb://unknown/")

src/Umbraco.Core/Umbraco.Core.csproj

@@ -245,6 +245,7 @@
     <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\RichTextPreValueMigrator.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\DropDownFlexiblePreValueMigrator.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_0\MergeDateAndDateTimePropertyEditor.cs" />
+    <Compile Include="Models\Editors\UmbracoEntityReference.cs" />
     <Compile Include="Models\Entities\EntityExtensions.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\PreValueMigratorBase.cs" />
     <Compile Include="Migrations\Upgrade\V_8_0_0\DataTypes\PreValueDto.cs" />

src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs

@@ -39,7 +39,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var relationTypeRepository = new RelationTypeRepository(scopeAccessor, AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository(scopeAccessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new DocumentRepository(scopeAccessor, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, propertyEditors);
+            var repository = new DocumentRepository(scopeAccessor, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
 

src/Umbraco.Tests/Persistence/Repositories/DocumentRepositoryTest.cs

@@ -72,7 +72,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var relationTypeRepository = new RelationTypeRepository(scopeAccessor, AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository(scopeAccessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new DocumentRepository(scopeAccessor, appCaches, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, propertyEditors);
+            var repository = new DocumentRepository(scopeAccessor, appCaches, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
 

src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs

@@ -30,7 +30,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var relationTypeRepository = new RelationTypeRepository(accessor, Core.Cache.AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            documentRepository = new DocumentRepository(accessor, Core.Cache.AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, propertyEditors);
+            documentRepository = new DocumentRepository(accessor, Core.Cache.AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors);
             var domainRepository = new DomainRepository(accessor, Core.Cache.AppCaches.Disabled, Logger);
             return domainRepository;
         }

src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs

@@ -45,7 +45,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var relationTypeRepository = new RelationTypeRepository(scopeAccessor, AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository(scopeAccessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new MediaRepository(scopeAccessor, appCaches, Logger, mediaTypeRepository, tagRepository, Mock.Of<ILanguageRepository>(), relationRepository, propertyEditors);
+            var repository = new MediaRepository(scopeAccessor, appCaches, Logger, mediaTypeRepository, tagRepository, Mock.Of<ILanguageRepository>(), relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
 

src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs

@@ -39,7 +39,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new MemberRepository(accessor, AppCaches.Disabled, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of<ILanguageRepository>(), relationRepository, propertyEditors);
+            var repository = new MemberRepository(accessor, AppCaches.Disabled, Logger, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of<ILanguageRepository>(), relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
 

src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs

@@ -314,7 +314,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches, Logger);
             var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new DocumentRepository(accessor, AppCaches, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, propertyEditors);
+            var repository = new DocumentRepository(accessor, AppCaches, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
 

src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs

@@ -963,7 +963,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new DocumentRepository(accessor, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, propertyEditors);
+            var repository = new DocumentRepository(accessor, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
 
@@ -978,7 +978,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new MediaRepository(accessor, AppCaches.Disabled, Logger, mediaTypeRepository, tagRepository, Mock.Of<ILanguageRepository>(), relationRepository, propertyEditors);
+            var repository = new MediaRepository(accessor, AppCaches.Disabled, Logger, mediaTypeRepository, tagRepository, Mock.Of<ILanguageRepository>(), relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
     }

src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs

@@ -245,7 +245,7 @@ namespace Umbraco.Tests.Persistence.Repositories
                 var relationTypeRepository = new RelationTypeRepository(ScopeProvider, AppCaches.Disabled, Logger);
                 var relationRepository = new RelationRepository(ScopeProvider, Logger, relationTypeRepository);
                 var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-                var contentRepo = new DocumentRepository(ScopeProvider, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, propertyEditors);
+                var contentRepo = new DocumentRepository(ScopeProvider, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors);
 
                 var contentType = MockedContentTypes.CreateSimpleContentType("umbTextpage2", "Textpage");
                 ServiceContext.FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType!

src/Umbraco.Tests/Persistence/Repositories/UserRepositoryTest.cs

@@ -34,7 +34,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new MediaRepository(accessor, AppCaches, Mock.Of<ILogger>(), mediaTypeRepository, tagRepository, Mock.Of<ILanguageRepository>(), relationRepository, propertyEditors);
+            var repository = new MediaRepository(accessor, AppCaches, Mock.Of<ILogger>(), mediaTypeRepository, tagRepository, Mock.Of<ILanguageRepository>(), relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
 
@@ -55,7 +55,7 @@ namespace Umbraco.Tests.Persistence.Repositories
             var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new DocumentRepository(accessor, AppCaches, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, propertyEditors);
+            var repository = new DocumentRepository(accessor, AppCaches, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
 

src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs

@@ -50,7 +50,7 @@ namespace Umbraco.Tests.Services
             var relationTypeRepository = new RelationTypeRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository((IScopeAccessor)provider, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new DocumentRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository, relationRepository, propertyEditors);
+            var repository = new DocumentRepository((IScopeAccessor)provider, AppCaches.Disabled, Logger, ctRepository, tRepository, tagRepo, languageRepository, relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
 

src/Umbraco.Tests/Services/ContentServiceTests.cs

@@ -3169,7 +3169,7 @@ namespace Umbraco.Tests.Services
             var relationTypeRepository = new RelationTypeRepository(accessor, AppCaches.Disabled, Logger);
             var relationRepository = new RelationRepository(accessor, Logger, relationTypeRepository);
             var propertyEditors = new Lazy<PropertyEditorCollection>(() => new PropertyEditorCollection(new DataEditorCollection(Enumerable.Empty<IDataEditor>())));
-            var repository = new DocumentRepository(accessor, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, propertyEditors);
+            var repository = new DocumentRepository(accessor, AppCaches.Disabled, Logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditors);
             return repository;
         }
 

src/Umbraco.Tests/Services/RelationServiceTests.cs

@@ -23,5 +23,7 @@ namespace Umbraco.Tests.Services
 
             Assert.AreEqual(rt.Name, "repeatedEventOccurence");
         }
+
+        //TODO: Create a relation for entities of the wrong Entity Type (GUID) based on the Relation Type's defined parent/child object types
     }
 }

src/Umbraco.Web/PropertyEditors/RichTextPropertyEditor.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using Umbraco.Core;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
+using Umbraco.Core.Models.Editors;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Services;
 using Umbraco.Examine;
@@ -135,15 +136,15 @@ namespace Umbraco.Web.PropertyEditors
             /// </summary>
             /// <param name="value"></param>
             /// <returns></returns>
-            public IEnumerable<Udi> GetReferences(object value)
+            public IEnumerable<UmbracoEntityReference> GetReferences(object value)
             {
                 var asString = value == null ? string.Empty : value is string str ? str : value.ToString();
 
                 foreach (var udi in _imageSourceParser.FindUdisFromDataAttributes(asString))
-                    yield return udi;
+                    yield return new UmbracoEntityReference(udi, Constants.Conventions.RelationTypes.RelatedMediaAlias);
 
                 foreach (var udi in _localLinkParser.FindUdisFromLocalLinks(asString))
-                    yield return udi;
+                    yield return new UmbracoEntityReference(udi, Constants.Conventions.RelationTypes.RelatedMediaAlias);
 
                 //TODO: Detect Macros too ... but we can save that for a later date, right now need to do media refs
             }