Replaces instances of anyOf to oneOf

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

@@ -129,6 +129,11 @@ internal static class Constants
         /// Name used for reference request PUT body.
         /// </summary>
         public static string ReferencePutRequestBodyName = "refPutBody";
+
+        /// <summary>
+        /// Name used to reference INF, -INF and NaN
+        /// </summary>
+        public static string ReferenceNumericName = "ReferenceNumeric";
 
         /// <summary>
         /// The odata type name.
@@ -149,5 +154,25 @@ internal static class Constants
         /// string type
         /// </summary>
         public static string StringType = "string";
+
+        /// <summary>
+        /// integer type
+        /// </summary>
+        public static string IntegerType = "integer";
+
+        /// <summary>
+        /// number type
+        /// </summary>
+        public static string NumberType = "number";
+
+        /// <summary>
+        /// int64 format
+        /// </summary>
+        public static string Int64Format = "int64";
+
+        /// <summary>
+        /// decimal format
+        /// </summary>
+        public static string DecimalFormat = "decimal";
     }
 }

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

@@ -147,132 +147,130 @@ public static OpenApiSchema CreateSchema(this ODataContext context, IEdmPrimitiv
                 OneOf = null,
                 AnyOf = null
             };
+
             switch (primitiveType.PrimitiveKind)
             {
                 case EdmPrimitiveTypeKind.Binary: // binary
-                    schema.Type = "string";
+                    schema.Type = Constants.StringType;
                     schema.Format = "base64url";
                     break;
                 case EdmPrimitiveTypeKind.Boolean: // boolean
                     schema.Type = "boolean";
                     schema.Default = new OpenApiBoolean(false);
                     break;
                 case EdmPrimitiveTypeKind.Byte: // byte
-                    schema.Type = "integer";
+                    schema.Type = Constants.IntegerType;
                     schema.Format = "uint8";
                     break;
                 case EdmPrimitiveTypeKind.DateTimeOffset: // datetime offset
-                    schema.Type = "string";
+                    schema.Type = Constants.StringType;
                     schema.Format = "date-time";
                     schema.Pattern = "^[0-9]{4,}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]([.][0-9]{1,12})?(Z|[+-][0-9][0-9]:[0-9][0-9])$";
                     break;
                 case EdmPrimitiveTypeKind.Decimal: // decimal
                     if (context.Settings.IEEE754Compatible)
                     {
-                        schema.AnyOf = new List<OpenApiSchema>
+                        schema.OneOf = new List<OpenApiSchema>
                         {
-                            new OpenApiSchema { Type = "number" },
-                            new OpenApiSchema { Type = "string" },
+                            new OpenApiSchema { Type = Constants.NumberType, Format = Constants.DecimalFormat },
+                            new OpenApiSchema { Type = Constants.StringType },
                         };
                     }
                     else
                     {
-                        schema.Type = "number";
+                        schema.Type = Constants.NumberType;
+                        schema.Format = Constants.DecimalFormat;
                     }
-                    schema.Format = "decimal";
                     break;
                 case EdmPrimitiveTypeKind.Double: // double
-                    schema.AnyOf = new List<OpenApiSchema>
+                    schema.OneOf = new List<OpenApiSchema>
                     {
-                        new OpenApiSchema { Type = "number" },
-                        new OpenApiSchema { Type = "string" },
+                        new OpenApiSchema { Type = Constants.NumberType, Format = "double" },
+                        new OpenApiSchema { Type = Constants.StringType },
                         new OpenApiSchema
                         {
-                            Enum = new List<IOpenApiAny>
+                            UnresolvedReference = true,
+                            Reference = new OpenApiReference
                             {
-                                new OpenApiString("-INF"),
-                                new OpenApiString("INF"),
-                                new OpenApiString("NaN")
+                                Type = ReferenceType.Schema,
+                                Id = Constants.ReferenceNumericName
                             }
                         }
                     };
-                    schema.Format = "double";
                     break;
                 case EdmPrimitiveTypeKind.Single: // single
-                    schema.AnyOf = new List<OpenApiSchema>
+                    schema.OneOf = new List<OpenApiSchema>
                     {
-                        new OpenApiSchema { Type = "number" },
-                        new OpenApiSchema { Type = "string" },
+                        new OpenApiSchema { Type = Constants.NumberType, Format = "float" },
+                        new OpenApiSchema { Type = Constants.StringType },
                         new OpenApiSchema
                         {
-                            Enum = new List<IOpenApiAny>
+                            UnresolvedReference = true,
+                            Reference = new OpenApiReference
                             {
-                                new OpenApiString("-INF"),
-                                new OpenApiString("INF"),
-                                new OpenApiString("NaN")
+                                Type = ReferenceType.Schema,
+                                Id = Constants.ReferenceNumericName
                             }
                         }
                     };
-                    schema.Format = "float";
                     break;
                 case EdmPrimitiveTypeKind.Guid: // guid
-                    schema.Type = "string";
+                    schema.Type = Constants.StringType;
                     schema.Format = "uuid";
                     schema.Pattern = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";
                     break;
                 case EdmPrimitiveTypeKind.Int16:
-                    schema.Type = "integer";
+                    schema.Type = Constants.IntegerType;
                     schema.Format = "int16";
                     schema.Minimum = Int16.MinValue; // -32768
                     schema.Maximum = Int16.MaxValue; // 32767
                     break;
                 case EdmPrimitiveTypeKind.Int32:
-                    schema.Type = "integer";
+                    schema.Type = Constants.IntegerType;
                     schema.Format = "int32";
                     schema.Minimum = Int32.MinValue; // -2147483648
                     schema.Maximum = Int32.MaxValue; // 2147483647
                     break;
                 case EdmPrimitiveTypeKind.Int64:
                     if (context.Settings.IEEE754Compatible)
                     {
-                        schema.AnyOf = new List<OpenApiSchema>
+                        schema.OneOf = new List<OpenApiSchema>
                         {
-                            new OpenApiSchema { Type = "integer" },
-                            new OpenApiSchema { Type = "string" }
+                            new OpenApiSchema { Type = Constants.IntegerType, Format = Constants.Int64Format },
+                            new OpenApiSchema { Type = Constants.StringType }
                         };
                     }
                     else
                     {
-                        schema.Type = "integer";
+                        schema.Type = Constants.IntegerType;
+                        schema.Format = Constants.Int64Format;
                     }
-
-                    schema.Format = "int64";
                     break;
                 case EdmPrimitiveTypeKind.SByte:
-                    schema.Type = "integer";
+                    schema.Type = Constants.IntegerType;
                     schema.Format = "int8";
                     schema.Minimum = SByte.MinValue; // -128
                     schema.Maximum = SByte.MaxValue; // 127
                     break;
                 case EdmPrimitiveTypeKind.String: // string
-                    schema.Type = "string";
+                    schema.Type = Constants.StringType;
                     break;
                 case EdmPrimitiveTypeKind.Stream: // stream
-                    schema.Type = "string";
+                    schema.Type = Constants.StringType;
                     schema.Format = "base64url";
                     break;
                 case EdmPrimitiveTypeKind.Duration: // duration
-                    schema.Type = "string";
+                    schema.Type = Constants.StringType;
                     schema.Format = "duration";
                     schema.Pattern = "^-?P([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+([.][0-9]+)?S)?)?$";
                     break;
                 case EdmPrimitiveTypeKind.Date:
-                    schema.Type = "string";
+                    schema.Type = Constants.StringType;
                     schema.Format = "date";
                     schema.Pattern = "^[0-9]{4,}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$";
                     break;
                 case EdmPrimitiveTypeKind.TimeOfDay:
-                    schema.Type = "string";
+                    schema.Type = Constants.StringType;
                     schema.Format = "time";
                     schema.Pattern = "^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]([.][0-9]{1,12})?$";
                     break;

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

@@ -118,6 +118,16 @@ public static IDictionary<string, OpenApiSchema> CreateSchemas(this ODataContext
                 AdditionalProperties = new OpenApiSchema { Type = Constants.ObjectType }
             };
 
+            schemas[Constants.ReferenceNumericName] = new()
+            {
+                Enum = new List<IOpenApiAny>
+                {
+                    new OpenApiString("-INF"),
+                    new OpenApiString("INF"),
+                    new OpenApiString("NaN")
+                }
+            };
+
             // @odata.nextLink + @odata.count
             if (context.Settings.EnablePagination || context.Settings.EnableCount)
             {
@@ -611,7 +621,11 @@ private static IOpenApiAny GetTypeNameForExample(ODataContext context, IEdmTypeR
                         }
                         else
                         {
-                            return new OpenApiString(schema.Type ?? schema.Format);
+                            return new OpenApiString(schema.Type ??
+                                (schema.AnyOf ?? Enumerable.Empty<OpenApiSchema>())
+                                .Union(schema.AllOf ?? Enumerable.Empty<OpenApiSchema>())
+                                .Union(schema.OneOf ?? Enumerable.Empty<OpenApiSchema>())
+                                .FirstOrDefault(static x => !string.IsNullOrEmpty(x.Format))?.Format ?? schema.Format);
                         }
                     }
 

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

@@ -214,7 +214,7 @@ public static OpenApiSchema CreateEdmGeometrySchema()
             return new OpenApiSchema
             {
                 Type = "object",
-                AnyOf = new List<OpenApiSchema>
+                OneOf = new List<OpenApiSchema>
                 {
                     new OpenApiSchema { UnresolvedReference = true, Reference = new OpenApiReference { Type = ReferenceType.Schema, Id = "Edm.GeometryPoint" } },
                     new OpenApiSchema { UnresolvedReference = true, Reference = new OpenApiReference { Type = ReferenceType.Schema, Id = "Edm.GeometryLineString" } },

src/Microsoft.OpenApi.OData.Reader/Microsoft.OpenAPI.OData.Reader.csproj

@@ -41,7 +41,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.OData.Edm" Version="7.10.0" />
-    <PackageReference Include="Microsoft.OpenApi" Version="1.2.3" />
+    <PackageReference Include="Microsoft.OpenApi" Version="1.4.1" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

src/OoasGui/OoasGui.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>net6.0-windows</TargetFramework>
     <OutputType>WinExe</OutputType>
@@ -17,7 +17,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
     <PackageReference Include="Microsoft.OData.Edm" Version="7.12.2" />
-    <PackageReference Include="Microsoft.OpenApi" Version="1.4.0" />
+    <PackageReference Include="Microsoft.OpenApi" Version="1.4.1" />
     <PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
   </ItemGroup>
 </Project>

test/Microsoft.OpenAPI.OData.Reader.Tests/Generator/OpenApiEdmTypeSchemaGeneratorTest.cs

@@ -1,4 +1,4 @@
-// ------------------------------------------------------------
+// ------------------------------------------------------------
 //  Copyright (c) Microsoft Corporation.  All rights reserved.
 //  Licensed under the MIT License (MIT). See LICENSE in the repo root for license information.
 // ------------------------------------------------------------
@@ -407,14 +407,14 @@ public void CreateEdmTypeSchemaReturnSchemaForDecimal(bool isNullable, bool IEEE
             if (IEEE754Compatible)
             {
                 Assert.Null(schema.Type);
-                Assert.NotNull(schema.AnyOf);
-                Assert.Equal(2, schema.AnyOf.Count);
-                Assert.Equal(new[] { "number", "string" }, schema.AnyOf.Select(a => a.Type));
+                Assert.NotNull(schema.OneOf);
+                Assert.Equal(2, schema.OneOf.Count);
+                Assert.Equal(new[] { "number", "string" }, schema.OneOf.Select(a => a.Type));
             }
             else
             {
                 Assert.Equal("number", schema.Type);
-                Assert.Null(schema.AnyOf);
+                Assert.Null(schema.OneOf);
             }
 
             Assert.Equal(isNullable, schema.Nullable);
@@ -445,9 +445,9 @@ public void CreateEdmTypeSchemaReturnSchemaForInt64(bool isNullable, bool IEEE75
             if (IEEE754Compatible)
             {
                 Assert.Null(schema.Type);
-                Assert.NotNull(schema.AnyOf);
-                Assert.Equal(2, schema.AnyOf.Count);
-                Assert.Equal(new[] { "integer", "string" }, schema.AnyOf.Select(a => a.Type));
+                Assert.NotNull(schema.OneOf);
+                Assert.Equal(2, schema.OneOf.Count);
+                Assert.Equal(new[] { "integer", "string" }, schema.OneOf.Select(a => a.Type));
             }
             else
             {
@@ -510,13 +510,13 @@ public void CreateEdmTypeSchemaReturnSchemaForDouble(bool isNullable)
             // & Assert
             Assert.Null(schema.Type);
 
-            Assert.Equal("double", schema.Format);
+            Assert.Equal("double", schema.OneOf.FirstOrDefault(x => !string.IsNullOrEmpty(x.Format))?.Format);
             Assert.Equal(isNullable, schema.Nullable);
 
-            Assert.Null(schema.OneOf);
+            Assert.Null(schema.AnyOf);
 
-            Assert.NotNull(schema.AnyOf);
-            Assert.Equal(3, schema.AnyOf.Count);
+            Assert.NotNull(schema.OneOf);
+            Assert.Equal(3, schema.OneOf.Count);
         }
 
         [Theory]
@@ -536,13 +536,13 @@ public void CreateEdmTypeSchemaReturnSchemaForSingle(bool isNullable)
             // & Assert
             Assert.Null(schema.Type);
 
-            Assert.Equal("float", schema.Format);
+            Assert.Equal("float", schema.OneOf.FirstOrDefault(x => !string.IsNullOrEmpty(x.Format))?.Format);
             Assert.Equal(isNullable, schema.Nullable);
 
-            Assert.Null(schema.OneOf);
+            Assert.Null(schema.AnyOf);
 
-            Assert.NotNull(schema.AnyOf);
-            Assert.Equal(3, schema.AnyOf.Count);
+            Assert.NotNull(schema.OneOf);
+            Assert.Equal(3, schema.OneOf.Count);
         }
         #endregion
     }