Merge commit 'refs/pull/483/merge' of github.com:ciscoheat/sveltekit-superforms

Author: ciscoheat

package.json

@@ -102,13 +102,15 @@
 		"!dist/**/*.spec.*"
 	],
 	"peerDependencies": {
+		"@effect/schema": "^0.73.4",
 		"@exodus/schemasafe": "^1.3.0",
 		"@sinclair/typebox": ">=0.32.30 <1",
 		"@sveltejs/kit": "1.x || 2.x",
 		"@typeschema/class-validator": "^0.2.0",
 		"@vinejs/vine": "^1.8.0",
 		"arktype": ">=2.0.0-rc.8",
 		"class-validator": "^0.14.1",
+		"effect": "^3.8.2",
 		"joi": "^17.13.1",
 		"superstruct": "^2.0.2",
 		"svelte": "3.x || 4.x || >=5.0.0-next.51",
@@ -149,16 +151,24 @@
 		},
 		"@vinejs/vine": {
 			"optional": true
+		},
+		"effect": {
+			"optional": true
+		},
+		"@effect/schema": {
+			"optional": true
 		}
 	},
 	"optionalDependencies": {
+		"@effect/schema": "^0.73.4",
 		"@exodus/schemasafe": "^1.3.0",
 		"@gcornut/valibot-json-schema": "^0.31.0",
 		"@sinclair/typebox": "^0.32.35",
 		"@typeschema/class-validator": "^0.2.0",
 		"@vinejs/vine": "^1.8.0",
 		"arktype": "2.0.0-rc.8",
 		"class-validator": "^0.14.1",
+		"effect": "^3.8.2",
 		"joi": "^17.13.3",
 		"json-schema-to-ts": "^3.1.1",
 		"superstruct": "^2.0.2",

pnpm-lock.yaml

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

src/lib/adapters/adapters.ts

@@ -0,0 +1,70 @@
+import { Schema, JSONSchema, ArrayFormatter } from '@effect/schema';
+import { Either } from 'effect';
+import type { JSONSchema as TJSONSchema } from '../jsonSchema/index.js';
+import {
+	createAdapter,
+	type AdapterOptions,
+	type ClientValidationAdapter,
+	type Infer,
+	type InferIn,
+	type ValidationAdapter,
+	type ValidationResult
+} from './adapters.js';
+import type { ParseOptions } from '@effect/schema/AST';
+import { memoize } from '$lib/memoize.js';
+
+export const effectToJSONSchema = <A, I>(schema: Schema.Schema<A, I>) => {
+	// effect's json schema type is slightly different so we have to cast it
+	return JSONSchema.make(schema) as TJSONSchema;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnySchema = Schema.Schema<any, any>;
+
+async function validate<T extends AnySchema>(
+	schema: T,
+	data: unknown,
+	options?: AdapterOptions<Infer<T>> & { parseOptions?: ParseOptions }
+): Promise<ValidationResult<Infer<T>>> {
+	const result = Schema.decodeUnknownEither(schema, { errors: 'all' })(data, options?.parseOptions);
+	if (Either.isRight(result)) {
+		return {
+			data: result.right as Infer<T>,
+			success: true
+		};
+	}
+	return {
+		// get rid of the _tag property
+		issues: ArrayFormatter.formatErrorSync(result.left).map(({ message, path }) => ({
+			message,
+			path: [...path] // path is readonly array so we have to copy it
+		})),
+		success: false
+	} satisfies ValidationResult<Infer<T>>;
+}
+
+function _effect<T extends AnySchema>(
+	schema: T,
+	options?: AdapterOptions<Infer<T>> & { parseOptions?: ParseOptions }
+): ValidationAdapter<Infer<T>, InferIn<T>> {
+	// @ts-expect-error idk why this happens, it seems to happen in other adapters too
+	return createAdapter({
+		superFormValidationLibrary: 'effect',
+		validate: async (data) => validate(schema, data, options),
+		jsonSchema: options?.jsonSchema ?? effectToJSONSchema(schema),
+		defaults: options?.defaults
+	});
+}
+
+function _effectClient<T extends AnySchema>(
+	schema: T,
+	options?: AdapterOptions<Infer<T>> & { parseOptions?: ParseOptions }
+): ClientValidationAdapter<Infer<T>, InferIn<T>> {
+	return {
+		superFormValidationLibrary: 'effect',
+		validate: async (data) => validate(schema, data, options)
+	};
+}
+
+export const effect = /* @__PURE__ */ memoize(_effect);
+export const effectClient = /* @__PURE__ */ memoize(_effectClient);

src/lib/adapters/effect.ts

@@ -18,6 +18,7 @@ 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 { Schema as Schema$1 } from '@effect/schema/Schema';
 
 /*
 import type { SchemaObject } from 'ajv';
@@ -156,6 +157,15 @@ interface SuperstructResolver extends Resolver {
 	output: this['schema'] extends Struct<any, any> ? Infer$2<this['schema']> : never;
 }
 
+interface EffectResolver extends Resolver {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	base: Schema$1<any>;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	input: this['schema'] extends Schema$1<any> ? Schema$1.Encoded<this['schema']> : never;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	output: this['schema'] extends Schema$1<any> ? Schema$1.Type<this['schema']> : never;
+}
+
 /*
 interface AjvResolver extends Resolver {
 	base: SchemaObject;
@@ -165,12 +175,6 @@ interface DeepkitResolver extends Resolver {
   base: Type$1;
 }
 
-interface EffectResolver extends Resolver {
-  base: Schema$1<any>;
-  input: this['schema'] extends Schema$1<any> ? Schema$1.From<this['schema']> : never;
-  output: this['schema'] extends Schema$1<any> ? Schema$1.To<this['schema']> : never;
-}
-
 interface IoTsResolver extends Resolver {
   base: Any;
   input: this['schema'] extends Any ? OutputOf<this['schema']> : never;
@@ -203,10 +207,10 @@ type Registry = {
 	vine: VineResolver;
 	schemasafe: SchemasafeResolver<JSONSchema>;
 	superstruct: SuperstructResolver;
+	effect: EffectResolver;
 	/*
 		ajv: AjvResolver;
     deepkit: DeepkitResolver;
-    effect: EffectResolver;
     'io-ts': IoTsResolver;
     ow: OwResolver;
     runtypes: RuntypesResolver;

src/lib/adapters/typeSchema.ts

@@ -78,6 +78,9 @@ import {
 
 import { schemasafe } from '$lib/adapters/schemasafe.js';
 
+import { effect } from '$lib/adapters/effect.js';
+import { Schema } from '@effect/schema';
+
 import { traversePath } from '$lib/traversal.js';
 import { splitPath } from '$lib/stringPath.js';
 import { SchemaError, type JSONSchema } from '$lib/index.js';
@@ -864,6 +867,33 @@ describe('superstruct', () => {
 	schemaTest(adapter, undefined, 'simple');
 });
 
+describe('Effect', async () => {
+	// effect deliberately does not provide email parsing out of the box
+	// https://github.com/Effect-TS/schema/issues/294
+	// i just found this regex online, does the job
+	const emailRegex = /^[^@]+@[^@]+\.[^@]+$/;
+	const schema = Schema.Struct({
+		name: Schema.String.annotations({ default: 'Unknown' }),
+		email: Schema.String.pipe(
+			Schema.filter((s) => emailRegex.test(s) || 'must be a valid email', {
+				jsonSchema: {}
+			})
+		),
+		tags: Schema.Array(Schema.String.pipe(Schema.minLength(2))).pipe(Schema.minItems(3)),
+		score: Schema.Number.pipe(Schema.int(), Schema.greaterThanOrEqualTo(0)),
+		date: Schema.DateFromSelf.annotations({
+			jsonSchema: {
+				type: 'date'
+			}
+		}).pipe(Schema.optional),
+		nospace: Schema.String.pipe(Schema.pattern(nospacePattern), Schema.optional),
+		extra: Schema.String.pipe(Schema.NullOr).annotations({ default: null })
+	});
+
+	const adapter = effect(schema);
+	schemaTest(adapter);
+});
+
 ///// Common ////////////////////////////////////////////////////////
 
 describe('Schema In/Out transformations', () => {

src/tests/superValidate.test.ts

@@ -12,6 +12,7 @@
 		"sourceMap": true,
 		"strict": true,
 		"module": "NodeNext",
-		"moduleResolution": "NodeNext"
+		"moduleResolution": "NodeNext",
+		"exactOptionalPropertyTypes": true
 	}
 }