Type inference finally works for schemasafe

Author: ciscoheat

package.json

@@ -13,6 +13,7 @@
 		"json-schema",
 		"arktype",
 		"joi",
+		"schemasafe",
 		"typebox",
 		"valibot",
 		"vinejs",

src/lib/adapters/index.ts

@@ -8,6 +8,7 @@ export { valibot, valibotClient } from './valibot.js';
 export { yup, yupClient } from './yup.js';
 export { zod, zodClient } from './zod.js';
 export { vine, vineClient } from './vine.js';
+export { schemasafe, schemasafeClient } from './schemasafe.js';
 
 /*
 // Cannot use due to moduleResolution problem: https://github.com/ianstormtaylor/superstruct/issues/1200

src/lib/adapters/schemasafe.ts

@@ -2,8 +2,8 @@ import { memoize } from '$lib/memoize.js';
 import {
 	createAdapter,
 	type AdapterOptions,
-	type ValidationAdapter,
-	type ValidationResult
+	type ClientValidationAdapter,
+	type ValidationAdapter
 } from './adapters.js';
 import {
 	validator,
@@ -15,60 +15,103 @@ import {
 import type { FromSchema, JSONSchema } from 'json-schema-to-ts';
 import type { JSONSchema as JSONSchema7 } from '$lib/jsonSchema/index.js';
 
+/*
+ * Adapter specificts:
+ * Type inference problem unless this is applied:
+ * https://github.com/ThomasAribart/json-schema-to-ts/blob/main/documentation/FAQs/applying-from-schema-on-generics.md
+ * Must duplicate validate method, otherwise the above type inference will fail.
+ */
+
 const Email =
 	/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;
 
-// Type inference problem unless this is applied: https://github.com/ThomasAribart/json-schema-to-ts/blob/main/documentation/FAQs/applying-from-schema-on-generics.md
+const defaultOptions = {
+	formats: {
+		email: (str: string) => Email.test(str)
+	},
+	includeErrors: true,
+	allErrors: true
+};
+
+function cachedValidator(currentSchema: JSONSchema7, config?: ValidatorOptions) {
+	if (!cache.has(currentSchema)) {
+		cache.set(
+			currentSchema,
+			validator(currentSchema as Schema, {
+				...defaultOptions,
+				...config
+			})
+		);
+	}
+
+	return cache.get(currentSchema)!;
+}
 
 function _schemasafe<
 	T extends JSONSchema | Record<string, unknown>,
