[TypeScript] Add support for nested arrays (array of string arrays)

[joebalancioLP]

Hey there. Running into an issue with the generated client. I have a schema where one of the properties is an array of string arrays. It is returned in an API response and it looks like the following:

      "Foo": {
        "type": "object",
        "properties": {
          "sortBy": {
            "type": "array",
            "items": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          }
        }
      },

When I make an API call using the generated client, I get this error:

Error: encountered an unknown type during deserialization object

The stacktrace points to the generated models. When I inspect the generated model, I see that the a few things are off.

The code fails during deserialization in this function. Looks like the wrong function is invoked getCollectionOfPrimitiveValues

export function deserializeIntoFoo(foo: Partial<Foo> | undefined = {}) : Record<string, (node: ParseNode) => void> {
    return {
        "sortBy": n => { foo.sortBy = n.getCollectionOfPrimitiveValues<string>(); },
    }
}

The schema is typed incorrectly. It should be string[][]

export interface Foo extends Parsable {
    /**
     * The sortBy property
     */
    sortBy?: string[];
}

Also I changed the OpenAPI spec a few different ways and here are my findings.

1. Untyped the nested array. Same error. The property is typed as UntypedNode[]
2. Changed the nested array to object type. No error, but in the response the array value is parsed as an object { "0": "updatedAt", "1": "DESC" }
3. Removed properties from Foo. No error, but Foo is no longer typed correctly.

[baywet]

Hi @joebalancioLP
Thanks for using kiota and for reaching out.

General context: multi-dimensional arrays are generally not supported for generation, meaning that kiota will never generate foo: string[][]. This because it'd either require to start generating overly complex orchestration code with loops and whatnot for serialization or require many more methods in the parsenode/serializationwriter interfaces.

I'd have expected kiota to generate foo: UntypedNode[] here, and at runtime the serialization to manage to return UntypedArray[UntypeArray[string]].

Have you tried generating other languages (CSharp/Go/Java) to see if you get a different result in the generated code? (not asking to run it for now)

@andrueastman what's your opinion here?

[andrueastman]

You're right, I think this is an edge case the KiotaBuilder should probably be updated to handle as an unknown type. I suspect it keeps trying to unwrap the type for the array to come up with type annotation.

Ideally in this scenario, this should be generated as either

• UntypedNode (not UntypedNode [] as this is the essentially an UntypedArray). This should work out out the box with no serialization changes as the seriliazer will give us a UntypedArray[UntypeArray[string]] at runtime.
• UntypedArray since we have a hint from the schema that this is definitely a collection of some kind. We may need to validate runtime vs generation implications but I believe the serializer still returning a value of UntypedArray[UntypeArray[string]] at runtime should be compatible and still work out for us.

[joebalancioLP]

Have you tried generating other languages (CSharp/Go/Java) to see if you get a different result in the generated code? (not asking to run it for now)

@baywet Thanks for triaging. I haven't tried generating in other languages since TypeScript is my only target for now.

[baywet]

@andrueastman when you have some time can you investigate to see whether it's specific to TS or general to all languages at this point please?

[andrueastman]

Validated this affects other languages as well as the Kiota Builder will recursively unwrap the Items property and still represent the type found as a single dimensional array.
Authored #4606 to address this one.