fix: #487 additional fixes and tests

src/IntelliTect.Coalesce.Tests/TargetClasses/TestDbContext/OneToOne.cs

@@ -1,17 +1,25 @@
-using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
+using System.Collections.Generic;
+using System;
+using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Security.Cryptography;
 
 namespace IntelliTect.Coalesce.Tests.TargetClasses.TestDbContext
 {
     public class OneToOneParent
     {
         public int Id { get; set; }
 
-       // [InverseProperty(nameof(Child1.Parent))]
+        // [InverseProperty(nameof(Child1.Parent))]
         public OneToOneChild1 Child1 { get; set; }
 
         [InverseProperty(nameof(Child2.Parent))] // Can be specified, but not required.
         public OneToOneChild2 Child2 { get; set; }
+
+        public List<OneToOneManyChildren> ManyChildren { get; set; } = [];
     }
 
     public class OneToOneChild1
@@ -27,4 +35,12 @@ public class OneToOneChild2
         public int ParentId { get; set; }
         public OneToOneParent Parent { get; set; }
     }
+
+    public class OneToOneManyChildren
+    {
+        public int Id { get; set; }
+
+        public int OneToOneParentId { get; set; }
+        public OneToOneParent OneToOneParent { get; set; }
+    }
 }

src/IntelliTect.Coalesce.Tests/TargetClasses/TestDbContext/TestDbContext.cs

@@ -39,6 +39,8 @@ public class AppDbContext : DbContext
         public DbSet<OneToOneParent> OneToOneParents { get; set; }
         public DbSet<OneToOneChild1> OneToOneChild1s { get; set; }
         public DbSet<OneToOneChild2> OneToOneChild2s { get; set; }
+        public DbSet<OneToOneManyChildren> OneToOneManyChildren { get; set; }
+
 
         public AppDbContext() : this(Guid.NewGuid().ToString()) { }
 

src/IntelliTect.Coalesce.Tests/Tests/TypeDefinition/PropertyViewModelTests.cs

@@ -4,10 +4,8 @@
 using IntelliTect.Coalesce.TypeDefinition;
 using IntelliTect.Coalesce.TypeDefinition.Enums;
 using Microsoft.EntityFrameworkCore;
-using System.Text;
-using Xunit;
+using System.ComponentModel;
 using static IntelliTect.Coalesce.DataAnnotations.DateTypeAttribute;
-using static System.Runtime.InteropServices.JavaScript.JSType;
 
 namespace IntelliTect.Coalesce.Tests.TypeDefinition
 {
@@ -298,18 +296,44 @@ public void OneToOne_ParentNavigations_HasCorrectMetadata(PropertyViewModelData
         }
 
         [Theory]
-        [PropertyViewModelData<OneToOneChild1>(nameof(OneToOneChild1.Parent))]
-        [PropertyViewModelData<OneToOneChild2>(nameof(OneToOneChild2.Parent))]
-        public void OneToOne_ChildNavigations_HasCorrectMetadata(PropertyViewModelData data)
+        [PropertyViewModelData<OneToOneChild1>(nameof(OneToOneChild1.Parent), "Child1")]
+        [PropertyViewModelData<OneToOneChild2>(nameof(OneToOneChild2.Parent), "Child2")]
+        public void OneToOne_ChildNavigations_HasCorrectMetadata(PropertyViewModelData data, string inverse)
         {
             PropertyViewModel vm = data;
             Assert.Equal(PropertyRole.ReferenceNavigation, vm.Role);
             Assert.Equal(vm.Parent.PropertyByName("ParentId"), vm.ForeignKeyProperty);
+            Assert.Equal(inverse, vm.InverseProperty.Name);
+        }
+
+        [Theory]
+        [PropertyViewModelData<OneToOneManyChildren>(nameof(OneToOneManyChildren.OneToOneParent))]
+        [Description("https://github.com/IntelliTect/Coalesce/commit/513db257dda32b99099355f1a6de0f5fbf367f5a")]
+        public void ReferenceNavigation_HasCorrectFkWhenPrincipalAlsoParticipatesInOneToOne(PropertyViewModelData data)
+        {
+            PropertyViewModel prop = data;
+
+            // Precodition: Principal participates in a one-to-one
+            Assert.True(prop.Object!.PrimaryKey.IsForeignKey);
+
+            // Correct foreign key here is ParentId, not the child's PK.
+            Assert.Equal(PropertyRole.ReferenceNavigation, prop.Role);
+            Assert.Equal(nameof(OneToOneManyChildren.OneToOneParentId), prop.ForeignKeyProperty.Name);
+        }
+
+        [Theory]
+        [PropertyViewModelData<OneToOneParent>(nameof(OneToOneParent.ManyChildren))]
+        [Description("https://github.com/IntelliTect/Coalesce/commit/513db257dda32b99099355f1a6de0f5fbf367f5a")]
+        public void CollectionNavigation_HasCorrectFkWhenPrincipalAlsoParticipatesInOneToOne(PropertyViewModelData data)
+        {
+            PropertyViewModel prop = data;
+
+            // Precodition: Principal participates in a one-to-one
+            Assert.True(prop.EffectiveParent.PrimaryKey.IsForeignKey);
 
-            // We currently assume that reverence inverses are only ever collection navigations.
-            // This could change in the future, but at least for now the typescript types don't allow
-            // for representing this here, which is fine and doesn't currently hurt anything.
-            Assert.Null(vm.InverseProperty);
+            // Correct foreign key here is ParentId, not the child's PK.
+            Assert.Equal(PropertyRole.CollectionNavigation, prop.Role);
+            Assert.Equal(nameof(OneToOneManyChildren.OneToOneParentId), prop.ForeignKeyProperty.Name);
         }
 
     }

