fix: docs, publicName

Author: maurei

docs/usage/extensibility/middleware.md

@@ -1,14 +1,86 @@
 # 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 controll 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. 
+
+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(x =>
+        {
+            // execute the mvc configuration callback after the JsonApiDotNetCore callback as been executed.
+            _postConfigureMvcOptions?.Invoke(x);
+        });
+
+        ...
+    }
+
+    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

@@ -92,6 +92,7 @@ options.SerializerSettings.Formatting = Formatting.Indented;
 
 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

@@ -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 `publicResourceName` option when manually adding a resource to the graph
+1. The `publicName` option when manually adding a resource to the graph
 ```c#
 services.AddJsonApi(resources: builder =>
 {
-    builder.AddResource<Person>(publicResourceName: "people");
+    builder.AddResource<Person>(publicName: "people");
 });
 ```
 

docs/usage/routing.md

@@ -38,13 +38,12 @@ GET /myResources HTTP/1.1
 ```
 
 ## Customized the Routing Convention
-It is possible to fully customize routing behaviour by registering a `IJsonApiRoutingConvention` implementation **before** calling `AddJsonApi( ... )`.
+It is possible to fully customize routing behaviour by registering a `IJsonApiRoutingConvention` implementation.
 ```c#
 // Startup.cs
 public void ConfigureServices(IServiceCollection services)
 {
     services.AddSingleton<IJsonApiConvention, CustomRoutingConvention>();
-    services.AddJsonApi( /* ... */ );
 }
 ```
 

src/JsonApiDotNetCore/Configuration/ResourceGraphBuilder.cs

@@ -40,25 +40,25 @@ private void SetResourceLinksOptions(ResourceContext resourceContext)
         }
 
         /// <inheritdoc />
-        public ResourceGraphBuilder Add<TResource>(string publicResourceName = null) where TResource : class, IIdentifiable<int>
-            => Add<TResource, int>(publicResourceName);
+        public ResourceGraphBuilder Add<TResource>(string publicName = null) where TResource : class, IIdentifiable<int>
+            => Add<TResource, int>(publicName);
 
         /// <inheritdoc />
-        public ResourceGraphBuilder Add<TResource, TId>(string publicResourceName = null) where TResource : class, IIdentifiable<TId>
-            => Add(typeof(TResource), typeof(TId), publicResourceName);
+        public ResourceGraphBuilder Add<TResource, TId>(string publicName = null) where TResource : class, IIdentifiable<TId>
+            => Add(typeof(TResource), typeof(TId), publicName);
 
         /// <inheritdoc />
-        public ResourceGraphBuilder Add(Type resourceType, Type idType = null, string publicResourceName = null)
+        public ResourceGraphBuilder Add(Type resourceType, Type idType = null, string publicName = null)
         {
             if (resourceType == null) throw new ArgumentNullException(nameof(resourceType));
 
             if (_resources.All(e => e.ResourceType != resourceType))
             {
                 if (TypeHelper.IsOrImplementsInterface(resourceType, typeof(IIdentifiable)))
                 {
-                    publicResourceName ??= FormatResourceName(resourceType);
+                    publicName ??= FormatResourceName(resourceType);
                     idType ??= TypeLocator.GetIdType(resourceType);
-                    var resourceContext = CreateResourceContext(publicResourceName, resourceType, idType);
+                    var resourceContext = CreateResourceContext(publicName, resourceType, idType);
                     _resources.Add(resourceContext);
                 }
                 else
@@ -70,9 +70,9 @@ public ResourceGraphBuilder Add(Type resourceType, Type idType = null, string pu
             return this;
         }
 
-        private ResourceContext CreateResourceContext(string publicResourceName, Type resourceType, Type idType) => new ResourceContext
+        private ResourceContext CreateResourceContext(string publicName, Type resourceType, Type idType) => new ResourceContext
         {
-            ResourceName = publicResourceName,
+            ResourceName = publicName,
             ResourceType = resourceType,
             IdentityType = idType,
             Attributes = GetAttributes(resourceType),