fix: missing array of primitive types in union or intersection types

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Fixed a bug where collection/array of primitive types members for union/intersection types would be ignored. [#5283](https://github.com/microsoft/kiota/issues/5283)
 - Fixed a when generating a plugin when only an operation is selected in the root node in the extension. [#5300](https://github.com/microsoft/kiota/issues/5300)
 
 ## [1.18.0] - 2024-09-05
@@ -1444,4 +1445,3 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Initial GitHub release
-

it/config.json

@@ -161,8 +161,7 @@
         "Rationale": "https://github.com/microsoft/kiota/issues/2957"
       }
     ],
-    "IdempotencySuppressions": [
-    ]
+    "IdempotencySuppressions": []
   },
   "apisguru::twilio.com:api": {
     "ExcludePatterns": [
@@ -253,6 +252,10 @@
       {
         "Language": "ruby",
         "Rationale": "https://github.com/microsoft/kiota/issues/1816"
+      },
+      {
+        "Language": "php",
+        "Rationale": "https://github.com/microsoft/kiota/issues/5354"
       }
     ],
     "IdempotencySuppressions": [
@@ -301,13 +304,10 @@
         "Rationale": "https://github.com/microsoft/kiota/issues/1816"
       }
     ],
-    "IdempotencySuppressions": [
-    ]
+    "IdempotencySuppressions": []
   },
   "apisguru::apis.guru": {
-    "Suppressions": [
-    ],
-    "IdempotencySuppressions": [
-    ]
+    "Suppressions": [],
+    "IdempotencySuppressions": []
   }
 }

src/Kiota.Builder/KiotaBuilder.cs