-	Data = unknown extends FromSchema<T> ? Record<string, unknown> : FromSchema<T>
+	Data = unknown extends FromSchema<T> ? Record<string, unknown> : FromSchema<T>,
+	Out = [Data] extends [never] ? Record<string, unknown> : Data
 >(
 	schema: T,
-	options?: AdapterOptions<Data> & { config?: ValidatorOptions }
-): ValidationAdapter<Data> {
+	options?: AdapterOptions<Out> & { config?: ValidatorOptions }
+): ValidationAdapter<Out> {
 	return createAdapter({
 		superFormValidationLibrary: 'schemasafe',
 		jsonSchema: schema as JSONSchema7,
 		defaults: options?.defaults,
-		async validate(data: unknown): Promise<ValidationResult<Data>> {
-			const currentSchema = schema as JSONSchema7;
+		async validate(data: unknown) {
+			const validator = cachedValidator(schema as JSONSchema7, options?.config);
+			const isValid = validator(data as Json);
 
-			if (!cache.has(currentSchema)) {
-				cache.set(
-					currentSchema,
-					validator(currentSchema as Schema, {
-						formats: {
-							email: (str) => Email.test(str)
-						},
-						includeErrors: true,
-						allErrors: true,
-						...options?.config
-					})
-				);
+			if (isValid) {
+				return {
+					data: data as Out,
+					success: true
+				};
 			}
+			return {
+				issues: (validator.errors ?? []).map(({ instanceLocation, keywordLocation }) => ({
+					message: keywordLocation,
+					path: instanceLocation.split('/').slice(1)
+				})),
+				success: false
+			};
+		}
+	});
+}
 
-			const _validate = cache.get(currentSchema)!;
-
-			const isValid = _validate(data as Json);
+function _schemasafeClient<
+	T extends JSONSchema | Record<string, unknown>,
+	Data = unknown extends FromSchema<T> ? Record<string, unknown> : FromSchema<T>,
+	Out = [Data] extends [never] ? Record<string, unknown> : Data
+>(
+	schema: T,
+	options?: AdapterOptions<Out> & { config?: ValidatorOptions }
+): ClientValidationAdapter<Out> {
+	return {
+		superFormValidationLibrary: 'schemasafe',
+		async validate(data: unknown) {
+			const validator = cachedValidator(schema as JSONSchema7, options?.config);
+			const isValid = validator(data as Json);
 
 			if (isValid) {
 				return {
-					data: data as Data,
+					data: data as Out,
 					success: true
 				};
 			}
 			return {
-				issues: (_validate.errors ?? []).map(({ instanceLocation, keywordLocation }) => ({
+				issues: (validator.errors ?? []).map(({ instanceLocation, keywordLocation }) => ({
 					message: keywordLocation,
 					path: instanceLocation.split('/').slice(1)
 				})),
 				success: false
 			};
 		}
-	});
+	};
 }
 
 export const schemasafe = /* @__PURE__ */ memoize(_schemasafe);
+export const schemasafeClient = /* @__PURE__ */ memoize(_schemasafeClient);
 
 const cache = new WeakMap<JSONSchema7, Validate>();

src/routes/(v2)/v2/schemasafe-types/+page.server.ts

@@ -0,0 +1,26 @@
+import { schemasafe } from '$lib/adapters/schemasafe.js';
+import { message, superValidate } from '$lib/server/index.js';
+import { schema, constSchema } from './schema.js';
+import { fail } from '@sveltejs/kit';
+
+export const load = async () => {
+	const form = await superValidate(schemasafe(schema));
+	const constForm = await superValidate(schemasafe(constSchema));
+
+	return { form, constForm };
+};
+
+export const actions = {
+	default: async ({ request }) => {
+		const adapter = schemasafe(schema);
+		const adapter2 = schemasafe(constSchema);
+		const form = await superValidate(request, adapter);
+		const form2 = await superValidate(request, adapter2);
+
+		if (!form.valid || !form2.valid) {
+			return fail(400, { form });
+		}
+
+		return message(form, 'Form posted successfully!');
+	}
+};

src/routes/(v2)/v2/schemasafe-types/+page.svelte

@@ -0,0 +1,24 @@
+<script lang="ts">
+	import { schemasafeClient } from '$lib/adapters/schemasafe.js';
+	import { superForm } from '$lib/client/index.js';
+	import { schema } from './schema.js';
+
+	export let data;
+
+	const { form } = superForm(data.form);
+	const { form: form2 } = superForm(data.constForm, {
+		validators: schemasafeClient(schema)
+	});
+	const name: unknown = $form.name;
+	const name2: string = $form2.name;
+</script>
+
+<form method="POST">
+	<label for="name">Name ({name} {name2})</label>
+	<input type="text" name="name" bind:value={$form.name} />
+
+	<label for="email">E-mail</label>
+	<input type="email" name="email" bind:value={$form.email} />
+
+	<div><button>Submit</button></div>
+</form>

src/routes/(v2)/v2/schemasafe-types/schema.ts

@@ -0,0 +1,24 @@
+import type { JSONSchema } from 'sveltekit-superforms';
+
+// Define outside the load function so the adapter can be cached
+export const schema = {
+	type: 'object',
+	properties: {
+		name: { type: 'string', default: 'Hello world!' },
+		email: { type: 'string', format: 'email' }
+	},
+	required: ['email'],
+	additionalProperties: false,
+	$schema: 'http://json-schema.org/draft-07/schema#'
+} satisfies JSONSchema;
+
+export const constSchema = {
+	type: 'object',
+	properties: {
+		name: { type: 'string', default: 'Hello world!' },
+		email: { type: 'string', format: 'email' }
+	},
+	required: ['email'],
+	additionalProperties: false,
+	$schema: 'http://json-schema.org/draft-07/schema#'
+} as const satisfies JSONSchema;

src/tests/superValidate.test.ts

@@ -51,7 +51,7 @@ import { schemasafe } from '$lib/adapters/schemasafe.js';
 
 import { traversePath } from '$lib/traversal.js';
 import { splitPath } from '$lib/stringPath.js';
-import { SchemaError } from '$lib/index.js';
+import { SchemaError, type JSONSchema } from '$lib/index.js';
 
 ///// Test data /////////////////////////////////////////////////////
 
@@ -274,6 +274,39 @@ describe('Schemasafe', () => {
 	schemaTest(constAdapter, undefined, 'full', 'string');
 	schemaTest(adapter, undefined, 'full', 'string');
 	schemaTest(dynamicAdapter, undefined, 'full', 'string');
+
+	it('should work with type inference for superValidate with a request', async () => {
+		const schema = {
+			type: 'object',
+			properties: {
+				name: { type: 'string', default: 'Hello world!' },
+				email: { type: 'string', format: 'email' }
+			},
+			required: ['email'],
+			additionalProperties: false,
+			$schema: 'http://json-schema.org/draft-07/schema#'
+		} as const satisfies JSONSchema;
+
+		const formData = new FormData();
+		formData.set('name', 'Test');
+		formData.set('email', 'test');
+
+		const request = new Request('https://example.com', {
+			method: 'POST',
+			body: formData
+		});
+
+		//const data = await request.formData();
+		//console.log('🚀 ~ it ~ data:', data);
+
+		const adapter = schemasafe(schema);
+		const form = await superValidate(request, adapter);
+		console.log('🚀 ~ it ~ form:', form);
+		const email: string = form.data.email;
+
+		assert(!form.valid);
+		expect(email).toBe('test');
+	});
 });
 
 /////////////////////////////////////////////////////////////////////