DefaultEntityRepository cleanup

src/Examples/JsonApiDotNetCoreExample/Models/Passport.cs

@@ -0,0 +1,11 @@
+using JsonApiDotNetCore.Models;
+
+namespace JsonApiDotNetCoreExample.Models
+{
+    public class Passport : Identifiable
+    {
+        public virtual int? SocialSecurityNumber { get; set; }
+        [HasOne("person")]
+        public virtual Person Person { get; set; }
+    }
+}

src/Examples/JsonApiDotNetCoreExample/Models/Person.cs

@@ -45,5 +45,9 @@ public Dictionary<string, object> GetMeta(IJsonApiContext context)
                 { "authors", new string[] { "Jared Nance" } }
             };
         }
+        public int? PassportId { get; set; }
+        [HasOne("passport")]
+        public virtual Passport Passport { get; set; }
+
     }
 }

src/JsonApiDotNetCore/Data/IEntityWriteRepository.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using JsonApiDotNetCore.Models;
@@ -14,6 +15,9 @@ public interface IEntityWriteRepository<TEntity, in TId>
     {
         Task<TEntity> CreateAsync(TEntity entity);
 
+        Task<TEntity> UpdateAsync(TEntity entity);
+
+        [Obsolete("Use overload UpdateAsync(TEntity updatedEntity): providing parameter ID does no longer add anything relevant")]
         Task<TEntity> UpdateAsync(TId id, TEntity entity);
 
         Task UpdateRelationshipsAsync(object parent, RelationshipAttribute relationship, IEnumerable<string> relationshipIds);

src/JsonApiDotNetCore/Extensions/DbContextExtensions.cs

@@ -1,8 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using JsonApiDotNetCore.Models;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.ChangeTracking.Internal;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage;
 
@@ -32,6 +34,7 @@ public static bool EntityIsTracked(this DbContext context, IIdentifiable entity)
             return GetTrackedEntity(context, entity) != null;
         }
 
+
         /// <summary>
         /// Determines whether or not EF is already tracking an entity of the same Type and Id
         /// and returns that entity.

src/JsonApiDotNetCore/Extensions/IApplicationBuilderExtensions.cs

@@ -4,6 +4,7 @@
 using JsonApiDotNetCore.Middleware;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace JsonApiDotNetCore.Extensions
@@ -21,6 +22,12 @@ public static IApplicationBuilder UseJsonApi(this IApplicationBuilder app, bool
             if (useMvc)
                 app.UseMvc();
 
+            using (var scope = app.ApplicationServices.CreateScope())
+            {
+                var inverseRelationshipResolver = scope.ServiceProvider.GetService<IInverseRelationships>();
+                inverseRelationshipResolver?.Resolve();
+            }
+
             return app;
         }
 

src/JsonApiDotNetCore/Extensions/IServiceCollectionExtensions.cs

@@ -155,6 +155,9 @@ public static void AddJsonApiInternals(
             services.AddScoped<IControllerContext, Services.ControllerContext>();
             services.AddScoped<IDocumentBuilderOptionsProvider, DocumentBuilderOptionsProvider>();
 
+            services.AddScoped<IInverseRelationships, InverseRelationships>();
+
+
             // services.AddScoped<IActionFilter, TypeMatchFilter>();
         }
 

src/JsonApiDotNetCore/Extensions/TypeExtensions.cs

