Superstruct tests passing.

Author: ciscoheat

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- New validation library: [Superstruct](https://docs.superstructjs.org/)!
+
 ### Fixed
 
 - Type inference for validation errors didn't include `_errors` for objects, only for arrays.

package.json

@@ -108,7 +108,7 @@
 		"@vinejs/vine": "^1.8.0",
 		"arktype": ">=2.0.0-dev.21",
 		"joi": "^17.13.1",
-		"superstruct": "^1.0.4",
+		"superstruct": "^2.0.2",
 		"svelte": "3.x || 4.x || >=5.0.0-next.51",
 		"valibot": ">=0.33.0 <1",
 		"yup": "^1.4.0",
@@ -152,7 +152,7 @@
 		"arktype": "2.0.0-dev.21",
 		"joi": "^17.13.3",
 		"json-schema-to-ts": "^3.1.0",
-		"superstruct": "^1.0.4",
+		"superstruct": "^2.0.2",
 		"valibot": "^0.35.0",
 		"yup": "^1.4.0",
 		"zod": "^3.23.8",

pnpm-lock.yaml

@@ -28,7 +28,8 @@ export type ValidationLibrary =
 	| 'yup'
 	| 'zod'
 	| 'vine'
-	| 'schemasafe';
+	| 'schemasafe'
+	| 'superstruct';
 
 export type AdapterOptions<T> = {
 	jsonSchema?: JSONSchema;

src/lib/adapters/adapters.ts

@@ -0,0 +1,63 @@
+import {
+	type ValidationAdapter,
+	createAdapter,
+	type ClientValidationAdapter,
+	createJsonSchema,
+	type RequiredDefaultsOptions,
+	type Infer,
+	type ValidationResult
+} from './adapters.js';
+import type { Struct } from 'superstruct';
+import { memoize } from '$lib/memoize.js';
+
+// async function modules() {
+// 	const { validate } = await import(/* webpackIgnore: true */ 'superstruct');
+// 	return { validate };
+// }
+
+// const fetchModule = /* @__PURE__ */ memoize(modules);
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function validate<T extends Struct<any, any>>(
+	schema: T,
+	data: unknown
+): Promise<ValidationResult<Infer<T>>> {
+	const result = schema.validate(data, { coerce: true });
+	if (!result[0]) {
+		return {
+			data: result[1] as Infer<T>,
+			success: true
+		};
+	}
+	const errors = result[0];
+	return {
+		success: false,
+		issues: errors.failures().map((error) => ({
+			message: error.message,
+			path: error.path
+		}))
+	};
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function _superstruct<T extends Struct<any, any>>(
+	schema: T,
+	options: RequiredDefaultsOptions<Infer<T>>
+): ValidationAdapter<Infer<T>> {
+	return createAdapter({
+		superFormValidationLibrary: 'superstruct',
+		defaults: options.defaults,
+		jsonSchema: createJsonSchema(options),
+		validate: async (data) => validate(schema, data)
+	});
+}
+
+function _superstructClient<T extends Struct>(schema: T): ClientValidationAdapter<Infer<T>> {
+	return {
+		superFormValidationLibrary: 'superstruct',
+		validate: async (data) => validate(schema, data)
+	};
+}
+
+export const superstruct = /* @__PURE__ */ memoize(_superstruct);
+export const superstructClient = /* @__PURE__ */ memoize(_superstructClient);

src/lib/adapters/superstruct.ts

@@ -11,6 +11,7 @@ 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 { FromSchema, JSONSchema } from 'json-schema-to-ts';
+import type { Struct, Infer as Infer$2 } from 'superstruct';
 
 /*
 import type { SchemaObject } from 'ajv';
@@ -19,7 +20,6 @@ import type { Schema as Schema$1 } from '@effect/schema/Schema';
 import type { Any, OutputOf, TypeOf } from 'io-ts';
 import type { Predicate, Infer as Infer$1 } from 'ow';
 import type { Runtype, Static } from 'runtypes';
-import type { Struct, Infer as Infer$2 } from 'superstruct';
 */
 
 type Replace<T, From, To> =
@@ -133,6 +133,15 @@ interface SchemasafeResolver<Schema extends JSONSchema, Data = FromSchema<Schema
 	output: this['schema'] extends Schema ? Data : never;
 }
 
+interface SuperstructResolver extends Resolver {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	base: Struct<any, any>;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	input: this['schema'] extends Struct<any, any> ? Infer$2<this['schema']> : never;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	output: this['schema'] extends Struct<any, any> ? Infer$2<this['schema']> : never;
+}
+
 /*
 interface AjvResolver extends Resolver {
 	base: SchemaObject;
@@ -166,10 +175,6 @@ interface RuntypesResolver extends Resolver {
     output: this['schema'] extends Runtype ? Static<this['schema']> : never;
 }
 
-interface SuperstructResolver extends Resolver {
-    base: Struct<any, any>;
-    output: this['schema'] extends Struct<any, any> ? Infer$2<this['schema']> : never;
-}
 */
 
 type Registry = {
@@ -182,14 +187,14 @@ type Registry = {
 	zod: ZodResolver;
 	vine: VineResolver;
 	schemasafe: SchemasafeResolver<JSONSchema>;
+	superstruct: SuperstructResolver;
 	/*
 		ajv: AjvResolver;
     deepkit: DeepkitResolver;
     effect: EffectResolver;
     'io-ts': IoTsResolver;
     ow: OwResolver;
     runtypes: RuntypesResolver;
-    superstruct: SuperstructResolver;
     */
 };
 

src/lib/adapters/typeSchema.ts

@@ -47,6 +47,21 @@ import {
 import { vine } from '$lib/adapters/vine.js';
 import Vine from '@vinejs/vine';
 
+import { superstruct } from '$lib/adapters/superstruct.js';
+import {
+	object as ssObject,
+	string as ssString,
+	number as ssNumber,
+	array as ssArray,
+	date as ssDate,
+	optional as ssOptional,
+	define as ssDefine,
+	size as ssSize,
+	min as ssMin,
+	pattern as ssPattern,
+	nullable as ssNullable
+} from 'superstruct';
+
 import { schemasafe } from '$lib/adapters/schemasafe.js';
 
 import { traversePath } from '$lib/traversal.js';
@@ -745,6 +760,24 @@ describe('vine', () => {
 	schemaTest(adapter, ['email', 'nospace', 'tags'], 'simple', 'stringToDate');
 });
 
+describe('superstruct', () => {
+	const email = () => ssDefine('email', (value) => String(value).includes('@'));
+
+	const schema = ssObject({
+		name: ssOptional(ssString()),
+		email: email(),
+		tags: ssSize(ssArray(ssSize(ssString(), 2, Infinity)), 3, Infinity),
+		score: ssMin(ssNumber(), 0),
+		date: ssOptional(ssDate()),
+		nospace: ssOptional(ssPattern(ssString(), nospacePattern)),
+		extra: ssNullable(ssString())
+	});
+
+	const adapter = superstruct(schema, { defaults });
+
+	schemaTest(adapter, undefined, 'simple');
+});
+
 ///// Common ////////////////////////////////////////////////////////
 
 describe('Schema In/Out transformations', () => {