How to support JSON API Error Objects?

[Bouke]

JSON API specifies a format for so-called "error objects". While I could create such error documents myself, I would be interested to see what would be needed to support creating such documents based on ModelState validation.

An example from the JSON API site:

HTTP/1.1 422 Unprocessable Entity
Content-Type: application/vnd.api+json

{
  "jsonapi": { "version": "1.0" },
  "errors": [
    {
      "code":   "123",
      "source": { "pointer": "/data/attributes/firstName" },
      "title":  "Value is too short",
      "detail": "First name must contain at least three characters."
    },
    {
      "code":   "225",
      "source": { "pointer": "/data/attributes/password" },
      "title": "Passwords must contain a letter, number, and punctuation character.",
      "detail": "The password provided is missing a punctuation character."
    },
    {
      "code":   "226",
      "source": { "pointer": "/data/attributes/password" },
      "title": "Password and password confirmation do not match."
    }
  ]
}

For reference, the default output of ModelState looks like this:

if (!ModelState.IsValid)
    throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));

{
    "Message": "The request is invalid.",
    "ModelState": {
        "category.Name": [
            "The field Name must be a string or array type with a minimum length of '20'."
        ]
    }
}

[alex-davies]

So the model for errors already exists (https://github.com/codecutout/JsonApiSerializer/blob/master/src/JsonApiSerializer/JsonApi/Error.cs), are looking for is something to map ModelState to an ErrorDocument?

I have a few concerns about providing utilities to map from ModelState to ErrorDocument

• Lots of the details on an Error document are application specific and this information isn't available on the ModelState, we can only reliably map the Detail property (and maybe the source property)
• The serializer library would have to bring in a Dependency to Microsoft.AspNetCore.Mvc.Abstractions which is something I would be reluctant in doing
• Implementation is simple enough to do in user code, something like

public IDocument ModelStateToErrorDocument(ModelStateDictionary modelstate)
        {
            return new Document<string>
            {
                Errors = modelstate.SelectMany(ms => ms.Value.Errors, (ms, mse) => new Error()
                {
                    Detail = mse.ErrorMessage
                });
            }
        }

If you wanted to map the source that could be useful. It would require some utility methods to map .NET Model path (category.Name) to JsonApi path (/data/attributes/name). This is something that makes sense to be bundled with the serializer. If you want this I am open to PRs that provide such a utility

[Bouke]

If you wanted to map the source that could be useful. It would require some utility methods to map .NET Model path (category.Name) to JsonApi path (/data/attributes/name). This is something that makes sense to be bundled with the serializer.

So yeah, that's the difficult part here. Ideally I'd use the configured contract resolver for this, but from initial inspection of the API I haven't found the hooks I was looking for. Maybe you have a few pointers for me? I could try and create a PR for this.

[alex-davies]

Thinking about this for a bit, this addition is reasonably involved. Currently the json is serialized/deserialzed incrementally via calls to various convertors, there is nothing in the codebase that directly maps full paths.

We would have to map the path by following the same sort of rules and behavior that both the JsonApiSerializer uses and the rules that JsonSerializer uses.

From JsonApiContractResolver will have be able to get the ResourceObjectConvertor to determine if a Type is a resource object (which you need to determine if we should path to /relationships or /attributes). You will also need to call the contract resolver to get JsonObjectContract for various types, this contains lots of information used by the JsonSerializer (e.g. what name the field is serialized/deserialized with)

Ill try and have a deeper look later this week to see if I can get something simple going that we can iterate on

[alex-davies]

@Bouke here is a first cut of generating source pointers #76

It needs a more testing around different model layouts before I am comfortable merging. Ideally would also like a way to convert back from source pointer to model pointer as well

The public methods added are

var pointer = SourcePointer.FromModel<Article>(x => x.Author.FirstName, new JsonApiSerializerSettings());
var pointer = SourcePointer.FromModel<Article>("x.Author.Firstname", new JsonApiSerializerSettings());

var canResolve = SourcePointer.TryFromModel<Article>(x => x.Author.FirstName, new JsonApiSerializerSettings(), out string pointer);
var canResolve = SourcePointer.TryFromModel<Article>("x.Author.Firstname", new JsonApiSerializerSettings(), out string pointer);

Would appreciate a review and keen to get some feedback if this was the sort of functionality you were looking for

[marijnz0r]

Hi @alex-davies and @Bouke
Would you be interested if I take a look at this issue and try to create a pull request?
Kind regards

[alex-davies]

@marijnz0r you are welcome to have a look at this.

PR #76 is a good starting point. As it is at the moment in the PR the pointer logic is entirely separate from the rest of the library, this is good in that it can be implemented in isolation, but it has the drawback in that you have to implement in a way such that the behaviour is the same as the rest of the library.

Ill leave it to you if you want to build on the PR, or if you want to try and fold the pointer logic into the converters

[falestra]

How to use error response in asp.net core web api?

[rbonestell]

Checking in another year later, has anyone accomplished supporting JSON:API serialization of ASP.NET model validation errors to JSON:API error objects?

Update!

For anyone else looking to support JSON:API format for ASP.NET validation responses using this JsonApiSerializer library, here's how I've accomplished that goal in ASP.NET Core 5:

1. Disable ASP.NET ApiController's implicit model state validation in Startup.ConfigureServices():
   services.Configure<ApiBehaviorOptions>(options => { options.SuppressModelStateInvalidFilter = true; });
2. Create a new custom ActionFilterAttribute:

public class JsonApiValidationFilterAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        if (!context.ModelState.IsValid)
        {
            DocumentRoot<string> response = new()
            {
                Errors = context.ModelState
                    .SelectMany(ms => ms.Value.Errors, (ms, mse) =>
                        new Error()
                        {
                            Detail = mse.ErrorMessage,
                            Status = "400",
                            Title = "Validation error"
                        }).ToList()
            };
            context.Result = new BadRequestObjectResult(response);
        }
        base.OnActionExecuting(context);
    }
}

3. Add your new [JsonApiValidationFilter] attribute to your JSON:API-friendly controller classes.