@furystack/rest-service 10.1.2 → 11.0.0

package/src/swagger/generate-swagger-json.ts

@@ -1,4 +1,11 @@
-import type { ApiEndpointDefinition, Operation, ParameterObject, SwaggerDocument } from '@furystack/rest'
+import type {
+  ApiEndpointDefinition,
+  ApiEndpointSchema,
+  Method,
+  Operation,
+  ParameterObject,
+  SwaggerDocument,
+} from '@furystack/rest'
 
 /**
  * Converts a FuryStack API schema to an OpenAPI 3.1 compatible document
@@ -12,7 +19,7 @@ export const generateSwaggerJsonFromApiSchema = ({
   description = 'API documentation generated from FuryStack API schema',
   version = '1.0.0',
 }: {
-  api: Record<string, ApiEndpointDefinition>
+  api: ApiEndpointSchema['endpoints']
   title?: string
   description?: string
   version?: string
@@ -40,82 +47,84 @@ export const generateSwaggerJsonFromApiSchema = ({
     },
   }
 
-  for (const [path, definition] of Object.entries(api)) {
-    // Normalize path to OpenAPI format (convert :param to {param})
-    const normalizedPath = path.replace(/:([^/]+)/g, '{$1}')
-    if (!swaggerJson.paths![normalizedPath]) {
-      swaggerJson.paths![normalizedPath] = {}
-    }
+  for (const [methodKey, paths] of Object.entries(api) as Array<[Method, Record<string, ApiEndpointDefinition>]>) {
+    for (const [path, definition] of Object.entries(paths)) {
+      // Normalize path to OpenAPI format (convert :param to {param})
+      const normalizedPath = path.replace(/:([^/]+)/g, '{$1}')
+      if (!swaggerJson.paths![normalizedPath]) {
+        swaggerJson.paths![normalizedPath] = {}
+      }
 
-    // Extract path parameters
-    const pathParams = Array.from(path.matchAll(/:([^/]+)/g), (m) => m[1])
-    const parameters: ParameterObject[] = pathParams.map((param) => ({
-      name: param,
-      in: 'path',
-      required: true,
-      description: `Path parameter: ${param}`,
-      schema: { type: 'string' },
-    }))
+      // Extract path parameters
+      const pathParams = Array.from(path.matchAll(/:([^/]+)/g), (m) => m[1])
+      const parameters: ParameterObject[] = pathParams.map((param) => ({
+        name: param,
+        in: 'path',
+        required: true,
+        description: `Path parameter: ${param}`,
+        schema: { type: 'string' },
+      }))
 
-    // Build operation
-    const method = definition.method.toLowerCase()
-    const operation: Operation = {
-      summary: `${definition.method} ${path}`,
-      description: `Endpoint for ${path}`,
-      operationId: `${method}${path.replace(/\//g, '_').replace(/:/g, '').replace(/-/g, '_')}`,
-      security: definition.isAuthenticated ? [{ cookieAuth: [] }] : [],
-      parameters,
-      responses: {
-        '200': {
-          description: 'Successful operation',
-          content: {
-            'application/json': {
-              schema: definition.schemaName
-                ? { $ref: `#/components/schemas/${definition.schemaName}` }
-                : { type: 'object' },
+      // Build operation
+      const method = methodKey.toLowerCase()
+      const operation: Operation = {
+        summary: `${methodKey} ${path}`,
+        description: `Endpoint for ${path}`,
+        operationId: `${method}${path.replace(/\//g, '_').replace(/:/g, '').replace(/-/g, '_')}`,
+        security: definition.isAuthenticated ? [{ cookieAuth: [] }] : [],
+        parameters,
+        responses: {
+          '200': {
+            description: 'Successful operation',
+            content: {
+              'application/json': {
+                schema: definition.schemaName
+                  ? { $ref: `#/components/schemas/${definition.schemaName}` }
+                  : { type: 'object' },
+              },
             },
           },
+          '401': { description: 'Unauthorized' },
+          '500': { description: 'Internal server error' },
         },
-        '401': { description: 'Unauthorized' },
-        '500': { description: 'Internal server error' },
-      },
-    }
+      }
 
-    // Add schema to components if not already there
-    if (definition.schema && definition.schemaName) {
-      swaggerJson.components!.schemas![definition.schemaName] = definition.schema
-    }
+      // Add schema to components if not already there
+      if (definition.schema && definition.schemaName) {
+        swaggerJson.components!.schemas![definition.schemaName] = definition.schema
+      }
 
-    // Assign the operation to the correct HTTP method property of PathItem
-    const pathItem = swaggerJson.paths![normalizedPath]
-    switch (method) {
-      case 'get':
-        pathItem.get = operation
-        break
-      case 'put':
-        pathItem.put = operation
-        break
-      case 'post':
-        pathItem.post = operation
-        break
-      case 'delete':
-        pathItem.delete = operation
-        break
-      case 'options':
-        pathItem.options = operation
-        break
-      case 'head':
-        pathItem.head = operation
-        break
-      case 'patch':
-        pathItem.patch = operation
-        break
-      case 'trace':
-        pathItem.trace = operation
-        break
-      default:
-        // Ignore unknown methods
-        break
+      // Assign the operation to the correct HTTP method property of PathItem
+      const pathItem = swaggerJson.paths![normalizedPath]
+      switch (method) {
+        case 'get':
+          pathItem.get = operation
+          break
+        case 'put':
+          pathItem.put = operation
+          break
+        case 'post':
+          pathItem.post = operation
+          break
+        case 'delete':
+          pathItem.delete = operation
+          break
+        case 'options':
+          pathItem.options = operation
+          break
+        case 'head':
+          pathItem.head = operation
+          break
+        case 'patch':
+          pathItem.patch = operation
+          break
+        case 'trace':
+          pathItem.trace = operation
+          break
+        default:
+          // Ignore unknown methods
+          break
+      }
     }
   }
 

package/src/validate.integration.schema.ts

@@ -29,22 +29,28 @@ export interface ValidateBody {
   result: { foo: string; bar: number; baz: boolean }
 }
 
+export type PostMockEndpoint = PostEndpoint<Mock, 'id', Mock>
+export type PatchMockEndpoint = PatchEndpoint<Mock, 'id', Mock>
+export type DeleteMockEndpoint = DeleteEndpoint<Mock, 'id'>
+export type GetMockCollectionEndpoint = GetCollectionEndpoint<Mock>
+export type GetMockEntityEndpoint = GetEntityEndpoint<Mock, 'id'>
+
 export interface ValidationApi extends RestApi {
   GET: {
     '/validate-query': ValidateQuery
     '/validate-url/:id': ValidateUrl
     '/validate-headers': ValidateHeaders
-    '/mock': GetCollectionEndpoint<Mock>
-    '/mock/:id': GetEntityEndpoint<Mock, 'id'>
+    '/mock': GetMockCollectionEndpoint
+    '/mock/:id': GetMockEntityEndpoint
   }
   POST: {
     '/validate-body': ValidateBody
-    '/mock': PostEndpoint<Mock, 'id'>
+    '/mock': PostMockEndpoint
   }
   PATCH: {
-    '/mock/:id': PatchEndpoint<Mock, 'id'>
+    '/mock/:id': PatchMockEndpoint
   }
   DELETE: {
-    '/mock/:id': DeleteEndpoint<Mock, 'id'>
+    '/mock/:id': DeleteMockEndpoint
   }
 }

package/src/validate.integration.spec.schema.json

@@ -22,6 +22,9 @@
       "required": ["url", "result"],
       "type": "object"
     },
+    "DeleteMockEndpoint": {
+      "$ref": "#/definitions/DeleteEndpoint%3CMock%2C%22id%22%3E"
+    },
     "FilterType<Mock>": {
       "additionalProperties": false,
       "properties": {
@@ -273,6 +276,12 @@
       "required": ["query", "url", "result"],
       "type": "object"
     },
+    "GetMockCollectionEndpoint": {
+      "$ref": "#/definitions/GetCollectionEndpoint%3CMock%3E"
+    },
+    "GetMockEntityEndpoint": {
+      "$ref": "#/definitions/GetEntityEndpoint%3CMock%2C%22id%22%3E"
+    },
     "Mock": {
       "additionalProperties": false,
       "properties": {
@@ -286,21 +295,12 @@
       "required": ["id", "value"],
       "type": "object"
     },
-    "PatchEndpoint<Mock,\"id\">": {
+    "PatchEndpoint<Mock,\"id\",Mock>": {
       "additionalProperties": false,
       "description": "Endpoint model for updating entities",
       "properties": {
         "body": {
-          "additionalProperties": false,
-          "properties": {
-            "id": {
-              "type": "string"
-            },
-            "value": {
-              "type": "string"
-            }
-          },
-          "type": "object"
+          "$ref": "#/definitions/Mock"
         },
         "result": {
           "type": "object"
@@ -319,12 +319,15 @@
       "required": ["body", "url", "result"],
       "type": "object"
     },
-    "PostEndpoint<Mock,\"id\">": {
+    "PatchMockEndpoint": {
+      "$ref": "#/definitions/PatchEndpoint%3CMock%2C%22id%22%2CMock%3E"
+    },
+    "PostEndpoint<Mock,\"id\",Mock>": {
       "additionalProperties": false,
       "description": "Endpoint model for creating new entities",
       "properties": {
         "body": {
-          "$ref": "#/definitions/WithOptionalId%3CMock%2C%22id%22%3E"
+          "$ref": "#/definitions/Mock"
         },
         "result": {
           "$ref": "#/definitions/Mock"
@@ -333,6 +336,9 @@
       "required": ["body", "result"],
       "type": "object"
     },
+    "PostMockEndpoint": {
+      "$ref": "#/definitions/PostEndpoint%3CMock%2C%22id%22%2CMock%3E"
+    },
     "RestApi": {
       "additionalProperties": false,
       "properties": {
@@ -640,7 +646,7 @@
           "additionalProperties": false,
           "properties": {
             "/mock/:id": {
-              "$ref": "#/definitions/DeleteEndpoint%3CMock%2C%22id%22%3E"
+              "$ref": "#/definitions/DeleteMockEndpoint"
             }
           },
           "required": ["/mock/:id"],
@@ -650,10 +656,10 @@
           "additionalProperties": false,
           "properties": {
             "/mock": {
-              "$ref": "#/definitions/GetCollectionEndpoint%3CMock%3E"
+              "$ref": "#/definitions/GetMockCollectionEndpoint"
             },
             "/mock/:id": {
-              "$ref": "#/definitions/GetEntityEndpoint%3CMock%2C%22id%22%3E"
+              "$ref": "#/definitions/GetMockEntityEndpoint"
             },
             "/validate-headers": {
               "$ref": "#/definitions/ValidateHeaders"
@@ -702,7 +708,7 @@
           "additionalProperties": false,
           "properties": {
             "/mock/:id": {
-              "$ref": "#/definitions/PatchEndpoint%3CMock%2C%22id%22%3E"
+              "$ref": "#/definitions/PatchMockEndpoint"
             }
           },
           "required": ["/mock/:id"],
@@ -712,7 +718,7 @@
           "additionalProperties": false,
           "properties": {
             "/mock": {
-              "$ref": "#/definitions/PostEndpoint%3CMock%2C%22id%22%3E"
+              "$ref": "#/definitions/PostMockEndpoint"
             },
             "/validate-body": {
               "$ref": "#/definitions/ValidateBody"
@@ -754,19 +760,6 @@
       },
       "required": ["GET", "POST", "PATCH", "DELETE"],
       "type": "object"
-    },
-    "WithOptionalId<Mock,\"id\">": {
-      "additionalProperties": false,
-      "properties": {
-        "id": {
-          "type": "string"
-        },
-        "value": {
-          "type": "string"
-        }
-      },
-      "required": ["value"],
-      "type": "object"
     }
   }
 }

package/src/validate.integration.spec.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import { getStoreManager, InMemoryStore, User } from '@furystack/core'
 import { getPort } from '@furystack/core/port-generator'
 import { Injector } from '@furystack/inject'
@@ -6,6 +7,12 @@ import { createClient, ResponseError } from '@furystack/rest-client-fetch'
 import { usingAsync } from '@furystack/utils'
 import type Ajv from 'ajv'
 import { describe, expect, it } from 'vitest'
+import { createDeleteEndpoint } from './endpoint-generators/create-delete-endpoint.js'
+import { createGetCollectionEndpoint } from './endpoint-generators/create-get-collection-endpoint.js'
+import { createGetEntityEndpoint } from './endpoint-generators/create-get-entity-endpoint.js'
+import { createPatchEndpoint } from './endpoint-generators/create-patch-endpoint.js'
+import { createPostEndpoint } from './endpoint-generators/create-post-endpoint.js'
+import { MockClass } from './endpoint-generators/utils.js'
 import { useRestService } from './helpers.js'
 import { DefaultSession } from './models/default-session.js'
 import { JsonResult } from './request-action-implementation.js'
@@ -46,8 +53,14 @@ const createValidateApi = async (options = { enableGetSchema: false }) => {
           schema,
           schemaName: 'ValidateHeaders',
         })(async ({ headers }) => JsonResult({ ...headers })),
-        '/mock': undefined as any, // ToDo: Generator and test
-        '/mock/:id': undefined as any, // ToDo: Generator and test
+        '/mock': Validate({
+          schema,
+          schemaName: 'GetMockCollectionEndpoint',
+        })(createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' })),
+        '/mock/:id': Validate({
+          schema,
+          schemaName: 'GetMockEntityEndpoint',
+        })(createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' })),
       },
       POST: {
         '/validate-body': Validate({
@@ -57,13 +70,22 @@ const createValidateApi = async (options = { enableGetSchema: false }) => {
           const body = await getBody()
           return JsonResult({ ...body })
         }),
-        '/mock': undefined as any, // ToDo: Generator and test
+        '/mock': Validate({
+          schema,
+          schemaName: 'PostMockEndpoint',
+        })(createPostEndpoint({ model: MockClass, primaryKey: 'id' })),
       },
       PATCH: {
-        '/mock/:id': undefined as any, // ToDo: Generator and test
+        '/mock/:id': Validate({
+          schema,
+          schemaName: 'PatchMockEndpoint',
+        })(createPatchEndpoint({ model: MockClass, primaryKey: 'id' })),
       },
       DELETE: {
-        '/mock/:id': undefined as any, // ToDo: Generator and test
+        '/mock/:id': Validate({
+          schema,
+          schemaName: 'DeleteMockEndpoint',
+        })(createDeleteEndpoint({ model: MockClass, primaryKey: 'id' })),
       },
     },
     port,
@@ -207,37 +229,63 @@ describe('Validation integration tests', () => {
         expect(result.result.description).toBe(description)
         expect(result.result.version).toBe(version)
 
-        expect(result.result.endpoints['/validate-query']).toBeDefined()
-
-        expect(result.result.endpoints['/validate-query'].schema).toStrictEqual(schema)
-        expect(result.result.endpoints['/validate-query'].schemaName).toBe('ValidateQuery')
-        expect(result.result.endpoints['/validate-query'].method).toBe('GET')
-        expect(result.result.endpoints['/validate-query'].path).toBe('/validate-query')
-        expect(result.result.endpoints['/validate-query'].isAuthenticated).toBe(false)
-
-        expect(result.result.endpoints['/validate-url/:id']).toBeDefined()
-        expect(result.result.endpoints['/validate-url/:id'].schema).toStrictEqual(schema)
-        expect(result.result.endpoints['/validate-url/:id'].schemaName).toBe('ValidateUrl')
-        expect(result.result.endpoints['/validate-url/:id'].method).toBe('GET')
-        expect(result.result.endpoints['/validate-url/:id'].path).toBe('/validate-url/:id')
-        expect(result.result.endpoints['/validate-url/:id'].isAuthenticated).toBe(false)
-
-        expect(result.result.endpoints['/validate-headers']).toBeDefined()
-        expect(result.result.endpoints['/validate-headers'].schema).toStrictEqual(schema)
-        expect(result.result.endpoints['/validate-headers'].schemaName).toBe('ValidateHeaders')
-        expect(result.result.endpoints['/validate-headers'].method).toBe('GET')
-        expect(result.result.endpoints['/validate-headers'].path).toBe('/validate-headers')
-        expect(result.result.endpoints['/validate-headers'].isAuthenticated).toBe(false)
-
-        expect(result.result.endpoints['/validate-body']).toBeDefined()
-        expect(result.result.endpoints['/validate-body'].schema).toStrictEqual(schema)
-        expect(result.result.endpoints['/validate-body'].schemaName).toBe('ValidateBody')
-        expect(result.result.endpoints['/validate-body'].method).toBe('POST')
-        expect(result.result.endpoints['/validate-body'].path).toBe('/validate-body')
-        expect(result.result.endpoints['/validate-body'].isAuthenticated).toBe(false)
-
-        expect(result.result.endpoints['/mock']).toBeUndefined()
-        expect(result.result.endpoints['/mock/:id']).toBeUndefined()
+        // GET endpoints
+        expect(result.result.endpoints.GET?.['/validate-query']).toBeDefined()
+        expect(result.result.endpoints.GET?.['/validate-query']?.schema).toStrictEqual(schema)
+        expect(result.result.endpoints.GET?.['/validate-query']?.schemaName).toBe('ValidateQuery')
+        expect(result.result.endpoints.GET?.['/validate-query']?.path).toBe('/validate-query')
+        expect(result.result.endpoints.GET?.['/validate-query']?.isAuthenticated).toBe(false)
+
+        expect(result.result.endpoints.GET?.['/validate-url/:id']).toBeDefined()
+        expect(result.result.endpoints.GET?.['/validate-url/:id']?.schema).toStrictEqual(schema)
+        expect(result.result.endpoints.GET?.['/validate-url/:id']?.schemaName).toBe('ValidateUrl')
+        expect(result.result.endpoints.GET?.['/validate-url/:id']?.path).toBe('/validate-url/:id')
+        expect(result.result.endpoints.GET?.['/validate-url/:id']?.isAuthenticated).toBe(false)
+
+        expect(result.result.endpoints.GET?.['/validate-headers']).toBeDefined()
+        expect(result.result.endpoints.GET?.['/validate-headers']?.schema).toStrictEqual(schema)
+        expect(result.result.endpoints.GET?.['/validate-headers']?.schemaName).toBe('ValidateHeaders')
+        expect(result.result.endpoints.GET?.['/validate-headers']?.path).toBe('/validate-headers')
+        expect(result.result.endpoints.GET?.['/validate-headers']?.isAuthenticated).toBe(false)
+
+        expect(result.result.endpoints.GET?.['/mock']).toBeDefined()
+        expect(result.result.endpoints.GET?.['/mock']?.schema).toStrictEqual(schema)
+        expect(result.result.endpoints.GET?.['/mock']?.schemaName).toBe('GetMockCollectionEndpoint')
+        expect(result.result.endpoints.GET?.['/mock']?.path).toBe('/mock')
+        expect(result.result.endpoints.GET?.['/mock']?.isAuthenticated).toBe(false)
+
+        expect(result.result.endpoints.GET?.['/mock/:id']).toBeDefined()
+        expect(result.result.endpoints.GET?.['/mock/:id']?.schema).toStrictEqual(schema)
+        expect(result.result.endpoints.GET?.['/mock/:id']?.schemaName).toBe('GetMockEntityEndpoint')
+        expect(result.result.endpoints.GET?.['/mock/:id']?.path).toBe('/mock/:id')
+        expect(result.result.endpoints.GET?.['/mock/:id']?.isAuthenticated).toBe(false)
+
+        // POST endpoints
+        expect(result.result.endpoints.POST?.['/validate-body']).toBeDefined()
+        expect(result.result.endpoints.POST?.['/validate-body']?.schema).toStrictEqual(schema)
+        expect(result.result.endpoints.POST?.['/validate-body']?.schemaName).toBe('ValidateBody')
+        expect(result.result.endpoints.POST?.['/validate-body']?.path).toBe('/validate-body')
+        expect(result.result.endpoints.POST?.['/validate-body']?.isAuthenticated).toBe(false)
+
+        expect(result.result.endpoints.POST?.['/mock']).toBeDefined()
+        expect(result.result.endpoints.POST?.['/mock']?.schema).toStrictEqual(schema)
+        expect(result.result.endpoints.POST?.['/mock']?.schemaName).toBe('PostMockEndpoint')
+        expect(result.result.endpoints.POST?.['/mock']?.path).toBe('/mock')
+        expect(result.result.endpoints.POST?.['/mock']?.isAuthenticated).toBe(false)
+
+        // PATCH endpoints
+        expect(result.result.endpoints.PATCH?.['/mock/:id']).toBeDefined()
+        expect(result.result.endpoints.PATCH?.['/mock/:id']?.schema).toStrictEqual(schema)
+        expect(result.result.endpoints.PATCH?.['/mock/:id']?.schemaName).toBe('PatchMockEndpoint')
+        expect(result.result.endpoints.PATCH?.['/mock/:id']?.path).toBe('/mock/:id')
+        expect(result.result.endpoints.PATCH?.['/mock/:id']?.isAuthenticated).toBe(false)
+
+        // DELETE endpoints
+        expect(result.result.endpoints.DELETE?.['/mock/:id']).toBeDefined()
+        expect(result.result.endpoints.DELETE?.['/mock/:id']?.schema).toStrictEqual(schema)
+        expect(result.result.endpoints.DELETE?.['/mock/:id']?.schemaName).toBe('DeleteMockEndpoint')
+        expect(result.result.endpoints.DELETE?.['/mock/:id']?.path).toBe('/mock/:id')
+        expect(result.result.endpoints.DELETE?.['/mock/:id']?.isAuthenticated).toBe(false)
       })
     })
   })

package/src/validate.ts

@@ -1,12 +1,31 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import type { ActionResult, RequestAction, RequestActionOptions } from './request-action-implementation.js'
 import { SchemaValidator } from './schema-validator/schema-validator.js'
 
+/**
+ * Represents a JSON Schema definition structure
+ */
+type JsonSchemaDefinition = {
+  required?: string[]
+  additionalProperties?: boolean
+  properties?: {
+    headers?: {
+      additionalProperties?: boolean
+      [key: string]: unknown
+    }
+    [key: string]: unknown
+  }
+  [key: string]: unknown
+}
+
+/**
+ * Represents a JSON Schema with definitions
+ */
+type JsonSchemaWithDefinitions = {
+  definitions: Record<string, JsonSchemaDefinition>
+}
+
 export const Validate =
