Default relationships to ownership for Cosmos

Allow to reconfigure STETs as regular entity types

Fixes #24803

Author: AndriySvyryd

src/EFCore.Cosmos/Metadata/Conventions/CosmosInversePropertyAttributeConvention.cs

@@ -0,0 +1,51 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Reflection;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
+{
+    /// <summary>
+    ///     A convention that configures the inverse navigation property based on the <see cref="InversePropertyAttribute" />
+    ///     specified on the other navigation property.
+    ///     All navigations are assumed to be targeting owned entity types for Cosmos.
+    /// </summary>
+    public class CosmosInversePropertyAttributeConvention : InversePropertyAttributeConvention
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="InversePropertyAttributeConvention" />.
+        /// </summary>
+        /// <param name="dependencies"> Parameter object containing dependencies for this convention. </param>
+        public CosmosInversePropertyAttributeConvention(ProviderConventionSetBuilderDependencies dependencies)
+            : base(dependencies)
+        {
+        }
+
+        /// <summary>
+        ///     Finds or tries to create an entity type target for the given navigation member.
+        /// </summary>
+        /// <param name="entityTypeBuilder"> The builder for the referencing entity type. </param>
+        /// <param name="targetClrType"> The CLR type of the target entity type. </param>
+        /// <param name="navigationMemberInfo"> The navigation member. </param>
+        /// <param name="shouldCreate"> Whether an entity type should be created if one doesn't currently exist. </param>
+        /// <returns> The builder for the target entity type or <see langword="null"/> if it can't be created. </returns>
+        protected override IConventionEntityTypeBuilder? TryGetTargetEntityTypeBuilder(
+            IConventionEntityTypeBuilder entityTypeBuilder,
+            Type targetClrType,
+            MemberInfo navigationMemberInfo,
+            bool shouldCreate = true)
+            => ((InternalEntityTypeBuilder)entityTypeBuilder)
+#pragma warning disable EF1001 // Internal EF Core API usage.
+                .GetTargetEntityTypeBuilder(
+                    targetClrType,
+                    navigationMemberInfo,
+                    shouldCreate ? ConfigurationSource.DataAnnotation : null,
+                    targetShouldBeOwned: true);
+#pragma warning restore EF1001 // Internal EF Core API usage.
+    }
+}

src/EFCore.Cosmos/Metadata/Conventions/CosmosRelationshipDiscoveryConvention.cs

@@ -0,0 +1,34 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure;
+
+namespace Microsoft.EntityFrameworkCore.Metadata.Conventions
+{
+    /// <summary>
+    ///     A convention that configures relationships between entity types based on the navigation properties
+    ///     as long as there is no ambiguity as to which is the corresponding inverse navigation.
+    ///     All navigations are assumed to be targeting owned entity types for Cosmos.
+    /// </summary>
+    public class CosmosRelationshipDiscoveryConvention : RelationshipDiscoveryConvention
+    {
+        /// <summary>
+        ///     Creates a new instance of <see cref="RelationshipDiscoveryConvention" />.
+        /// </summary>
+        /// <param name="dependencies"> Parameter object containing dependencies for this convention. </param>
+        public CosmosRelationshipDiscoveryConvention(ProviderConventionSetBuilderDependencies dependencies)
+            : base(dependencies)
+        {
+        }
+
+        /// <summary>
+        ///     Returns a value indicating whether the given entity type should be added as owned if it isn't currently in the model.
+        /// </summary>
+        /// <param name="targetType"> Target entity type. </param>
+        /// <param name="model"> The model. </param>
+        /// <returns> <see langword="true"/> if the given entity type should be owned. </returns>
+        protected override bool? ShouldBeOwned(Type targetType, IConventionModel model)
+            => true;
+    }
+}

src/EFCore.Cosmos/Metadata/Conventions/Internal/CosmosConventionSetBuilder.cs