@@ -708,7 +708,7 @@
         methodToAdd.AddParameter(new CodeParameter
         {
             Name = "rawUrl",
             Type = new CodeType { Name = "string", IsExternal = true },
             Optional = false,
             Documentation = new()
             {
@@ -822,7 +822,7 @@
             IsAsync = false,
             IsStatic = false,
             Documentation = new(new() {
                                 {"TypeName", new CodeType {
                                     IsExternal = false,
                                     TypeDefinition = currentClass,
                                 }
@@ -1064,7 +1064,7 @@
 
         if (!"string".Equals(parameter.Type.Name, StringComparison.OrdinalIgnoreCase) && config.IncludeBackwardCompatible)
         { // adding a second indexer for the string version of the parameter so we keep backward compatibility
             //TODO remove for v2
             var backCompatibleValue = (CodeIndexer)result[0].Clone();
             backCompatibleValue.Name += "-string";
             backCompatibleValue.IndexParameter.Type = DefaultIndexerParameterType;
@@ -1138,15 +1138,15 @@
             var primitiveTypeName = (typeName?.ToLowerInvariant(), format?.ToLowerInvariant()) switch
             {
                 ("string", "base64url") => "base64url",
                 ("file", _) => "binary",
                 ("string", "duration") => "TimeSpan",
                 ("string", "time") => "TimeOnly",
                 ("string", "date") => "DateOnly",
                 ("string", "date-time") => "DateTimeOffset",
                 ("string", "uuid") => "Guid",
                 ("string", _) => "string", // covers commonmark and html
                 ("number", "double" or "float" or "decimal") => format.ToLowerInvariant(),
                 ("number" or "integer", "int8") => "sbyte",
                 ("number" or "integer", "uint8") => "byte",
                 ("number" or "integer", "int64") => "int64",
                 ("number", "int32") => "integer",
@@ -1220,7 +1220,7 @@
             var suffix = $"{operationType}Response";
             var modelType = CreateModelDeclarations(currentNode, schema, operation, parentClass, suffix);
             if (modelType is not null && config.IncludeBackwardCompatible && config.Language is GenerationLanguage.CSharp or GenerationLanguage.Go && modelType.Name.EndsWith(suffix, StringComparison.Ordinal))
             { //TODO remove for v2
                 var obsoleteTypeName = modelType.Name[..^suffix.Length] + "Response";
                 if (modelType is CodeType codeType &&
                     codeType.TypeDefinition is CodeClass codeClass)
@@ -1352,7 +1352,7 @@
             executorMethod.AddParameter(cancellationParam);// Add cancellation token parameter
 
             if (returnTypes.Item2 is not null && config.IncludeBackwardCompatible)
             { //TODO remove for v2
                 var additionalExecutorMethod = (CodeMethod)executorMethod.Clone();
                 additionalExecutorMethod.ReturnType = returnTypes.Item2;
                 additionalExecutorMethod.OriginalMethod = executorMethod;
@@ -1744,6 +1744,8 @@
             if (string.IsNullOrEmpty(className))
                 if (GetPrimitiveType(currentSchema) is CodeType primitiveType && !string.IsNullOrEmpty(primitiveType.Name))
                 {
+                    if (currentSchema.IsArray())
+                        primitiveType.CollectionKind = CodeTypeBase.CodeTypeCollectionKind.Complex;
                     if (!unionType.ContainsType(primitiveType))
                         unionType.AddType(primitiveType);
                     continue;
@@ -2417,7 +2419,7 @@
         if (!parameterClass.ContainsPropertyWithWireName(prop.WireName))
         {
             if (addBackwardCompatibleParameter && config.IncludeBackwardCompatible && config.Language is GenerationLanguage.CSharp or GenerationLanguage.Go)
             { //TODO remove for v2
                 var modernProp = (CodeProperty)prop.Clone();
                 modernProp.Name = $"{prop.Name}As{modernProp.Type.Name.ToFirstCharacterUpperCase()}";
                 modernProp.SerializationName = prop.WireName;

src/Kiota.Builder/Writers/TypeScript/CodeFunctionWriter.cs

@@ -70,7 +70,7 @@ private void WriteComposedTypeDeserializer(CodeFunction codeElement, LanguageWri
         if (GetOriginalComposedType(composedParam) is not { } composedType) return;
 
         writer.StartBlock("return {");
-        foreach (var mappedType in composedType.Types.Where(x => !IsPrimitiveType(x, composedType)))
+        foreach (var mappedType in composedType.Types.Where(x => !IsPrimitiveType(x, composedType, false)))
         {
             var functionName = GetDeserializerFunctionName(codeElement, mappedType);
             var variableName = composedParam.Name.ToFirstCharacterLowerCase();
@@ -86,12 +86,12 @@ private void WriteComposedTypeSerializer(CodeFunction codeElement, LanguageWrite
     {
         if (GetOriginalComposedType(composedParam) is not { } composedType) return;
 
-        if (composedType.IsComposedOfPrimitives(IsPrimitiveType))
+        if (composedType.IsComposedOfPrimitives((x, y) => IsPrimitiveType(x, y, false)))
         {
             var paramName = composedParam.Name.ToFirstCharacterLowerCase();
             writer.WriteLine($"if ({paramName} === undefined || {paramName} === null) return;");
             writer.StartBlock($"switch (typeof {paramName}) {{");
-            foreach (var type in composedType.Types.Where(x => IsPrimitiveType(x, composedType)))
+            foreach (var type in composedType.Types.Where(x => IsPrimitiveType(x, composedType, false)))
             {
                 WriteCaseStatementForPrimitiveTypeSerialization(type, "key", paramName, codeElement, writer);
             }
@@ -327,11 +327,8 @@ private string FindFunctionInNameSpace(string functionName, CodeElement codeElem
         CodeFunction[] codeFunctions = myNamespace.FindChildrenByName<CodeFunction>(functionName).ToArray();
 
         var codeFunction = Array.Find(codeFunctions,
-            func => func.GetImmediateParentOfType<CodeNamespace>().Name == myNamespace.Name);
-
-        if (codeFunction == null)
+            func => func.GetImmediateParentOfType<CodeNamespace>().Name == myNamespace.Name) ??
             throw new InvalidOperationException($"Function {functionName} not found in namespace {myNamespace.Name}");
-
         return conventions.GetTypeString(new CodeType { TypeDefinition = codeFunction }, codeElement, false);
     }
 

src/Kiota.Builder/Writers/TypeScript/TypeScriptConventionService.cs

@@ -40,7 +40,7 @@
     public const string TYPE_DURATION = "Duration";
 #pragma warning restore CA1707 // Remove the underscores
 
     internal void WriteAutoGeneratedStart(LanguageWriter writer)
     {
         writer.WriteLine("/* tslint:disable */");
         writer.WriteLine("/* eslint-disable */");
@@ -225,7 +225,9 @@
         };
     }
 
-    public static bool IsPrimitiveType(CodeType codeType, CodeComposedTypeBase codeComposedTypeBase) => IsPrimitiveType(GetTypescriptTypeString(codeType, codeComposedTypeBase));
+    public static bool IsPrimitiveType(CodeType codeType, CodeComposedTypeBase codeComposedTypeBase) => IsPrimitiveType(codeType, codeComposedTypeBase, true);
+
+    public static bool IsPrimitiveType(CodeType codeType, CodeComposedTypeBase codeComposedTypeBase, bool includeCollectionInformation) => IsPrimitiveType(GetTypescriptTypeString(codeType, codeComposedTypeBase, includeCollectionInformation));
 
     internal static string RemoveInvalidDescriptionCharacters(string originalDescription) => originalDescription?.Replace("\\", "/", StringComparison.OrdinalIgnoreCase) ?? string.Empty;
     public override bool WriteShortDescription(IDocumentedElement element, LanguageWriter writer, string prefix = "", string suffix = "")

tests/Kiota.Builder.Tests/KiotaBuilderTests.cs

@@ -2841,6 +2841,89 @@ public void SquishesLonelyNullablesBothAnyOf()
         Assert.Null(codeModel.FindChildByName<CodeClass>("createUploadSessionResponseMember1"));
     }
     [Fact]
+    public void SupportsArraysInComposedTypes()
+    {
+        var anyOfSchema = new OpenApiSchema
+        {
+            Type = "object",
+            AdditionalPropertiesAllowed = false,
+            Properties = new Dictionary<string, OpenApiSchema> {
+                {
+                    "date", new OpenApiSchema {
+                        AnyOf = [
+                            new OpenApiSchema {
+                                Type = "string",
+                            },
+                            new OpenApiSchema {
+                                Type = "array",
+                                Items = new OpenApiSchema {
+                                    Type = "string",
+                                },
+                            },
+                        ]
+                    }
+                }
+            },
+            Reference = new OpenApiReference
+            {
+                Id = "anyOfNullable",
+                Type = ReferenceType.Schema
+            },
+            UnresolvedReference = false
+        };
+        var document = new OpenApiDocument
+        {
+            Paths = new OpenApiPaths
+            {
+                ["createUploadSession"] = new OpenApiPathItem
+                {
+                    Operations = {
+                        [OperationType.Get] = new OpenApiOperation
+                        {
+                            Responses = new OpenApiResponses
+                            {
+                                ["200"] = new OpenApiResponse
+                                {
+                                    Content = new Dictionary<string, OpenApiMediaType> {
+                                        ["application/json"] = new OpenApiMediaType
+                                        {
+                                            Schema = anyOfSchema
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            Components = new OpenApiComponents
+            {
+                Schemas = new Dictionary<string, OpenApiSchema> {
+                    {
+                        "anyOfNullable", anyOfSchema
+                    }
+                },
+            },
+        };
+        var mockLogger = new Mock<ILogger<KiotaBuilder>>();
+        var builder = new KiotaBuilder(mockLogger.Object, new GenerationConfiguration { ClientClassName = "Graph", ApiRootUrl = "https://localhost" }, _httpClient);
+        builder.SetOpenApiDocument(document);
+        var node = builder.CreateUriSpace(document);
+        var codeModel = builder.CreateSourceModel(node);
+        var anyOfClass = codeModel.FindChildByName<CodeClass>("anyOfNullable");
+        Assert.NotNull(anyOfClass);
+        var dateProperty = anyOfClass.FindChildByName<CodeProperty>("date", false);
+        Assert.NotNull(dateProperty);
+        if (dateProperty.Type is not CodeIntersectionType unionType)
+            Assert.Fail("Date property type is not a union type");
+        else
+        {
+            Assert.Equal(2, unionType.Types.Count());
+            Assert.Contains(unionType.Types, x => x.Name.Equals("string", StringComparison.OrdinalIgnoreCase) && x.CollectionKind is CodeTypeBase.CodeTypeCollectionKind.None);
+            Assert.Contains(unionType.Types, x => x.Name.Equals("string", StringComparison.OrdinalIgnoreCase) && x.CollectionKind is CodeTypeBase.CodeTypeCollectionKind.Complex);
+        }
+    }
+    [Fact]
     public void SupportsNullableAnyOf()
     {
         var anyOfSchema = new OpenApiSchema