Define JSON schema type as a flaggable enum to allow storing strings or array of strings

Author: MaggieKimani1

src/Microsoft.OpenApi.Hidi/Formatters/PowerShellFormatter.cs

@@ -166,10 +166,10 @@ private static IList<OpenApiParameter> ResolveFunctionParameters(IList<OpenApiPa
                 parameter.Content = null;
                 parameter.Schema = new()
                 {
-                    Type = "array",
+                    Type = JsonSchemaType.Array,
                     Items = new()
                     {
-                        Type = "string"
+                        Type = JsonSchemaType.String
                     }
                 };
             }
@@ -178,9 +178,9 @@ private static IList<OpenApiParameter> ResolveFunctionParameters(IList<OpenApiPa
 
         private void AddAdditionalPropertiesToSchema(OpenApiSchema schema)
         {
-            if (schema != null && !_schemaLoop.Contains(schema) && "object".Equals((string)schema.Type, StringComparison.OrdinalIgnoreCase))
+            if (schema != null && !_schemaLoop.Contains(schema) && schema.Type.Equals(JsonSchemaType.Object))
             {
-                schema.AdditionalProperties = new() { Type = "object" };
+                schema.AdditionalProperties = new() { Type = JsonSchemaType.Object };
 
                 /* Because 'additionalProperties' are now being walked,
                  * we need a way to keep track of visited schemas to avoid

src/Microsoft.OpenApi/Models/JsonSchemaType.cs

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using System;
+
+namespace Microsoft.OpenApi.Models
+{
+    /// <summary>
+    /// Represents the type of a JSON schema.
+    /// </summary>
+    [Flags]
+    public enum JsonSchemaType
+    {
+        /// <summary>
+        /// Represents any type.
+        /// </summary>
+        Any = 0,
+
+        /// <summary>
+        /// Represents a null type.
+        /// </summary>
+        Null = 1,
+
+        /// <summary>
+        /// Represents a boolean type.
+        /// </summary>
+        Boolean = 2,
+
+        /// <summary>
+        /// Represents an integer type.
+        /// </summary>
+        Integer = 4,
+
+        /// <summary>
+        /// Represents a number type.
+        /// </summary>
+        Number = 8,
+
+        /// <summary>
+        /// Represents a string type.
+        /// </summary>
+        String = 16,
+
+        /// <summary>
+        /// Represents an object type.
+        /// </summary>
+        Object = 32,
+
+        /// <summary>
+        /// Represents an array type.
+        /// </summary>
+        Array = 64,
+    }
+}

src/Microsoft.OpenApi/Models/OpenApiParameter.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
 using System;
@@ -292,7 +292,7 @@ public virtual void SerializeAsV2(IOpenApiWriter writer)
             }
             // In V2 parameter's type can't be a reference to a custom object schema or can't be of type object
             // So in that case map the type as string.
-            else if (Schema?.UnresolvedReference == true || "object".Equals(Schema?.Type?.ToString(), StringComparison.OrdinalIgnoreCase))
+            else if (Schema?.UnresolvedReference == true || Schema?.Type == JsonSchemaType.Object)
             {
                 writer.WriteProperty(OpenApiConstants.Type, "string");
             }
@@ -333,7 +333,7 @@ public virtual void SerializeAsV2(IOpenApiWriter writer)
                 // allowEmptyValue
                 writer.WriteProperty(OpenApiConstants.AllowEmptyValue, AllowEmptyValue, false);
 
-                if (this.In == ParameterLocation.Query && "array".Equals(Schema?.Type.ToString(), StringComparison.OrdinalIgnoreCase))
+                if (this.In == ParameterLocation.Query && Schema?.Type == JsonSchemaType.Array)
                 {
                     if (this.Style == ParameterStyle.Form && this.Explode == true)
                     {

src/Microsoft.OpenApi/Models/OpenApiSchema.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json.Nodes;
+using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Helpers;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Writers;
@@ -90,7 +91,7 @@ public class OpenApiSchema : IOpenApiAnnotatable, IOpenApiExtensible, IOpenApiRe
         /// Follow JSON Schema definition: https://tools.ietf.org/html/draft-fge-json-schema-validation-00
         /// Value MUST be a string in V2 and V3.
         /// </summary>
-        public virtual object Type { get; set; }
+        public virtual JsonSchemaType? Type { get; set; }
 
         /// <summary>
         /// Follow JSON Schema definition: https://tools.ietf.org/html/draft-fge-json-schema-validation-00
@@ -367,7 +368,7 @@ public OpenApiSchema(OpenApiSchema schema)
             UnevaluatedProperties = schema?.UnevaluatedProperties ?? UnevaluatedProperties;
             V31ExclusiveMaximum = schema?.V31ExclusiveMaximum ?? V31ExclusiveMaximum;
             V31ExclusiveMinimum = schema?.V31ExclusiveMinimum ?? V31ExclusiveMinimum;
-            Type = DeepCloneType(schema?.Type);
+            Type = schema?.Type ?? Type;
             Format = schema?.Format ?? Format;
             Description = schema?.Description ?? Description;
             Maximum = schema?.Maximum ?? Maximum;
@@ -590,7 +591,7 @@ internal void WriteV31Properties(IOpenApiWriter writer)
         internal void WriteAsItemsProperties(IOpenApiWriter writer)
         {
             // type
-            writer.WriteProperty(OpenApiConstants.Type, (string)Type);
+            writer.WriteProperty(OpenApiConstants.Type, OpenApiTypeMapper.ToIdentifier(Type));
 
             // format
             if (string.IsNullOrEmpty(Format))
@@ -670,14 +671,7 @@ internal void SerializeAsV2(
             writer.WriteStartObject();
 
             // type
-            if (Type is string[] array)
-            {
-                DowncastTypeArrayToV2OrV3(array, writer, OpenApiSpecVersion.OpenApi2_0);
-            }
-            else 
-            {
-                writer.WriteProperty(OpenApiConstants.Type, (string)Type);
-            }
+            SerializeTypeProperty(Type, writer, OpenApiSpecVersion.OpenApi2_0);
 
             // description
             writer.WriteProperty(OpenApiConstants.Description, Description);
@@ -806,88 +800,112 @@ internal void SerializeAsV2(
             writer.WriteEndObject();
         }
 
-        private void SerializeTypeProperty(object type, IOpenApiWriter writer, OpenApiSpecVersion version)
+        private void SerializeTypeProperty(JsonSchemaType? type, IOpenApiWriter writer, OpenApiSpecVersion version)
         {
-            if (type?.GetType() == typeof(string))
+            var flagsCount = CountEnumSetFlags(type);
+            if (flagsCount is 1)
             {
                 // check whether nullable is true for upcasting purposes
-                if (Nullable || Extensions.ContainsKey(OpenApiConstants.NullableExtension))
+                if (version is OpenApiSpecVersion.OpenApi3_1 && (Nullable || Extensions.ContainsKey(OpenApiConstants.NullableExtension)))
                 {
-                    // create a new array and insert the type and "null" as values
-                    Type = new[] { (string)Type, OpenApiConstants.Null };
+                    UpCastSchemaTypeToV31(type, writer);
                 }
                 else
                 {
-                    writer.WriteProperty(OpenApiConstants.Type, (string)Type);
+                    writer.WriteProperty(OpenApiConstants.Type, OpenApiTypeMapper.ToIdentifier(type));
                 }
             }
-            if (Type is string[] array)
+            else if(flagsCount > 1)
             {
                 // type
-                if (version is OpenApiSpecVersion.OpenApi3_0)
+                if (version is OpenApiSpecVersion.OpenApi2_0 || version is OpenApiSpecVersion.OpenApi3_0)
                 {
-                    DowncastTypeArrayToV2OrV3(array, writer, OpenApiSpecVersion.OpenApi3_0);
+                    DowncastTypeArrayToV2OrV3(type, writer, version, flagsCount);
                 }
                 else
                 {
-                    writer.WriteOptionalCollection(OpenApiConstants.Type, (string[])Type, (w, s) => w.WriteRaw(s));
+                    var list = new List<JsonSchemaType>();
+                    foreach (JsonSchemaType flag in System.Enum.GetValues(typeof(JsonSchemaType)))
+                    {
+                        list.Add(flag);
+                    }
+                        
+                    writer.WriteOptionalCollection(OpenApiConstants.Type, list, (w, s) => w.WriteRaw(OpenApiTypeMapper.ToIdentifier(s)));
                 }
             }
         }
 
-        private object DeepCloneType(object type)
+        private static int CountEnumSetFlags(JsonSchemaType? schemaType)
         {
-            if (type == null)
-                return null;
+            int count = 0;
 
-            if (type is string)
+            if(schemaType != null)
             {
-                return type; // Return the string as is
-            }
+                // Check each flag in the enum
+                foreach (JsonSchemaType value in System.Enum.GetValues(typeof(JsonSchemaType)))
+                {
+                    // Ignore the None flag and check if the flag is set
+                    if (value != JsonSchemaType.Any && (schemaType & value) == value)
+                    {
+                        count++;
+                    }
+                }
+            }            
+
+            return count;
+        }
 
-            if (type is Array array)
+        private void UpCastSchemaTypeToV31(JsonSchemaType? type, IOpenApiWriter writer)
+        {
+            // create a new array and insert the type and "null" as values
+            Type = type | JsonSchemaType.Null;
+            var list = new List<string>();
+            foreach (JsonSchemaType flag in System.Enum.GetValues(typeof(JsonSchemaType)))
             {
-                Type elementType = type.GetType().GetElementType();
-                Array copiedArray = Array.CreateInstance(elementType, array.Length);
-                for (int i = 0; i < array?.Length; i++)
+                // Check if the flag is set in 'type' using a bitwise AND operation
+                if ((Type & flag) == flag && flag != JsonSchemaType.Any)
                 {
-                    copiedArray.SetValue(DeepCloneType(array?.GetValue(i)), i);
+                    list.Add(OpenApiTypeMapper.ToIdentifier(flag));
                 }
-                return copiedArray;
             }
 
-            return null;
+            writer.WriteOptionalCollection(OpenApiConstants.Type, list, (w, s) => w.WriteRaw(s));
         }
 
-        private void DowncastTypeArrayToV2OrV3(string[] array, IOpenApiWriter writer, OpenApiSpecVersion version)
+        private void DowncastTypeArrayToV2OrV3(JsonSchemaType? schemaType, IOpenApiWriter writer, OpenApiSpecVersion version, int flagsCount)
         {
             /* If the array has one non-null value, emit Type as string
             * If the array has one null value, emit x-nullable as true
             * If the array has two values, one null and one non-null, emit Type as string and x-nullable as true
             * If the array has more than two values or two non-null values, do not emit type
             * */
 
-            var nullableProp = version.Equals(OpenApiSpecVersion.OpenApi2_0) 
+            var nullableProp = version.Equals(OpenApiSpecVersion.OpenApi2_0)
                 ? OpenApiConstants.NullableExtension
                 : OpenApiConstants.Nullable;
 
-            if (array.Length is 1)
+            if (flagsCount is 1)
             {
-                var value = array[0];
-                if (value is OpenApiConstants.Null)
+                if (schemaType is JsonSchemaType.Null)
                 {
                     writer.WriteProperty(nullableProp, true);
                 }
                 else
                 {
-                    writer.WriteProperty(OpenApiConstants.Type, value);
+                    writer.WriteProperty(OpenApiConstants.Type, OpenApiTypeMapper.ToIdentifier(schemaType));
                 }
             }
-            else if (array.Length is 2 && array.Contains(OpenApiConstants.Null))
+            else if (flagsCount is 2 && (schemaType & JsonSchemaType.Null) == JsonSchemaType.Null)
             {
-                // Find the non-null value and write it out
-                var nonNullValue = array.First(v => v != OpenApiConstants.Null);
-                writer.WriteProperty(OpenApiConstants.Type, nonNullValue);
+                foreach (JsonSchemaType flag in System.Enum.GetValues(typeof(JsonSchemaType)))
+                {
+                    // Skip if the flag is not set or if it's the Null flag
+                    if ((schemaType & flag) == flag && flag != JsonSchemaType.Null && flag != JsonSchemaType.Any)
+                    {
+                        // Write the non-null flag value to the writer
+                        writer.WriteProperty(OpenApiConstants.Type, OpenApiTypeMapper.ToIdentifier(flag));
+                    }
+                }
                 if (!Nullable)
                 {
                     writer.WriteProperty(nullableProp, true);

src/Microsoft.OpenApi/Models/References/OpenApiSchemaReference.cs

@@ -92,7 +92,7 @@ internal OpenApiSchemaReference(OpenApiSchema target, string referenceId)
         /// <inheritdoc/>
         public override bool UnEvaluatedProperties { get => Target.UnEvaluatedProperties; set => Target.UnEvaluatedProperties = value; }
         /// <inheritdoc/>
-        public override object Type { get => Target.Type; set => Target.Type = value; }
+        public override JsonSchemaType? Type { get => Target.Type; set => Target.Type = value; }
         /// <inheritdoc/>
         public override string Format { get => Target.Format; set => Target.Format = value; }
         /// <inheritdoc/>

src/Microsoft.OpenApi/Reader/V2/OpenApiOperationDeserializer.cs

@@ -173,8 +173,8 @@ private static OpenApiRequestBody CreateFormBody(ParsingContext context, List<Op
                     _ => mediaType)
             };
 
-            foreach (var value in formBody.Content.Values.Where(static x => x.Schema is not null && x.Schema.Properties.Any() && string.IsNullOrEmpty((string)x.Schema.Type)))
-                value.Schema.Type = "object";
+            foreach (var value in formBody.Content.Values.Where(static x => x.Schema is not null && x.Schema.Properties.Any() && x.Schema.Type == null))
+                value.Schema.Type = JsonSchemaType.Object;
 
             return formBody;
         }