Self Descriptive HTTP API in ASP.NET Core: Siren

This post is in my Self Descriptive HTTP API in ASP.NET Core series. It demonstrates how to design an HTTP API like a regular HTML website. Bringing the concepts of links and actions to your API allows your clients to consume it with ease.

If you’re new to this series, here are earlier posts to get up to speed:

If you have any questions, please follow me on Twitter.

Siren

I mentioned that Siren was one media type that appeals to me because it supports both links and actions.  This is important because I generally build core parts of an application following CQRS by implementing commands that change the state of my system or queries that return state.

Libraries

There are a few projects/libraries that help with generating a output that follows the siren spec.

With all these libraries, the number of downloads on NuGet is really low. However, I think they all have value in at least looking at the source to get some ideas if you aren’t comfortable with taking a dependency on them.

Nancy.Siren

I discovered Jonathan Channon’s Nancy.Siren a couple months ago and really liked the idea of having your endpoints return your usual DTO and having a response processor mutate your DTO into a Siren payload.

If you use Nancy (as I do) this is worth looking at.  I plan on digging into this a bit more for all you NancyFX fans.

Migrap.AspNetCore.Hateoas

This is a project I found on GitHub that takes the same approach as Nancy.Siren by handling requests that accept application/vnd.siren+json by transforming them to a siren payload.

I’ve forked this and have added a ASP.NET Core MVC application to it to build a Todo demo.

All the source code you will find below through the rest of this post is available on GitHub.

Note: I’m intentionally leaving some snippets of setup code out of this blog post.  The demo source code in its entirety is pretty easy to follow.

Todo

So for some context about this Todo application.  I’ve got a simple model to represent a todo item.

I’ve setup a simple Controller that provides endpoints for performing the following:

  • Get all the Todo’s
  • Get an individual Todo
  • Add a Todo
  • Delete a Todo
  • Mark a Todo as complete

This should look at pretty familiar and straight forward.  Here’s a result in postman when getting the list of our Todo’s.

 

Relation and Actions

What’s missing from that payload are the related URIs or actions I could perform related to this resource or others.  As mentioned in my prior blog post about Hypermedia, is that where media types like Siren provide the ability to give your consuming clients this information.

StateConverter

In order to transform our collection of TodoModel’s into a siren payload we need to create an implementation of the IStateConverter.  We will return a Document that will describe the properties and entities (Todo’s) for this resource.  For each Todo we will also provide the URI of how to access it specifically.

 

Once we do this, if we make our HTTP call but this time specifying an Accept header of application/vnd.siren+json, we will get our siren payload.

 

Next

All the source code for my demo is available on GitHub.

In the next few posts we will start digging in more by adding actions and workflow based on application state.

If anyone has any other suggestions or recommendations about this series, please leave comment or let me know on twitter.

  1. Building a Self Descriptive HTTP API in ASP.NET Core
  2. Object as Resource
  3. Hypermedia
  4. Siren
  5. HATEOAS
  6. Hypermedia Clients

Self Descriptive HTTP API in ASP.NET Core: Hypermedia

This post is in my Self Descriptive HTTP API in ASP.NET Core series. It demonstrates how to design an HTTP API like a regular HTML website. Bringing the concepts of links and actions to your API allows your clients to consume it with ease.

If you’re new to this series, here are earlier posts to get up to speed:

Hypermedia

You probably have already heard the term hypermedia before.  Hypermedia and Hypertext are nothing new.  They were both coined in the 60’s by Ted Nelson.

You’ve definitely used hypermedia in the form of HTML.

HTML has a great set of tags that represent hypermedia.

When you are writing HTML and using <a>  <forms> <img>  <link> <script> tags you are proving information to the client about other navigation or actions they can perform.

Your browser is nothing more then a hypermedia client that understands HTML.  In the case of <a> or <form> the end user behind the browser ultimately decides if they are going to follow those links or submit the form.  You generally hit a a website either by navigating from another site, or manually enter the URI in your browsers address bar.  You then navigate the site via links and forms.  I generally don’t see people typing in every URI in there browser address bar 🙂

Googlebot (web crawler) is another great example of a hypermedia client that understands HTML.  It follows <a> tags through your site to crawl all the exposed pages.  Googlebot doesn’t know how to craw a random URI on your site unless you tell it.

It’s not magic.  It’s about returning a media type (content-type) and payload the client can understand.

APIs

What I find really interesting is even with how successful HTML is the popularity of using hypermedia in our HTTP API’s seems really low.

