chore: review 2

Author: maurei

docs/usage/extensibility/middleware.md

@@ -39,11 +39,11 @@ All of these components (except for `JsonApiMiddleware`) can be customized by re
 services.AddSingleton<IJsonApiExceptionFilter, MyCustomExceptionFilter>();
 ```
 
-It is also possible to directly access the .NET Core `MvcOptions` object and have full controll over which components are registered. 
+It is also possible to directly access the .NET Core `MvcOptions` object and have full control over which components are registered. 
 
 ## Configuring MvcOptions
 
-JsonApiDotNetCore internally configures `MvcOptions` when calling `AddJsonApi( ... )`. However, it is still possible to register a custom configuration callback. To achieve this it is recommended to register this callback *after* the `AddJsonApi( ... )` call. It is also possible to do it earlier, but your configuration might be overridden by the JsonApiDotNetCore configuration. 
+JsonApiDotNetCore internally configures `MvcOptions` when calling `AddJsonApi( ... )`. However, it is still possible to register a custom configuration callback. To achieve this it is recommended to register this callback *after* the `AddJsonApi( ... )` call. It is also possible to do it earlier, but your configuration might be overwritten by the JsonApiDotNetCore configuration. 
 
 The following example replaces all internally registered filters by retrieving a custom filter from the DI container.
 ```c#
@@ -57,10 +57,10 @@ public class Startup
 
         var builder = services.AddMvcCore();
         services.AddJsonApi<AppDbContext>( ... , mvcBuilder: builder);