@@ -8,6 +8,42 @@ namespace JsonApiDotNetCore.Extensions
 {
     internal static class TypeExtensions
     {
+        /// <summary>
+        /// Extension to use the LINQ AddRange method on an IList
+        /// </summary>
+        public static void AddRange<T>(this IList list, IEnumerable<T> items)
+        {
+            if (list == null) throw new ArgumentNullException(nameof(list));
+            if (items == null) throw new ArgumentNullException(nameof(items));
+
+            if (list is List<T>)
+            {
+                ((List<T>)list).AddRange(items);
+            }
+            else
+            {
+                foreach (var item in items)
+                {
+                    list.Add(item);
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Extension to use the LINQ cast method in a non-generic way:
+        /// <code>
+        /// Type targetType = typeof(TEntity)
+        /// ((IList)myList).Cast(targetType).
+        /// </code>
+        /// </summary>
+        public static IEnumerable Cast(this IEnumerable source, Type type)
+        {
+            if (source == null) throw new ArgumentNullException(nameof(source));
+            if (type == null) throw new ArgumentNullException(nameof(type));
+            return TypeHelper.ConvertCollection(source.Cast<object>(), type);
+        }
+
         public static Type GetElementType(this IEnumerable enumerable)
         {
             var enumerableTypes = enumerable.GetType()

src/JsonApiDotNetCore/Formatters/JsonApiReader.cs

@@ -1,7 +1,9 @@
 using System;
+using System.Collections;
 using System.IO;
 using System.Threading.Tasks;
 using JsonApiDotNetCore.Internal;
+using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Serialization;
 using JsonApiDotNetCore.Services;
 using Microsoft.AspNetCore.Mvc.Formatters;
@@ -37,7 +39,7 @@ public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
             {
                 var body = GetRequestBody(context.HttpContext.Request.Body);
 
-                object model =null;
+                object model = null;
 
                 if (_jsonApiContext.IsRelationshipPath)
                 {
@@ -48,10 +50,29 @@ public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
                     model = _deSerializer.Deserialize(body);
                 }
 
+
                 if (model == null)
                 {
                     _logger?.LogError("An error occurred while de-serializing the payload");
                 }
+
+                if (context.HttpContext.Request.Method == "PATCH")
+                {
+                    bool idMissing;
+                    if (model is IList list)
+                    {
+                        idMissing = CheckForId(list);
+                    }
+                    else
+                    {
+                        idMissing = CheckForId(model);
+                    }
+                    if (idMissing)
+                    {
+                        _logger?.LogError("Payload must include id attribute");
+                        throw new JsonApiException(400, "Payload must include id attribute");
+                    }
+                }
                 return InputFormatterResult.SuccessAsync(model);
             }
             catch (Exception ex)
@@ -62,6 +83,40 @@ public Task<InputFormatterResult> ReadAsync(InputFormatterContext context)
             }
         }
 
+        /// <summary> Checks if the deserialized payload has an ID included </summary
+        private bool CheckForId(object model)
+        {
+            if (model == null) return false;
+            if (model is ResourceObject ro)
+            {
+                if (string.IsNullOrEmpty(ro.Id)) return true;
+            }
+            else if (model is IIdentifiable identifiable)
+            {
+                if (string.IsNullOrEmpty(identifiable.StringId)) return true;
+            }
+            return false;
+        }
+
+        /// <summary> Checks if the elements in the deserialized payload have an ID included </summary
+        private bool CheckForId(IList modelList)
+        {
+            foreach (var model in modelList)
+            {
+                if (model == null) continue;
+                if (model is ResourceObject ro)
+                {
+                    if (string.IsNullOrEmpty(ro.Id)) return true;
+                }
+                else if (model is IIdentifiable identifiable)
+                {
+                    if (string.IsNullOrEmpty(identifiable.StringId)) return true;
+                }
+            }
+            return false;
+
+        }
+
         private string GetRequestBody(Stream body)
         {
             using (var reader = new StreamReader(body))

src/JsonApiDotNetCore/Internal/InverseRelationships.cs

@@ -0,0 +1,71 @@
+using System;
+using JsonApiDotNetCore.Data;
+using JsonApiDotNetCore.Models;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace JsonApiDotNetCore.Internal
+{
+    /// <summary>
+    /// Responsible for populating the RelationshipAttribute InverseNavigation property.
+    /// 
+    /// This service is instantiated in the configure phase of the application.
+    /// 
+    /// When using a data access layer different from EF Core, and when using ResourceHooks
+    /// that depend on the inverse navigation property (BeforeImplicitUpdateRelationship),
+    /// you will need to override this service, or pass along the inverseNavigationProperty in
+    /// the RelationshipAttribute.
+    /// </summary>
+    public interface IInverseRelationships
+    {
+        /// <summary>
+        /// This method is called upon startup by JsonApiDotNetCore. It should 
+        /// deal with resolving the inverse relationships. 
+        /// </summary>
+        void Resolve();
+    }
+
+    /// <inheritdoc />
+    public class InverseRelationships : IInverseRelationships
+    {
+        private readonly ResourceGraph _graph;
+        private readonly IDbContextResolver _resolver;
+
+        public InverseRelationships(IResourceGraph graph, IDbContextResolver resolver = null)
+        {
+            _graph = (ResourceGraph)graph;
+            _resolver = resolver;
+        }
+
+        /// <inheritdoc />
+        public void Resolve()
+        {
+            if (EntityFrameworkCoreIsEnabled())
+            {
+                DbContext context = _resolver.GetContext();
+
+                foreach (ContextEntity ce in _graph.Entities)
+                {
+                    IEntityType meta = context.Model.FindEntityType(ce.EntityType);
+                    if (meta == null) continue;
+                    foreach (var attr in ce.Relationships)
+                    {
+                        if (attr is HasManyThroughAttribute) continue;
+                        INavigation inverseNavigation = meta.FindNavigation(attr.InternalRelationshipName)?.FindInverse();
+                        attr.InverseNavigation = inverseNavigation?.Name;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// If EF Core is not being used, we're expecting the resolver to not be registered.
+        /// </summary>
+        /// <returns><c>true</c>, if entity framework core was enabled, <c>false</c> otherwise.</returns>
+        /// <param name="resolver">Resolver.</param>
+        private bool EntityFrameworkCoreIsEnabled()
+        {
+            return _resolver != null;
+        }
+    }
+}

src/JsonApiDotNetCore/Models/HasManyAttribute.cs

@@ -24,9 +24,11 @@ public class HasManyAttribute : RelationshipAttribute
         /// </code>
         /// 
         /// </example>
-        public HasManyAttribute(string publicName = null, Link documentLinks = Link.All, bool canInclude = true, string mappedBy = null)
+        public HasManyAttribute(string publicName = null, Link documentLinks = Link.All, bool canInclude = true, string mappedBy = null, string inverseNavigationProperty = null)
         : base(publicName, documentLinks, canInclude, mappedBy)
-        { }
+        {
+            InverseNavigation = inverseNavigationProperty;
+        }
 
         /// <summary>
         /// Sets the value of the property identified by this attribute

src/JsonApiDotNetCore/Models/HasOneAttribute.cs

@@ -28,10 +28,11 @@ public class HasOneAttribute : RelationshipAttribute
         /// </code>
         /// 
         /// </example>
-        public HasOneAttribute(string publicName = null, Link documentLinks = Link.All, bool canInclude = true, string withForeignKey = null, string mappedBy = null)
+        public HasOneAttribute(string publicName = null, Link documentLinks = Link.All, bool canInclude = true, string withForeignKey = null, string mappedBy = null, string inverseNavigationProperty = null)
         : base(publicName, documentLinks, canInclude, mappedBy)
         {
             _explicitIdentifiablePropertyName = withForeignKey;
+            InverseNavigation = inverseNavigationProperty;
         }
 
         private readonly string _explicitIdentifiablePropertyName;
@@ -50,14 +51,13 @@ public HasOneAttribute(string publicName = null, Link documentLinks = Link.All,
         /// <param name="newValue">The new property value</param>
         public override void SetValue(object resource, object newValue)
         {
-            var propertyName = (newValue?.GetType() == Type)
-                ? InternalRelationshipName
-                : IdentifiablePropertyName;
-
-            var propertyInfo = resource
-                .GetType()
-                .GetProperty(propertyName);
+            string propertyName = InternalRelationshipName;
+            // if we're deleting the relationship (setting it to null),
+            // we set the foreignKey to null. We could also set the actual property to null,
+            // but then we would first need to load the current relationship, which requires an extra query.
+            if (newValue == null) propertyName = IdentifiablePropertyName;
 
+            var propertyInfo = resource.GetType().GetProperty(propertyName);
             propertyInfo.SetValue(resource, newValue);
         }
 

src/JsonApiDotNetCore/Models/RelationshipAttribute.cs

@@ -15,8 +15,9 @@ protected RelationshipAttribute(string publicName, Link documentLinks, bool canI
         }
 
         public string PublicRelationshipName { get; internal set; }
-        public string InternalRelationshipName { get; internal set; } 
-
+        public string InternalRelationshipName { get; internal set; }
+        public string InverseNavigation { get; internal set; }
+
         /// <summary>
         /// The related entity type. This does not necessarily match the navigation property type.
         /// In the case of a HasMany relationship, this value will be the generic argument type.

src/JsonApiDotNetCore/Request/HasManyRelationshipPointers.cs

@@ -32,7 +32,7 @@ namespace JsonApiDotNetCore.Request
     /// </summary>
     public class HasManyRelationshipPointers
     {
-        private Dictionary<RelationshipAttribute, IList> _hasManyRelationships = new Dictionary<RelationshipAttribute, IList>();
+        private readonly Dictionary<RelationshipAttribute, IList> _hasManyRelationships = new Dictionary<RelationshipAttribute, IList>();
 
         /// <summary>
         /// Add the relationship to the list of relationships that should be 

src/JsonApiDotNetCore/Request/HasOneRelationshipPointers.cs

@@ -28,18 +28,18 @@ namespace JsonApiDotNetCore.Request
     /// </summary>
     public class HasOneRelationshipPointers
     {
-        private Dictionary<RelationshipAttribute, IIdentifiable> _hasOneRelationships = new Dictionary<RelationshipAttribute, IIdentifiable>();
+        private readonly Dictionary<HasOneAttribute, IIdentifiable> _hasOneRelationships = new Dictionary<HasOneAttribute, IIdentifiable>();
 
         /// <summary>
         /// Add the relationship to the list of relationships that should be 
         /// set in the repository layer.
         /// </summary>
-        public void Add(RelationshipAttribute relationship, IIdentifiable entity)
+        public void Add(HasOneAttribute relationship, IIdentifiable entity)
             => _hasOneRelationships[relationship] = entity;
 
         /// <summary>
         /// Get all the models that should be associated
         /// </summary>
-        public Dictionary<RelationshipAttribute, IIdentifiable> Get() => _hasOneRelationships;
+        public Dictionary<HasOneAttribute, IIdentifiable> Get() => _hasOneRelationships;
     }
 }