fix: support array of 1 for query parameter arrays

- introduce `x-alpha-transform` concept, allowing for a arbitrary
  transformation function to be applied to a schema
  - not yet supported by `joi`
  - not yet supported by `type-builder`
  - only really useful for this specific case so far
- detect query parameters of an array type, and parse as a `T | T[]`,
  and then transform to a `T[]` for convenience
  - does not yet support `$ref`d schemas properly

relates #217

Author: mnahkies

packages/openapi-code-generator/src/core/input.ts

@@ -368,6 +368,7 @@ function normalizeSchemaObject(
   const base: IRModelBase = {
     nullable: schemaObject.nullable || false,
     readOnly: schemaObject.readOnly || false,
+    "x-alpha-transform": schemaObject["x-alpha-transform"],
   }
 
   switch (schemaObject.type) {

packages/openapi-code-generator/src/core/openapi-types-normalized.ts

@@ -8,6 +8,8 @@ export interface IRModelBase {
   // Note: meaningless for top level objects, maybe we can exclude these somehow in that case
   nullable: boolean /* false */
   readOnly: boolean /* false */
+
+  "x-alpha-transform"?: string | undefined
 }
 
 export type IRModelNumericFormat = "int32" | "int64" | "float" | "double"

packages/openapi-code-generator/src/core/openapi-types.ts

@@ -248,6 +248,9 @@ export interface Schema {
   externalDocs?: ExternalDocumentation | undefined
   deprecated?: boolean | undefined
   // xml?: XML | undefined
+
+  // TODO: not yet supported by type-builder or joi
+  "x-alpha-transform"?: string | undefined
 }
 
 export interface Discriminator {

packages/openapi-code-generator/src/typescript/common/schema-builders/abstract-schema-builder.ts

@@ -163,7 +163,29 @@ export abstract class AbstractSchemaBuilder<
       if (parameter.required) {
         model.required.push(parameter.name)
       }
-      model.properties[parameter.name] = parameter.schema
+
+      // TODO: support $ref properly
+      if (
+        parameter.in === "query" &&
+        !isRef(parameter.schema) &&
+        parameter.schema.type === "array"
+      ) {
+        model.properties[parameter.name] = {
+          type: "object",
+          additionalProperties: false,
+          properties: {},
+          readOnly: false,
+          allOf: [],
+          nullable: false,
+          oneOf: [],
+          required: [],
+          anyOf: [parameter.schema, parameter.schema.items],
+          "x-alpha-transform": ((it: unknown) =>
+            Array.isArray(it) || it === undefined ? it : [it]).toString(),
+        }
+      } else {
+        model.properties[parameter.name] = parameter.schema
+      }
     }
 
     return this.fromModel(model, true, true)
@@ -304,6 +326,10 @@ export abstract class AbstractSchemaBuilder<
 
     result = required ? this.required(result) : this.optional(result)
 
+    if (model["x-alpha-transform"]) {
+      result = this.transform(result, model["x-alpha-transform"])
+    }
+
     return result
   }
 
@@ -327,6 +353,11 @@ export abstract class AbstractSchemaBuilder<
 
   protected abstract union(schemas: string[]): string
 
+  protected abstract transform(
+    schema: string,
+    transformation: string | ((it: unknown) => unknown),
+  ): string
+
   protected abstract nullable(schema: string): string
 
   protected abstract optional(schema: string): string

packages/openapi-code-generator/src/typescript/common/schema-builders/joi-schema-builder.ts

@@ -108,6 +108,14 @@ export class JoiBuilder extends AbstractSchemaBuilder<
       .join(".")
   }
 
+  protected transform(
+    schema: string,
+    transformation: string | ((it: unknown) => unknown),
+  ) {
+    // TODO: is it possible to do arbitrary transformations with `joi`?
+    return schema
+  }
+
   protected nullable(schema: string): string {
     return [schema, "allow(null)"].join(".")
   }

packages/openapi-code-generator/src/typescript/common/schema-builders/zod-schema-builder.ts

@@ -133,6 +133,15 @@ export class ZodBuilder extends AbstractSchemaBuilder<
       .join(".")
   }
 
+  protected transform(
+    schema: string,
+    transformation: string | ((it: unknown) => unknown),
+  ) {
+    return [schema, `transform(${transformation.toString()})`]
+      .filter(isDefined)
+      .join(".")
+  }
+
   protected nullable(schema: string): string {
     return [schema, "nullable()"].filter(isDefined).join(".")
   }

packages/openapi-code-generator/src/typescript/typescript-koa/typescript-koa.generator.ts

@@ -25,14 +25,14 @@ import {
 
 function reduceParamsToOpenApiSchema(parameters: IRParameter[]): IRModelObject {
   return parameters.reduce(
-    (acc, parameter) => {
-      acc.properties[parameter.name] = parameter.schema
+    (model, parameter) => {
+      model.properties[parameter.name] = parameter.schema
 
       if (parameter.required) {
-        acc.required.push(parameter.name)
+        model.required.push(parameter.name)
       }
 
-      return acc
+      return model
     },
     {
       type: "object",