Feature: Add VineJS Adapter (#342)

Author: matfire

package.json

@@ -101,7 +101,8 @@
 		"svelte": "3.x || 4.x || >=5.0.0-next.51",
 		"valibot": "^0.28.1",
 		"yup": "^1.3.3",
-		"zod": "^3.22.4"
+		"zod": "^3.22.4",
+		"@vinejs/vine": "^1.7.1"
 	},
 	"peerDependenciesMeta": {
 		"@sinclair/typebox": {
@@ -124,6 +125,9 @@
 		},
 		"zod": {
 			"optional": true
+		},
+		"@vinejs/vine": {
+			"optional": true
 		}
 	},
 	"optionalDependencies": {
@@ -136,6 +140,7 @@
 		"valibot": "^0.28.1",
 		"yup": "^1.3.3",
 		"zod": "^3.22.4",
+		"@vinejs/vine": "^1.7.1",
 		"zod-to-json-schema": "^3.22.4"
 	},
 	"dependencies": {

pnpm-lock.yaml

@@ -26,7 +26,8 @@ export type ValidationLibrary =
 	| 'typebox'
 	| 'valibot'
 	| 'yup'
-	| 'zod';
+	| 'zod'
+	| 'vine';
 
 export type AdapterOptions<T extends Schema> = {
 	jsonSchema?: JSONSchema;

src/lib/adapters/adapters.ts

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

src/lib/adapters/index.ts

@@ -4,6 +4,8 @@ import type { AnySchema } from 'joi';
 import type { BaseSchema, BaseSchemaAsync, Input, Output } from 'valibot';
 import type { Schema as Schema$2, InferType } from 'yup';
 import type { ZodSchema, input, output } from 'zod';
+import type { SchemaTypes, Infer as VineInfer } from '@vinejs/vine/types';
+
 /*
 import type { SchemaObject } from 'ajv';
 import type { Type as Type$1 } from '@deepkit/type';
@@ -14,6 +16,13 @@ import type { Runtype, Static } from 'runtypes';
 import type { Struct, Infer as Infer$2 } from 'superstruct';
 */
 
+type Replace<T, From, To> =
+	NonNullable<T> extends From
+		? To | Exclude<T, From>
+		: NonNullable<T> extends object
+			? { [K in keyof T]: Replace<T[K], From, To> }
+			: T;
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type IfDefined<T> = any extends T ? never : T;
 type UnknownIfNever<T> = [T] extends [never] ? unknown : T;
@@ -101,6 +110,14 @@ interface ZodResolver extends Resolver {
 	output: this['schema'] extends ZodSchema ? output<this['schema']> : never;
 }
 
+interface VineResolver extends Resolver {
+	base: SchemaTypes;
+	input: this['schema'] extends SchemaTypes
+		? Replace<VineInfer<this['schema']>, Date, string>
+		: never;
+	output: this['schema'] extends SchemaTypes ? VineInfer<this['schema']> : never;
+}
+
 /*
 interface AjvResolver extends Resolver {
 	base: SchemaObject;
@@ -148,6 +165,7 @@ type Registry = {
 	valibot: ValibotResolver;
 	yup: YupResolver;
 	zod: ZodResolver;
+	vine: VineResolver;
 	/*
 		ajv: AjvResolver;
     deepkit: DeepkitResolver;

src/lib/adapters/typeSchema.ts

@@ -0,0 +1,69 @@
+import {
+	createAdapter,
+	createJsonSchema,
+	type ValidationAdapter,
+	type ValidationResult,
+	type ClientValidationAdapter,
+	type RequiredDefaultsOptions,
+	type Infer,
+	type InferIn
+} from './adapters.js';
+import { memoize } from '$lib/memoize.js';
+import type { SchemaTypes } from '@vinejs/vine/types';
+
+async function modules() {
+	const { Vine, errors } = await import(/* webpackIgnore: true */ '@vinejs/vine');
+	return { Vine, errors };
+}
+
+const fetchModule = /* @__PURE__ */ memoize(modules);
+
+async function validate<T extends SchemaTypes>(
+	schema: T,
+	data: unknown
+): Promise<ValidationResult<Infer<T>>> {
+	const { Vine, errors } = await fetchModule();
+	try {
+		const output = await new Vine().validate({ schema, data });
+		return {
+			success: true,
+			data: output as Infer<T>
+		};
+	} catch (e) {
+		if (e instanceof errors.E_VALIDATION_ERROR) {
+			return {
+				success: false,
+				issues: e.messages.map((m: { field: string; message: string }) => ({
+					path: m.field.split('.'),
+					message: m.message
+				}))
+			};
+		} else {
+			return { success: false, issues: [] };
+		}
+	}
+}
+
+function _vine<T extends SchemaTypes>(
+	schema: T,
+	options: RequiredDefaultsOptions<T>
+): ValidationAdapter<Infer<T>, InferIn<T>> {
+	return createAdapter({
+		superFormValidationLibrary: 'vine',
+		validate: async (data: unknown) => validate(schema, data),
+		jsonSchema: createJsonSchema(options),
+		defaults: options.defaults
+	});
+}
+
+function _vineClient<T extends SchemaTypes>(
+	schema: T
+): ClientValidationAdapter<Infer<T>, InferIn<T>> {
+	return {
+		superFormValidationLibrary: 'vine',
+		validate: async (data) => validate(schema, data)
+	};
+}
+
+export const vine = /* @__PURE__ */ memoize(_vine);
+export const vineClient = /* @__PURE__ */ memoize(_vineClient);

