Merge branch 'master' into various-fixes

Author: Bart Koelman

src/Examples/JsonApiDotNetCoreExample/Models/Passport.cs

@@ -65,7 +65,7 @@ public string BirthCountryName
         [EagerLoad]
         public Country BirthCountry { get; set; }
 
-        [Attr(isImmutable: true)]
+        [Attr(AttrCapabilities.All & ~AttrCapabilities.AllowMutate)]
         [NotMapped]
         public string GrantedVisaCountries => GrantedVisas == null || !GrantedVisas.Any()
             ? null

src/Examples/JsonApiDotNetCoreExample/Models/TodoItem.cs

@@ -32,13 +32,13 @@ public string AlwaysChangingValue
         [Attr]
         public DateTime CreatedDate { get; set; }
 
-        [Attr(isFilterable: false, isSortable: false)]
+        [Attr(AttrCapabilities.All & ~(AttrCapabilities.AllowFilter | AttrCapabilities.AllowSort))]
         public DateTime? AchievedDate { get; set; }
 
         [Attr]
         public DateTime? UpdatedDate { get; set; }
 
-        [Attr(isImmutable: true)]
+        [Attr(AttrCapabilities.All & ~AttrCapabilities.AllowMutate)]
         public string CalculatedValue => "calculated";
 
         [Attr]

src/JsonApiDotNetCore/Builders/ResourceGraphBuilder.cs

@@ -88,30 +88,35 @@ protected virtual List<AttrAttribute> GetAttributes(Type entityType)
         {
             var attributes = new List<AttrAttribute>();
 
-            var properties = entityType.GetProperties();
-
-            foreach (var prop in properties)
+            foreach (var property in entityType.GetProperties())
             {
-                // todo: investigate why this is added in the exposed attributes list
+                var attribute = (AttrAttribute)property.GetCustomAttribute(typeof(AttrAttribute));
+
+                // TODO: investigate why this is added in the exposed attributes list
                 // because it is not really defined attribute considered from the json:api
                 // spec point of view.
-                if (prop.Name == nameof(Identifiable.Id))
+                if (property.Name == nameof(Identifiable.Id) && attribute == null)
                 {
                     var idAttr = new AttrAttribute
                     {
-                        PublicAttributeName = FormatPropertyName(prop),
-                        PropertyInfo = prop
+                        PublicAttributeName = FormatPropertyName(property),
+                        PropertyInfo = property,
+                        Capabilities = _options.DefaultAttrCapabilities
                     };
                     attributes.Add(idAttr);
                     continue;
                 }
 
-                var attribute = (AttrAttribute)prop.GetCustomAttribute(typeof(AttrAttribute));
                 if (attribute == null)
                     continue;
 
-                attribute.PublicAttributeName ??= FormatPropertyName(prop);
-                attribute.PropertyInfo = prop;
+                attribute.PublicAttributeName ??= FormatPropertyName(property);
+                attribute.PropertyInfo = property;
+
+                if (!attribute.HasExplicitCapabilities)
+                {
+                    attribute.Capabilities = _options.DefaultAttrCapabilities;
+                }
 
                 attributes.Add(attribute);
             }
@@ -238,8 +243,7 @@ private string FormatResourceName(Type resourceType)
 
         private string FormatPropertyName(PropertyInfo resourceProperty)
         {
-            var contractResolver = (DefaultContractResolver)_options.SerializerSettings.ContractResolver;
-            return contractResolver.NamingStrategy.GetPropertyName(resourceProperty.Name, false);
+            return _options.SerializerContractResolver.NamingStrategy.GetPropertyName(resourceProperty.Name, false);
         }
     }
 }

src/JsonApiDotNetCore/Configuration/IJsonApiOptions.cs

@@ -1,6 +1,8 @@
 using System;
+using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Models.JsonApiDocuments;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
 
 namespace JsonApiDotNetCore.Configuration
 {
@@ -59,5 +61,13 @@ public interface IJsonApiOptions : ILinksConfiguration
         /// </example>
         /// </summary>
         JsonSerializerSettings SerializerSettings { get; }
+
+        internal DefaultContractResolver SerializerContractResolver => (DefaultContractResolver)SerializerSettings.ContractResolver;
+        
+        /// <summary>
+        /// Specifies the default query string capabilities that can be used on exposed json:api attributes.
+        /// Defaults to <see cref="AttrCapabilities.All"/>.
+        /// </summary>
+        AttrCapabilities DefaultAttrCapabilities { get; }
     }
 }

