feat(*): interface segregation

src/JsonApiDotNetCore/Controllers/BaseJsonApiController.cs

@@ -0,0 +1,136 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Internal;
+using JsonApiDotNetCore.Models;
+using JsonApiDotNetCore.Services;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCore.Controllers
+{
+ public class BaseJsonApiController<T, TId>
+ : JsonApiControllerMixin
+ where T : class, IIdentifiable<TId>
+ {
+ private readonly IResourceQueryService<T, TId> _queryService;
+ private readonly IResourceCmdService<T, TId> _cmdService;
+ private readonly IJsonApiContext _jsonApiContext;
+
+ protected BaseJsonApiController(
+ IJsonApiContext jsonApiContext,
+ IResourceService<T, TId> resourceService)
+ {
+ _jsonApiContext = jsonApiContext.ApplyContext<T>();
+ _queryService = resourceService;
+ _cmdService = resourceService;
+ }
+
+ protected BaseJsonApiController(
+ IJsonApiContext jsonApiContext,
+ IResourceQueryService<T, TId> queryService)
+ {
+ _jsonApiContext = jsonApiContext.ApplyContext<T>();
+ _queryService = queryService;
+ }
+
+ protected BaseJsonApiController(
+ IJsonApiContext jsonApiContext,
+ IResourceCmdService<T, TId> cmdService)
+ {
+ _jsonApiContext = jsonApiContext.ApplyContext<T>();
+ _cmdService = cmdService;
+ }
+
+ public virtual async Task<IActionResult> GetAsync()
+ {
+ if (_queryService == null) throw new JsonApiException(405, "Query requests are not supported");
+
+ var entities = await _queryService.GetAsync();
+
+ return Ok(entities);
+ }
+
+ public virtual async Task<IActionResult> GetAsync(TId id)
+ {
+ if (_queryService == null) throw new JsonApiException(405, "Query requests are not supported");
+
+ var entity = await _queryService.GetAsync(id);
+
+ if (entity == null)
+ return NotFound();
+
+ return Ok(entity);
+ }
+
+ public virtual async Task<IActionResult> GetRelationshipsAsync(TId id, string relationshipName)
+ {
+ if (_queryService == null) throw new JsonApiException(405, "Query requests are not supported");
+
+ var relationship = await _queryService.GetRelationshipsAsync(id, relationshipName);
+ if (relationship == null)
+ return NotFound();
+
+ return Ok(relationship);
+ }
+
+ public virtual async Task<IActionResult> GetRelationshipAsync(TId id, string relationshipName)
+ {
+ if (_queryService == null) throw new JsonApiException(405, "Query requests are not supported");
+
+ var relationship = await _queryService.GetRelationshipAsync(id, relationshipName);
+
+ return Ok(relationship);
+ }
+
+ public virtual async Task<IActionResult> PostAsync([FromBody] T entity)
+ {
+ if (_cmdService == null) throw new JsonApiException(405, "Command requests are not supported");
+
+ if (entity == null)
+ return UnprocessableEntity();
+
+ if (!_jsonApiContext.Options.AllowClientGeneratedIds && !string.IsNullOrEmpty(entity.StringId))
+ return Forbidden();
+
+ entity = await _cmdService.CreateAsync(entity);
+
+ return Created($"{HttpContext.Request.Path}/{entity.Id}", entity);
+ }
+
+ public virtual async Task<IActionResult> PatchAsync(TId id, [FromBody] T entity)
+ {
+ if (_cmdService == null) throw new JsonApiException(405, "Command requests are not supported");
+
+ if (entity == null)
+ return UnprocessableEntity();
+
+ var updatedEntity = await _cmdService.UpdateAsync(id, entity);
+
+ if (updatedEntity == null)
+ return NotFound();
+
+ return Ok(updatedEntity);
+ }
+
+ public virtual async Task<IActionResult> PatchRelationshipsAsync(TId id, string relationshipName, [FromBody] List<DocumentData> relationships)
+ {
+ if (_cmdService == null) throw new JsonApiException(405, "Command requests are not supported");
+
+ await _cmdService.UpdateRelationshipsAsync(id, relationshipName, relationships);
+
+ return Ok();
+ }
+
+ public virtual async Task<IActionResult> DeleteAsync(TId id)
+ {
+ if (_cmdService == null) throw new JsonApiException(405, "Command requests are not supported");
+
+ var wasDeleted = await _cmdService.DeleteAsync(id);
+
+ if (!wasDeleted)
+ return NotFound();
+
+ return NoContent();
+ }
+ }
+}

