fix/#445

.gitignore

@@ -234,3 +234,6 @@ _Pvt_Extensions
 
 # FAKE - F# Make
 .fake/
+
+### Rider ###
+.idea/

src/Examples/JsonApiDotNetCoreExample/Models/Resources/CourseResource.cs

@@ -1,6 +1,7 @@
 using JsonApiDotNetCore.Models;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using JsonApiDotNetCoreExample.Models.Entities;
 
 namespace JsonApiDotNetCoreExample.Models.Resources
 {
@@ -17,7 +18,7 @@ public class CourseResource : Identifiable
         [Attr("description")]
         public string Description { get; set; }
 
-        [HasOne("department")]
+        [HasOne("department", mappedBy: "Department")]
         public DepartmentResource Department { get; set; }
         public int? DepartmentId { get; set; }
 

src/Examples/JsonApiDotNetCoreExample/Models/Resources/DepartmentResource.cs

@@ -8,7 +8,7 @@ public class DepartmentResource : Identifiable
         [Attr("name")]
         public string Name { get; set; }
 
-        [HasMany("courses")]
+        [HasMany("courses", mappedBy: "Courses")]
         public List<CourseResource> Courses { get; set; }
     }
 }

src/JsonApiDotNetCore/Builders/ContextGraphBuilder.cs

@@ -168,7 +168,7 @@ protected virtual List<RelationshipAttribute> GetRelationships(Type entityType)
                 attribute.Type = GetRelationshipType(attribute, prop);
                 attributes.Add(attribute);
 
