Rename ResourceTypeInfo to ResourceSchemaType

bkoelman · bkoelman · commit 5454188573af · 2024-11-29T03:36:44.000+01:00
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerators/Bodies/ResourceOrRelationshipBodySchemaGenerator.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerators/Bodies/ResourceOrRelationshipBodySchemaGenerator.cs
@@ -67,15 +67,15 @@ protected override OpenApiSchema GenerateBodySchema(Type bodyType, SchemaReposit
             return referenceSchemaForBody;
         }
 
-        var resourceTypeInfo = ResourceTypeInfo.Create(bodyType, _resourceGraph);
-        bool isRequestSchema = RequestBodySchemaTypes.Contains(bodyType.ConstructedToOpenType());
+        var resourceSchemaType = ResourceSchemaType.Create(bodyType, _resourceGraph);
+        bool isRequestSchema = RequestBodySchemaTypes.Contains(resourceSchemaType.SchemaOpenType);
 
-        _ = _dataContainerSchemaGenerator.GenerateSchema(bodyType, resourceTypeInfo.ResourceType, isRequestSchema, schemaRepository);
+        _ = _dataContainerSchemaGenerator.GenerateSchema(bodyType, resourceSchemaType.ResourceType, isRequestSchema, schemaRepository);
 
         referenceSchemaForBody = _defaultSchemaGenerator.GenerateSchema(bodyType, schemaRepository);
         OpenApiSchema fullSchemaForBody = schemaRepository.Schemas[referenceSchemaForBody.Reference.Id].UnwrapLastExtendedSchema();
 
