makes collection responses reusable

src/Microsoft.OpenApi.OData.Reader/Common/Constants.cs

@@ -84,5 +84,10 @@ internal static class Constants
         /// Name used for the OpenAPI referenced schema for OData Count operations responses.
         /// </summary>
         public static string DollarCountSchemaName = "ODataCountResponse";
+
+        /// <summary>
+        /// Suffix used for collection response schemas.
+        /// </summary>
+        public static string CollectionSchemaSuffix = "CollectionResponse";
     }
 }

src/Microsoft.OpenApi.OData.Reader/Generator/OpenApiResponseGenerator.cs

@@ -62,10 +62,25 @@ public static IDictionary<string, OpenApiResponse> CreateResponses(this ODataCon
         {
             Utils.CheckArgumentNull(context, nameof(context));
 
-            return new Dictionary<string, OpenApiResponse>
+            var responses =  new Dictionary<string, OpenApiResponse>
             {
                 { "error", CreateErrorResponse() }
             };
+
+            if(context.Settings.EnableDollarCountPath)
+                responses[Constants.DollarCountSchemaName] = CreateCountResponse();
+
+            responses = responses.Concat(context.GetAllCollectionEntityTypes()
+                                        .Select(x => new KeyValuePair<string, OpenApiResponse>(
+                                                            $"{(x is IEdmEntityType eType ? eType.FullName() : x.FullTypeName())}{Constants.CollectionSchemaSuffix}",
+                                                            CreateCollectionResponse(x)))
+                                        .Where(x => !responses.ContainsKey(x.Key)))
+                            .ToDictionary(x => x.Key, x => x.Value);
+
+            if(context.HasAnyNonContainedCollections())                                        
+                responses[$"String{Constants.CollectionSchemaSuffix}"] = CreateCollectionResponse("String");
+
+            return responses;
         }
 
         /// <summary>
@@ -165,6 +180,61 @@ public static OpenApiResponses CreateResponses(this ODataContext context, IEdmOp
             return responses;
         }
 
+        private static OpenApiResponse CreateCollectionResponse(IEdmStructuredType structuredType)
+        {
+            var entityType = structuredType as IEdmEntityType;
+            return CreateCollectionResponse(entityType?.FullName() ?? structuredType.FullTypeName());
+        }
+        private static OpenApiResponse CreateCollectionResponse(string typeName)
+        {
+            return new OpenApiResponse
+            {
+                Description = "Retrieved collection",
+                Content = new Dictionary<string, OpenApiMediaType>
+                {
+                    {
+                        Constants.ApplicationJsonMediaType,
+                        new OpenApiMediaType
+                        {
+                            Schema = new OpenApiSchema
+                            {
+                                Reference = new OpenApiReference
+                                {
+                                    Type = ReferenceType.Schema,
+                                    Id = $"{typeName}{Constants.CollectionSchemaSuffix}"
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        private static OpenApiResponse CreateCountResponse()
+        {
+            OpenApiSchema schema = new()
+            {
+                Reference = new() {
+                    Type = ReferenceType.Schema,
+                    Id = Constants.DollarCountSchemaName
+                }
+            };
+            return new OpenApiResponse
+            {
+                Description = "The count of the resource",
+                Content = new Dictionary<string, OpenApiMediaType>
+                {
+                    {
+                        "text/plain",
+                        new OpenApiMediaType
+                        {
+                            Schema = schema
+                        }
+                    }
+                }
+            };
+        }
+
         private static OpenApiResponse CreateErrorResponse()
         {
             return new OpenApiResponse

src/Microsoft.OpenApi.OData.Reader/Generator/OpenApiSchemaGenerator.cs

@@ -73,8 +73,100 @@ public static IDictionary<string, OpenApiSchema> CreateSchemas(this ODataContext
                     Format = "int32"
                 };
 
+            schemas = schemas.Concat(context.GetAllCollectionEntityTypes()
+                                        .Select(x => new KeyValuePair<string, OpenApiSchema>(
+                                                            $"{(x is IEdmEntityType eType ? eType.FullName() : x.FullTypeName())}{Constants.CollectionSchemaSuffix}",
+                                                            CreateCollectionSchema(context, x)))
+                                        .Where(x => !schemas.ContainsKey(x.Key)))
+                            .ToDictionary(x => x.Key, x => x.Value);
+
+            if(context.HasAnyNonContainedCollections())                                        
+                schemas[$"String{Constants.CollectionSchemaSuffix}"] = CreateCollectionSchema(context, new OpenApiSchema { Type = "string" }, "string");
+
             return schemas;
         }
+        internal static bool HasAnyNonContainedCollections(this ODataContext context)
+        {
+            return context.Model
+                    .SchemaElements
+                    .OfType<IEdmStructuredType>()
+                    .SelectMany(x => x.NavigationProperties())
+                    .Any(x => x.TargetMultiplicity() == EdmMultiplicity.Many && !x.ContainsTarget);
+        }
+        internal static IEnumerable<IEdmStructuredType> GetAllCollectionEntityTypes(this ODataContext context)
+        {
+            var collectionEntityTypes = new HashSet<IEdmStructuredType>(
+                                                (context.EntityContainer?
+                                                    .EntitySets()
+                                                    .Select(x => x.EntityType()) ??
+                                                Enumerable.Empty<IEdmStructuredType>())
+                                                .Union(context.Model
+                                                                .SchemaElements
+                                                        	    .OfType<IEdmStructuredType>()
+                                                                .SelectMany(x => x.NavigationProperties())
+                                                                .Where(x => x.TargetMultiplicity() == EdmMultiplicity.Many)
+                                                                .Select(x => x.Type.ToStructuredType()))
+                                                .Distinct()); // we could include actions and functions but actions are not pageable by nature (OData.NextLink) and functions might have specific annotations (deltalink)
+            var derivedCollectionTypes = collectionEntityTypes.SelectMany(x => context.Model.FindAllDerivedTypes(x).OfType<IEdmStructuredType>())
+                                                                .Where(x => !collectionEntityTypes.Contains(x))
+                                                                .Distinct()
+                                                                .ToArray();
+            return collectionEntityTypes.Union(derivedCollectionTypes);
+        }
+
+        private static OpenApiSchema CreateCollectionSchema(ODataContext context, IEdmStructuredType structuredType)
+        {
+            OpenApiSchema schema = null;
+            var entityType = structuredType as IEdmEntityType;
+
+            if (context.Settings.EnableDerivedTypesReferencesForResponses && entityType != null)
+            {
+                schema = EdmModelHelper.GetDerivedTypesReferenceSchema(entityType, context.Model);
+            }
+
+            if (schema == null)
+            {
+                schema = new OpenApiSchema
+                {
+                    Reference = new OpenApiReference
+                    {
+                        Type = ReferenceType.Schema,
+                        Id = entityType?.FullName() ?? structuredType.FullTypeName()
+                    }
+                };
+            }
+            return CreateCollectionSchema(context, schema, entityType?.Name ?? structuredType.FullTypeName());
+        }
+        private static OpenApiSchema CreateCollectionSchema(ODataContext context, OpenApiSchema schema, string typeName)
+        {
+            var properties = new Dictionary<string, OpenApiSchema>
+            {
+                {
+                    "value",
+                    new OpenApiSchema
+                    {
+                        Type = "array",
+                        Items = schema
+                    }
+                }
+            };
+            if (context.Settings.EnablePagination)
+            {
+                properties.Add(
+                    "@odata.nextLink",
+                    new OpenApiSchema
+                    {
+                        Type = "string"
+                    });
+            }
+
+            return new OpenApiSchema
+            {
+                Title = $"Collection of {typeName}",
+                Type = "object",
+                Properties = properties
+            };
+        }
 
         /// <summary>
         /// Create a <see cref="OpenApiSchema"/> for a <see cref="IEdmEnumType"/>.

src/Microsoft.OpenApi.OData.Reader/Operation/DollarCountGetOperationHandler.cs

@@ -3,7 +3,6 @@
 //  Licensed under the MIT License (MIT). See LICENSE in the repo root for license information.
 // ------------------------------------------------------------
 
-using System.Collections.Generic;
 using System.Linq;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.OData.Common;
@@ -55,30 +54,15 @@ protected override void SetBasicInfo(OpenApiOperation operation)
         /// <inheritdoc/>
         protected override void SetResponses(OpenApiOperation operation)
         {
-            OpenApiSchema schema = new()
-			{
-                Reference = new() {
-                    Type = ReferenceType.Schema,
-                    Id = Constants.DollarCountSchemaName
-                }
-            };
-
             operation.Responses = new OpenApiResponses
             {
                 {
                     Constants.StatusCode200,
                     new OpenApiResponse
                     {
-                        Description = "The count of the resource",
-                        Content = new Dictionary<string, OpenApiMediaType>
-                        {
-                            {
-                                "text/plain",
-                                new OpenApiMediaType
-                                {
-                                    Schema = schema
-                                }
-                            }
+                        Reference = new OpenApiReference() {
+                            Type = ReferenceType.Response,
+                            Id = Constants.DollarCountSchemaName
                         }
                     }
                 }

src/Microsoft.OpenApi.OData.Reader/Operation/EntitySetGetOperationHandler.cs

@@ -130,69 +130,17 @@ protected override void SetParameters(OpenApiOperation operation)
         /// <inheritdoc/>
         protected override void SetResponses(OpenApiOperation operation)
         {
-            OpenApiSchema schema = null;
-
-            if (Context.Settings.EnableDerivedTypesReferencesForResponses)
-            {
-                schema = EdmModelHelper.GetDerivedTypesReferenceSchema(EntitySet.EntityType(), Context.Model);
-            }
-
-            if (schema == null)
-            {
-                schema = new OpenApiSchema
-                {
-                    Reference = new OpenApiReference
-                    {
-                        Type = ReferenceType.Schema,
-                        Id = EntitySet.EntityType().FullName()
-                    }
-                };
-            }
-
-            var properties = new Dictionary<string, OpenApiSchema>
-            {
-                {
-                    "value",
-                    new OpenApiSchema
-                    {
-                        Type = "array",
-                        Items = schema
-                    }
-                }
-            };
-
-            if (Context.Settings.EnablePagination)
-            {
-                properties.Add(
-                    "@odata.nextLink",
-                    new OpenApiSchema
-                    {
-                        Type = "string"
-                    });
-            }
-
             operation.Responses = new OpenApiResponses
             {
                 {
                     Constants.StatusCode200,
                     new OpenApiResponse
                     {
-                        Description = "Retrieved entities",
-                        Content = new Dictionary<string, OpenApiMediaType>
+                        Reference = new OpenApiReference()
                         {
-                            {
-                                Constants.ApplicationJsonMediaType,
-                                new OpenApiMediaType
-                                {
-                                    Schema = new OpenApiSchema
-                                    {
-                                        Title = "Collection of " + EntitySet.EntityType().Name,
-                                        Type = "object",
-                                        Properties = properties
-                                    }
-                                }
-                            }
-                        }
+                            Type = ReferenceType.Response,
+                            Id = $"{EntitySet.EntityType().FullName()}{Constants.CollectionSchemaSuffix}"
+                        },
                     }
                 }
             };