It’s not because of lack of media types.  HAL (Hypertext Application Language) was the first media type I discovered when starting thinking about the idea of linking one URI to another in my HTTP API.

I was late to the party since these ideas started coming to me several years after HAL was created in 2011.

Since then have been other media types that have gained some traction:

Actions

Following CQRS, I expose commands and queries and URIs.   Some media types like HAL don’t really give me the ability to specify how to perform various actions (commands) with payloads a user can invoke in the system.

However, a media type like Siren does.  The general idea can really be related to an HTML <form>

Here is a basic HTML form.  If you were creating an client that understood HTML you would be able to easily create a HTTP request to perform the action.

The above form describes an action.   If we wanted to create an HTTP request to submit this action, we have all the information in the form to build the request.

  • The URI is by action=”/books/add”
  • The HTTP method used whith the method=”post”
  • The body of our request is defined by the <input> and <select> elements
  • The select <option>’s define valid valid for the price

Because we understand HTML specification, we can easily create the HTTP request as:

Self Descriptive

By using a media type like Siren we can start to develop HTTP APIs that are self descriptive.

It’s a combination of the content type and the message body that makes our API self descriptive.  You cannot just return arbitrary JSON and expect your clients to understand how to use it.  They must understand what the content is.

 

Next

To the code!  In my next post I’m going to start providing some sample code for creating an HTTP API in ASP.NET Core using Hypermedia.

If anyone has any other suggestions or recommendations about this series, please leave comment or let me know on twitter.

  1. Building a Self Descriptive HTTP API in ASP.NET Core
  2. Object as Resource
  3. Hypermedia
  4. Siren
  5. HATEOAS
  6. Hypermedia Clients

 


Self Descriptive HTTP API in ASP.NET Core: Object as Resource

In my opening post I went over some of the issues I encountered when initially developing an HTTP API.  In this post I’m going to cover some of those pain points and what I think the solution was.

Objects

The first pain point revolves around the idea of your HTTP API returning objects.  Meaning you serialize an object to JSON and return to the client.

This seems pretty typical.   Almost every example you find in regards to Web API describes this behavior.

Here’s an example of what this looks like:

We’re doing nothing more than fetching a record out of our repository/database and serializing it down the to the client.

On the flip side, all of our endpoints for mutating state of our system take the same object back.

Object as Resource

There was a great and short blog post by Alex Moore last year.

You’ve doubtless seen the OAR pattern out in the wild. I’d define its constraints this way: 1. a resource maps 1:1(-ish) to an object in your server’s application logic, 2. uris and http methods are given conventions mapping to CRUD operations

These are what most examples I find describe.  If you ever used OData with Entity Framework, it’s another great example of OAR.

Model Changes

The first obvious issue with this is your exposing your internal data structure to your consuming clients.

If you do not have ownership over the clients, then making any breaking change to the structure TodoItem is going to be pretty difficult.

This is really problematic when your internal models are still evolving.

DTO

The obvious answer is to create DTO (Data Transfer Objects) as the essentially a contract to your consuming clients.  Meaning you will create a separate object that will be serialized and return to clients rather than your database entity.

This is generally a recommended approach that I use.  This is where a library like AutoMapper shines.

Representation

But we need to take this a step further.  The idea of returning serialized DTO that still are in a 1:1-ish with some underlying data entity only provides our clients a single piece of information.

Often times in order for the client to perform a given action, they generally need related data.

An example, maybe our Todo application had the ability to create different categories so we could break up and categorize our items.  If we wanted to edit our TodoItem to specify a Category, we would need to pass it the CategoryId.

How exactly do we get the list of categories from the client?  Would the client be required to call another endpoint to them?

Why not return them in our DTO?

We would be doing this already if you were creating an MVC application returning a rendered HTML to the client/browser.

Your edit screen would contain a <select> list of all the categories in your edit <form>.

Messages

If you start thinking about sending down messages to the client rather than objects, you can open up to the idea of your messages being a much more rich representation.  This representation could contain referential data, actions the client could preform or other places the client could navigate your HTTP API.

Last year, I wrote a blog post about your Resource Model not being your Data Model after I seen a great tweet by Mike Amundsen.

Next

In my next post I’m going to look at how we build HTML web applications and what we can learn and use to develop our HTTP APIs.  If anyone has any other suggestions or recommendations about this series, or the sample project to convert, please leave comment or let me know on twitter.

  1. Building a Self Descriptive HTTP API in ASP.NET Core
  2. Object as Resource
  3. Hypermedia
  4. Siren
  5. HATEOAS
  6. Hypermedia Clients