src/IntelliTect.Coalesce/TypeDefinition/PropertyViewModel.cs

@@ -443,7 +443,9 @@ public bool IsPrimaryKey
         /// Returns true if this property is a foreign key.
         /// Guarantees that <see cref="ForeignKeyPrincipalType"/> is not null.
         /// </summary>
-        public bool IsForeignKey => ForeignKeyPrincipalType != null;
+        public bool IsForeignKey => 
+            ForeignKeyPrincipalType != null || 
+            EffectiveParent.ClientProperties.Any(p => p != this && p.ForeignKeyProperty == this);
 
 
         public DatabaseGeneratedOption DatabaseGenerated
@@ -510,13 +512,28 @@ public PropertyViewModel? ForeignKeyProperty
 
                     prop = EffectiveParent.PropertyByName(name);
 
-                    if (prop == null && InverseProperty?.Role == PropertyRole.ReferenceNavigation)
+                    if (prop == null)
                     {
                         // If the other side of the relationship is also a reference navigation,
                         // this is a 1-to-1. If there's otherwise no FK specified, assume that the PK
                         // of this type is the FK we're looking for here.
                         // See test models "OneToOneParent"/"OneToOneChild1" for example.
-                        return EffectiveParent.PrimaryKey;
+
+                        if (this.HasAttribute<InversePropertyAttribute>() &&
+                            InverseProperty?.Role == PropertyRole.ReferenceNavigation)
+                        {
+                            // Only look at `InverseProperty` if explicitly annotated.
+                            // Otherwise, this will cause infinite recursion.
+                            return EffectiveParent.PrimaryKey;
+                        }
+
+                        if (Object!.ClientProperties.Any(p => 
+                            p.ForeignKeyProperty == Object.PrimaryKey && 
+                            p.Type == this.EffectiveParent.Type
+                        ))
+                        {
+                            return EffectiveParent.PrimaryKey;
+                        }
                     }
                 }
 
@@ -694,6 +711,13 @@ public PropertyViewModel? InverseProperty
                     return Object.ClientProperties.FirstOrDefault(p =>
                         p.Role == PropertyRole.CollectionNavigation
                         && p.InverseProperty == this
+                    )
+                    // Or, try to find 1-to-1 reference navigations
+                    ?? Object.ClientProperties.FirstOrDefault(p =>
+                        p.Role == PropertyRole.ReferenceNavigation && 
+                        p.Type == EffectiveParent.Type &&
+                        p.ForeignKeyProperty?.IsPrimaryKey == true
+
                     );
                 }
 

src/coalesce-vue/src/metadata.ts

@@ -494,7 +494,10 @@ export interface ModelReferenceNavigationProperty
   // PK is the foreign key into the parent's type.
   readonly foreignKey: ForeignKeyProperty | PrimaryKeyProperty;
   readonly principalKey: PrimaryKeyProperty;
-  readonly inverseNavigation?: ModelCollectionNavigationProperty;
+  // Note: Can be a `ModelReferenceNavigationProperty` for a 1-to-1
+  readonly inverseNavigation?:
+    | ModelReferenceNavigationProperty
+    | ModelCollectionNavigationProperty;
 }
 
 /**