Can the builder represent 2-dimentional arrays?

[UDA-CamB]

I have a scenario where there is a property specified as

property:
  type: array
  items:
    type: array
    items:
      type: string

When the c# model is created it is defined as List<string> where it should be List<List<string>>

Upon investigation it would appear that the CreateSourceModel method is not capable of representing a property that is a multi-dimensional array of any type

Given the following input:

openapi: 3.0.1
info:
  title: Arrays, Arrays everywhere
  version: 1.0.0
paths:
  /foo:
    get:
      responses:
        200:
          description: ""OK""
          content:
            application/json:
              schema:
                $ref: ""#/components/schemas/FooResponseObject""
components:
  schemas:
    FooResponseObject:
      type: object
      properties:
        currentDay:
          type: array
          description: Array current
          items:
            description: Values current
            type: string
        previousDays:
          type: array
          description: Array previous
          items:
            type: array
            description: Array previous nested
            items:
              description: Values previous
              type: string
        previouseOther:
          type: array
          description: other array
          items:
            type: array
            description: other array array
            items:
                type: object
                description: other value object
                properties:
                    value1:
                        description: other value object value1
                        type: string
                    value2:
                        description: other value object value2
                        type: string

All 3 properties are created as being single lists.

Am I missing something?

[baywet]

Hi @UDA-CamB
Thanks for using kiota and for reaching out.
Not today, there are multiple challenges to supporting them:

• technically the number of dimensions can be infinite. We could decide to limit it to 2 or even 3, but there would still be unsupported edge cases.
• when we first implemented kiota, the CodeDOM (how we project the clients in memory before writing objects) didn't have a concept of generic types. Now it has one. So the modelling would be possible.
• the serialization/deserialization would be challenging, as the ParseNode/SerializationWriter interfaces were designed with a single dimension in mind. Expanding to more might be feasible in CSharp, but would be extremely challenging without a breaking change in Java (type erasure), Go (no generic types on interfaces), TypeScript (lots of type information lost at runtime), etc...

I'd say that in my experience working with APIs, unless there are very specific use cases (like geo-mapping, and even this one could be designed another way), multi-dimensional arrays are more often than not a bad design that lead to a poor experience for the API consumer.

[UDA-CamB]

Hi @baywet
Thanks for the response.
Yes I see where it becomes a problem with other languages.

I am having to work with an API spec that is prescribed and have no ability to change. I agree that multi-dimensional arrays in this case are a poor design

Given that it is an edge case and probably only viable in CSharp, if I looked to make it work and submit a PR would it be considered?
If it would be I'd have a look at trying to fixe it, if not I'll look for a different solution to my specific use case

[baywet]

We try to make languages features evolve at the same pace, or at least to have a workable design for other languages. This is to avoid having completely different experiences across them.

The only way I could see this working on languages that do not have a great support for generics is if we passed some kind of factory for the collection, plus a callback to insert items in the collection to the parsing methods.

Can you think of any alternative?

Meanwhile for your specific case, how much of the API you want to integrate with depends on multi dimensional arrays? If it's one endpoint, could you simply not make a raw call for that endpoint and keep using your kiota client for the rest of the API?