Routing does not respect custom pluralized resource name

benchmarks/DependencyFactory.cs

@@ -10,7 +10,7 @@ internal static class DependencyFactory
     {
         public static IResourceGraph CreateResourceGraph(IJsonApiOptions options)
         {
-            IResourceGraphBuilder builder = new ResourceGraphBuilder(options, NullLoggerFactory.Instance);
+            ResourceGraphBuilder builder = new ResourceGraphBuilder(options, NullLoggerFactory.Instance);
             builder.Add<BenchmarkResource>(BenchmarkResourcePublicNames.Type);
             return builder.Build();
         }

docs/usage/extensibility/middleware.md

@@ -1,14 +1,45 @@
 # Middleware
-Add the following to your Startup.ConfigureServices method. Replace AppDbContext with your DbContext.
 
-```c3
-services.AddJsonApi<AppDbContext>();
+It is possible to execute your own middleware before or after `JsonApiMiddleware` by registering it accordingly.
+
+```c#
+/// In Startup.Configure
+app.UseMiddleware<CustomPreMiddleware>();
+app.UseJsonApi();
+app.UseMiddleware<CustomPostMiddleware>();
+```
+
+It is also possible to replace any other JsonApiDotNetCore middleware component. The following example replaces the internal exception filter with a custom implementation
+```c#
+/// In Startup.ConfigureServices
+services.AddService<IJsonApiGlobalExceptionFilter, CustomExceptionFilter>()
 ```
 
-Add the middleware to the Startup.Configure method.
+Alternatively, you can add additional middleware components by configuring `MvcOptions` directly.
+
+## Configuring MvcOptions
+
+JsonApiDotNetCore configures `MvcOptions` internally when calling `AddJsonApi()`. Additionaly, it is possible to perform a custom configuration of `MvcOptions`. To prevent the library from overwriting your configuration, it is recommended to configure it *after* the library is done configuring `MvcOptions`.
+
+The following example demonstrates this by clearing all internal filters and registering a custom one.
+```c#
+/// In Startup.ConfigureServices
+services.AddSingleton<CustomFilter>();
+var builder = services.AddMvcCore();
+services.AddJsonApi<AppDbContext>(mvcBuilder: builder);
+// Ensure the configuration action is registered after the `AddJsonApiCall`.
+builder.AddMvcOptions( mvcOptions =>
+{
+    // Execute the MvcOptions configuration callback after the JsonApiDotNetCore callback as been executed.
+    _postConfigureMvcOptions?.Invoke(mvcOptions);
+});
 
-```c3
-app.UseRouting();
+/// In Startup.Configure
 app.UseJsonApi();
-app.UseEndpoints(endpoints => endpoints.MapControllers());
+// Ensure the configuration callback is set after calling `UseJsonApi()`.
+_postConfigureMvcOptions = mvcOptions => 
+{ 
+    mvcOptions.Filters.Clear();
+    mvcOptions.Filters.Insert(0, app.ApplicationServices.GetService<CustomFilter>());
+};
 ```

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

@@ -10,31 +10,30 @@ It is built at app startup and available as a singleton through Dependency Injec
 
 There are three ways the resource graph can be created:
 
-1. Auto-discovery
+1. Manually specifying each resource
 2. Specifying an entire DbContext
-3. Manually specifying each resource
+3. Auto-discovery
 
-### Auto-Discovery
+It is also possible to combine the three of them at once. Be aware that some configuration might overlap, 
+for example you could manually add a resource to the graph which is also auto-discovered. In such a scenario, the configuration
+is prioritized by the order of the list above.
 
-Auto-discovery refers to the process of reflecting on an assembly and
-detecting all of the json:api resources and services.
+### Manual Specification
 
-The following command will build the resource graph using all `IIdentifiable`
-implementations. It also injects resource definitions and service layer overrides which we will
-cover in a later section. You can enable auto-discovery for the
-current assembly by adding the following to your `Startup` class.
+You can manually construct the graph.
 
 ```c#
 // Startup.cs
 public void ConfigureServices(IServiceCollection services)
 {
-    services.AddJsonApi(
-        options => { /* ... */ },
-        discovery => discovery.AddCurrentAssembly());
+    services.AddJsonApi(resources: builder =>
+    {
+        builder.Add<Person>();
+    });
 }
 ```
 
-### Entity Framework Core DbContext
+### Specifying an Entity Framework Core DbContext
 
 If you are using Entity Framework Core as your ORM, you can add an entire `DbContext` with one line.
 
@@ -58,33 +57,47 @@ public void ConfigureServices(IServiceCollection services)
 }
 ```
 
-### Manual Specification
+### Auto-discovery
 
-You can also manually construct the graph.
+Auto-discovery refers to the process of reflecting on an assembly and
+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
+cover in a later section. You can enable auto-discovery for the
+current assembly by adding the following to your `Startup` class.
 
 ```c#
 // Startup.cs
 public void ConfigureServices(IServiceCollection services)
 {
-    services.AddJsonApi(resources: builder =>
-    {
-        builder.AddResource<Person>();
-    });
+    services.AddJsonApi(
+        options => { /* ... */ },
+        discovery => discovery.AddCurrentAssembly());
 }
 ```
 
-### Public Resource Type Name
+### Public Resource Name
+
+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):
 
-The public resource type name is determined by the following criteria (in order of priority):
+1. The `publicName` parameter when manually adding a resource to the graph
+```c#
+services.AddJsonApi(resources: builder =>
+{
+    builder.Add<Person>(publicName: "people");
+});
+```
 
-1. The model is decorated with a `ResourceAttribute`
+2. The model is decorated with a `ResourceAttribute`
 ```c#