@@ -44,45 +44,67 @@ public override ConventionSet CreateConventionSet()
 
             var storeKeyConvention = new StoreKeyConvention(Dependencies);
             var discriminatorConvention = new CosmosDiscriminatorConvention(Dependencies);
-            var keyDiscoveryConvention = new CosmosKeyDiscoveryConvention(Dependencies);
+            KeyDiscoveryConvention keyDiscoveryConvention = new CosmosKeyDiscoveryConvention(Dependencies);
+            InversePropertyAttributeConvention inversePropertyAttributeConvention =
+                new CosmosInversePropertyAttributeConvention(Dependencies);
+            RelationshipDiscoveryConvention relationshipDiscoveryConvention =
+                new CosmosRelationshipDiscoveryConvention(Dependencies);
             conventionSet.EntityTypeAddedConventions.Add(storeKeyConvention);
             conventionSet.EntityTypeAddedConventions.Add(discriminatorConvention);
-            ReplaceConvention(conventionSet.EntityTypeAddedConventions, (KeyDiscoveryConvention)keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.EntityTypeAddedConventions, keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.EntityTypeAddedConventions, inversePropertyAttributeConvention);
+            ReplaceConvention(conventionSet.EntityTypeAddedConventions, relationshipDiscoveryConvention);
+
+            ReplaceConvention(conventionSet.EntityTypeIgnoredConventions, relationshipDiscoveryConvention);
 
             ReplaceConvention(conventionSet.EntityTypeRemovedConventions, (DiscriminatorConvention)discriminatorConvention);
+            ReplaceConvention(conventionSet.EntityTypeRemovedConventions, inversePropertyAttributeConvention);
 
             conventionSet.EntityTypeBaseTypeChangedConventions.Add(storeKeyConvention);
             ReplaceConvention(conventionSet.EntityTypeBaseTypeChangedConventions, (DiscriminatorConvention)discriminatorConvention);
-            ReplaceConvention(conventionSet.EntityTypeBaseTypeChangedConventions, (KeyDiscoveryConvention)keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.EntityTypeBaseTypeChangedConventions, keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.EntityTypeBaseTypeChangedConventions, inversePropertyAttributeConvention);
+            ReplaceConvention(conventionSet.EntityTypeBaseTypeChangedConventions, relationshipDiscoveryConvention);
+
+            ReplaceConvention(conventionSet.EntityTypeMemberIgnoredConventions, inversePropertyAttributeConvention);
+            ReplaceConvention(conventionSet.EntityTypeMemberIgnoredConventions, relationshipDiscoveryConvention);
 
             conventionSet.EntityTypePrimaryKeyChangedConventions.Add(storeKeyConvention);
 
             conventionSet.KeyAddedConventions.Add(storeKeyConvention);
 
             conventionSet.KeyRemovedConventions.Add(storeKeyConvention);
-            ReplaceConvention(conventionSet.KeyRemovedConventions, (KeyDiscoveryConvention)keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.KeyRemovedConventions, keyDiscoveryConvention);
 
-            ReplaceConvention(conventionSet.ForeignKeyAddedConventions, (KeyDiscoveryConvention)keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.ForeignKeyAddedConventions, keyDiscoveryConvention);
 
             conventionSet.ForeignKeyRemovedConventions.Add(discriminatorConvention);
             conventionSet.ForeignKeyRemovedConventions.Add(storeKeyConvention);
-            ReplaceConvention(conventionSet.ForeignKeyRemovedConventions, (KeyDiscoveryConvention)keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.ForeignKeyRemovedConventions, keyDiscoveryConvention);
 
-            ReplaceConvention(conventionSet.ForeignKeyPropertiesChangedConventions, (KeyDiscoveryConvention)keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.ForeignKeyPropertiesChangedConventions, keyDiscoveryConvention);
 
