fix(typescript-fetch): runtime validation works (#287)

solves #286 

- Use `--enable-runtime-response-validation` for the E2E tests
- Refactor `typescript-fetch` response validation factory to share most
of the implementation between schema builders
- Fix the returned `res` of the response validation factory to be a
`Proxy` to the actual `res` object, only intercepting the `json` method

e2e/scripts/generate.sh

@@ -16,6 +16,7 @@ yarn openapi-code-generator \
   --template typescript-fetch \
   --schema-builder zod \
   --extract-inline-schemas \
+  --enable-runtime-response-validation \
   --override-specification-title "E2E Test Client"
 
 yarn openapi-code-generator \
@@ -24,4 +25,5 @@ yarn openapi-code-generator \
   --template typescript-axios \
   --schema-builder zod \
   --extract-inline-schemas \
+  --enable-runtime-response-validation \
   --override-specification-title "E2E Test Client"

packages/typescript-fetch-runtime/src/common.ts

@@ -0,0 +1,50 @@
+import type {Res, StatusCode} from "./types"
+
+export function responseValidationFactoryFactory<Schema>(
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  parse: (schema: Schema, value: unknown) => any,
+  possibleResponses: [string, Schema][],
+  defaultResponse?: Schema,
+) {
+  // Exploit the natural ordering matching the desired specificity of eg: 404 vs 4xx
+  possibleResponses.sort((x, y) => (x[0] < y[0] ? -1 : 1))
+
+  return async (
+    whenRes: Promise<Res<StatusCode, unknown>>,
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  ): Promise<any> => {
+    const res = await whenRes
+
+    const json = async () => {
+      const status = res.status
+      const value = await res.json()
+
+      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) {
+          return parse(schema, value)
+        }
+      }
+
+      if (defaultResponse) {
+        return parse(defaultResponse, value)
+      }
+
+      // TODO: throw on unmatched response?
+      return value
+    }
+
+    return new Proxy(res, {
+      get(target, prop, receiver) {
+        if (prop === "json") {
+          return json
+        }
+
+        return Reflect.get(target, prop, receiver)
+      },
+    })
+  }
+}

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

@@ -1,55 +1,21 @@
 import type {Schema as JoiSchema} from "joi"
-import type {Res, StatusCode} from "./main"
+import {responseValidationFactoryFactory} from "./common"
 
 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))
-
-  // TODO: avoid any
-  return async (
-    whenRes: Promise<Res<StatusCode, unknown>>,
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-  ): Promise<any> => {
-    const res = await whenRes
-
-    return {
-      ...res,
-      json: async () => {
-        const status = res.status
-        const value = await res.json()
-
-        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
-        }
-
-        // TODO: throw on unmatched response?
-        return value
-      },
-    }
-  }
+  return responseValidationFactoryFactory(
+    (schema, value) => {
+      const result = schema.validate(value)
+
+      if (result.error) {
+        throw result.error
+      }
+
+      return result.value
+    },
+    possibleResponses,
+    defaultResponse,
+  )
 }

packages/typescript-fetch-runtime/src/main.ts

@@ -1,68 +1,14 @@
 import qs from "qs"
-
-// from https://stackoverflow.com/questions/39494689/is-it-possible-to-restrict-number-to-a-certain-range
-type Enumerate<
-  N extends number,
-  Acc extends number[] = [],
-> = Acc["length"] extends N
-  ? Acc[number]
-  : Enumerate<N, [...Acc, Acc["length"]]>
-
-type IntRange<F extends number, T extends number> = F extends T
-  ? F
-  : Exclude<Enumerate<T>, Enumerate<F>> extends never
-    ? never
-    : Exclude<Enumerate<T>, Enumerate<F>> | T
-
-export type StatusCode1xx = IntRange<100, 199>
-export type StatusCode2xx = IntRange<200, 299>
-export type StatusCode3xx = IntRange<300, 399>
-export type StatusCode4xx = IntRange<400, 499>
-export type StatusCode5xx = IntRange<500, 599>
-export type StatusCode =
-  | StatusCode1xx
-  | StatusCode2xx
-  | StatusCode3xx
-  | StatusCode4xx
-  | StatusCode5xx
-
-export interface Res<Status extends StatusCode, JsonBody> extends Response {
-  status: Status
-  json: () => Promise<JsonBody>
-}
-
-export type Server<T> = string & {__server__: T}
-
-export interface AbstractFetchClientConfig {
-  basePath: string
-  defaultHeaders?: Record<string, string>
-  defaultTimeout?: number
-}
-
-export type QueryParams = {
-  [name: string]:
-    | string
-    | number
-    | number[]
-    | boolean
-    | string[]
-    | undefined
-    | null
-    | QueryParams
-    | QueryParams[]
-}
-
-export type HeaderParams =
-  | Record<string, string | number | undefined | null>
-  | [string, string | number | undefined | null][]
-  | Headers
-
-// fetch HeadersInit type
-export type HeadersInit =
-  | string[][]
-  | readonly (readonly [string, string])[]
-  | Record<string, string | ReadonlyArray<string>>
-  | Headers
+import type {
+  AbstractFetchClientConfig,
+  HeaderParams,
+  HeadersInit,
+  QueryParams,
+  Res,
+  StatusCode,
+} from "./types"
+
+export * from "./types"
 
 export abstract class AbstractFetchClient {
   protected readonly basePath: string