-                if(attribute is HasManyThroughAttribute hasManyThroughAttribute) {
+                if (attribute is HasManyThroughAttribute hasManyThroughAttribute) {
                     var throughProperty = properties.SingleOrDefault(p => p.Name == hasManyThroughAttribute.InternalThroughName);
                     if(throughProperty == null)
                         throw new JsonApiSetupException($"Invalid '{nameof(HasManyThroughAttribute)}' on type '{entityType}'. Type does not contain a property named '{hasManyThroughAttribute.InternalThroughName}'.");
@@ -211,13 +211,8 @@ protected virtual List<RelationshipAttribute> GetRelationships(Type entityType)
             return attributes;
         }
 
-        protected virtual Type GetRelationshipType(RelationshipAttribute relation, PropertyInfo prop)
-        {
-            if (relation.IsHasMany)
-                return prop.PropertyType.GetGenericArguments()[0];
-            else
-                return prop.PropertyType;
-        }
+        protected virtual Type GetRelationshipType(RelationshipAttribute relation, PropertyInfo prop) =>
+            relation.IsHasMany ? prop.PropertyType.GetGenericArguments()[0] : prop.PropertyType;
 
         private Type GetResourceDefinitionType(Type entityType) => typeof(ResourceDefinition<>).MakeGenericType(entityType);
 

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -155,24 +155,46 @@ public virtual async Task<TEntity> CreateAsync(TEntity entity)
         protected virtual void AttachRelationships(TEntity entity = null)
         {
             AttachHasManyPointers(entity);
-            AttachHasOnePointers();
+            AttachHasOnePointers(entity);
         }
 
         /// <inheritdoc />
         public void DetachRelationshipPointers(TEntity entity)
         {
             foreach (var hasOneRelationship in _jsonApiContext.HasOneRelationshipPointers.Get())
             {
-                _context.Entry(hasOneRelationship.Value).State = EntityState.Detached;
+                var hasOne = (HasOneAttribute) hasOneRelationship.Key;
+                if (hasOne.EntityPropertyName != null)
+                {
+                    var relatedEntity = entity.GetType().GetProperty(hasOne.EntityPropertyName)?.GetValue(entity);
+                    if (relatedEntity != null)
+                        _context.Entry(relatedEntity).State = EntityState.Detached;
+                }
+                else
+                {
+                    _context.Entry(hasOneRelationship.Value).State = EntityState.Detached;
+                }
             }
 
             foreach (var hasManyRelationship in _jsonApiContext.HasManyRelationshipPointers.Get())
             {
-                foreach (var pointer in hasManyRelationship.Value)
+                var hasMany = (HasManyAttribute) hasManyRelationship.Key;
+                if (hasMany.EntityPropertyName != null)
                 {
-                    _context.Entry(pointer).State = EntityState.Detached;
+                    var relatedList = (IList)entity.GetType().GetProperty(hasMany.EntityPropertyName)?.GetValue(entity);
+                    foreach (var related in relatedList)
+                    {
+                        _context.Entry(related).State = EntityState.Detached;
+                    }
                 }
-
+                else
+                {
+                    foreach (var pointer in hasManyRelationship.Value)
+                    {
+                        _context.Entry(pointer).State = EntityState.Detached;
+                    }
+                }
+
                 // HACK: detaching has many relationships doesn't appear to be sufficient
                 // the navigation property actually needs to be nulled out, otherwise
                 // EF adds duplicate instances to the collection
@@ -192,14 +214,27 @@ private void AttachHasManyPointers(TEntity entity)
                 if (relationship.Key is HasManyThroughAttribute hasManyThrough)
                     AttachHasManyThrough(entity, hasManyThrough, relationship.Value);
                 else
-                    AttachHasMany(relationship.Key as HasManyAttribute, relationship.Value);
+                    AttachHasMany(entity, relationship.Key as HasManyAttribute, relationship.Value);
             }
         }
 
-        private void AttachHasMany(HasManyAttribute relationship, IList pointers)
+        private void AttachHasMany(TEntity entity, HasManyAttribute relationship, IList pointers)
         {
-            foreach (var pointer in pointers)
-                _context.Entry(pointer).State = EntityState.Unchanged;
+            if (relationship.EntityPropertyName != null)
+            {
+                var relatedList = (IList)entity.GetType().GetProperty(relationship.EntityPropertyName)?.GetValue(entity);
+                foreach (var related in relatedList)
+                {
+                    _context.Entry(related).State = EntityState.Unchanged;
+                }
+            }
+            else
+            {
+                foreach (var pointer in pointers)
+                {
+                    _context.Entry(pointer).State = EntityState.Unchanged;
+                }
+            }  
         }
 
         private void AttachHasManyThrough(TEntity entity, HasManyThroughAttribute hasManyThrough, IList pointers)
@@ -227,12 +262,27 @@ private void AttachHasManyThrough(TEntity entity, HasManyThroughAttribute hasMan
         /// This is used to allow creation of HasOne relationships when the
         /// independent side of the relationship already exists.
         /// </summary>
-        private void AttachHasOnePointers()
+        private void AttachHasOnePointers(TEntity entity)
         {
             var relationships = _jsonApiContext.HasOneRelationshipPointers.Get();
             foreach (var relationship in relationships)
-                if (_context.Entry(relationship.Value).State == EntityState.Detached && _context.EntityIsTracked(relationship.Value) == false)
-                    _context.Entry(relationship.Value).State = EntityState.Unchanged;
+            {
+                if (relationship.Key.GetType() != typeof(HasOneAttribute))
+                    continue;
+
+                var hasOne = (HasOneAttribute) relationship.Key;
+                if (hasOne.EntityPropertyName != null)
+                {
+                    var relatedEntity = entity.GetType().GetProperty(hasOne.EntityPropertyName)?.GetValue(entity);
+                    if (relatedEntity != null && _context.Entry(relatedEntity).State == EntityState.Detached && _context.EntityIsTracked((IIdentifiable)relatedEntity) == false)
+                        _context.Entry(relatedEntity).State = EntityState.Unchanged;
+                }
+                else
+                {
+                    if (_context.Entry(relationship.Value).State == EntityState.Detached && _context.EntityIsTracked(relationship.Value) == false)
+                        _context.Entry(relationship.Value).State = EntityState.Unchanged;
+                }
+            }
         }
 
         /// <inheritdoc />

src/JsonApiDotNetCore/JsonApiDotNetCore.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <VersionPrefix>3.0.0</VersionPrefix>
+    <VersionPrefix>3.0.1</VersionPrefix>
     <TargetFrameworks>$(NetStandardVersion)</TargetFrameworks>
     <AssemblyName>JsonApiDotNetCore</AssemblyName>
     <PackageId>JsonApiDotNetCore</PackageId>

src/JsonApiDotNetCore/Models/HasManyAttribute.cs

@@ -11,6 +11,7 @@ public class HasManyAttribute : RelationshipAttribute
         /// <param name="publicName">The relationship name as exposed by the API</param>
         /// <param name="documentLinks">Which links are available. Defaults to <see cref="Link.All"/></param>
         /// <param name="canInclude">Whether or not this relationship can be included using the <c>?include=public-name</c> query string</param>
+        /// <param name="mappedBy">The name of the entity mapped property, defaults to null</param>
         /// 
         /// <example>
         /// 
@@ -23,8 +24,8 @@ public class HasManyAttribute : RelationshipAttribute
         /// </code>
         /// 
         /// </example>
-        public HasManyAttribute(string publicName = null, Link documentLinks = Link.All, bool canInclude = true)
-        : base(publicName, documentLinks, canInclude)
+        public HasManyAttribute(string publicName = null, Link documentLinks = Link.All, bool canInclude = true, string mappedBy = null)
+        : base(publicName, documentLinks, canInclude, mappedBy)
         { }
 
         /// <summary>

src/JsonApiDotNetCore/Models/HasManyThroughAttribute.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Reflection;
+using System.Security;
 
 namespace JsonApiDotNetCore.Models
 {
@@ -30,14 +31,15 @@ public class HasManyThroughAttribute : HasManyAttribute
         /// <param name="internalThroughName">The name of the navigation property that will be used to get the HasMany relationship</param>
         /// <param name="documentLinks">Which links are available. Defaults to <see cref="Link.All"/></param>
         /// <param name="canInclude">Whether or not this relationship can be included using the <c>?include=public-name</c> query string</param>
+        /// <param name="mappedBy">The name of the entity mapped property, defaults to null</param>
         /// 
         /// <example>
         /// <code>
         /// [HasManyThrough(nameof(ArticleTags), documentLinks: Link.All, canInclude: true)]
         /// </code>
         /// </example>
-        public HasManyThroughAttribute(string internalThroughName, Link documentLinks = Link.All, bool canInclude = true)
-        : base(null, documentLinks, canInclude)
+        public HasManyThroughAttribute(string internalThroughName, Link documentLinks = Link.All, bool canInclude = true, string mappedBy = null)
+        : base(null, documentLinks, canInclude, mappedBy)
         {
             InternalThroughName = internalThroughName;
         }
@@ -50,14 +52,15 @@ public HasManyThroughAttribute(string internalThroughName, Link documentLinks =
         /// <param name="internalThroughName">The name of the navigation property that will be used to get the HasMany relationship</param>
         /// <param name="documentLinks">Which links are available. Defaults to <see cref="Link.All"/></param>
         /// <param name="canInclude">Whether or not this relationship can be included using the <c>?include=public-name</c> query string</param>
+        /// <param name="mappedBy">The name of the entity mapped property, defaults to null</param>
         /// 
         /// <example>
         /// <code>
         /// [HasManyThrough("tags", nameof(ArticleTags), documentLinks: Link.All, canInclude: true)]
         /// </code>
         /// </example>
-        public HasManyThroughAttribute(string publicName, string internalThroughName, Link documentLinks = Link.All, bool canInclude = true)
-        : base(publicName, documentLinks, canInclude)
+        public HasManyThroughAttribute(string publicName, string internalThroughName, Link documentLinks = Link.All, bool canInclude = true, string mappedBy = null)
+        : base(publicName, documentLinks, canInclude, mappedBy)
         {
             InternalThroughName = internalThroughName;
         }
@@ -161,4 +164,4 @@ public HasManyThroughAttribute(string publicName, string internalThroughName, Li
         /// </example>
         public override string RelationshipPath => $"{InternalThroughName}.{RightProperty.Name}";
     }
-}
+}

src/JsonApiDotNetCore/Models/HasOneAttribute.cs

@@ -13,28 +13,29 @@ public class HasOneAttribute : RelationshipAttribute
         /// <param name="documentLinks">Which links are available. Defaults to <see cref="Link.All"/></param>
         /// <param name="canInclude">Whether or not this relationship can be included using the <c>?include=public-name</c> query string</param>
         /// <param name="withForeignKey">The foreign key property name. Defaults to <c>"{RelationshipName}Id"</c></param>
+        /// <param name="mappedBy">The name of the entity mapped property, defaults to null</param>
         /// 
         /// <example>
         /// Using an alternative foreign key:
         /// 
         /// <code>
         /// public class Article : Identifiable 
         /// {
-        ///     [HasOne("author", withForiegnKey: nameof(AuthorKey)]
+        ///     [HasOne("author", withForeignKey: nameof(AuthorKey)]
         ///     public Author Author { get; set; }
         ///     public int AuthorKey { get; set; }
         /// }
         /// </code>
         /// 
         /// </example>
-        public HasOneAttribute(string publicName = null, Link documentLinks = Link.All, bool canInclude = true, string withForeignKey = null)
-        : base(publicName, documentLinks, canInclude)
+        public HasOneAttribute(string publicName = null, Link documentLinks = Link.All, bool canInclude = true, string withForeignKey = null, string mappedBy = null)
+        : base(publicName, documentLinks, canInclude, mappedBy)
         {
             _explicitIdentifiablePropertyName = withForeignKey;
         }
 
         private readonly string _explicitIdentifiablePropertyName;
-
+        
         /// <summary>
         /// The independent resource identifier.
         /// </summary>

src/JsonApiDotNetCore/Models/RelationshipAttribute.cs

@@ -6,15 +6,16 @@ namespace JsonApiDotNetCore.Models
 {
     public abstract class RelationshipAttribute : Attribute
     {
-        protected RelationshipAttribute(string publicName, Link documentLinks, bool canInclude)
+        protected RelationshipAttribute(string publicName, Link documentLinks, bool canInclude, string mappedBy)
         {
             PublicRelationshipName = publicName;
             DocumentLinks = documentLinks;
             CanInclude = canInclude;
+            EntityPropertyName = mappedBy;
         }
 
         public string PublicRelationshipName { get; internal set; }
-        public string InternalRelationshipName { get; internal set; }
+        public string InternalRelationshipName { get; internal set; } 
 
         /// <summary>
         /// The related entity type. This does not necessarily match the navigation property type.
@@ -31,6 +32,7 @@ protected RelationshipAttribute(string publicName, Link documentLinks, bool canI
         public bool IsHasOne => GetType() == typeof(HasOneAttribute);
         public Link DocumentLinks { get; } = Link.All;
         public bool CanInclude { get; }
+        public string EntityPropertyName { get; }
 
         public bool TryGetHasOne(out HasOneAttribute result)
         {
@@ -55,10 +57,10 @@ public bool TryGetHasMany(out HasManyAttribute result)
         }
 
         public abstract void SetValue(object entity, object newValue);
-
+        
         public object GetValue(object entity) => entity
-            ?.GetType()
-            .GetProperty(InternalRelationshipName)
+            ?.GetType()?
+            .GetProperty(InternalRelationshipName)?
             .GetValue(entity);
 
         public override string ToString()