src/JsonApiDotNetCore/Controllers/HttpMethodRestrictionFilter.cs

@@ -19,7 +19,7 @@ public override async Task OnActionExecutionAsync(
  var method = context.HttpContext.Request.Method;
 
  if(CanExecuteAction(method) == false)
- throw new JsonApiException("405", $"This resource does not support {method} requests.");
+ throw new JsonApiException(405, $"This resource does not support {method} requests.");
 
  await next();
  }

src/JsonApiDotNetCore/Controllers/JsonApiCmdController.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Models;
+using JsonApiDotNetCore.Services;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCore.Controllers
+{
+ public class JsonApiCmdController<T>
+ : JsonApiCmdController<T, int> where T : class, IIdentifiable<int>
+ {
+ public JsonApiCmdController(
+ IJsonApiContext jsonApiContext,
+ IResourceService<T, int> resourceService)
+ : base(jsonApiContext, resourceService)
+ { }
+ }
+
+ public class JsonApiCmdController<T, TId>
+ : BaseJsonApiController<T, TId> where T : class, IIdentifiable<TId>
+ {
+ public JsonApiCmdController(
+ IJsonApiContext jsonApiContext,
+ IResourceService<T, TId> resourceService)
+ : base(jsonApiContext, resourceService)
+ { }
+
+ [HttpPost]
+ public override async Task<IActionResult> PostAsync([FromBody] T entity)
+ => await base.PostAsync(entity);
+
+ [HttpPatch("{id}")]
+ public override async Task<IActionResult> PatchAsync(TId id, [FromBody] T entity)
+ => await base.PatchAsync(id, entity);
+
+ [HttpPatch("{id}/relationships/{relationshipName}")]
+ public override async Task<IActionResult> PatchRelationshipsAsync(
+ TId id, string relationshipName, [FromBody] List<DocumentData> relationships)
+ => await base.PatchRelationshipsAsync(id, relationshipName, relationships);
+
+ [HttpDelete("{id}")]
+ public override async Task<IActionResult> DeleteAsync(TId id) => await base.DeleteAsync(id);
+ }
+}

src/JsonApiDotNetCore/Controllers/JsonApiController.cs

@@ -19,109 +19,49 @@ public JsonApiController(
  }
 
  public class JsonApiController<T, TId>
- : JsonApiControllerMixin where T : class, IIdentifiable<TId>
+ : BaseJsonApiController<T, TId> where T : class, IIdentifiable<TId>
  {
- private readonly ILogger _logger;
- private readonly IResourceService<T, TId> _resourceService;
- private readonly IJsonApiContext _jsonApiContext;
-
  public JsonApiController(
  IJsonApiContext jsonApiContext,
  IResourceService<T, TId> resourceService,
- ILoggerFactory loggerFactory)
- {
- _jsonApiContext = jsonApiContext.ApplyContext<T>();
- _resourceService = resourceService;
- _logger = loggerFactory.CreateLogger<JsonApiController<T, TId>>();
- }
+ ILoggerFactory loggerFactory) 
+ : base(jsonApiContext, resourceService)
+ { }
 
  public JsonApiController(
  IJsonApiContext jsonApiContext,
  IResourceService<T, TId> resourceService)
- {
- _jsonApiContext = jsonApiContext.ApplyContext<T>();
- _resourceService = resourceService;
- }
+ : base(jsonApiContext, resourceService)
+ { }
 
  [HttpGet]
- public virtual async Task<IActionResult> GetAsync()
- {
- var entities = await _resourceService.GetAsync();
- return Ok(entities);
- }
+ public override async Task<IActionResult> GetAsync() => await base.GetAsync();
 
  [HttpGet("{id}")]
- public virtual async Task<IActionResult> GetAsync(TId id)
- {
- var entity = await _resourceService.GetAsync(id);
-
- if (entity == null)
- return NotFound();
-
- return Ok(entity);
- }
+ public override async Task<IActionResult> GetAsync(TId id) => await base.GetAsync(id);
 
  [HttpGet("{id}/relationships/{relationshipName}")]
- public virtual async Task<IActionResult> GetRelationshipsAsync(TId id, string relationshipName)
- {
- var relationship = await _resourceService.GetRelationshipsAsync(id, relationshipName);
- if(relationship == null) 
- return NotFound();
-
- return Ok(relationship);
- }
+ public override async Task<IActionResult> GetRelationshipsAsync(TId id, string relationshipName)
+ => await base.GetRelationshipsAsync(id, relationshipName);
 
  [HttpGet("{id}/{relationshipName}")]