src/JsonApiDotNetCore/Configuration/JsonApiOptions.cs

@@ -1,4 +1,5 @@
 using JsonApiDotNetCore.Graph;
+using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Models.Links;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
@@ -58,6 +59,9 @@ public class JsonApiOptions : IJsonApiOptions
         /// <inheritdoc/>
         public bool AllowQueryStringOverrideForSerializerDefaultValueHandling { get; set; }
 
+        /// <inheritdoc/>
+        public AttrCapabilities DefaultAttrCapabilities { get; } = AttrCapabilities.All;
+
         /// <summary>
         /// The default page size for all resources. The value zero means: no paging.
         /// </summary>

src/JsonApiDotNetCore/Controllers/BaseJsonApiController.cs

@@ -6,6 +6,7 @@
 using JsonApiDotNetCore.Services;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
+using Newtonsoft.Json.Serialization;
 
 namespace JsonApiDotNetCore.Controllers
 {
@@ -114,7 +115,10 @@ public virtual async Task<IActionResult> PostAsync([FromBody] T entity)
                 throw new ResourceIdInPostRequestNotAllowedException();
 
             if (_jsonApiOptions.ValidateModelState && !ModelState.IsValid)
-                throw new InvalidModelStateException(ModelState, typeof(T), _jsonApiOptions.IncludeExceptionStackTraceInErrors);
+            {
+                var namingStrategy = _jsonApiOptions.SerializerContractResolver.NamingStrategy;
+                throw new InvalidModelStateException(ModelState, typeof(T), _jsonApiOptions.IncludeExceptionStackTraceInErrors, namingStrategy);
+            }
 
             entity = await _create.CreateAsync(entity);
 
@@ -130,7 +134,10 @@ public virtual async Task<IActionResult> PatchAsync(TId id, [FromBody] T entity)
                 throw new InvalidRequestBodyException(null, null, null);
 
             if (_jsonApiOptions.ValidateModelState && !ModelState.IsValid)
-                throw new InvalidModelStateException(ModelState, typeof(T), _jsonApiOptions.IncludeExceptionStackTraceInErrors);
+            {
+                var namingStrategy = _jsonApiOptions.SerializerContractResolver.NamingStrategy;
+                throw new InvalidModelStateException(ModelState, typeof(T), _jsonApiOptions.IncludeExceptionStackTraceInErrors, namingStrategy);
+            }
 
             var updatedEntity = await _update.UpdateAsync(id, entity);
             return updatedEntity == null ? Ok(null) : Ok(updatedEntity);

src/JsonApiDotNetCore/Exceptions/InvalidModelStateException.cs

@@ -6,6 +6,7 @@
 using JsonApiDotNetCore.Models;
 using JsonApiDotNetCore.Models.JsonApiDocuments;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
+using Newtonsoft.Json.Serialization;
 
 namespace JsonApiDotNetCore.Exceptions
 {
@@ -17,13 +18,13 @@ public class InvalidModelStateException : Exception
         public IList<Error> Errors { get; }
 
         public InvalidModelStateException(ModelStateDictionary modelState, Type resourceType,
-            bool includeExceptionStackTraceInErrors)
+            bool includeExceptionStackTraceInErrors, NamingStrategy namingStrategy)
         {
-            Errors = FromModelState(modelState, resourceType, includeExceptionStackTraceInErrors);
+            Errors = FromModelState(modelState, resourceType, includeExceptionStackTraceInErrors, namingStrategy);
         }
 
         private static List<Error> FromModelState(ModelStateDictionary modelState, Type resourceType,
-            bool includeExceptionStackTraceInErrors)
+            bool includeExceptionStackTraceInErrors, NamingStrategy namingStrategy)
         {
             List<Error> errors = new List<Error>();
 
@@ -32,9 +33,8 @@ private static List<Error> FromModelState(ModelStateDictionary modelState, Type
                 var propertyName = pair.Key;
                 PropertyInfo property = resourceType.GetProperty(propertyName);
 
-                // TODO: Need access to ResourceContext here, in order to determine attribute name when not explicitly set.
                 string attributeName =
-                    property?.GetCustomAttribute<AttrAttribute>().PublicAttributeName ?? property?.Name;
+                    property.GetCustomAttribute<AttrAttribute>().PublicAttributeName ?? namingStrategy.GetPropertyName(property.Name, false);
 
                 foreach (var modelError in pair.Value.Errors)
                 {

src/JsonApiDotNetCore/Graph/ResourceNameFormatter.cs

@@ -13,8 +13,7 @@ internal sealed class ResourceNameFormatter
 
         public ResourceNameFormatter(IJsonApiOptions options)
         {
-            var contractResolver = (DefaultContractResolver) options.SerializerSettings.ContractResolver;
-            _namingStrategy = contractResolver.NamingStrategy;
+            _namingStrategy = options.SerializerContractResolver.NamingStrategy;
         }
 
         /// <summary>

src/JsonApiDotNetCore/Internal/DefaultRoutingConvention.cs

@@ -106,8 +106,7 @@ private string TemplateFromResource(ControllerModel model)
         /// </summary>
         private string TemplateFromController(ControllerModel model)
         {
-            var contractResolver = (DefaultContractResolver) _options.SerializerSettings.ContractResolver;
-            string controllerName = contractResolver.NamingStrategy.GetPropertyName(model.ControllerName, false);
+            string controllerName = _options.SerializerContractResolver.NamingStrategy.GetPropertyName(model.ControllerName, false);
 
             var template = $"{_options.Namespace}/{controllerName}";
             if (_registeredTemplates.Add(template))

src/JsonApiDotNetCore/Models/Annotation/AttrAttribute.cs

@@ -8,58 +8,75 @@ namespace JsonApiDotNetCore.Models
     public sealed class AttrAttribute : Attribute, IResourceField
     {
         /// <summary>
-        /// Defines a public attribute exposed by the API
+        /// Exposes a resource property as a json:api attribute using the configured casing convention and capabilities.
         /// </summary>
-        /// 
-        /// <param name="publicName">How this attribute is exposed through the API</param>
-        /// <param name="isImmutable">Prevent PATCH requests from updating the value</param>
-        /// <param name="isFilterable">Prevent filters on this attribute</param>
-        /// <param name="isSortable">Prevent this attribute from being sorted by</param>
-        /// 
         /// <example>
-        /// 
         /// <code>
         /// public class Author : Identifiable
         /// {
         ///     [Attr]
         ///     public string Name { get; set; }
         /// }
         /// </code>
-        /// 
         /// </example>
-        public AttrAttribute(string publicName = null, bool isImmutable = false, bool isFilterable = true, bool isSortable = true)
+        public AttrAttribute()
         {
-            PublicAttributeName = publicName;
-            IsImmutable = isImmutable;
-            IsFilterable = isFilterable;
-            IsSortable = isSortable;
         }
 
-        string IResourceField.PropertyName => PropertyInfo.Name;
-
         /// <summary>
-        /// How this attribute is exposed through the API
+        /// Exposes a resource property as a json:api attribute with an explicit name, using configured capabilities.
         /// </summary>
-        public string PublicAttributeName { get; internal set; }
+        public AttrAttribute(string publicName)
+        {
+            if (publicName == null)
+            {
+                throw new ArgumentNullException(nameof(publicName));
+            }
+
+            if (string.IsNullOrWhiteSpace(publicName))
+            {
+                throw new ArgumentException("Exposed name cannot be empty or contain only whitespace.", nameof(publicName));
+            }
+
+            PublicAttributeName = publicName;
+        }
 
         /// <summary>
-        /// Prevents PATCH requests from updating the value.
+        /// Exposes a resource property as a json:api attribute using the configured casing convention and an explicit set of capabilities.
         /// </summary>
-        public bool IsImmutable { get; }
+        /// <example>
+        /// <code>
+        /// public class Author : Identifiable
+        /// {
+        ///     [Attr(AttrCapabilities.AllowFilter | AttrCapabilities.AllowSort)]
+        ///     public string Name { get; set; }
+        /// }
+        /// </code>
+        /// </example>
+        public AttrAttribute(AttrCapabilities capabilities)
+        {
+            HasExplicitCapabilities = true;
+            Capabilities = capabilities;
+        }
 
         /// <summary>
-        /// Whether or not this attribute can be filtered on via a query string filters.
-        /// Attempts to filter on an attribute with `IsFilterable == false` will return
-        /// an HTTP 400 response.
+        /// Exposes a resource property as a json:api attribute with an explicit name and capabilities.
         /// </summary>
-        public bool IsFilterable { get; }
+        public AttrAttribute(string publicName, AttrCapabilities capabilities) : this(publicName)
+        {
+            HasExplicitCapabilities = true;
+            Capabilities = capabilities;
+        }
+
+        string IResourceField.PropertyName => PropertyInfo.Name;
 
         /// <summary>
-        /// Whether or not this attribute can be sorted on via a query string sort.
-        /// Attempts to filter on an attribute with `IsSortable == false` will return
-        /// an HTTP 400 response.
+        /// The publicly exposed name of this json:api attribute.
         /// </summary>
-        public bool IsSortable { get; }
+        public string PublicAttributeName { get; internal set; }
+
+        internal bool HasExplicitCapabilities { get; }
+        public AttrCapabilities Capabilities { get; internal set; }
 
         /// <summary>
         /// The resource property that this attribute is declared on.

src/JsonApiDotNetCore/Models/AttrCapabilities.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace JsonApiDotNetCore.Models
+{
+    /// <summary>
+    /// Indicates query string capabilities that can be performed on an <see cref="AttrAttribute"/>.
+    /// </summary>
+    [Flags]
+    public enum AttrCapabilities
+    {
+        None = 0,
+        
+        /// <summary>
+        /// Whether or not PATCH requests can update the attribute value.
+        /// Attempts to update when disabled will return an HTTP 422 response.
+        /// </summary>
+        AllowMutate = 1,
+        
+        /// <summary>
+        /// Whether or not an attribute can be filtered on via a query string parameter.
+        /// Attempts to sort when disabled will return an HTTP 400 response.
+        /// </summary>
+        AllowFilter = 2,
+        
+        /// <summary>
+        /// Whether or not an attribute can be sorted on via a query string parameter.
+        /// Attempts to sort when disabled will return an HTTP 400 response.
+        /// </summary>
+        AllowSort = 4,
+
+        All = AllowMutate | AllowFilter | AllowSort
+    }
+}

src/JsonApiDotNetCore/Models/Annotation/IResourceField.cs renamed to src/JsonApiDotNetCore/Models/IResourceField.cs

@@ -15,8 +15,15 @@ public sealed class ErrorMeta
 
         public void IncludeExceptionStackTrace(Exception exception)
         {
-            Data["StackTrace"] = exception?.Demystify().ToString()
-                .Split(new[] {"\n"}, int.MaxValue, StringSplitOptions.RemoveEmptyEntries);
+            if (exception == null)
+            {
+                Data.Remove("StackTrace");
+            }
+            else
+            {
+                Data["StackTrace"] = exception.Demystify().ToString()
+                    .Split(new[] { "\n" }, int.MaxValue, StringSplitOptions.RemoveEmptyEntries);
+            }
         }
     }
 }

src/JsonApiDotNetCore/Models/JsonApiDocuments/ErrorMeta.cs

@@ -63,7 +63,7 @@ private FilterQueryContext GetQueryContexts(FilterQuery query, string parameterN
             queryContext.Relationship = GetRelationship(parameterName, query.Relationship);
             var attribute = GetAttribute(parameterName, query.Attribute, queryContext.Relationship);
 
-            if (!attribute.IsFilterable)
+            if (!attribute.Capabilities.HasFlag(AttrCapabilities.AllowFilter))
             {
                 throw new InvalidQueryStringParameterException(parameterName, "Filtering on the requested attribute is not allowed.",
                     $"Filtering on attribute '{attribute.PublicAttributeName}' is not allowed.");

src/JsonApiDotNetCore/QueryParameterServices/FilterService.cs

@@ -5,6 +5,7 @@
 using JsonApiDotNetCore.Internal.Contracts;
 using JsonApiDotNetCore.Internal.Query;
 using JsonApiDotNetCore.Managers.Contracts;
+using JsonApiDotNetCore.Models;
 using Microsoft.Extensions.Primitives;
 
 namespace JsonApiDotNetCore.Query
@@ -90,7 +91,7 @@ private SortQueryContext BuildQueryContext(SortQuery query)
             var relationship = GetRelationship("sort", query.Relationship);
             var attribute = GetAttribute("sort", query.Attribute, relationship);
 
-            if (!attribute.IsSortable)
+            if (!attribute.Capabilities.HasFlag(AttrCapabilities.AllowSort))
             {
                 throw new InvalidQueryStringParameterException("sort", "Sorting on the requested attribute is not allowed.",
                     $"Sorting on attribute '{attribute.PublicAttributeName}' is not allowed.");