How to define an array of arrays of something with @tsed/schema?

[KBroichhausen]

I basically need something like public arrayOfArraysOfInternalStructure: Array<Array<InternalStructure>>; in my API but I could not find a way in the docs how to do it properly. @CollectionOf seems to be only for one dimension?

I tried some workarounds by directly defining the schema via @Schema. Using a $ref to the InternalStructure works as output but throws an error as input. But that might be an XY problem (and also has another drawback, see comments in code).
Nevertheless, here is a small repro with annotations which explains it much better than writing more here.
Controller: https://github.com/KBroichhausen/arrayofarrays/blob/main/src/controllers/rest/HelloWorldController.ts
Testfile: https://github.com/KBroichhausen/arrayofarrays/blob/main/src/controllers/rest/HelloWorldController.integration.spec.ts

[Romakita]

Hi @KBroichhausen

Ts.ED provides a Function API to describe json-schema (look https://tsed.dev/docs/model.html#using-functions).

Here is a working example:

import {Controller} from "@tsed/di";
import {BodyParams} from "@tsed/platform-params";
import {Post, array, Property, Required, Schema, getSpec} from "@tsed/schema";

describe("collection", function() {
  describe("collection of collection of model", () => {
    it("should generate a collection of collection of model", () => {
      class InternalStructure {
        @Required()
        @Property(String)
        public field: string;
      }

      const ArrayOfArrayOfInternalStructure = array()
        .items(array().items(InternalStructure))
        .label("ArrayOfArrayOfInternalStructure");

      expect(ArrayOfArrayOfInternalStructure.toJSON()).toMatchInlineSnapshot(`
        {
          "definitions": {
            "InternalStructure": {
              "properties": {
                "field": {
                  "minLength": 1,
                  "type": "string",
                },
              },
              "required": [
                "field",
              ],
              "type": "object",
            },
          },
          "items": {
            "items": {
              "$ref": "#/definitions/InternalStructure",
            },
            "type": "array",
          },
          "type": "array",
        }
      `);

      @Controller("/hello-world")
      class HelloWorldController {
        @Post("/")
        post(@BodyParams() @Schema(ArrayOfArrayOfInternalStructure) items: InternalStructure[][]): void {
          console.log(items);
        }
      }

      expect(getSpec(HelloWorldController)).toMatchInlineSnapshot(`
        {
          "components": {
            "schemas": {
              "ArrayOfArrayOfInternalStructure": {
                "items": {
                  "items": {
                    "$ref": "#/components/schemas/InternalStructure",
                  },
                  "type": "array",
                },
                "type": "array",
              },
              "InternalStructure": {
                "properties": {
                  "field": {
                    "minLength": 1,
                    "type": "string",
                  },
                },
                "required": [
                  "field",
                ],
                "type": "object",
              },
            },
          },
          "paths": {
            "/hello-world": {
              "post": {
                "operationId": "helloWorldControllerPost",
                "parameters": [],
                "requestBody": {
                  "content": {
                    "application/json": {
                      "schema": {
                        "$ref": "#/components/schemas/ArrayOfArrayOfInternalStructure",
                      },
                    },
                  },
                  "required": false,
                },
                "responses": {
                  "200": {
                    "description": "Success",
                  },
                },
                "tags": [
                  "HelloWorldController",
                ],
              },
            },
          },
          "tags": [
            {
              "name": "HelloWorldController",
            },
          ],
        }
      `);
    });
  });
});

See you ;)

[Romakita]

Note in this case, json-mapper won't deserialize automatically your payload, because, you use a custom schema. AJV, will validate and coerce types, but InternalStructure won't be deserialized.

To solve that you have to use a custom Pipe:

@Injectable()
class ArrayOfArrayDeserializer implements PipeMethods {
   transform(value: unknown[][]) {
     return value.map((items) => {
         return deserialize(items, {collectionType: Array, type: InternalStructure})
     }) 
   }
}

[KBroichhausen]

Works like a charm. Thank you!
I only changed the imports - or better to say vs code auto imported them - to import from @tsed/schema instead from collection.js etc.

At the moment, I don't need the deserialization because I only require the fields without any methods, which also works without defining a custom deserializer. In the real world application the ArrayOfArrayOfInternalStructure is a field in an object but I read the docs and figured (+tested) that I would use @OnDeserialize in the class definition for a ArrayOfArrayOfInternalStructure.
On a side note: value: unknow[][] in your code is missing a n for unknown

[Romakita]

Fixed ;)