ConfigureSwaggerGenOptions.cs

using System.Reflection;
using JsonApiDotNetCore.Configuration;
using JsonApiDotNetCore.Middleware;
using JsonApiDotNetCore.OpenApi.Swashbuckle.JsonApiObjects.AtomicOperations;
using JsonApiDotNetCore.OpenApi.Swashbuckle.JsonApiObjects.ResourceObjects;
using JsonApiDotNetCore.OpenApi.Swashbuckle.SwaggerComponents;
using JsonApiDotNetCore.Resources;
using Microsoft.AspNetCore.Mvc.ApiExplorer;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Swashbuckle.AspNetCore.SwaggerGen;

namespace JsonApiDotNetCore.OpenApi.Swashbuckle;

internal sealed class ConfigureSwaggerGenOptions : IConfigureOptions<SwaggerGenOptions>
{
    private static readonly Dictionary<Type, Type> BaseToDerivedSchemaTypes = new()
    {
        [typeof(IdentifierInRequest)] = typeof(IdentifierInRequest<>),
        [typeof(ResourceInCreateRequest)] = typeof(DataInCreateRequest<>),
        [typeof(ResourceInUpdateRequest)] = typeof(DataInUpdateRequest<>),
        [typeof(ResourceInResponse)] = typeof(DataInResponse<>)
    };

    private static readonly Type[] AtomicOperationDerivedSchemaTypes =
    [
        typeof(CreateOperation<>),
        typeof(UpdateOperation<>),
        typeof(DeleteOperation<>),
        typeof(UpdateToOneRelationshipOperation<>),
        typeof(UpdateToManyRelationshipOperation<>),
        typeof(AddToRelationshipOperation<>),
        typeof(RemoveFromRelationshipOperation<>)
    ];

    private readonly OpenApiOperationIdSelector _operationIdSelector;
    private readonly JsonApiSchemaIdSelector _schemaIdSelector;
    private readonly IControllerResourceMapping _controllerResourceMapping;
    private readonly IResourceGraph _resourceGraph;

    public ConfigureSwaggerGenOptions(OpenApiOperationIdSelector operationIdSelector, JsonApiSchemaIdSelector schemaIdSelector,
        IControllerResourceMapping controllerResourceMapping, IResourceGraph resourceGraph)
    {
        ArgumentNullException.ThrowIfNull(operationIdSelector);
        ArgumentNullException.ThrowIfNull(schemaIdSelector);
        ArgumentNullException.ThrowIfNull(controllerResourceMapping);
        ArgumentNullException.ThrowIfNull(resourceGraph);

        _operationIdSelector = operationIdSelector;
        _schemaIdSelector = schemaIdSelector;
        _controllerResourceMapping = controllerResourceMapping;
        _resourceGraph = resourceGraph;
    }

    public void Configure(SwaggerGenOptions options)
    {
        ArgumentNullException.ThrowIfNull(options);

        options.SupportNonNullableReferenceTypes();
        options.UseAllOfToExtendReferenceSchemas();

        options.UseAllOfForInheritance();
        options.SelectDiscriminatorNameUsing(_ => JsonApiPropertyName.Type);
        options.SelectDiscriminatorValueUsing(clrType => _resourceGraph.GetResourceType(clrType).PublicName);
        options.SelectSubTypesUsing(SelectDerivedTypes);

        options.TagActionsBy(description => GetOpenApiOperationTags(description, _controllerResourceMapping));
        options.CustomOperationIds(_operationIdSelector.GetOpenApiOperationId);
        options.CustomSchemaIds(_schemaIdSelector.GetSchemaId);

        options.OperationFilter<DocumentationOpenApiOperationFilter>();
        options.DocumentFilter<ServerDocumentFilter>();
        options.DocumentFilter<EndpointOrderingFilter>();
        options.DocumentFilter<StringEnumOrderingFilter>();
        options.DocumentFilter<SetSchemaTypeToObjectDocumentFilter>();
        options.DocumentFilter<UnusedComponentSchemaCleaner>();
        options.DocumentFilter<SortSchemasFilter>();
    }

    private List<Type> SelectDerivedTypes(Type baseType)
    {
        if (BaseToDerivedSchemaTypes.TryGetValue(baseType, out var schemaOpenType))
        {
            return GetConstructedTypesFromResourceGraph(schemaOpenType);
        }

        if (baseType == typeof(AtomicOperation))
        {
            return GetConstructedTypesForAtomicOperation();
        }

        if (baseType.IsAssignableTo(typeof(IIdentifiable)))
        {
            var resourceType = _resourceGraph.FindResourceType(baseType);

            if (resourceType != null && resourceType.IsPartOfTypeHierarchy())
            {
                return GetResourceDerivedTypes(resourceType);
            }
        }

        return [];
    }

    private List<Type> GetConstructedTypesFromResourceGraph(Type schemaOpenType)
    {
        List<Type> constructedTypes = [];

        foreach (var resourceType in _resourceGraph.GetResourceTypes())
        {
            var constructedType = schemaOpenType.MakeGenericType(resourceType.ClrType);
            constructedTypes.Add(constructedType);
        }

        return constructedTypes;
    }

    private List<Type> GetConstructedTypesForAtomicOperation()
    {
        List<Type> derivedTypes = [];

        foreach (var resourceType in _resourceGraph.GetResourceTypes())
        {
            derivedTypes.AddRange(AtomicOperationDerivedSchemaTypes.Select(openType => openType.MakeGenericType(resourceType.ClrType)));
        }

        return derivedTypes;
    }

    private static List<Type> GetResourceDerivedTypes(ResourceType baseType)
    {
        List<Type> clrTypes = [];
        IncludeDerivedTypes(baseType, clrTypes);
        return clrTypes;
    }

    private static void IncludeDerivedTypes(ResourceType baseType, List<Type> clrTypes)
    {
        foreach (var derivedType in baseType.DirectlyDerivedTypes)
        {
            clrTypes.Add(derivedType.ClrType);
            IncludeDerivedTypes(derivedType, clrTypes);
        }
    }

    private static List<string> GetOpenApiOperationTags(ApiDescription description, IControllerResourceMapping controllerResourceMapping)
    {
        var actionMethod = description.ActionDescriptor.GetActionMethod();
        var resourceType = controllerResourceMapping.GetResourceTypeForController(actionMethod.ReflectedType);

        return resourceType == null ? ["operations"] : [resourceType.PublicName];
    }
}