src/lib/adapters/vine.ts

@@ -43,6 +43,8 @@ import {
 	array as yupArray,
 	date as yupDate
 } from 'yup';
+import { vine } from '$lib/adapters/vine.js';
+import Vine from '@vinejs/vine';
 import { traversePath } from '$lib/traversal.js';
 import { splitPath } from '$lib/stringPath.js';
 
@@ -399,6 +401,31 @@ describe('Zod', () => {
 	schemaTest(zod(schema));
 });
 
+/////////////////////////////////////////////////////////////////////
+
+describe('vine', () => {
+	const schema = Vine.object({
+		name: Vine.string().optional(),
+		email: Vine.string().email(),
+		tags: Vine.array(Vine.string().minLength(2)).minLength(3),
+		score: Vine.number().min(0),
+		date: Vine.date().optional(),
+		nospace: Vine.string().regex(nospacePattern).optional()
+	});
+
+	const adapter = vine(schema, { defaults });
+
+	it('should accept string as input for inferred Date fields', async () => {
+		const date = '2024-02-14';
+		const form = await superValidate({ ...validData, date }, adapter);
+
+		const realDate: Date | undefined = form.data.date;
+		expect(realDate).toEqual(new Date(date + 'T00:00:00'));
+	});
+
+	schemaTest(adapter, ['email', 'nospace', 'tags'], 'simple', true);
+});
+
 ///// Common ////////////////////////////////////////////////////////
 
 describe('Schema In/Out transformations', () => {
@@ -460,11 +487,14 @@ type ErrorFields = ('email' | 'date' | 'nospace' | 'tags' | 'tags[1]')[];
 function schemaTest(
 	adapter: ValidationAdapter<Record<string, unknown>, Record<string, unknown>>,
 	errors: ErrorFields = ['email', 'nospace', 'tags', 'tags[1]'],
-	adapterType: 'full' | 'simple' = 'full'
+	adapterType: 'full' | 'simple' = 'full',
+	dateAsString: boolean = false
 ) {
+	const validD = { ...validData, date: dateAsString ? '2024-01-01' : validData.date };
+
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	function expectErrors(errors: ErrorFields, errorMessages: Record<string, any>) {
-		//console.log('🚀 ~ expectErrors ~ errorMessages:', errorMessages);
+		// console.log('🚀 ~ expectErrors ~ errorMessages:', errorMessages);
 
 		if (errors.includes('nospace')) expect(errorMessages.nospace).toBeTruthy();
 		if (errors.includes('email')) expect(errorMessages.email).toBeTruthy();
@@ -530,11 +560,14 @@ function schemaTest(
 	});
 
 	it('with valid test data', async () => {
-		const output = await superValidate(validData, adapter);
+		const output = await superValidate(validD, adapter);
 		expect(output.errors).toEqual({});
 		expect(output.valid).toEqual(true);
-		expect(output.data).not.toBe(validData);
-		expect(output.data).toEqual(validData);
+		expect(output.data).not.toBe(validD);
+		expect(output.data).toEqual({
+			...validD,
+			date: dateAsString ? new Date(validD.date + 'T00:00:00') : validD.date
+		});
 		expect(output.message).toBeUndefined();
 		expectConstraints(output.constraints);
 	});