-        if (JsonApiSchemaFacts.HasNullableDataProperty(bodyType))
+        if (JsonApiSchemaFacts.HasNullableDataProperty(resourceSchemaType.SchemaOpenType))
         {
             fullSchemaForBody.Properties[JsonApiPropertyName.Data].Nullable = true;
         }
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerators/Components/AbstractResourceDataSchemaGenerator.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerators/Components/AbstractResourceDataSchemaGenerator.cs
@@ -91,9 +91,9 @@ public void MapDiscriminator(Type resourceDataConstructedType, OpenApiSchema ref
         ArgumentGuard.NotNull(referenceSchemaForResourceData);
         ArgumentGuard.NotNull(schemaRepository);
 
-        var resourceTypeInfo = ResourceTypeInfo.Create(resourceDataConstructedType, _resourceGraph);
+        var resourceSchemaType = ResourceSchemaType.Create(resourceDataConstructedType, _resourceGraph);
 
-        if (resourceTypeInfo.ResourceDataOpenType == typeof(ResourceDataInResponse<>))
+        if (resourceSchemaType.SchemaOpenType == typeof(ResourceDataInResponse<>))
         {
             if (!schemaRepository.TryLookupByType(ResourceDataAbstractType, out OpenApiSchema? referenceSchemaForAbstractResourceData))
             {
@@ -102,7 +102,7 @@ public void MapDiscriminator(Type resourceDataConstructedType, OpenApiSchema ref
 
             OpenApiSchema fullSchemaForAbstractResourceData = schemaRepository.Schemas[referenceSchemaForAbstractResourceData.Reference.Id];
             string dataSchemaId = referenceSchemaForResourceData.Reference.ReferenceV3;
-            string publicName = resourceTypeInfo.ResourceType.PublicName;
+            string publicName = resourceSchemaType.ResourceType.PublicName;
 
             if (fullSchemaForAbstractResourceData.Discriminator.Mapping.TryAdd(publicName, dataSchemaId))
             {
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerators/Components/DataContainerSchemaGenerator.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerators/Components/DataContainerSchemaGenerator.cs
@@ -101,9 +101,9 @@ private void EnsureResourceDataInResponseDerivedTypesAreMappedInDiscriminator(Ty
 
         if (dataOpenType == typeof(ResourceDataInResponse<>))
         {
-            var resourceTypeInfo = ResourceTypeInfo.Create(dataConstructedType, _resourceGraph);
+            var resourceSchemaType = ResourceSchemaType.Create(dataConstructedType, _resourceGraph);
 
-            foreach (ResourceType relatedType in _includeDependencyScanner.GetReachableRelatedTypes(resourceTypeInfo.ResourceType))
+            foreach (ResourceType relatedType in _includeDependencyScanner.GetReachableRelatedTypes(resourceSchemaType.ResourceType))
             {
                 MapResourceDataInResponseDerivedTypeInDiscriminator(relatedType, schemaRepository);
             }
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerators/Components/DataSchemaGenerator.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerators/Components/DataSchemaGenerator.cs
@@ -74,8 +74,8 @@ public OpenApiSchema GenerateSchema(Type dataSchemaType, SchemaRepository schema
             return referenceSchemaForData;
         }
 
-        var resourceTypeInfo = ResourceTypeInfo.Create(dataSchemaType, _resourceGraph);
-        ResourceType resourceType = resourceTypeInfo.ResourceType;
+        var resourceSchemaType = ResourceSchemaType.Create(dataSchemaType, _resourceGraph);
+        ResourceType resourceType = resourceSchemaType.ResourceType;
 
         referenceSchemaForData = _defaultSchemaGenerator.GenerateSchema(dataSchemaType, schemaRepository);
         OpenApiSchema fullSchemaForResourceData = schemaRepository.Schemas[referenceSchemaForData.Reference.Id];
@@ -86,11 +86,11 @@ public OpenApiSchema GenerateSchema(Type dataSchemaType, SchemaRepository schema
 
         SetAbstract(inlineSchemaForResourceData, resourceType);
         SetResourceType(inlineSchemaForResourceData, resourceType, schemaRepository);
-        AdaptResourceIdentity(inlineSchemaForResourceData, resourceTypeInfo, isRequestSchema, schemaRepository);
+        AdaptResourceIdentity(inlineSchemaForResourceData, resourceSchemaType, isRequestSchema, schemaRepository);
         SetResourceId(inlineSchemaForResourceData, resourceType, schemaRepository);
-        SetResourceFields(inlineSchemaForResourceData, resourceTypeInfo, isRequestSchema, schemaRepository);
+        SetResourceFields(inlineSchemaForResourceData, resourceSchemaType, isRequestSchema, schemaRepository);
         SetDocumentation(fullSchemaForResourceData, resourceType);
-        SetLinksVisibility(inlineSchemaForResourceData, resourceTypeInfo, schemaRepository);
+        SetLinksVisibility(inlineSchemaForResourceData, resourceSchemaType, schemaRepository);
 
         inlineSchemaForResourceData.ReorderProperties(ResourceDataPropertyNamesInOrder);
 
@@ -114,7 +114,8 @@ private void SetResourceType(OpenApiSchema fullSchema, ResourceType resourceType
         }
     }
 
-    private void AdaptResourceIdentity(OpenApiSchema fullSchema, ResourceTypeInfo resourceTypeInfo, bool forRequestSchema, SchemaRepository schemaRepository)
+    private void AdaptResourceIdentity(OpenApiSchema fullSchema, ResourceSchemaType resourceSchemaType, bool forRequestSchema,
+        SchemaRepository schemaRepository)
     {
         if (!forRequestSchema)
         {
@@ -128,9 +129,9 @@ private void AdaptResourceIdentity(OpenApiSchema fullSchema, ResourceTypeInfo re
             fullSchema.Properties.Remove(JsonApiPropertyName.Lid);
         }
 
-        if (resourceTypeInfo.ResourceDataOpenType == typeof(DataInCreateResourceRequest<>))
+        if (resourceSchemaType.SchemaOpenType == typeof(DataInCreateResourceRequest<>))
         {
-            ClientIdGenerationMode clientIdGeneration = resourceTypeInfo.ResourceType.ClientIdGeneration ?? _options.ClientIdGeneration;
+            ClientIdGenerationMode clientIdGeneration = resourceSchemaType.ResourceType.ClientIdGeneration ?? _options.ClientIdGeneration;
 
             if (hasAtomicOperationsEndpoint)
             {
@@ -174,17 +175,18 @@ private void SetResourceId(OpenApiSchema fullSchema, ResourceType resourceType,
         }
     }
 
-    private void SetResourceFields(OpenApiSchema fullSchemaForData, ResourceTypeInfo resourceTypeInfo, bool forRequestSchema, SchemaRepository schemaRepository)
+    private void SetResourceFields(OpenApiSchema fullSchemaForData, ResourceSchemaType resourceSchemaType, bool forRequestSchema,
+        SchemaRepository schemaRepository)
     {
         bool schemaHasFields = fullSchemaForData.Properties.ContainsKey(JsonApiPropertyName.Attributes) &&
             fullSchemaForData.Properties.ContainsKey(JsonApiPropertyName.Relationships);
 
         if (schemaHasFields)
         {
             var fieldSchemaBuilder = new ResourceFieldSchemaBuilder(_defaultSchemaGenerator, _resourceIdentifierSchemaGenerator,
-                _linksVisibilitySchemaGenerator, _resourceFieldValidationMetadataProvider, _relationshipTypeFactory, resourceTypeInfo);
+                _linksVisibilitySchemaGenerator, _resourceFieldValidationMetadataProvider, _relationshipTypeFactory, resourceSchemaType);
 
-            ResourceType resourceType = resourceTypeInfo.ResourceType;
+            ResourceType resourceType = resourceSchemaType.ResourceType;
 
             SetFieldSchemaMembers(fullSchemaForData, resourceType, forRequestSchema, true, fieldSchemaBuilder, schemaRepository);
             SetFieldSchemaMembers(fullSchemaForData, resourceType, forRequestSchema, false, fieldSchemaBuilder, schemaRepository);
@@ -222,8 +224,8 @@ private void SetDocumentation(OpenApiSchema fullSchema, ResourceType resourceTyp
         fullSchema.Description = _resourceDocumentationReader.GetDocumentationForType(resourceType);
     }
 
-    private void SetLinksVisibility(OpenApiSchema fullSchema, ResourceTypeInfo resourceTypeInfo, SchemaRepository schemaRepository)
+    private void SetLinksVisibility(OpenApiSchema fullSchema, ResourceSchemaType resourceSchemaType, SchemaRepository schemaRepository)
     {
-        _linksVisibilitySchemaGenerator.UpdateSchemaForResource(resourceTypeInfo, fullSchema, schemaRepository);
+        _linksVisibilitySchemaGenerator.UpdateSchemaForResource(resourceSchemaType, fullSchema, schemaRepository);
     }
 }
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerators/Components/LinksVisibilitySchemaGenerator.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SchemaGenerators/Components/LinksVisibilitySchemaGenerator.cs
@@ -83,12 +83,12 @@ public void UpdateSchemaForTopLevel(Type modelType, OpenApiSchema fullSchemaForL
         }
     }
 
-    public void UpdateSchemaForResource(ResourceTypeInfo resourceTypeInfo, OpenApiSchema fullSchemaForResourceData, SchemaRepository schemaRepository)
+    public void UpdateSchemaForResource(ResourceSchemaType resourceSchemaType, OpenApiSchema fullSchemaForResourceData, SchemaRepository schemaRepository)
     {
-        ArgumentGuard.NotNull(resourceTypeInfo);
+        ArgumentGuard.NotNull(resourceSchemaType);
         ArgumentGuard.NotNull(fullSchemaForResourceData);
 
-        if (LinksInJsonApiSchemaTypes.TryGetValue(resourceTypeInfo.ResourceDataOpenType, out LinkTypes possibleLinkTypes))
+        if (LinksInJsonApiSchemaTypes.TryGetValue(resourceSchemaType.SchemaOpenType, out LinkTypes possibleLinkTypes))
         {
             UpdateLinksProperty(fullSchemaForResourceData, _lazyLinksVisibility.Value.ResourceLinks, possibleLinkTypes, schemaRepository);
         }
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SwaggerComponents/ResourceFieldSchemaBuilder.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SwaggerComponents/ResourceFieldSchemaBuilder.cs
@@ -13,7 +13,7 @@ internal sealed class ResourceFieldSchemaBuilder
     private readonly SchemaGenerator _defaultSchemaGenerator;
     private readonly ResourceIdentifierSchemaGenerator _resourceIdentifierSchemaGenerator;
     private readonly LinksVisibilitySchemaGenerator _linksVisibilitySchemaGenerator;
-    private readonly ResourceTypeInfo _resourceTypeInfo;
+    private readonly ResourceSchemaType _resourceSchemaType;
     private readonly ResourceFieldValidationMetadataProvider _resourceFieldValidationMetadataProvider;
     private readonly RelationshipTypeFactory _relationshipTypeFactory;
 
@@ -23,19 +23,19 @@ internal sealed class ResourceFieldSchemaBuilder
 
     public ResourceFieldSchemaBuilder(SchemaGenerator defaultSchemaGenerator, ResourceIdentifierSchemaGenerator resourceIdentifierSchemaGenerator,
         LinksVisibilitySchemaGenerator linksVisibilitySchemaGenerator, ResourceFieldValidationMetadataProvider resourceFieldValidationMetadataProvider,
-        RelationshipTypeFactory relationshipTypeFactory, ResourceTypeInfo resourceTypeInfo)
+        RelationshipTypeFactory relationshipTypeFactory, ResourceSchemaType resourceSchemaType)
     {
         ArgumentGuard.NotNull(defaultSchemaGenerator);
         ArgumentGuard.NotNull(resourceIdentifierSchemaGenerator);
         ArgumentGuard.NotNull(linksVisibilitySchemaGenerator);
-        ArgumentGuard.NotNull(resourceTypeInfo);
+        ArgumentGuard.NotNull(resourceSchemaType);
         ArgumentGuard.NotNull(resourceFieldValidationMetadataProvider);
         ArgumentGuard.NotNull(relationshipTypeFactory);
 
         _defaultSchemaGenerator = defaultSchemaGenerator;
         _resourceIdentifierSchemaGenerator = resourceIdentifierSchemaGenerator;
         _linksVisibilitySchemaGenerator = linksVisibilitySchemaGenerator;
-        _resourceTypeInfo = resourceTypeInfo;
+        _resourceSchemaType = resourceSchemaType;
         _resourceFieldValidationMetadataProvider = resourceFieldValidationMetadataProvider;
         _relationshipTypeFactory = relationshipTypeFactory;
 
@@ -44,9 +44,9 @@ public ResourceFieldSchemaBuilder(SchemaGenerator defaultSchemaGenerator, Resour
 
     private IDictionary<string, OpenApiSchema> GetFieldSchemas()
     {
-        if (!_resourceSchemaRepository.TryLookupByType(_resourceTypeInfo.ResourceType.ClrType, out OpenApiSchema referenceSchemaForResource))
+        if (!_resourceSchemaRepository.TryLookupByType(_resourceSchemaType.ResourceType.ClrType, out OpenApiSchema referenceSchemaForResource))
         {
-            referenceSchemaForResource = _defaultSchemaGenerator.GenerateSchema(_resourceTypeInfo.ResourceType.ClrType, _resourceSchemaRepository);
+            referenceSchemaForResource = _defaultSchemaGenerator.GenerateSchema(_resourceSchemaType.ResourceType.ClrType, _resourceSchemaRepository);
         }
 
         OpenApiSchema fullSchemaForResource = _resourceSchemaRepository.Schemas[referenceSchemaForResource.Reference.Id];
@@ -57,12 +57,13 @@ public void SetMembersOfAttributes(OpenApiSchema fullSchemaForAttributes, bool f
     {
         ArgumentGuard.NotNull(fullSchemaForAttributes);
         ArgumentGuard.NotNull(schemaRepository);
+        AssertHasNoProperties(fullSchemaForAttributes);
 
-        AttrCapabilities requiredCapability = GetRequiredCapabilityForAttributes(_resourceTypeInfo.ResourceDataOpenType);
+        AttrCapabilities requiredCapability = GetRequiredCapabilityForAttributes(_resourceSchemaType.SchemaOpenType);
 
-        foreach ((string fieldName, OpenApiSchema resourceFieldSchema) in _schemasForResourceFields)
+        foreach ((string publicName, OpenApiSchema schemaForResourceField) in _schemasForResourceFields)
         {
-            AttrAttribute? matchingAttribute = _resourceTypeInfo.ResourceType.FindAttributeByPublicName(fieldName);
+            AttrAttribute? matchingAttribute = _resourceSchemaType.ResourceType.FindAttributeByPublicName(publicName);
 
             if (matchingAttribute != null && matchingAttribute.Capabilities.HasFlag(requiredCapability))
             {
@@ -81,24 +82,25 @@ public void SetMembersOfAttributes(OpenApiSchema fullSchemaForAttributes, bool f
                     }
                 }
 
-                bool isInlineSchemaType = resourceFieldSchema.AllOf.Count == 0;
+                bool isInlineSchemaType = schemaForResourceField.AllOf.Count == 0;
 
                 // Schemas for types like enum and complex attributes are handled as reference schemas.
                 if (!isInlineSchemaType)
                 {
-                    EnsureAttributeSchemaIsExposed(resourceFieldSchema.UnwrapLastExtendedSchema(), matchingAttribute, schemaRepository);
+                    OpenApiSchema referenceSchemaForAttribute = schemaForResourceField.UnwrapLastExtendedSchema();
+                    EnsureAttributeSchemaIsExposed(referenceSchemaForAttribute, matchingAttribute, schemaRepository);
                 }
 
-                fullSchemaForAttributes.Properties.Add(matchingAttribute.PublicName, resourceFieldSchema);
+                fullSchemaForAttributes.Properties.Add(matchingAttribute.PublicName, schemaForResourceField);
 
-                resourceFieldSchema.Nullable = _resourceFieldValidationMetadataProvider.IsNullable(matchingAttribute);
+                schemaForResourceField.Nullable = _resourceFieldValidationMetadataProvider.IsNullable(matchingAttribute);
 
                 if (IsFieldRequired(matchingAttribute))
                 {
                     fullSchemaForAttributes.Required.Add(matchingAttribute.PublicName);
                 }
 
-                resourceFieldSchema.Description = _resourceDocumentationReader.GetDocumentationForAttribute(matchingAttribute);
+                schemaForResourceField.Description = _resourceDocumentationReader.GetDocumentationForAttribute(matchingAttribute);
             }
         }
     }
@@ -142,18 +144,19 @@ private Type GetRepresentedTypeForAttributeSchema(AttrAttribute attribute)
 
     private bool IsFieldRequired(ResourceFieldAttribute field)
     {
-        bool isCreateResourceSchemaType = _resourceTypeInfo.ResourceDataOpenType == typeof(DataInCreateResourceRequest<>);
+        bool isCreateResourceSchemaType = _resourceSchemaType.SchemaOpenType == typeof(DataInCreateResourceRequest<>);
         return isCreateResourceSchemaType && _resourceFieldValidationMetadataProvider.IsRequired(field);
     }
 
     public void SetMembersOfRelationships(OpenApiSchema fullSchemaForRelationships, bool forRequestSchema, SchemaRepository schemaRepository)
     {
         ArgumentGuard.NotNull(fullSchemaForRelationships);
         ArgumentGuard.NotNull(schemaRepository);
+        AssertHasNoProperties(fullSchemaForRelationships);
 
-        foreach (string fieldName in _schemasForResourceFields.Keys)
+        foreach (string publicName in _schemasForResourceFields.Keys)
         {
-            RelationshipAttribute? matchingRelationship = _resourceTypeInfo.ResourceType.FindRelationshipByPublicName(fieldName);
+            RelationshipAttribute? matchingRelationship = _resourceSchemaType.ResourceType.FindRelationshipByPublicName(publicName);
 
             if (matchingRelationship != null)
             {
@@ -166,7 +169,7 @@ public void SetMembersOfRelationships(OpenApiSchema fullSchemaForRelationships,
     private void AddRelationshipSchemaToResourceData(RelationshipAttribute relationship, OpenApiSchema fullSchemaForRelationships,
         SchemaRepository schemaRepository)
     {
-        Type relationshipSchemaType = GetRelationshipSchemaType(relationship, _resourceTypeInfo.ResourceDataOpenType);
+        Type relationshipSchemaType = GetRelationshipSchemaType(relationship, _resourceSchemaType.SchemaOpenType);
 
         OpenApiSchema referenceSchemaForRelationship = GetReferenceSchemaForRelationship(relationshipSchemaType, schemaRepository) ??
             CreateReferenceSchemaForRelationship(relationshipSchemaType, schemaRepository);
@@ -182,9 +185,9 @@ private void AddRelationshipSchemaToResourceData(RelationshipAttribute relations
         }
     }
 
-    private Type GetRelationshipSchemaType(RelationshipAttribute relationship, Type resourceDataConstructedType)
+    private Type GetRelationshipSchemaType(RelationshipAttribute relationship, Type openSchemaType)
     {
-        bool isResponseSchemaType = resourceDataConstructedType.ConstructedToOpenType().IsAssignableTo(typeof(ResourceDataInResponse<>));
+        bool isResponseSchemaType = openSchemaType.IsAssignableTo(typeof(ResourceDataInResponse<>));
         return isResponseSchemaType ? _relationshipTypeFactory.GetForResponse(relationship) : _relationshipTypeFactory.GetForRequest(relationship);
     }
 
@@ -211,4 +214,12 @@ private OpenApiSchema CreateReferenceSchemaForRelationship(Type relationshipSche
 
         return referenceSchema;
     }
+
+    private static void AssertHasNoProperties(OpenApiSchema fullSchema)
+    {
+        if (fullSchema.Properties.Count > 0)
+        {
+            throw new UnreachableCodeException();
+        }
+    }
 }
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SwaggerComponents/ResourceSchemaType.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SwaggerComponents/ResourceSchemaType.cs
diff --git a/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SwaggerComponents/ResourceTypeInfo.cs b/src/JsonApiDotNetCore.OpenApi.Swashbuckle/SwaggerComponents/ResourceTypeInfo.cs

Original file line number	Diff line number	Diff line change
`@@ -67,15 +67,15 @@ protected override OpenApiSchema GenerateBodySchema(Type bodyType, SchemaReposit`
`67`	`67`	`return referenceSchemaForBody;`
`68`	`68`	`}`
`69`	`69`
`70`		`- var resourceTypeInfo = ResourceTypeInfo.Create(bodyType, _resourceGraph);`
`71`		`- bool isRequestSchema = RequestBodySchemaTypes.Contains(bodyType.ConstructedToOpenType());`
	`70`	`+ var resourceSchemaType = ResourceSchemaType.Create(bodyType, _resourceGraph);`
	`71`	`+ bool isRequestSchema = RequestBodySchemaTypes.Contains(resourceSchemaType.SchemaOpenType);`
`72`	`72`
`73`		`- _ = _dataContainerSchemaGenerator.GenerateSchema(bodyType, resourceTypeInfo.ResourceType, isRequestSchema, schemaRepository);`
	`73`	`+ _ = _dataContainerSchemaGenerator.GenerateSchema(bodyType, resourceSchemaType.ResourceType, isRequestSchema, schemaRepository);`
`74`	`74`
`75`	`75`	`referenceSchemaForBody = _defaultSchemaGenerator.GenerateSchema(bodyType, schemaRepository);`
`76`	`76`	`OpenApiSchema fullSchemaForBody = schemaRepository.Schemas[referenceSchemaForBody.Reference.Id].UnwrapLastExtendedSchema();`
`77`	`77`
`78`		`- if (JsonApiSchemaFacts.HasNullableDataProperty(bodyType))`
	`78`	`+ if (JsonApiSchemaFacts.HasNullableDataProperty(resourceSchemaType.SchemaOpenType))`
`79`	`79`	`{`
`80`	`80`	`fullSchemaForBody.Properties[JsonApiPropertyName.Data].Nullable = true;`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,9 +91,9 @@ public void MapDiscriminator(Type resourceDataConstructedType, OpenApiSchema ref`
`91`	`91`	`ArgumentGuard.NotNull(referenceSchemaForResourceData);`
`92`	`92`	`ArgumentGuard.NotNull(schemaRepository);`
`93`	`93`
`94`		`- var resourceTypeInfo = ResourceTypeInfo.Create(resourceDataConstructedType, _resourceGraph);`
	`94`	`+ var resourceSchemaType = ResourceSchemaType.Create(resourceDataConstructedType, _resourceGraph);`
`95`	`95`
`96`		`- if (resourceTypeInfo.ResourceDataOpenType == typeof(ResourceDataInResponse<>))`
	`96`	`+ if (resourceSchemaType.SchemaOpenType == typeof(ResourceDataInResponse<>))`
`97`	`97`	`{`
`98`	`98`	`if (!schemaRepository.TryLookupByType(ResourceDataAbstractType, out OpenApiSchema? referenceSchemaForAbstractResourceData))`
`99`	`99`	`{`
`@@ -102,7 +102,7 @@ public void MapDiscriminator(Type resourceDataConstructedType, OpenApiSchema ref`
`102`	`102`
`103`	`103`	`OpenApiSchema fullSchemaForAbstractResourceData = schemaRepository.Schemas[referenceSchemaForAbstractResourceData.Reference.Id];`
`104`	`104`	`string dataSchemaId = referenceSchemaForResourceData.Reference.ReferenceV3;`
`105`		`- string publicName = resourceTypeInfo.ResourceType.PublicName;`
	`105`	`+ string publicName = resourceSchemaType.ResourceType.PublicName;`
`106`	`106`
`107`	`107`	`if (fullSchemaForAbstractResourceData.Discriminator.Mapping.TryAdd(publicName, dataSchemaId))`
`108`	`108`	`{`
Original file line number	Diff line number	Diff line change
`@@ -101,9 +101,9 @@ private void EnsureResourceDataInResponseDerivedTypesAreMappedInDiscriminator(Ty`
`101`	`101`
`102`	`102`	`if (dataOpenType == typeof(ResourceDataInResponse<>))`
`103`	`103`	`{`
`104`		`- var resourceTypeInfo = ResourceTypeInfo.Create(dataConstructedType, _resourceGraph);`
	`104`	`+ var resourceSchemaType = ResourceSchemaType.Create(dataConstructedType, _resourceGraph);`
`105`	`105`
`106`		`- foreach (ResourceType relatedType in _includeDependencyScanner.GetReachableRelatedTypes(resourceTypeInfo.ResourceType))`
	`106`	`+ foreach (ResourceType relatedType in _includeDependencyScanner.GetReachableRelatedTypes(resourceSchemaType.ResourceType))`
`107`	`107`	`{`
`108`	`108`	`MapResourceDataInResponseDerivedTypeInDiscriminator(relatedType, schemaRepository);`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,8 +74,8 @@ public OpenApiSchema GenerateSchema(Type dataSchemaType, SchemaRepository schema`
`74`	`74`	`return referenceSchemaForData;`
`75`	`75`	`}`
`76`	`76`
`77`		`- var resourceTypeInfo = ResourceTypeInfo.Create(dataSchemaType, _resourceGraph);`
`78`		`- ResourceType resourceType = resourceTypeInfo.ResourceType;`
	`77`	`+ var resourceSchemaType = ResourceSchemaType.Create(dataSchemaType, _resourceGraph);`
	`78`	`+ ResourceType resourceType = resourceSchemaType.ResourceType;`
`79`	`79`
`80`	`80`	`referenceSchemaForData = _defaultSchemaGenerator.GenerateSchema(dataSchemaType, schemaRepository);`
`81`	`81`	`OpenApiSchema fullSchemaForResourceData = schemaRepository.Schemas[referenceSchemaForData.Reference.Id];`
`@@ -86,11 +86,11 @@ public OpenApiSchema GenerateSchema(Type dataSchemaType, SchemaRepository schema`
`86`	`86`
`87`	`87`	`SetAbstract(inlineSchemaForResourceData, resourceType);`
`88`	`88`	`SetResourceType(inlineSchemaForResourceData, resourceType, schemaRepository);`
`89`		`- AdaptResourceIdentity(inlineSchemaForResourceData, resourceTypeInfo, isRequestSchema, schemaRepository);`
	`89`	`+ AdaptResourceIdentity(inlineSchemaForResourceData, resourceSchemaType, isRequestSchema, schemaRepository);`
`90`	`90`	`SetResourceId(inlineSchemaForResourceData, resourceType, schemaRepository);`
`91`		`- SetResourceFields(inlineSchemaForResourceData, resourceTypeInfo, isRequestSchema, schemaRepository);`
	`91`	`+ SetResourceFields(inlineSchemaForResourceData, resourceSchemaType, isRequestSchema, schemaRepository);`
`92`	`92`	`SetDocumentation(fullSchemaForResourceData, resourceType);`
`93`		`- SetLinksVisibility(inlineSchemaForResourceData, resourceTypeInfo, schemaRepository);`
	`93`	`+ SetLinksVisibility(inlineSchemaForResourceData, resourceSchemaType, schemaRepository);`
`94`	`94`
`95`	`95`	`inlineSchemaForResourceData.ReorderProperties(ResourceDataPropertyNamesInOrder);`
`96`	`96`
`@@ -114,7 +114,8 @@ private void SetResourceType(OpenApiSchema fullSchema, ResourceType resourceType`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`117`		`- private void AdaptResourceIdentity(OpenApiSchema fullSchema, ResourceTypeInfo resourceTypeInfo, bool forRequestSchema, SchemaRepository schemaRepository)`
	`117`	`+ private void AdaptResourceIdentity(OpenApiSchema fullSchema, ResourceSchemaType resourceSchemaType, bool forRequestSchema,`
	`118`	`+ SchemaRepository schemaRepository)`
`118`	`119`	`{`
`119`	`120`	`if (!forRequestSchema)`
`120`	`121`	`{`
`@@ -128,9 +129,9 @@ private void AdaptResourceIdentity(OpenApiSchema fullSchema, ResourceTypeInfo re`
`128`	`129`	`fullSchema.Properties.Remove(JsonApiPropertyName.Lid);`
`129`	`130`	`}`
`130`	`131`
`131`		`- if (resourceTypeInfo.ResourceDataOpenType == typeof(DataInCreateResourceRequest<>))`
	`132`	`+ if (resourceSchemaType.SchemaOpenType == typeof(DataInCreateResourceRequest<>))`
`132`	`133`	`{`
`133`		`- ClientIdGenerationMode clientIdGeneration = resourceTypeInfo.ResourceType.ClientIdGeneration ?? _options.ClientIdGeneration;`
	`134`	`+ ClientIdGenerationMode clientIdGeneration = resourceSchemaType.ResourceType.ClientIdGeneration ?? _options.ClientIdGeneration;`
`134`	`135`
`135`	`136`	`if (hasAtomicOperationsEndpoint)`
`136`	`137`	`{`
`@@ -174,17 +175,18 @@ private void SetResourceId(OpenApiSchema fullSchema, ResourceType resourceType,`
`174`	`175`	`}`
`175`	`176`	`}`
`176`	`177`
`177`		`- private void SetResourceFields(OpenApiSchema fullSchemaForData, ResourceTypeInfo resourceTypeInfo, bool forRequestSchema, SchemaRepository schemaRepository)`
	`178`	`+ private void SetResourceFields(OpenApiSchema fullSchemaForData, ResourceSchemaType resourceSchemaType, bool forRequestSchema,`
	`179`	`+ SchemaRepository schemaRepository)`
`178`	`180`	`{`
`179`	`181`	`bool schemaHasFields = fullSchemaForData.Properties.ContainsKey(JsonApiPropertyName.Attributes) &&`
`180`	`182`	`fullSchemaForData.Properties.ContainsKey(JsonApiPropertyName.Relationships);`
`181`	`183`
`182`	`184`	`if (schemaHasFields)`
`183`	`185`	`{`
`184`	`186`	`var fieldSchemaBuilder = new ResourceFieldSchemaBuilder(_defaultSchemaGenerator, _resourceIdentifierSchemaGenerator,`
`185`		`- _linksVisibilitySchemaGenerator, _resourceFieldValidationMetadataProvider, _relationshipTypeFactory, resourceTypeInfo);`
	`187`	`+ _linksVisibilitySchemaGenerator, _resourceFieldValidationMetadataProvider, _relationshipTypeFactory, resourceSchemaType);`
`186`	`188`
`187`		`- ResourceType resourceType = resourceTypeInfo.ResourceType;`
	`189`	`+ ResourceType resourceType = resourceSchemaType.ResourceType;`
`188`	`190`
`189`	`191`	`SetFieldSchemaMembers(fullSchemaForData, resourceType, forRequestSchema, true, fieldSchemaBuilder, schemaRepository);`
`190`	`192`	`SetFieldSchemaMembers(fullSchemaForData, resourceType, forRequestSchema, false, fieldSchemaBuilder, schemaRepository);`
`@@ -222,8 +224,8 @@ private void SetDocumentation(OpenApiSchema fullSchema, ResourceType resourceTyp`
`222`	`224`	`fullSchema.Description = _resourceDocumentationReader.GetDocumentationForType(resourceType);`
`223`	`225`	`}`
`224`	`226`
`225`		`- private void SetLinksVisibility(OpenApiSchema fullSchema, ResourceTypeInfo resourceTypeInfo, SchemaRepository schemaRepository)`
	`227`	`+ private void SetLinksVisibility(OpenApiSchema fullSchema, ResourceSchemaType resourceSchemaType, SchemaRepository schemaRepository)`
`226`	`228`	`{`
`227`		`- _linksVisibilitySchemaGenerator.UpdateSchemaForResource(resourceTypeInfo, fullSchema, schemaRepository);`
	`229`	`+ _linksVisibilitySchemaGenerator.UpdateSchemaForResource(resourceSchemaType, fullSchema, schemaRepository);`
`228`	`230`	`}`
`229`	`231`	`}`
Original file line number	Diff line number	Diff line change
`@@ -83,12 +83,12 @@ public void UpdateSchemaForTopLevel(Type modelType, OpenApiSchema fullSchemaForL`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
`86`		`- public void UpdateSchemaForResource(ResourceTypeInfo resourceTypeInfo, OpenApiSchema fullSchemaForResourceData, SchemaRepository schemaRepository)`
	`86`	`+ public void UpdateSchemaForResource(ResourceSchemaType resourceSchemaType, OpenApiSchema fullSchemaForResourceData, SchemaRepository schemaRepository)`
`87`	`87`	`{`
`88`		`- ArgumentGuard.NotNull(resourceTypeInfo);`
	`88`	`+ ArgumentGuard.NotNull(resourceSchemaType);`
`89`	`89`	`ArgumentGuard.NotNull(fullSchemaForResourceData);`
`90`	`90`
`91`		`- if (LinksInJsonApiSchemaTypes.TryGetValue(resourceTypeInfo.ResourceDataOpenType, out LinkTypes possibleLinkTypes))`
	`91`	`+ if (LinksInJsonApiSchemaTypes.TryGetValue(resourceSchemaType.SchemaOpenType, out LinkTypes possibleLinkTypes))`
`92`	`92`	`{`
`93`	`93`	`UpdateLinksProperty(fullSchemaForResourceData, _lazyLinksVisibility.Value.ResourceLinks, possibleLinkTypes, schemaRepository);`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ internal sealed class ResourceFieldSchemaBuilder`
`13`	`13`	`private readonly SchemaGenerator _defaultSchemaGenerator;`
`14`	`14`	`private readonly ResourceIdentifierSchemaGenerator _resourceIdentifierSchemaGenerator;`
`15`	`15`	`private readonly LinksVisibilitySchemaGenerator _linksVisibilitySchemaGenerator;`
`16`		`- private readonly ResourceTypeInfo _resourceTypeInfo;`
	`16`	`+ private readonly ResourceSchemaType _resourceSchemaType;`
`17`	`17`	`private readonly ResourceFieldValidationMetadataProvider _resourceFieldValidationMetadataProvider;`
`18`	`18`	`private readonly RelationshipTypeFactory _relationshipTypeFactory;`
`19`	`19`
`@@ -23,19 +23,19 @@ internal sealed class ResourceFieldSchemaBuilder`
`23`	`23`
`24`	`24`	`public ResourceFieldSchemaBuilder(SchemaGenerator defaultSchemaGenerator, ResourceIdentifierSchemaGenerator resourceIdentifierSchemaGenerator,`
`25`	`25`	`LinksVisibilitySchemaGenerator linksVisibilitySchemaGenerator, ResourceFieldValidationMetadataProvider resourceFieldValidationMetadataProvider,`
`26`		`- RelationshipTypeFactory relationshipTypeFactory, ResourceTypeInfo resourceTypeInfo)`
	`26`	`+ RelationshipTypeFactory relationshipTypeFactory, ResourceSchemaType resourceSchemaType)`
`27`	`27`	`{`
`28`	`28`	`ArgumentGuard.NotNull(defaultSchemaGenerator);`
`29`	`29`	`ArgumentGuard.NotNull(resourceIdentifierSchemaGenerator);`
`30`	`30`	`ArgumentGuard.NotNull(linksVisibilitySchemaGenerator);`
`31`		`- ArgumentGuard.NotNull(resourceTypeInfo);`
	`31`	`+ ArgumentGuard.NotNull(resourceSchemaType);`
`32`	`32`	`ArgumentGuard.NotNull(resourceFieldValidationMetadataProvider);`
`33`	`33`	`ArgumentGuard.NotNull(relationshipTypeFactory);`
`34`	`34`
`35`	`35`	`_defaultSchemaGenerator = defaultSchemaGenerator;`
`36`	`36`	`_resourceIdentifierSchemaGenerator = resourceIdentifierSchemaGenerator;`
`37`	`37`	`_linksVisibilitySchemaGenerator = linksVisibilitySchemaGenerator;`
`38`		`- _resourceTypeInfo = resourceTypeInfo;`
	`38`	`+ _resourceSchemaType = resourceSchemaType;`
`39`	`39`	`_resourceFieldValidationMetadataProvider = resourceFieldValidationMetadataProvider;`
`40`	`40`	`_relationshipTypeFactory = relationshipTypeFactory;`
`41`	`41`
`@@ -44,9 +44,9 @@ public ResourceFieldSchemaBuilder(SchemaGenerator defaultSchemaGenerator, Resour`
`44`	`44`
`45`	`45`	`private IDictionary<string, OpenApiSchema> GetFieldSchemas()`
`46`	`46`	`{`
`47`		`- if (!_resourceSchemaRepository.TryLookupByType(_resourceTypeInfo.ResourceType.ClrType, out OpenApiSchema referenceSchemaForResource))`
	`47`	`+ if (!_resourceSchemaRepository.TryLookupByType(_resourceSchemaType.ResourceType.ClrType, out OpenApiSchema referenceSchemaForResource))`
`48`	`48`	`{`
`49`		`- referenceSchemaForResource = _defaultSchemaGenerator.GenerateSchema(_resourceTypeInfo.ResourceType.ClrType, _resourceSchemaRepository);`
	`49`	`+ referenceSchemaForResource = _defaultSchemaGenerator.GenerateSchema(_resourceSchemaType.ResourceType.ClrType, _resourceSchemaRepository);`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`OpenApiSchema fullSchemaForResource = _resourceSchemaRepository.Schemas[referenceSchemaForResource.Reference.Id];`
`@@ -57,12 +57,13 @@ public void SetMembersOfAttributes(OpenApiSchema fullSchemaForAttributes, bool f`
`57`	`57`	`{`
`58`	`58`	`ArgumentGuard.NotNull(fullSchemaForAttributes);`
`59`	`59`	`ArgumentGuard.NotNull(schemaRepository);`
	`60`	`+ AssertHasNoProperties(fullSchemaForAttributes);`
`60`	`61`
`61`		`- AttrCapabilities requiredCapability = GetRequiredCapabilityForAttributes(_resourceTypeInfo.ResourceDataOpenType);`
	`62`	`+ AttrCapabilities requiredCapability = GetRequiredCapabilityForAttributes(_resourceSchemaType.SchemaOpenType);`
`62`	`63`
`63`		`- foreach ((string fieldName, OpenApiSchema resourceFieldSchema) in _schemasForResourceFields)`
	`64`	`+ foreach ((string publicName, OpenApiSchema schemaForResourceField) in _schemasForResourceFields)`
`64`	`65`	`{`
`65`		`- AttrAttribute? matchingAttribute = _resourceTypeInfo.ResourceType.FindAttributeByPublicName(fieldName);`
	`66`	`+ AttrAttribute? matchingAttribute = _resourceSchemaType.ResourceType.FindAttributeByPublicName(publicName);`
`66`	`67`
`67`	`68`	`if (matchingAttribute != null && matchingAttribute.Capabilities.HasFlag(requiredCapability))`
`68`	`69`	`{`
`@@ -81,24 +82,25 @@ public void SetMembersOfAttributes(OpenApiSchema fullSchemaForAttributes, bool f`
`81`	`82`	`}`
`82`	`83`	`}`
`83`	`84`
`84`		`- bool isInlineSchemaType = resourceFieldSchema.AllOf.Count == 0;`
	`85`	`+ bool isInlineSchemaType = schemaForResourceField.AllOf.Count == 0;`
`85`	`86`
`86`	`87`	`// Schemas for types like enum and complex attributes are handled as reference schemas.`
`87`	`88`	`if (!isInlineSchemaType)`
`88`	`89`	`{`
`89`		`- EnsureAttributeSchemaIsExposed(resourceFieldSchema.UnwrapLastExtendedSchema(), matchingAttribute, schemaRepository);`
	`90`	`+ OpenApiSchema referenceSchemaForAttribute = schemaForResourceField.UnwrapLastExtendedSchema();`
	`91`	`+ EnsureAttributeSchemaIsExposed(referenceSchemaForAttribute, matchingAttribute, schemaRepository);`
`90`	`92`	`}`
`91`	`93`
`92`		`- fullSchemaForAttributes.Properties.Add(matchingAttribute.PublicName, resourceFieldSchema);`
	`94`	`+ fullSchemaForAttributes.Properties.Add(matchingAttribute.PublicName, schemaForResourceField);`
`93`	`95`
`94`		`- resourceFieldSchema.Nullable = _resourceFieldValidationMetadataProvider.IsNullable(matchingAttribute);`
	`96`	`+ schemaForResourceField.Nullable = _resourceFieldValidationMetadataProvider.IsNullable(matchingAttribute);`
`95`	`97`
`96`	`98`	`if (IsFieldRequired(matchingAttribute))`
`97`	`99`	`{`
`98`	`100`	`fullSchemaForAttributes.Required.Add(matchingAttribute.PublicName);`
`99`	`101`	`}`
`100`	`102`
`101`		`- resourceFieldSchema.Description = _resourceDocumentationReader.GetDocumentationForAttribute(matchingAttribute);`
	`103`	`+ schemaForResourceField.Description = _resourceDocumentationReader.GetDocumentationForAttribute(matchingAttribute);`
`102`	`104`	`}`
`103`	`105`	`}`
`104`	`106`	`}`
`@@ -142,18 +144,19 @@ private Type GetRepresentedTypeForAttributeSchema(AttrAttribute attribute)`
`142`	`144`
`143`	`145`	`private bool IsFieldRequired(ResourceFieldAttribute field)`
`144`	`146`	`{`
`145`		`- bool isCreateResourceSchemaType = _resourceTypeInfo.ResourceDataOpenType == typeof(DataInCreateResourceRequest<>);`
	`147`	`+ bool isCreateResourceSchemaType = _resourceSchemaType.SchemaOpenType == typeof(DataInCreateResourceRequest<>);`
`146`	`148`	`return isCreateResourceSchemaType && _resourceFieldValidationMetadataProvider.IsRequired(field);`
`147`	`149`	`}`
`148`	`150`
`149`	`151`	`public void SetMembersOfRelationships(OpenApiSchema fullSchemaForRelationships, bool forRequestSchema, SchemaRepository schemaRepository)`
`150`	`152`	`{`
`151`	`153`	`ArgumentGuard.NotNull(fullSchemaForRelationships);`
`152`	`154`	`ArgumentGuard.NotNull(schemaRepository);`
	`155`	`+ AssertHasNoProperties(fullSchemaForRelationships);`
`153`	`156`
`154`		`- foreach (string fieldName in _schemasForResourceFields.Keys)`
	`157`	`+ foreach (string publicName in _schemasForResourceFields.Keys)`
`155`	`158`	`{`
`156`		`- RelationshipAttribute? matchingRelationship = _resourceTypeInfo.ResourceType.FindRelationshipByPublicName(fieldName);`
	`159`	`+ RelationshipAttribute? matchingRelationship = _resourceSchemaType.ResourceType.FindRelationshipByPublicName(publicName);`
`157`	`160`
`158`	`161`	`if (matchingRelationship != null)`
`159`	`162`	`{`
`@@ -166,7 +169,7 @@ public void SetMembersOfRelationships(OpenApiSchema fullSchemaForRelationships,`
`166`	`169`	`private void AddRelationshipSchemaToResourceData(RelationshipAttribute relationship, OpenApiSchema fullSchemaForRelationships,`
`167`	`170`	`SchemaRepository schemaRepository)`
`168`	`171`	`{`
`169`		`- Type relationshipSchemaType = GetRelationshipSchemaType(relationship, _resourceTypeInfo.ResourceDataOpenType);`
	`172`	`+ Type relationshipSchemaType = GetRelationshipSchemaType(relationship, _resourceSchemaType.SchemaOpenType);`
`170`	`173`
`171`	`174`	`OpenApiSchema referenceSchemaForRelationship = GetReferenceSchemaForRelationship(relationshipSchemaType, schemaRepository) ??`
`172`	`175`	`CreateReferenceSchemaForRelationship(relationshipSchemaType, schemaRepository);`
`@@ -182,9 +185,9 @@ private void AddRelationshipSchemaToResourceData(RelationshipAttribute relations`
`182`	`185`	`}`
`183`	`186`	`}`
`184`	`187`
`185`		`- private Type GetRelationshipSchemaType(RelationshipAttribute relationship, Type resourceDataConstructedType)`
	`188`	`+ private Type GetRelationshipSchemaType(RelationshipAttribute relationship, Type openSchemaType)`
`186`	`189`	`{`
`187`		`- bool isResponseSchemaType = resourceDataConstructedType.ConstructedToOpenType().IsAssignableTo(typeof(ResourceDataInResponse<>));`
	`190`	`+ bool isResponseSchemaType = openSchemaType.IsAssignableTo(typeof(ResourceDataInResponse<>));`
`188`	`191`	`return isResponseSchemaType ? _relationshipTypeFactory.GetForResponse(relationship) : _relationshipTypeFactory.GetForRequest(relationship);`
`189`	`192`	`}`
`190`	`193`
`@@ -211,4 +214,12 @@ private OpenApiSchema CreateReferenceSchemaForRelationship(Type relationshipSche`
`211`	`214`
`212`	`215`	`return referenceSchema;`
`213`	`216`	`}`
	`217`	`+`
	`218`	`+ private static void AssertHasNoProperties(OpenApiSchema fullSchema)`
	`219`	`+ {`
	`220`	`+ if (fullSchema.Properties.Count > 0)`
	`221`	`+ {`
	`222`	`+ throw new UnreachableCodeException();`
	`223`	`+ }`
	`224`	`+ }`
`214`	`225`	`}`