feat: request model arg parameter handler

internal/test-utils/src/server.ts

@@ -1,15 +1,28 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import Fastify, { FastifyInstance, FastifyRequest } from 'fastify'
 import FastifyFormBody from 'fastify-formbody'
 
 const fastify = Fastify({ logger: false })
 
 fastify.register(FastifyFormBody)
 
+export const respond = (req: FastifyRequest, obj: any): unknown => ({
+  url: req.url,
+  headers: req.headers,
+  query: req.query,
+  params: req.params,
+  body: req.body,
+  method: req.method,
+  result: obj
+})
+
 // Routes
 // ----------
 
-fastify.setErrorHandler(function (error: any, _request, reply) {
+fastify.setErrorHandler(function (error: Error, request, reply) {
   this.log.error(error)
+
   reply.status(500).send({
     ok: false,
     error
@@ -36,20 +49,10 @@ fastify.post('/:id/projects/:project', (request, reply) => {
   reply.send(respond(request, { ok: true }))
 })
 
-export const respond = (req: FastifyRequest, obj: any): any => ({
-  url: req.url,
-  headers: req.headers,
-  query: req.query,
-  params: req.params,
-  body: req.body,
-  method: req.method,
-  result: obj
-})
-
 // Server
 // ----------
 
-export const setupTestServer = (setup: (f: FastifyInstance) => void) => setup(fastify)
+export const setupTestServer = (setup?: (f: FastifyInstance) => void) => setup?.(fastify)
 export const startTestServer = (port = 0) => fastify.listen(port)
 export const closeTestServer = () => fastify.close()
 

pkgs/core/Drizzle.ts

@@ -130,15 +130,12 @@ export class Drizzle {
    * @returns {@link ParameterHandler} instance
    * @throws {@link NoParameterHandlerError} if no handler is found for provided parameter type
    */
-  parameterHandler<P extends Parameter, V>(
-    requestFactory: RequestFactory,
-    parameter: Parameter
-  ): ParameterHandler<P, V> {
+  parameterHandler<V>(requestFactory: RequestFactory, parameter: Parameter): ParameterHandler<V> {
     for (const factory of this._parameterHandlerFactories) {
       const handler = factory.provide(this, requestFactory, parameter)
 
       if (handler !== null) {
-        return handler as ParameterHandler<P, V>
+        return handler as ParameterHandler<V>
       }
     }
 

pkgs/core/DrizzleBuilder.ts

@@ -19,6 +19,7 @@ import { PathParameterHandlerFactory } from './builtin'
 import { SignalParameterHandlerFactory } from './builtin'
 import { RawResponseHandlerFactory } from './builtin'
 import { PlainTextResponseConverterFactory } from './builtin'
+import { ModelArgumentParameterHandlerFactory } from './builtin'
 import { Interceptor } from './Interceptor'
 import { InterceptorFactory } from './Interceptor'
 import { InterceptorFunction } from './Interceptor'
@@ -305,6 +306,7 @@ export class DrizzleBuilder {
     this.addParameterHandlerFactory(FormParameterHandlerFactory.INSTANCE)
     this.addParameterHandlerFactory(BodyParameterHandlerFactory.INSTANCE)
     this.addParameterHandlerFactory(SignalParameterHandlerFactory.INSTANCE)
+    this.addParameterHandlerFactory(ModelArgumentParameterHandlerFactory.INSTANCE)
 
     this.addRequestConverterFactories(new JsonRequestConverterFactory())
     this.addRequestConverterFactories(new FormRequestConverterFactory())

pkgs/core/RequestFactory.ts

@@ -43,7 +43,7 @@ export class RequestFactory {
     public defaultHeaders: HttpHeaders = new HttpHeaders(),
     public readTimeout: number | undefined = undefined,
     public connectTimeout: number | undefined = undefined,
-    public parameterHandlers: ParameterHandler<Parameter, unknown>[] = [],
+    public parameterHandlers: { parameter: Parameter; handler: ParameterHandler }[] = [],
     public parameters: Parameter[] = [],
     public signal: unknown = null,
     public noResponseConverter: boolean = false,
@@ -208,7 +208,12 @@ export class RequestFactory {
 
     this.parameters
       .sort((a, b) => a.index - b.index)
-      .forEach(parameter => this.parameterHandlers.push(drizzle.parameterHandler(this, parameter)))
+      .forEach(parameter =>
+        this.parameterHandlers.push({
+          parameter,
+          handler: drizzle.parameterHandler(this, parameter)
+        })
+      )
 
     this.preProcessed = true
   }
@@ -591,8 +596,8 @@ export class DynamicParametrizedRequestBuilder implements RequestBuilder {
       this.requestFactory.signal
     )
 
-    for (const parameterHandler of this.requestFactory.parameterHandlers) {
-      parameterHandler.apply(requestParameterization, args[parameterHandler.parameter.index])
+    for (const p of this.requestFactory.parameterHandlers) {
+      p.handler.handle(requestParameterization, args[p.parameter.index])
     }
 
     if (requestParameterization.body === null && this.requestFactory.hasBody()) {

pkgs/core/builtin/parameterhandlers/ParameterHandler.ts

@@ -1,8 +1,5 @@
 import { RequestParameterization } from '../../RequestParameterization'
-import { Parameter } from './Parameter'
 
-export interface ParameterHandler<P extends Parameter, V> {
-  readonly parameter: P
-
-  apply(requestValues: RequestParameterization, value: V): void
+export interface ParameterHandler<V = unknown> {
+  handle(requestValues: RequestParameterization, value: V): void
 }

pkgs/core/builtin/parameterhandlers/ParameterHandlerFactory.ts

@@ -4,5 +4,5 @@ import { Parameter } from './Parameter'
 import { ParameterHandler } from './ParameterHandler'
 
 export interface ParameterHandlerFactory<P extends Parameter, R> {
-  provide(drizzle: Drizzle, requestFactory: RequestFactory, parameter: P): ParameterHandler<P, R> | null
+  provide(drizzle: Drizzle, requestFactory: RequestFactory, parameter: P): ParameterHandler<R> | null
 }

pkgs/core/builtin/parameterhandlers/handlers/BodyParameterHandler.ts

@@ -15,14 +15,13 @@ export class BodyParameter extends Parameter {
   }
 }
 
-export class BodyParameterHandler implements ParameterHandler<BodyParameter, BodyType> {
+export class BodyParameterHandler implements ParameterHandler<BodyType> {
   constructor(
     private readonly converter: RequestBodyConverter<BodyType>,
-    private readonly requestFactory: RequestFactory,
-    readonly parameter: BodyParameter
+    private readonly requestFactory: RequestFactory
   ) {}
 
-  apply(requestValues: RequestParameterization, value: BodyType): void {
+  handle(requestValues: RequestParameterization, value: BodyType): void {
     if (value === null || typeof value === 'undefined') {
       return
     }
@@ -34,19 +33,11 @@ export class BodyParameterHandler implements ParameterHandler<BodyParameter, Bod
 export class BodyParameterHandlerFactory implements ParameterHandlerFactory<BodyParameter, BodyType> {
   static INSTANCE: BodyParameterHandlerFactory = new BodyParameterHandlerFactory()
 
-  provide(
-    drizzle: Drizzle,
-    requestFactory: RequestFactory,
-    p: BodyParameter
-  ): ParameterHandler<BodyParameter, BodyType> | null {
+  provide(drizzle: Drizzle, requestFactory: RequestFactory, p: BodyParameter): ParameterHandler<BodyType> | null {
     if (p.type !== BodyParameter.Type) {
       return null
     }
 
-    return new BodyParameterHandler(
-      drizzle.requestBodyConverter(requestFactory.method, requestFactory),
-      requestFactory,
-      p
-    )
+    return new BodyParameterHandler(drizzle.requestBodyConverter(requestFactory.method, requestFactory), requestFactory)
   }
 }

pkgs/core/builtin/parameterhandlers/handlers/FormParameterHandler.ts

@@ -14,10 +14,10 @@ export class FormParameter extends Parameter {
   }
 }
 
-export class FormParameterHandler implements ParameterHandler<FormParameter, string | string[]> {
+export class FormParameterHandler implements ParameterHandler<string | string[]> {
   constructor(readonly parameter: FormParameter) {}
 
-  apply(requestValues: RequestParameterization, value: string | string[]): void {
+  handle(requestValues: RequestParameterization, value: string | string[]): void {
     if (value === null || typeof value === 'undefined') {
       return
     }
@@ -37,11 +37,7 @@ export class FormParameterHandler implements ParameterHandler<FormParameter, str
 export class FormParameterHandlerFactory implements ParameterHandlerFactory<FormParameter, string | string[]> {
   static INSTANCE: FormParameterHandlerFactory = new FormParameterHandlerFactory()
 
-  provide(
-    drizzle: Drizzle,
-    rf: RequestFactory,
-    p: FormParameter
-  ): ParameterHandler<FormParameter, string | string[]> | null {
+  provide(drizzle: Drizzle, rf: RequestFactory, p: FormParameter): ParameterHandler<string | string[]> | null {
     if (p.type === FormParameter.Type) {
       return new FormParameterHandler(p)
     }

pkgs/core/builtin/parameterhandlers/handlers/HeaderParameterHandler.ts

@@ -13,10 +13,10 @@ export class HeaderParameter extends Parameter {
   }
 }
 
-export class HeaderParameterHandler implements ParameterHandler<HeaderParameter, string | string[]> {
+export class HeaderParameterHandler implements ParameterHandler<string | string[]> {
   constructor(readonly parameter: HeaderParameter) {}
 
-  apply(requestValues: RequestParameterization, value: string | string[]): void {
+  handle(requestValues: RequestParameterization, value: string | string[]): void {
     if (value === null || typeof value === 'undefined') {
       return
     }
@@ -34,11 +34,7 @@ export class HeaderParameterHandler implements ParameterHandler<HeaderParameter,
 export class HeaderParameterHandlerFactory implements ParameterHandlerFactory<HeaderParameter, string | string[]> {
   static INSTANCE: HeaderParameterHandlerFactory = new HeaderParameterHandlerFactory()
 
-  provide(
-    drizzle: Drizzle,
-    rf: RequestFactory,
-    p: HeaderParameter
-  ): ParameterHandler<HeaderParameter, string | string[]> | null {
+  provide(drizzle: Drizzle, rf: RequestFactory, p: HeaderParameter): ParameterHandler<string | string[]> | null {
     if (p.type === HeaderParameter.Type) {
       return new HeaderParameterHandler(p)
     }