-[Resource("my-models")]
+[Resource("myResources")]
 public class MyModel : Identifiable { /* ... */ }
 ```
 
-2. The configured naming convention (by default this is camel-case).
+3. The configured naming convention (by default this is camel-case).
 ```c#
 // this will be registered as "myModels"
 public class MyModel : Identifiable { /* ... */ }
 ```
+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,15 +1,7 @@
 # Routing
 
-By default the library will configure routes for each controller.
-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
-```
-
 ## Namespacing and Versioning URLs
-
-You can add a namespace to all URLs by specifying it in ConfigureServices
+You can add a namespace to all URLs by specifying it in ConfigureServices.
 
 ```c#
 public void ConfigureServices(IServiceCollection services)
@@ -20,40 +12,46 @@ public void ConfigureServices(IServiceCollection services)
 ```
 Which results in URLs like: https://yourdomain.com/api/v1/people
 
-## Disable Convention
+## Customizing Routes
+
+The library will configure routes for all controllers in your project.
+
+### Json:api endpoints
 
-You can disable the default casing convention and specify your own template by using the `DisableRoutingConvention` attribute.
+By default, for json:api controllers, 
+- routes are camel-cased. This is based on the [recommendations](https://jsonapi.org/recommendations/) outlined in the json:api spec.
+- the route of a controller will match the public name of the resource that is associated it. This means that routes can be customized by [configuring the public name of the associated resource](./resource-graph.md#public-resource-name).
 
 ```c#
-[Route("[controller]")]
-[DisableRoutingConvention]
-public class CamelCasedModelsController : JsonApiController<CamelCasedModel>
-{
-    public CamelCasedModelsController(
-        IJsonApiOptions options,
-        ILoggerFactory loggerFactory,
-        IResourceService<CamelCasedModel> resourceService)
-        : base(options, loggerFactory, resourceService)
-    { }
-}
+public class MyResourceController : JsonApiController<MyApiResource> { /* .... */ }
 ```
+The route for this example will be `/myApiResources`, which will match the type in the json:api payload: `{ "type": "myApiResources", ... }`.
+
 
-It is important to note that your routes must still end with the model name in the same format as the resource name. This is so that we can build accurate resource links in the json:api document. For example, if you define a resource as MyModels, the controller route must match.
+### Non-json:api endpoints
 
+If a controller does not have an associated resource, the [configured naming strategy](./options.md#custom-serializer-settings) will be applied to the name of the controller.
 ```c#
-public void ConfigureServices(IServiceCollection services)
-{
-    services.AddJsonApi(resources: builder =>
-        builder.AddResource<TodoItem>("my-models")); // kebab-cased
-}
+public class MyResourceController : ControllerBase { /* .... */ }
+```
+The route for this example is `/myResources`, which can be changed by renaming the controller.
 
-// controller definition
-[Route("api/my-models"), DisableRoutingConvention]
-public class MyModelsController : JsonApiController<TodoItem>
-{
-  //...
-}
+
+## Disabling the Default Routing Convention
+
+It is possible to by-pass the default routing convention for a controller by combining the `Route` and `DisableRoutingConvention`attributes. Any usage of `Route` without `DisableRoutingConvention` is ignored.
+```c#
+[Route("v1/camelCasedModels"), DisableRoutingConvention]
+public class MyCustomResourceController : JsonApiController<CamelCasedModel> { /* ... */ }
 ```
+This example exposes a versioned `CamelCasedModel` endpoint. To ensure guarantee valid link building, it is *highly recommended* to match your custom url with the public name of the associated resource.
 
-See [this](~/usage/resource-graph.md#public-resource-type-name) for
-more information on how the resource name is determined.
+## Advanced Usage: Custom Routing Convention.
+
+It is possible to use a [custom routing convention](add-link) by registering a custom `IJsonApiRoutingConvention` implementation. This is generally not recommended and for advanced usage only.
+```c#
+public void ConfigureServices(IServiceCollection services)
+{
+	services.AddSingleton<IJsonApiConvention, CustomRoutingConvention>();
+}
+```

src/Examples/JsonApiDotNetCoreExample/Startups/Startup.cs

@@ -38,7 +38,7 @@ public override void ConfigureServices(IServiceCollection services)
             }, ServiceLifetime.Transient);
 
             services.AddJsonApi<AppDbContext>(ConfigureJsonApiOptions, discovery => discovery.AddCurrentAssembly());
-            
+
             // once all tests have been moved to WebApplicationFactory format we can get rid of this line below
             services.AddClientSerialization();
         }

src/JsonApiDotNetCore/Configuration/ApplicationBuilderExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using JsonApiDotNetCore.Middleware;
 using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace JsonApiDotNetCore.Configuration
 {
@@ -22,6 +23,23 @@ public static class ApplicationBuilderExtensions
         public static void UseJsonApi(this IApplicationBuilder builder)
         {
             if (builder == null) throw new ArgumentNullException(nameof(builder));
+
+            using var scope = builder.ApplicationServices.GetRequiredService<IServiceScopeFactory>().CreateScope();
+            var inverseRelationshipResolver = scope.ServiceProvider.GetRequiredService<IInverseRelationships>();
+            inverseRelationshipResolver.Resolve();
+
+            var jsonApiApplicationBuilder =  builder.ApplicationServices.GetRequiredService<IJsonApiApplicationBuilder>();
+            jsonApiApplicationBuilder.ConfigureMvcOptions = options =>
+            {
+                var inputFormatter = builder.ApplicationServices.GetRequiredService<IJsonApiInputFormatter>();
+                options.InputFormatters.Insert(0, inputFormatter);
+
+                var outputFormatter = builder.ApplicationServices.GetRequiredService<IJsonApiOutputFormatter>();
+                options.OutputFormatters.Insert(0, outputFormatter);
+
+                var routingConvention = builder.ApplicationServices.GetRequiredService<IJsonApiRoutingConvention>();
+                options.Conventions.Insert(0, routingConvention);
+            };
 
             builder.UseMiddleware<JsonApiMiddleware>();
         }

src/JsonApiDotNetCore/Configuration/IJsonApiApplicationBuilder.cs

@@ -0,0 +1,10 @@
+using System;
+using Microsoft.AspNetCore.Mvc;
+
+namespace JsonApiDotNetCore.Configuration
+{
+    internal interface IJsonApiApplicationBuilder
+    {
+        public Action<MvcOptions> ConfigureMvcOptions { set; }
+    }
+}