add documentation

Author: jaredcnance

docs/Models.md

@@ -56,6 +56,19 @@ public class Person : Identifiable<int>
 }
 ```
 
+### Immutability
+
+Attributes can be marked as immutable which will prevent `PATCH` requests
+from updating them:
+
+```csharp
+public class Person : Identifiable<int>
+{
+    [Attr("first-name", immutable: true)]
+    public string FirstName { get; set; }
+}
+```
+
 ## Relationships
 
 In order for navigation properties to be identified in the model, 

docs/ResourceServices.md

@@ -75,4 +75,62 @@ public class MyModelService : IResourceService<MyModel>
         return await _dal.GetModelAsync();
     }
 }
+```
+
+### Limited Requirements
+
+In some cases it may be necessary to only expose a few methods on the resource.
+For this reason, we have created a hierarchy of service interfaces that can be used to get the
+exact implementation you require. Below is a table outlining these interfaces:
+
+| METHOD                                   | IResourceService | IResourceCmdService | IResourceQueryService | IGetAllService | IGetByIdService | IGetRelationshipService | IGetRelationships | ICreateService | IDeleteService | IUpdateService | IUpdateRelationshipService |
+|------------------------------------------|:----------------:|:-------------------:|:---------------------:|:--------------:|:---------------:|:-----------------------:|:-----------------:|:--------------:|:--------------:|:--------------:|:--------------------------:|
+| GET /                                    |         ✓        |                     |           ✓           |        ✓       |                 |                         |                   |                |                |                |                            |
+| GET /{id}                                |         ✓        |                     |           ✓           |                |        ✓        |                         |                   |                |                |                |                            |
+| GET /{id}/{relationship}                 |         ✓        |                     |           ✓           |                |                 |            ✓            |                   |                |                |                |                            |
+| GET /{id}/relationships/{relationship}   |         ✓        |                     |           ✓           |                |                 |                         |         ✓         |                |                |                |                            |
+| POST /                                   |         ✓        |          ✓          |                       |                |                 |                         |                   |        ✓       |                |                |                            |
+| DELETE /{id}                             |         ✓        |          ✓          |                       |                |                 |                         |                   |                |        ✓       |                |                            |
+| PATCH /{id}                              |         ✓        |          ✓          |                       |                |                 |                         |                   |                |                |        ✓       |                            |
+| PATCH /{id}/relationships/{relationship} |         ✓        |          ✓          |                       |                |                 |                         |                   |                |                |                |              ✓             |
+
+ In order to take advantage of these interfaces you first need to inject the service for each implemented interface. 
+ Using Autofac, as an example, this is simply:
+
+```csharp
+public class MyResourceService : ICreateService<MyResource>, IDeleteService<MyResource> {
+ //...
+}
+
+public class Startup {
+  public IServiceProvider ConfigureServices(IServiceCollection services) {
+    // ...
+    builder.RegisterType<MyResourceService>().AsImplementedInterfaces();
+    // ...
+  }
+}
+```
+
+Then in the controller, you should inherit the base controller and pass the services into
+the named, optional base parameters:
+
+```csharp
+public class MyResourcesController : BaseJsonApiController<MyResource, int> {
+    public MyResourcesController(
+        IJsonApiContext jsonApiContext, 
+        ICreateService<MyResource> create,
+        IDeleteService<MyResource> delete) 
+    : base(
+        jsonApiContext, 
+        create: create, // <--- pass the services to the base controller using named optional parameters
+        delete: delete) { }
+
+    [HttpPost]
+    public override async Task<IActionResult> PostAsync([FromBody] MyResource entity) 
+        => await base.PostAsync(entity);
+
+    [HttpDelete("{id}")]
+    public override async Task<IActionResult>DeleteAsync(int id) 
+        => await base.DeleteAsync(id);
+}
 ```