-  <TSchema extends { definitions: { [K: string]: any } }>(validationOptions: {
+  <TSchema extends JsonSchemaWithDefinitions>(validationOptions: {
     /**
      * The Schema object
      */
@@ -16,12 +35,17 @@ export const Validate =
      */
     schemaName: keyof TSchema['definitions']
   }) =>
-  <T extends { result: any }>(action: RequestAction<T>): RequestAction<T> => {
+  <T extends { result: unknown }>(
+    action: RequestAction<T>,
+  ): RequestAction<T> & {
+    schema: TSchema
+    schemaName: keyof TSchema['definitions']
+  } => {
     const schema = { ...validationOptions.schema }
 
     Object.values(schema.definitions).forEach((definition) => {
-      if (definition.required && definition.required.includes('result')) {
-        definition.required = definition.required.filter((value: any) => value !== 'result')
+      if (definition.required?.includes('result')) {
+        definition.required = definition.required.filter((value) => value !== 'result')
       }
       definition.additionalProperties = true
       if (definition.properties?.headers) {
@@ -31,40 +55,45 @@ export const Validate =
 
     const validator = new SchemaValidator(schema, { coerceTypes: true, strict: false })
 
-    const wrapped = async (args: RequestActionOptions<T>): Promise<ActionResult<T>> => {
-      const anyArgs = args as any
-      let body!: any
-      const { headers } = anyArgs
-      const query = anyArgs.getQuery?.()
-      const url = anyArgs.getUrlParams?.()
+    const wrapped = async (args: RequestActionOptions<T>): Promise<ActionResult<T['result']>> => {
+      const headers = 'headers' in args ? (args.headers as Record<string, string>) : undefined
+      const query = 'getQuery' in args ? (args as { getQuery: () => unknown }).getQuery() : undefined
+      const url = 'getUrlParams' in args ? (args as { getUrlParams: () => unknown }).getUrlParams() : undefined
+
+      let body: unknown
       try {
-        body = await anyArgs.getBody?.()
-      } catch (error) {
-        // ignore
+        if ('getBody' in args) {
+          body = await (args as { getBody: () => Promise<unknown> }).getBody()
+        }
+      } catch {
+        // Body parsing may fail for requests without body
       }
+
       validator.isValid(
         {
-          ...(query ? { query } : {}),
-          ...(body ? { body } : {}),
-          ...(url ? { url } : {}),
-          ...(headers ? { headers } : {}),
+          ...(query !== undefined ? { query } : {}),
+          ...(body !== undefined ? { body } : {}),
+          ...(url !== undefined ? { url } : {}),
+          ...(headers !== undefined ? { headers } : {}),
         },
         { schemaName: validationOptions.schemaName },
       )
-      // @ts-expect-error
-      return await action({
+
+      const validatedArgs = {
         request: args.request,
         response: args.response,
         injector: args.injector,
-        headers,
-        getQuery: () => query,
-        getUrlParams: () => url,
-        getBody: () => Promise.resolve(body),
-      })
-    }
+        ...(headers !== undefined && { headers }),
+        ...(query !== undefined && { getQuery: () => query }),
+        ...(url !== undefined && { getUrlParams: () => url }),
+        ...(body !== undefined && { getBody: () => Promise.resolve(body) }),
+      } as RequestActionOptions<T>
 
-    wrapped.schema = schema
-    wrapped.schemaName = validationOptions.schemaName
+      return await action(validatedArgs)
+    }
 
-    return wrapped
+    return Object.assign(wrapped, {
+      schema,
+      schemaName: validationOptions.schemaName,
+    })
   }