-            ReplaceConvention(conventionSet.ForeignKeyUniquenessChangedConventions, (KeyDiscoveryConvention)keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.ForeignKeyUniquenessChangedConventions, keyDiscoveryConvention);
 
             conventionSet.ForeignKeyOwnershipChangedConventions.Add(discriminatorConvention);
             conventionSet.ForeignKeyOwnershipChangedConventions.Add(storeKeyConvention);
-            ReplaceConvention(conventionSet.ForeignKeyOwnershipChangedConventions, (KeyDiscoveryConvention)keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.ForeignKeyOwnershipChangedConventions, keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.ForeignKeyOwnershipChangedConventions, relationshipDiscoveryConvention);
+
+            ReplaceConvention(conventionSet.NavigationAddedConventions, inversePropertyAttributeConvention);
+            ReplaceConvention(conventionSet.NavigationAddedConventions, relationshipDiscoveryConvention);
+
+            ReplaceConvention(conventionSet.NavigationRemovedConventions, relationshipDiscoveryConvention);
 
             conventionSet.EntityTypeAnnotationChangedConventions.Add(storeKeyConvention);
-            conventionSet.EntityTypeAnnotationChangedConventions.Add(keyDiscoveryConvention);
+            conventionSet.EntityTypeAnnotationChangedConventions.Add((CosmosKeyDiscoveryConvention)keyDiscoveryConvention);
 
-            ReplaceConvention(conventionSet.PropertyAddedConventions, (KeyDiscoveryConvention)keyDiscoveryConvention);
+            ReplaceConvention(conventionSet.PropertyAddedConventions, keyDiscoveryConvention);
 
             conventionSet.PropertyAnnotationChangedConventions.Add(storeKeyConvention);
 
+            ReplaceConvention(conventionSet.ModelFinalizingConventions, inversePropertyAttributeConvention);
+
             return conventionSet;
         }
 

test/EFCore.Cosmos.Tests/ModelBuilding/CosmosModelBuilderGenericTest.cs

@@ -309,6 +309,35 @@ protected override TestModelBuilder CreateModelBuilder(Action<ModelConfiguration
 
         public class CosmosGenericOwnedTypes : GenericOwnedTypes
         {
+            [ConditionalFact]
+            public virtual void Reference_type_is_discovered_as_owned()
+            {
+                var modelBuilder = CreateModelBuilder();
+
+                modelBuilder.Entity<OneToOneOwnerWithField>(
+                    e =>
+                    {
+                        e.Property(p => p.Id);
+                        e.Property(p => p.AlternateKey);
+                        e.Property(p => p.Description);
+                        e.HasKey(p => p.Id);
+                    });
+
+                var model = modelBuilder.FinalizeModel();
+
+                var owner = model.FindEntityType(typeof(OneToOneOwnerWithField));
+                Assert.Equal(typeof(OneToOneOwnerWithField).FullName, owner.Name);
+                var ownership = owner.FindNavigation(nameof(OneToOneOwnerWithField.OwnedDependent)).ForeignKey;
+                Assert.True(ownership.IsOwnership);
+                Assert.Equal(nameof(OneToOneOwnerWithField.OwnedDependent), ownership.PrincipalToDependent.Name);
+                Assert.Equal(nameof(OneToOneOwnedWithField.OneToOneOwner), ownership.DependentToPrincipal.Name);
+                Assert.Equal(nameof(OneToOneOwnerWithField.Id), ownership.PrincipalKey.Properties.Single().Name);
+                var owned = ownership.DeclaringEntityType;
+                Assert.Single(owned.GetForeignKeys());
+                Assert.NotNull(model.FindEntityType(typeof(OneToOneOwnedWithField)));
+                Assert.Equal(1, model.GetEntityTypes().Count(e => e.ClrType == typeof(OneToOneOwnedWithField)));
+            }
+
             protected override TestModelBuilder CreateModelBuilder(Action<ModelConfigurationBuilder> configure = null)
                 => CreateTestModelBuilder(CosmosTestHelpers.Instance, configure);
         }