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,84 @@
 # Middleware
-Add the following to your Startup.ConfigureServices method. Replace AppDbContext with your DbContext.
 
-```c3
+The following is the default configuration of JsonApiDotNetCore:
+1. Call one of the `AddJsonApi( ... )` overloads in the ` Startup.ConfigureServices` method. In this example uses a `DbContext` to build the resource graph
+
+```c#
 services.AddJsonApi<AppDbContext>();
 ```
 
-Add the middleware to the Startup.Configure method.
+2. In the Startup.Configure method, configure your application to use routing, to add the JsonApiMiddleware and to configure endpoint routing.
 
-```c3
+```c#
 app.UseRouting();
 app.UseJsonApi();
 app.UseEndpoints(endpoints => endpoints.MapControllers());
 ```
+
+The following middleware components, in respective order, are registered:
+
+Filters:
+- `IJsonApiExceptionFilter`
+- `IJsonApiTypeMatchFilter`
+- `IQueryStringActionFilter`
+- `IConvertEmptyActionResultFilter`
+
+Formatters:
+- `IJsonApiInputFormatter`
+- `IJsonApiOutputFormatter`
+
+Routing convention:
+- `IJsonApiRoutingConvention`
+
+Middleware:
+- `JsonApiMiddleware`
+
+All of these components (except for `JsonApiMiddleware`) can be customized by registering your own implementation of these services. For example:
+
+```c#
+services.AddSingleton<IJsonApiExceptionFilter, MyCustomExceptionFilter>();
+```
+
+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 overwritten by the JsonApiDotNetCore configuration. 
+
+The following example replaces all internally registered filters by retrieving a custom filter from the DI container.
+```c#
+public class Startup
+{
+    private Action<MvcOptions> _postConfigureMvcOptions;
+
+    public void ConfigureServices(IServiceCollection services)
+    {
+        ...
+
+        var builder = services.AddMvcCore();
+        services.AddJsonApi<AppDbContext>( ... , mvcBuilder: builder);
+        mvcCoreBuilder.AddMvcOptions(mvcOptions =>
+        {
+            // Execute the mvcOptions configuration callback after the JsonApiDotNetCore callback as been executed.
+            _postConfigureMvcOptions?.Invoke(mvcOptions);
+        });
+
+        ...
+    }
+
+    public void Configure(IApplicationBuilder app, IWebHostEnvironment environment)
+    {
+
+        ... 
+
+        // Using a callback, we can defer to later (when service collection has become available).
+        _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,14 +1,6 @@
 # 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
 
 ```c#
@@ -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 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
+```
 
-You can disable the default casing convention and specify your own template by using the `DisableRoutingConvention` attribute.
+1. **Using the public name of the resource associated to a controller**.
 
 ```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> { /* .... */ }
 ```
+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. 
 
-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.
 
+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#
-public void ConfigureServices(IServiceCollection services)
-{
-    services.AddJsonApi(resources: builder =>
-        builder.AddResource<TodoItem>("my-models")); // kebab-cased
-}
+public class MyResourceController : ControllerBase { /* .... */ }
+```
+Note that the route is `myResources` can be changed by renaming the controller. This approach is the default .NET Core MVC routing approach.
 
-// controller definition
-[Route("api/my-models"), DisableRoutingConvention]
-public class MyModelsController : JsonApiController<TodoItem>
+## 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)
 {
-  //...
+    services.AddSingleton<IJsonApiConvention, CustomRoutingConvention>();
 }
 ```
 
-See [this](~/usage/resource-graph.md#public-resource-type-name) for
-more information on how the resource name is determined.
+## 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`.
+
+```c#
+[Route("my-custom-route"), DisableRoutingConvention]
+public class MyCustomResourceController : JsonApiController<CamelCasedModel> { /* ... */ }
+```

src/Examples/JsonApiDotNetCoreExample/Startups/EmptyStartup.cs

@@ -11,16 +11,10 @@ namespace JsonApiDotNetCoreExample
     /// </summary>
     public abstract class EmptyStartup
     {
-        protected EmptyStartup(IConfiguration configuration)
-        {
-        }
+        protected EmptyStartup(IConfiguration configuration) { }
 
-        public virtual void ConfigureServices(IServiceCollection services)
-        {
-        }
+        public virtual void ConfigureServices(IServiceCollection services) { }
 
-        public virtual void Configure(IApplicationBuilder app, IWebHostEnvironment environment)
-        {
-        }
+        public virtual void Configure(IApplicationBuilder app, IWebHostEnvironment environment) { }
     }
 }

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/Examples/JsonApiDotNetCoreExample/Startups/TestStartup.cs

@@ -7,9 +7,7 @@ namespace JsonApiDotNetCoreExample
 {
     public class TestStartup : Startup
     {
-        public TestStartup(IConfiguration configuration) : base(configuration)
-        {
-        }
+        public TestStartup(IConfiguration configuration) : base(configuration) { }
 
         protected override void ConfigureClock(IServiceCollection services)
         {

src/JsonApiDotNetCore/Configuration/ApplicationBuilderExtensions.cs

@@ -1,6 +1,6 @@
-using System;
 using JsonApiDotNetCore.Middleware;
 using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace JsonApiDotNetCore.Configuration
 {
@@ -21,7 +21,22 @@ public static class ApplicationBuilderExtensions
         /// </example>
         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; }
+    }
+}