Process review feedback

Author: maurei

src/JsonApiDotNetCore.OpenApi/JsonApiActionDescriptorCollectionProvider.cs

@@ -79,14 +79,14 @@ private static IEnumerable<ActionDescriptor> AddJsonApiMetadataToAction(ActionDe
                     UpdateBodyParameterDescriptor(endpoint, primaryMetadata.DocumentType);
                     return Array.Empty<ActionDescriptor>();
                 }
-                case NonPrimaryEndpointMetadata expansibleMetadata and (RelationshipResponseMetadata or SecondaryResponseMetadata):
+                case NonPrimaryEndpointMetadata nonPrimaryEndpointMetadata and (RelationshipResponseMetadata or SecondaryResponseMetadata):
                 {
-                    return Expand(endpoint, expansibleMetadata,
+                    return Expand(endpoint, nonPrimaryEndpointMetadata,
                         (expandedEndpoint, documentType, _) => UpdateProducesResponseTypeAttribute(expandedEndpoint, documentType));
                 }
-                case NonPrimaryEndpointMetadata expansibleMetadata and RelationshipRequestMetadata:
+                case NonPrimaryEndpointMetadata nonPrimaryEndpointMetadata and RelationshipRequestMetadata:
                 {
-                    return Expand(endpoint, expansibleMetadata, UpdateBodyParameterDescriptor);
+                    return Expand(endpoint, nonPrimaryEndpointMetadata, UpdateBodyParameterDescriptor);
                 }
                 default:
                 {

src/JsonApiDotNetCore.OpenApi/JsonApiObjects/Documents/PrimaryResourceResponseDocument.cs

@@ -7,7 +7,8 @@
 
 namespace JsonApiDotNetCore.OpenApi.JsonApiObjects.Documents
 {
-    // Types in the current namespace are never touched by ASP.NET ModelState validation, therefore using a non-nullable reference type for a property does not imply this property is required. Instead, we use [Required] explicitly, because is how Swashbuckle is instructed to mark properties as required.
+    // Types in the current namespace are never touched by ASP.NET ModelState validation, therefore using a non-nullable reference type for a property does not
+    // imply this property is required. Instead, we use [Required] explicitly, because this is how Swashbuckle is instructed to mark properties as required.
     [UsedImplicitly(ImplicitUseTargetFlags.Members)]
     internal sealed class PrimaryResourceResponseDocument<TResource> : SingleData<ResourceResponseObject<TResource>>
         where TResource : IIdentifiable

src/JsonApiDotNetCore.OpenApi/JsonApiObjects/NonPrimaryDocumentTypeFactory.cs

@@ -7,13 +7,13 @@ namespace JsonApiDotNetCore.OpenApi.JsonApiObjects
 {
     internal sealed class NonPrimaryDocumentTypeFactory
     {
-        private static readonly DocumentOpenTypeOptions SecondaryResponseDocumentTypeOptions = new(typeof(ResourceCollectionResponseDocument<>),
+        private static readonly DocumentOpenTypes SecondaryResponseDocumentOpenTypes = new(typeof(ResourceCollectionResponseDocument<>),
             typeof(NullableSecondaryResourceResponseDocument<>), typeof(SecondaryResourceResponseDocument<>));
 
-        private static readonly DocumentOpenTypeOptions RelationshipRequestDocumentTypeOptions = new(typeof(ToManyRelationshipRequestData<>),
+        private static readonly DocumentOpenTypes RelationshipRequestDocumentOpenTypes = new(typeof(ToManyRelationshipRequestData<>),
             typeof(NullableToOneRelationshipRequestData<>), typeof(ToOneRelationshipRequestData<>));
 
-        private static readonly DocumentOpenTypeOptions RelationshipResponseDocumentTypeOptions = new(typeof(ResourceIdentifierCollectionResponseDocument<>),
+        private static readonly DocumentOpenTypes RelationshipResponseDocumentOpenTypes = new(typeof(ResourceIdentifierCollectionResponseDocument<>),
             typeof(NullableResourceIdentifierResponseDocument<>), typeof(ResourceIdentifierResponseDocument<>));
 
         public static NonPrimaryDocumentTypeFactory Instance { get; } = new();
@@ -26,53 +26,53 @@ public Type GetForSecondaryResponse(RelationshipAttribute relationship)
         {
             ArgumentGuard.NotNull(relationship, nameof(relationship));
 
-            return Get(relationship, SecondaryResponseDocumentTypeOptions);
+            return Get(relationship, SecondaryResponseDocumentOpenTypes);
         }
 
         public Type GetForRelationshipRequest(RelationshipAttribute relationship)
         {
             ArgumentGuard.NotNull(relationship, nameof(relationship));
 
-            return Get(relationship, RelationshipRequestDocumentTypeOptions);
+            return Get(relationship, RelationshipRequestDocumentOpenTypes);
         }
 
         public Type GetForRelationshipResponse(RelationshipAttribute relationship)
         {
             ArgumentGuard.NotNull(relationship, nameof(relationship));
 
-            return Get(relationship, RelationshipResponseDocumentTypeOptions);
+            return Get(relationship, RelationshipResponseDocumentOpenTypes);
         }
 
-        private static Type Get(RelationshipAttribute relationship, DocumentOpenTypeOptions typeOptions)
+        private static Type Get(RelationshipAttribute relationship, DocumentOpenTypes types)
         {
             // @formatter:nested_ternary_style expanded
 
             Type documentOpenType = relationship is HasManyAttribute
-                ? typeOptions.ManyData
+                ? types.ManyDataOpenType
                 : relationship.IsNullable()
-                    ? typeOptions.NullableSingleData
-                    : typeOptions.SingleData;
+                    ? types.NullableSingleDataOpenType
+                    : types.SingleDataOpenType;
 
             // @formatter:nested_ternary_style restore
 
             return documentOpenType.MakeGenericType(relationship.RightType.ClrType);
         }
 
-        private sealed class DocumentOpenTypeOptions
+        private sealed class DocumentOpenTypes
         {
-            public Type ManyData { get; }
-            public Type NullableSingleData { get; }
-            public Type SingleData { get; }
+            public Type ManyDataOpenType { get; }
+            public Type NullableSingleDataOpenType { get; }
+            public Type SingleDataOpenType { get; }
 
-            public DocumentOpenTypeOptions(Type manyDataOpenType, Type nullableSingleDataOpenType, Type singleDataOpenType)
+            public DocumentOpenTypes(Type manyDataOpenType, Type nullableSingleDataOpenType, Type singleDataOpenType)
             {
                 ArgumentGuard.NotNull(manyDataOpenType, nameof(manyDataOpenType));
                 ArgumentGuard.NotNull(nullableSingleDataOpenType, nameof(nullableSingleDataOpenType));
                 ArgumentGuard.NotNull(singleDataOpenType, nameof(singleDataOpenType));
 
-                ManyData = manyDataOpenType;
-                NullableSingleData = nullableSingleDataOpenType;
-                SingleData = singleDataOpenType;
+                ManyDataOpenType = manyDataOpenType;
+                NullableSingleDataOpenType = nullableSingleDataOpenType;
+                SingleDataOpenType = singleDataOpenType;
             }
         }
     }

src/JsonApiDotNetCore.OpenApi/MemberInfoExtensions.cs

@@ -10,19 +10,28 @@ public static TypeCategory GetTypeCategory(this MemberInfo source)
         {
             ArgumentGuard.NotNull(source, nameof(source));
 
-            Type memberType = source.MemberType switch
+            Type memberType;
+
+            if (source.MemberType.HasFlag(MemberTypes.Field))
+            {
+                memberType = ((FieldInfo)source).FieldType;
+            }
+            else if (source.MemberType.HasFlag(MemberTypes.Property))
             {
-                MemberTypes.Field => ((FieldInfo)source).FieldType,
-                MemberTypes.Property => ((PropertyInfo)source).PropertyType,
-                _ => throw new ArgumentException("Cannot get the type category for members of type other than 'MemberTypes.Field' or 'MemberTypes.Property'.")
-            };
+                memberType = ((PropertyInfo)source).PropertyType;
+            }
+            else
+            {
+                throw new NotSupportedException($"Cannot get the type category for members of type '{source.MemberType}' is not supported.");
+            }
 
             if (memberType.IsValueType)
             {
                 return Nullable.GetUnderlyingType(memberType) != null ? TypeCategory.NullableValueType : TypeCategory.ValueType;
             }
 
-            // Once we switch to .NET 6, we should rely instead on the built-in reflection APIs for nullability information. See https://devblogs.microsoft.com/dotnet/announcing-net-6-preview-7/#libraries-reflection-apis-for-nullability-information.
+            // Once we switch to .NET 6, we should rely instead on the built-in reflection APIs for nullability information.
+            // See https://devblogs.microsoft.com/dotnet/announcing-net-6-preview-7/#libraries-reflection-apis-for-nullability-information.
             return source.IsNonNullableReferenceType() ? TypeCategory.NonNullableReferenceType : TypeCategory.NullableReferenceType;
         }
     }

src/JsonApiDotNetCore.OpenApi/SwaggerComponents/JsonApiSchemaGenerator.cs

@@ -109,7 +109,9 @@ private static bool IsDataPropertyNullable(Type type)
                 throw new UnreachableCodeException();
             }
 
-            return dataProperty.GetTypeCategory() == TypeCategory.NullableReferenceType;
+            TypeCategory typeCategory = dataProperty.GetTypeCategory();
+
+            return typeCategory == TypeCategory.NullableReferenceType;
         }
 
         private void SetDataObjectSchemaToNullable(OpenApiSchema referenceSchemaForDocument)

test/OpenApiTests/LegacyOpenApiIntegration/LegacyIntegrationDbContext.cs

@@ -29,7 +29,8 @@ protected override void OnModelCreating(ModelBuilder builder)
                 .WithMany(flightAttendant => flightAttendant.PurserOnFlights);
 
             builder.Entity<Flight>()
-                .HasOne(flight => flight.BackupPurser);
+                .HasOne(flight => flight.BackupPurser)
+                .WithMany();
         }
     }
 }