-        mvcCoreBuilder.AddMvcOptions(x =>
+        mvcCoreBuilder.AddMvcOptions(mvcOptions =>
         {
-            // execute the mvc configuration callback after the JsonApiDotNetCore callback as been executed.
-            _postConfigureMvcOptions?.Invoke(x);
+            // Execute the mvcOptions configuration callback after the JsonApiDotNetCore callback as been executed.
+            _postConfigureMvcOptions?.Invoke(mvcOptions);
         });
 
         ...

docs/usage/options.md

@@ -90,8 +90,14 @@ options.SerializerSettings.Converters.Add(new StringEnumConverter());
 options.SerializerSettings.Formatting = Formatting.Indented;
 ```
 
+The default naming convention as used in the routes and public resources names is also determined here, and can be changed (default is camel-case):
+```c#
+options.SerializerSettings.ContractResolver = new DefaultContractResolver { NamingStrategy = new KebabCaseNamingStrategy() };
+```
+
 Because we copy resource properties into an intermediate object before serialization, Newtonsoft.Json annotations on properties are ignored.
 
+
 ## Enable ModelState Validation
 
 If you would like to use ASP.NET Core ModelState validation into your controllers when creating / updating resources, set `ValidateModelState = true`. By default, no model validation is performed.

docs/usage/resource-graph.md

@@ -28,7 +28,7 @@ public void ConfigureServices(IServiceCollection services)
 {
     services.AddJsonApi(resources: builder =>
     {
-        builder.AddResource<Person>();
+        builder.Add<Person>();
     });
 }
 ```
@@ -60,7 +60,7 @@ public void ConfigureServices(IServiceCollection services)
 ### Auto-discovery
 
 Auto-discovery refers to the process of reflecting on an assembly and
-detecting all of the json:api resources and services.
+detecting all of the json:api resources, resource definitions, resource services and repositories.
 
 The following command will build the resource graph using all `IIdentifiable`
 implementations. It also injects resource definitions and service layer overrides which we will
@@ -81,11 +81,11 @@ public void ConfigureServices(IServiceCollection services)
 
 The public resource name is exposed through the `type` member in the json:api payload. This can be configured by the following approaches (in order of priority):
 
-1. The `publicName` option when manually adding a resource to the graph
+1. The `publicName` parameter when manually adding a resource to the graph
 ```c#
 services.AddJsonApi(resources: builder =>
 {
-    builder.AddResource<Person>(publicName: "people");
+    builder.Add<Person>(publicName: "people");
 });
 ```
 
@@ -100,17 +100,4 @@ public class MyModel : Identifiable { /* ... */ }
 // this will be registered as "myModels"
 public class MyModel : Identifiable { /* ... */ }
 ```
-This convention can be changed by setting the `SerializerSettings` property on `IJsonApiOptions`.
-```c#
-public void ConfigureServices(IServiceCollection services)
-{
-    services.AddJsonApi(
-        options =>
-        {
-            options.SerializerSettings.ContractResolver = new DefaultContractResolver
-            {
-                NamingStrategy = new KebabCaseNamingStrategy()
-            }
-        });
-}
-```
+This convention can be changed by setting the `SerializerSettings.ContractResolver` property on `IJsonApiOptions`. See the [options documentation](./options.md#custom-serializer-settings).

docs/usage/routing.md

@@ -1,44 +1,44 @@
 # Routing
+
+## Namespacing and Versioning URLs
+You can add a namespace to all URLs by specifying it in ConfigureServices
+
+```c#
+public void ConfigureServices(IServiceCollection services)
+{
+  services.AddJsonApi<AppDbContext>(
+      options => options.Namespace = "api/v1");
+}
+```
+Which results in URLs like: https://yourdomain.com/api/v1/people
+
+## Customizing Routes
+
 The library will configure routes for each controller. By default, based on the [recommendations](https://jsonapi.org/recommendations/) outlined in the json:api spec, routes are camel-cased.
 
 ```http
 GET /api/compoundModels HTTP/1.1
 ```
 
-There are two ways the library will try to create a route for a controller:
-1. **By inspecting the controller for an associated resource**. The library will try to first use the public resource name of the resource associated to a controller. This means that the value of the `type` member of the json:api document for a resource will be equal to the route.
-Note that this implies that it is possible to configure a route configuring the exposed resource name. See [this section](~/usage/resource-graph.md#public-resource-name) on how this can be achieved. Example:
-```c#
-// controller
-public class MyResourceController : JsonApiController<MyApiResource> { /* .... */ } // note that the route is NOT "myResources", but "myApiResources"
+1. **Using the public name of the resource associated to a controller**.
 
-// request
-GET /myApiResources HTTP/1.1
+```c#
+public class MyResourceController : JsonApiController<MyApiResource> { /* .... */ }
+```
+Note that the route
+- is `/myApiResources`, which matches the public resouce name in the json:api payload (`{ "type": "myApiResources", ... }`) 
+- can be configured by configuring the public resource name. See [this section](~/usage/resource-graph.md#public-resource-name) on how to do that. 
 
-// response
-HTTP/1.1 200 OK
-Content-Type: application/vnd.api+json
 
-{
-  "data": [{
-    "type": "myApiResources",
-    "id": "1",
-    "attributes": { ... }
-  }]
-}
-```
-2. **By using the name of the controller**. If no associated resource was detected for a controller, the library will construct a route from the name of the controller by using the configured naming strategy (*camelCase* by default, see [this section](~/usage/resource-graph.md#public-resource-name) on how to configure this). This is in alignment with the default .NET Core MVC routing approach. 
-In the following example the controller is not associated to a resource by the library because it does not inherit from `BaseJsonApiController<T>`.
+2. **Using the controller name**. 
+If a controller does not have an associated resource, the name of the controller will be used following the configured naming strategy.
 ```c#
-// controller
 public class MyResourceController : ControllerBase { /* .... */ }
-
-// request
-GET /myResources HTTP/1.1
 ```
+Note that the route is `myResources` can be changed by renaming the controller. This approach is the default .NET Core MVC routing approach.
 
-## Customized the Routing Convention
-It is possible to fully customize routing behaviour by registering a `IJsonApiRoutingConvention` implementation.
+## Customizing the Routing Convention
+It is possible to fully customize routing behavior by registering a `IJsonApiRoutingConvention` implementation.
 ```c#
 // Startup.cs
 public void ConfigureServices(IServiceCollection services)
@@ -47,18 +47,6 @@ public void ConfigureServices(IServiceCollection services)
 }
 ```
 
-## Namespacing and Versioning URLs
-You can add a namespace to all URLs by specifying it in ConfigureServices
-
-```c#
-public void ConfigureServices(IServiceCollection services)
-{
-  services.AddJsonApi<AppDbContext>(
-      options => options.Namespace = "api/v1");
-}
-```
-Which results in URLs like: https://yourdomain.com/api/v1/people
-
 ## Disabling the Default Routing Convention
 It is possible to completely bypass the default routing convention for a particular controller and specify a custom routing template by using the `DisableRoutingConvention` attribute.
 In the following example, the `CamelCasedModel` resource can be accessed on `/my-custom-route`.

src/Examples/JsonApiDotNetCoreExample/Startups/EmptyStartup.cs

@@ -2,7 +2,6 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
 
 namespace JsonApiDotNetCoreExample
 {

src/Examples/JsonApiDotNetCoreExample/Startups/TestStartup.cs

@@ -2,7 +2,6 @@
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
 
 namespace JsonApiDotNetCoreExample
 {

test/JsonApiDotNetCoreExampleTests/Acceptance/NonJsonApiControllerTests.cs

@@ -92,7 +92,6 @@ public async Task NonJsonApiController_Skips_Middleware_And_Formatters_On_Delete
 
             // Act
             var response = await client.SendAsync(request);
-            var test = await response.Content.ReadAsStringAsync();
             // Assert
             Assert.Equal(HttpStatusCode.OK, response.StatusCode);
             Assert.Equal("text/plain; charset=utf-8", response.Content.Headers.ContentType.ToString());