feat: config flag to switch schema parser

integration-tests/typescript-koa/generate.sh

@@ -8,5 +8,6 @@ for path in ../../integration-tests-definitions/*; do
   node ../../packages/openapi-code-generator/dist/index.js \
     --input="$path" \
     --output="./src/$filename" \
-    --template=typescript-koa
+    --template=typescript-koa \
+    --schema-builder=zod
 done

packages/openapi-code-generator/src/config.ts

@@ -1,5 +1,7 @@
 import convict from "convict"
-import {OpenapiGenerator, templates} from "./templates"
+import {templates} from "./templates"
+import {OpenapiGenerator} from "./templates.types"
+import {SchemaBuilderType} from "./typescript/common/schema-builders/schema-builder"
 
 const convictConfig = convict({
   input: {
@@ -23,6 +25,13 @@ const convictConfig = convict({
     env: "TEMPLATE",
     arg: "template",
   },
+  schemaBuilder: {
+    doc: "Runtime parsing library to use",
+    format: ["zod", "joi"],
+    default: "zod",
+    env: "SCHEMA_BUILDER",
+    arg: "schema-builder",
+  }
 })
 
 export class Config {
@@ -34,6 +43,10 @@ export class Config {
     return convictConfig.get("output")
   }
 
+  get schemaBuilder(): SchemaBuilderType {
+    return convictConfig.get<any>("schemaBuilder")
+  }
+
   get generator(): OpenapiGenerator {
     const template = convictConfig.get("template")
 

packages/openapi-code-generator/src/index.ts

@@ -22,7 +22,11 @@ async function main() {
 
   logger.time("generation")
   // TODO abort generation if not a git repo or there are uncommitted changes
-  await config.generator({input, dest: config.output})
+  await config.generator({
+    input,
+    dest: config.output,
+    schemaBuilder: config.schemaBuilder,
+  })
 }
 
 main()

packages/openapi-code-generator/src/templates.ts

@@ -1,12 +1,7 @@
-import {Input} from "./core/input"
-
 import {generateTypescriptAngular} from "./typescript/typescript-angular/typescript-angular.generator"
 import {generateTypescriptFetch} from "./typescript/typescript-fetch/typescript-fetch.generator"
 import {generateTypescriptKoa} from "./typescript/typescript-koa/typescript-koa.generator"
-
-export interface OpenapiGenerator {
-  (args: { dest: string, input: Input }): Promise<void>
-}
+import {OpenapiGenerator} from "./templates.types"
 
 export const templates: Record<string, OpenapiGenerator> = {
   "typescript-fetch": generateTypescriptFetch,

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

@@ -0,0 +1,12 @@
+import {Input} from "./core/input"
+import {SchemaBuilderType} from "./typescript/common/schema-builders/schema-builder"
+
+export interface OpenapiGeneratorConfig {
+  dest: string,
+  input: Input,
+  schemaBuilder: SchemaBuilderType
+}
+
+export interface OpenapiGenerator {
+  (args: OpenapiGeneratorConfig): Promise<void>
+}

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

@@ -21,36 +21,48 @@ export class JoiBuilder extends AbstractSchemaBuilder {
     imports: ImportBuilder,
   ) {
     super(filename, input, imports)
-  }
 
+    this.importHelpers(imports)
+
+    imports.from("@nahkies/typescript-koa-runtime/joi")
+      .add("parseRequestInput", "Params", "responseValidationFactory")
+  }
 
-  protected importHelpers(importBuilder: ImportBuilder) {
-    importBuilder.addModule(this.joi, "@hapi/joi")
 
-    importBuilder.from("@nahkies/typescript-koa-runtime/joi")
-      .add("parseRequestInput", "Params")
+  protected importHelpers(imports: ImportBuilder) {
+    imports.addModule(this.joi, "@hapi/joi")
   }
 
   public any(): string {
-    // TODO: implement
-    throw new Error("Method not implemented.")
+    return [
+      this.joi,
+      "any()",
+    ].filter(isDefined).join(".")
   }
 
   public void(): string {
-    // TODO: implement
-    throw new Error("Method not implemented.")
+    return [
+      this.joi,
+      "any()",
+      "valid(undefined)",
+    ].filter(isDefined).join(".")
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
   protected intersect(schemas: string[]): string {
-    // TODO: implement
-    throw new Error("Method not implemented.")
+    return schemas.filter(isDefined).reduce((acc, it) => {
+      return `${acc}\n.concat(${it})`
+    })
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
   protected union(schemas: string[]): string {
-    // TODO: implement
-    throw new Error("Method not implemented.")
+    return [
+      this.joi,
+      `alternatives().try(${
+        schemas.filter(isDefined).map(it => it).join(",")
+      })`
+    ].filter(isDefined).join(".")
   }
 
   protected nullable(schema: string): string {

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

@@ -18,8 +18,7 @@ export class ZodBuilder extends AbstractSchemaBuilder {
   ) {
     super(filename, input, imports)
 
-    imports.from("zod")
-      .add(this.zod)
+    this.importHelpers(imports)
 
     imports.from("@nahkies/typescript-koa-runtime/zod")
       .add("parseRequestInput", "Params", "responseValidationFactory")
@@ -40,7 +39,7 @@ export class ZodBuilder extends AbstractSchemaBuilder {
     return [
       this.zod,
       `union([\n${
-        schemas.map(it => it + ",").join("\n")
+        schemas.filter(isDefined).map(it => it + ",").join("\n")
       }\n])`
     ].filter(isDefined).join(".")
   }

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

@@ -7,6 +7,7 @@ import {TypeBuilder} from "../common/type-builder"
 import {isDefined, titleCase} from "../../core/utils"
 import {SchemaBuilder, schemaBuilderFactory} from "../common/schema-builders/schema-builder"
 import {requestBodyAsParameter, statusStringToType} from "../common/typescript-common"
+import {OpenapiGeneratorConfig} from "../../templates.types"
 
 function reduceParamsToOpenApiSchema(parameters: IRParameter[]): IRModelObject {
   return parameters.reduce((acc, parameter) => {
@@ -201,10 +202,11 @@ function route(route: string): string {
     }, route)
 }
 
-export async function generateTypescriptKoa({dest, input}: { dest: string, input: Input }): Promise<void> {
+export async function generateTypescriptKoa(config: OpenapiGeneratorConfig): Promise<void> {
+  const input = config.input
   const imports = new ImportBuilder()
   const types = TypeBuilder.fromInput("./models.ts", input).withImports(imports)
-  const schemaBuilder = schemaBuilderFactory("zod", input, imports)
+  const schemaBuilder = schemaBuilderFactory(config.schemaBuilder, input, imports)
 
   const server = new ServerBuilder(
     "generated.ts",
@@ -213,13 +215,13 @@ export async function generateTypescriptKoa({dest, input}: { dest: string, input
     imports,
     types,
     schemaBuilder,
-    loadExistingImplementations(await loadPreviousResult(dest, {filename: "index.ts"}))
+    loadExistingImplementations(await loadPreviousResult(config.dest, {filename: "index.ts"}))
   )
 
   input.allOperations()
     .map(it => server.add(it))
 
-  await emitGenerationResult(dest, [
+  await emitGenerationResult(config.dest, [
     types,
     server,
     schemaBuilder,

packages/typescript-koa-runtime/src/joi.ts

@@ -24,9 +24,46 @@ export function parseRequestInput<Schema extends JoiSchema>(
   const result = schema.validate(input, {stripUnknown: true})
 
   if (result.error) {
-    // TODO: improve error
-    throw new Error("validation error")
+    throw result.error
   }
 
   return result.value
 }
+
+export function responseValidationFactory(possibleResponses: [string, JoiSchema][], defaultResponse?: JoiSchema) {
+
+  // Exploit the natural ordering matching the desired specificity of eg: 404 vs 4xx
+  possibleResponses.sort((x, y) => x[0] < y[0] ? -1 : 1)
+
+  return (status: number, value: unknown) => {
+
+    for (const [match, schema] of possibleResponses) {
+
+      const isMatch =
+        /^\d+$/.test(match) && String(status) === match ||
+        /^\d[xX]{2}$/.test(match) && String(status)[0] === match[0]
+
+      if (isMatch) {
+        const result = schema.validate(value)
+
+        if (result.error) {
+          throw result.error
+        }
+
+        return result.value
+      }
+    }
+
+    if (defaultResponse) {
+      const result = defaultResponse.validate(value)
+
+      if (result.error) {
+        throw result.error
+      }
+
+      return result.value
+    }
+
+    return value
+  }
+}