- public virtual async Task<IActionResult> GetRelationshipAsync(TId id, string relationshipName)
- {
- var relationship = await _resourceService.GetRelationshipAsync(id, relationshipName); 
- return Ok(relationship);
- }
+ public override async Task<IActionResult> GetRelationshipAsync(TId id, string relationshipName)
+ => await base.GetRelationshipAsync(id, relationshipName);
 
  [HttpPost]
- public virtual async Task<IActionResult> PostAsync([FromBody] T entity)
- {
- if (entity == null)
- return UnprocessableEntity();
-
- if (!_jsonApiContext.Options.AllowClientGeneratedIds && !string.IsNullOrEmpty(entity.StringId))
- return Forbidden();
-
- entity = await _resourceService.CreateAsync(entity);
-
- return Created($"{HttpContext.Request.Path}/{entity.Id}", entity);
- }
+ public override async Task<IActionResult> PostAsync([FromBody] T entity)
+ => await base.PostAsync(entity);
 
  [HttpPatch("{id}")]
- public virtual async Task<IActionResult> PatchAsync(TId id, [FromBody] T entity)
- {
- if (entity == null)
- return UnprocessableEntity();
-
- var updatedEntity = await _resourceService.UpdateAsync(id, entity);
-
- if(updatedEntity == null)
- return NotFound();
-
- return Ok(updatedEntity);
- }
+ public override async Task<IActionResult> PatchAsync(TId id, [FromBody] T entity)
+ => await base.PatchAsync(id, entity);
 
  [HttpPatch("{id}/relationships/{relationshipName}")]
- public virtual async Task<IActionResult> PatchRelationshipsAsync(TId id, string relationshipName, [FromBody] List<DocumentData> relationships)
- {
- await _resourceService.UpdateRelationshipsAsync(id, relationshipName, relationships);
- return Ok();
- }
+ public override async Task<IActionResult> PatchRelationshipsAsync(
+ TId id, string relationshipName, [FromBody] List<DocumentData> relationships)
+ => await base.PatchRelationshipsAsync(id, relationshipName, relationships);
 
  [HttpDelete("{id}")]
- public virtual async Task<IActionResult> DeleteAsync(TId id)
- {
- var wasDeleted = await _resourceService.DeleteAsync(id);
-
- if (!wasDeleted)
- return NotFound();
-
- return NoContent();
- }
+ public override async Task<IActionResult> DeleteAsync(TId id) => await base.DeleteAsync(id);
  }
 }

src/JsonApiDotNetCore/Controllers/JsonApiQueryController.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using JsonApiDotNetCore.Models;
+using JsonApiDotNetCore.Services;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+
+namespace JsonApiDotNetCore.Controllers
+{
+ public class JsonApiQueryController<T>
+ : JsonApiQueryController<T, int> where T : class, IIdentifiable<int>
+ {
+ public JsonApiQueryController(
+ IJsonApiContext jsonApiContext,
+ IResourceService<T, int> resourceService)
+ : base(jsonApiContext, resourceService)
+ { }
+ }
+
+ public class JsonApiQueryController<T, TId>
+ : BaseJsonApiController<T, TId> where T : class, IIdentifiable<TId>
+ {
+ public JsonApiQueryController(
+ IJsonApiContext jsonApiContext,
+ IResourceService<T, TId> resourceService)
+ : base(jsonApiContext, resourceService)
+ { }
+
+ [HttpGet]
+ public override async Task<IActionResult> GetAsync() => await base.GetAsync();
+
+ [HttpGet("{id}")]
+ public override async Task<IActionResult> GetAsync(TId id) => await base.GetAsync(id);
+
+ [HttpGet("{id}/relationships/{relationshipName}")]
+ public override async Task<IActionResult> GetRelationshipsAsync(TId id, string relationshipName)
+ => await base.GetRelationshipsAsync(id, relationshipName);
+
+ [HttpGet("{id}/{relationshipName}")]
+ public override async Task<IActionResult> GetRelationshipAsync(TId id, string relationshipName)
+ => await base.GetRelationshipAsync(id, relationshipName);
+ }
+}

src/JsonApiDotNetCore/Data/DefaultEntityRepository.cs

@@ -170,7 +170,7 @@ public virtual IQueryable<TEntity> Include(IQueryable<TEntity> entities, string
  if(relationship != null)
  return entities.Include(relationship.InternalRelationshipName);
 
- throw new JsonApiException("400", $"Invalid relationship {relationshipName} on {entity.EntityName}",
+ throw new JsonApiException(400, $"Invalid relationship {relationshipName} on {entity.EntityName}",
  $"{entity.EntityName} does not have a relationship named {relationshipName}");
  }