delegate body validation (#4897)

* initial working BodyValidator

* delegate body generic validation

* enable previously failing test

* update failing tests

* delegate to BodyValidator

* add validator in private dts

* add notes

* add changeset

Author: ignatiusmb

.changeset/large-cows-suffer.md

@@ -0,0 +1,5 @@
+---
+"@sveltejs/kit": patch
+---
+
+delegate `RequestHandler` generics `Body` validation

packages/kit/src/core/sync/write_types.js

@@ -8,7 +8,7 @@ import type { ${imports} } from '@sveltejs/kit';`;
 
 /** @param {string} arg */
 const endpoint = (arg) => `
-export type RequestHandler<Output extends ResponseBody = ResponseBody> = GenericRequestHandler<${arg}, Output>;`;
+export type RequestHandler<Output = ResponseBody> = GenericRequestHandler<${arg}, Output>;`;
 
 /** @param {string} arg */
 const page = (arg) => `

packages/kit/test/typings/endpoint.test.ts

@@ -68,30 +68,53 @@ export const differential_headers_assignment: RequestHandler = () => {
 	}
 };
 
-// TODO https://github.com/sveltejs/kit/issues/1997
-// interface ExamplePost {
-// 	title: string;
-// 	description: string;
-// 	published_date?: string;
-// 	author_name?: string;
-// 	author_link?: string;
-// }
-// // valid - should not be any different
-// export const generic_case: RequestHandler<Record<string, string>, ExamplePost> = () => {
-// 	return {
-// 		body: {} as ExamplePost
-// 	};
-// };
+/**
+ * NOTE about type casting in body returned
+ *
+ * tests below with `{} as Interface` casts are there only for
+ * convenience purposes so we won't have to actually fill in the
+ * required data, it serves the exact same purpose and doesn't
+ * make the tests invalid
+ */
+
+/** example json-serializable POJO */
+interface ExamplePost {
+	title: string;
+	description: string;
+	published_date?: string;
+	author_name?: string;
+	author_link?: string;
+}
+// valid - should not be any different
+export const generic_case: RequestHandler<Record<string, string>, ExamplePost> = () => {
+	return {
+		body: {} as ExamplePost
+	};
+};
 
 // --- invalid cases ---
 
 // @ts-expect-error - body must be JSON serializable
-export const error_body_must_be_serializable: RequestHandler = () => {
+export const error_unserializable_literal: RequestHandler = () => {
 	return {
 		body: () => {}
 	};
 };
 
+/** example object that isn't serializable */
+interface InvalidPost {
+	sorter(a: any, b: any): number;
+}
+// @ts-expect-error - body must be JSON serializable with Generic passed
+export const error_unserializable_generic: RequestHandler<
+	Record<string, string>,
+	InvalidPost
+> = () => {
+	return {
+		body: {} as InvalidPost
+	};
+};
+
 // @ts-expect-error - body typed array must only be Uint8Array
 export const error_other_typed_array_instances: RequestHandler = () => {
 	return {

packages/kit/types/index.d.ts

@@ -6,6 +6,7 @@ import './ambient';
 import { CompileOptions } from 'svelte/types/compiler/interfaces';
 import {
 	AdapterEntry,
+	BodyValidator,
 	CspDirectives,
 	JSONValue,
 	Logger,
@@ -241,15 +242,15 @@ export interface ParamMatcher {
  */
 export interface RequestHandler<
 	Params extends Record<string, string> = Record<string, string>,
-	Output extends ResponseBody = ResponseBody
+	Output = ResponseBody
 > {
 	(event: RequestEvent<Params>): MaybePromise<RequestHandlerOutput<Output>>;
 }
 
-export interface RequestHandlerOutput<Output extends ResponseBody = ResponseBody> {
+export interface RequestHandlerOutput<Output = ResponseBody> {
 	status?: number;
 	headers?: Headers | Partial<ResponseHeaders>;
-	body?: Output;
+	body?: Output extends ResponseBody ? Output : BodyValidator<Output>;
 }
 
 export type ResponseBody = JSONValue | Uint8Array | ReadableStream | import('stream').Readable;

packages/kit/types/private.d.ts

@@ -26,6 +26,10 @@ export interface AdapterEntry {
 	}) => MaybePromise<void>;
 }
 
+export type BodyValidator<T> = {
+	[P in keyof T]: T[P] extends JSONValue ? BodyValidator<T[P]> : never;
+};
+
 // Based on https://github.com/josh-hemphill/csp-typed-directives/blob/latest/src/csp.types.ts
 //
 // MIT License