@nerd-bible/valio 0.0.1

package/src/containers.ts

@@ -0,0 +1,271 @@
+import type { Input, Output, Result } from "./pipe";
+import { type Context, HalfPipe, Pipe } from "./pipe";
+import * as p from "./primitives";
+
+class ValioArray<T> extends p.Arrayish<any[], T[]> {
+	constructor(public element: Pipe<any, T>) {
+		super(
+			new HalfPipe(
+				"array",
+				(v: any): v is any[] => Array.isArray(v),
+				(input: any[], ctx: Context): Result<T[]> => {
+					const output = new Array<T>(input.length);
+					let success = true;
+
+					const length = ctx.jsonPath.length;
+					for (let i = 0; i < input.length; i++) {
+						ctx.jsonPath[length] = i.toString();
+						const decoded = element.decode(input[i], ctx);
+						if (decoded.success) output[i] = decoded.output;
+						else success = false;
+					}
+					ctx.jsonPath.length = length;
+
+					if (!success) return { success, errors: ctx.errors };
+					return { success, output };
+				},
+			),
+			new HalfPipe(`array<${element.o.name}>`, (v: any): v is T[] => {
+				if (!Array.isArray(v)) return false;
+				for (const e of v) if (!element.o.typeCheck(e)) return false;
+				return true;
+			}),
+		);
+	}
+}
+export function array<T>(element: Pipe<any, T>): ValioArray<T> {
+	return new ValioArray(element);
+}
+
+class ValioRecord<K extends PropertyKey, V> extends Pipe<
+	Record<any, any>,
+	Record<K, V>
+> {
+	constructor(
+		public keyPipe: Pipe<any, K>,
+		public valPipe: Pipe<any, V>,
+	) {
+		super(
+			new HalfPipe(
+				"object",
+				(v): v is Record<any, any> =>
+					Object.prototype.toString.call(v) == "[object Object]",
+				(input: Record<any, any>, ctx: Context): Result<Record<K, V>> => {
+					const output = {} as Record<K, V>;
+
+					let success = true;
+					const length = ctx.jsonPath.length;
+					for (const key in input) {
+						ctx.jsonPath[length] = key;
+						const decodedKey = keyPipe.decode(key, ctx);
+						if (decodedKey.success) {
+							const decodedVal = valPipe.decode((input as any)[key], ctx);
+							if (decodedVal.success) {
+								output[decodedKey.output] = decodedVal.output;
+							} else {
+								success = false;
+							}
+						} else {
+							success = false;
+						}
+					}
+					ctx.jsonPath.length = length;
+
+					if (!success) return { success, errors: ctx.errors };
+					return { success, output };
+				},
+			),
+			new HalfPipe(
+				`record<${keyPipe.o.name},${valPipe.o.name}>`,
+				(v): v is Record<K, V> => {
+					if (Object.prototype.toString.call(v) != "[object Object]")
+						return false;
+					for (const k in v) {
+						// Keys will always be strings.
+						// if (!keyPipe.o.typeCheck(k)) return false;
+						if (!valPipe.o.typeCheck(v[k])) return false;
+					}
+					return true;
+				},
+			),
+		);
+	}
+}
+export function record<K extends PropertyKey, V>(
+	keyPipe: Pipe<any, K>,
+	valPipe: Pipe<any, V>,
+): ValioRecord<K, V> {
+	return new ValioRecord(keyPipe, valPipe);
+}
+
+class Union<T extends Readonly<Pipe[]>> extends Pipe<
+	Output<T[number]>,
+	Output<T[number]>
+> {
+	constructor(public options: T) {
+		const name = options.map((o) => o.o.name).join("|");
+		type O = Output<T[number]>;
+		super(
+			new HalfPipe(
+				name,
+				(v: any): v is O => {
+					for (const f of options) if (f.i.typeCheck(v)) return true;
+					return false;
+				},
+				(data: O, ctx: Context): Result<O> => {
+					const newCtx = ctx.clone();
+					for (const s in options) {
+						const decoded = options[s]!.decode(data, newCtx);
+						if (decoded.success) return decoded;
+					}
+
+					Object.assign(ctx.errors, newCtx.errors);
+					return { success: false, errors: ctx.errors };
+				},
+			),
+			new HalfPipe(name, (v: any): v is O => {
+				for (const f of options) if (f.o.typeCheck(v)) return true;
+				return false;
+			}),
+		);
+	}
+}
+export function union<T extends Readonly<Pipe[]>>(options: T): Union<T> {
+	return new Union(options);
+}
+
+type ObjectOutput<Shape extends Record<string, Pipe<any, any>>> = {
+	[K in keyof Shape]: Output<Shape[K]>;
+};
+type Mask<Keys extends PropertyKey> = { [K in Keys]?: true };
+type Identity<T> = T;
+type Flatten<T> = Identity<{ [k in keyof T]: T[k] }>;
+type Extend<A extends Record<any, any>, B extends Record<any, any>> = Flatten<
+	// fast path when there is no keys overlap
+	keyof A & keyof B extends never
+		? A & B
+		: {
+				[K in keyof A as K extends keyof B ? never : K]: A[K];
+			} & {
+				[K in keyof B]: B[K];
+			}
+>;
+
+class ValioObject<Shape extends Record<any, Pipe<any, any>>> extends Pipe<
+	Record<any, any>,
+	ObjectOutput<Shape>
+> {
+	constructor(
+		public shape: Shape,
+		public isLoose: boolean,
+	) {
+		super(
+			new HalfPipe(
+				"object",
+				(v): v is Record<any, any> =>
+					Object.prototype.toString.call(v) == "[object Object]",
+				(data, ctx) => this.transformInput(data, ctx),
+			),
+			new HalfPipe(
+				`{${Object.entries(shape)
+					.map(([k, v]) => `${k}: ${v.o.name}`)
+					.join(",")}}`,
+				(v) => this.typeCheckOutput(v),
+			),
+		);
+	}
+
+	clone(): this {
+		return new ValioObject(this.shape, this.isLoose) as any;
+	}
+
+	protected transformInput(
+		data: object,
+		ctx: Context,
+	): Result<ObjectOutput<Shape>> {
+		const output: Record<PropertyKey, any> = this.isLoose ? data : {};
+		let success = true;
+
+		const length = ctx.jsonPath.length;
+		// Always expect the shape since that's what typescript does.
+		for (const p in this.shape) {
+			ctx.jsonPath[length] = p;
+			const decoded = this.shape[p]!.decode((data as any)[p], ctx);
+			if (decoded.success) output[p] = decoded.output;
+			else {
+				success = false;
+				delete output[p];
+			}
+		}
+		ctx.jsonPath.length = length;
+
+		if (!success) return { success, errors: ctx.errors };
+		return { success, output: output as ObjectOutput<Shape> };
+	}
+
+	protected typeCheckOutput(v: any): v is ObjectOutput<Shape> {
+		if (Object.prototype.toString.call(v) != "[object Object]") return false;
+		for (const s in this.shape)
+			if (!this.shape[s]!.o.typeCheck(v[s])) return false;
+		return true;
+	}
+
+	pick<M extends Mask<keyof Shape>>(
+		mask: M,
+	): ValioObject<Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>> {
+		const next = this.clone();
+		for (const k in next.shape) {
+			if (!mask[k]) delete next.shape[k];
+		}
+		return next as any;
+	}
+
+	omit<M extends Mask<keyof Shape>>(
+		mask: M,
+	): ValioObject<Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>> {
+		const next = this.clone();
+		for (const k in next.shape) {
+			if (mask[k]) delete next.shape[k];
+		}
+		return next as any;
+	}
+
+	partial<M extends Mask<keyof Shape>>(
+		mask: M,
+	): ValioObject<{
+		[k in keyof Shape]: k extends keyof M
+			? Pipe<Input<Shape[k]>, Output<Shape[k]> | undefined>
+			: Shape[k];
+	}> {
+		const next = this.clone();
+		for (const k in next.shape) {
+			if (mask[k]) {
+				// @ts-expect-error
+				next.shape[k] = union([next.shape[k], p.undefined()]);
+			}
+		}
+		return next as any;
+	}
+
+	extend<T extends Record<any, Pipe<any, any>>>(
+		shape: T,
+	): ValioObject<Extend<Shape, T>> {
+		const next = this.clone();
+		Object.assign(next.shape, shape);
+		return next as any;
+	}
+
+	loose<T = any>(
+		isLoose = true,
+	): ValioObject<Shape & { [k: string]: Pipe<T, T> }> {
+		const next = this.clone();
+		next.isLoose = isLoose;
+		return next as any;
+	}
+}
+export function object<Shape extends Record<any, Pipe<any, any>>>(
+	shape: Shape,
+	loose = false,
+): ValioObject<Shape> {
+	return new ValioObject(shape, loose);
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * as codecs from "./codecs";
+export * from "./containers";
+export * from "./pipe";
+export * from "./primitives";

package/src/locales/en.ts

@@ -0,0 +1,23 @@
+const templates: Record<string, string> = {
+	gt: "must be > {$n}",
+	lt: "must be < {$n}",
+	gte: "must be >= {$n}",
+	lte: "must be <= {$n}",
+	eq: "must be {$n}",
+	minLength: "must have length <= {$n}",
+	maxLength: "must have length >= {$n}",
+	regex: "must match {$regex}",
+	type: "not type {$expected}",
+	coerce: "could not coerce to {$expected}",
+};
+
+function fmt(template: string, props: Record<any, any>) {
+	// You could use something like
+	// [MessageFormat](https://messageformat.unicode.org/) here.
+	return template.replace(/{\$(.*?)}/g, (_, g) => props[g]);
+}
+
+export default function format(name: string, props: Record<any, any>): string {
+	const template = templates[name];
+	return template ? fmt(template, props) : `TODO: add template for ${name}`;
+}

package/src/pipe.ts

@@ -0,0 +1,172 @@
+import enFormat from "./locales/en";
+
+export type Error = { input: any; message: string };
+export type Errors = { [inputPath: string]: Error[] };
+export type Result<T> =
+	| { success: true; output: T }
+	| { success: false; errors: any };
+
+function clone<T>(obj: T): T {
+	return Object.create(
+		Object.getPrototypeOf(obj),
+		Object.getOwnPropertyDescriptors(obj),
+	);
+}
+
+interface Check<T> {
+	valid(data: T, ctx: Context): boolean;
+	name: string;
+	props: Record<any, any>;
+}
+
+export class HalfPipe<I, O = never> {
+	constructor(
+		/** The type name */
+		public name: string,
+		/** The first check to run */
+		public typeCheck: (v: any) => v is I,
+		/** Optional transform for pipe to run at end. Useful for containers */
+		public transform?: (v: I, ctx: Context) => Result<O>,
+	) {}
+	/** The second checks to run */
+	checks: Check<I>[] = [];
+
+	clone(): this {
+		const res = clone(this);
+		res.checks = res.checks.slice();
+		return res;
+	}
+}
+
+/** During encoding, decoding, or validation. */
+export class Context {
+	jsonPath: (string | number)[] = [];
+	errors: Errors = {};
+
+	errorFmt(name: string, props: Record<any, any>): any {
+		return enFormat(name, props);
+	}
+
+	clone(): Context {
+		const res = clone(this);
+		res.jsonPath = res.jsonPath.slice();
+		res.errors = { ...res.errors };
+		return res;
+	}
+
+	pushError(error: Error) {
+		const key = `.${this.jsonPath.join(".")}`;
+		this.errors[key] ??= [];
+		this.errors[key].push(error);
+	}
+
+	pushErrorFmt(name: string, input: any, props: Record<any, any>) {
+		const message = this.errorFmt(name, props);
+		this.pushError({ input, message });
+	}
+
+	run<I, O>(input: any, halfPipe: HalfPipe<I, O>): Result<I> {
+		if (!halfPipe.typeCheck(input)) {
+			this.pushErrorFmt("type", input, { expected: halfPipe.name });
+			return { success: false, errors: this.errors };
+		}
+		let success = true;
+		for (const c of halfPipe.checks ?? []) {
+			if (!c.valid(input, this)) {
+				this.pushErrorFmt(c.name, input, c.props);
+				success = false;
+			}
+		}
+		if (!success) return { success, errors: this.errors };
+		return { success, output: input };
+	}
+}
+
+export class Pipe<I = any, O = any> {
+	constructor(
+		public i: HalfPipe<I, O>,
+		public o: HalfPipe<O, I>,
+	) {}
+
+	pipes: Pipe<any, any>[] = [];
+	registry: Record<PropertyKey, any> = {};
+
+	clone(): this {
+		const res = clone(this);
+		res.i = res.i.clone();
+		res.o = res.o.clone();
+		res.pipes = res.pipes.slice();
+		res.registry = { ...res.registry };
+		return res;
+	}
+
+	refine(
+		valid: (data: O, ctx: Context) => boolean,
+		name: string,
+		props: Record<any, any>,
+	): this {
+		const res = this.clone();
+		res.o.checks.push({ valid, name, props });
+		return res;
+	}
+
+	pipe<I2 extends O, O2>(pipe: Pipe<I2, O2>): Pipe<I, O2> {
+		const res: Pipe<any, any> = this.clone();
+		res.pipes.push(pipe);
+		return res;
+	}
+
+	decodeAny(input: any, ctx = new Context()): Result<O> {
+		// 1. Verify input
+		let res: Result<any> = ctx.run(input, this.i);
+		if (!res.success) return res;
+		// 2. Transform input to output
+		if (this.i.transform) {
+			res = this.i.transform(res.output, ctx);
+			if (!res.success) return res;
+		}
+		// 3. Verify output
+		res = ctx.run(res.output, this.o);
+		if (!res.success) return res;
+		// 4. Next
+		for (const p of this.pipes) {
+			res = p.decode(res.output, ctx);
+			if (!res.success) return res;
+		}
+		return res;
+	}
+	decode(input: I, ctx = new Context()): Result<O> {
+		return this.decodeAny(input, ctx);
+	}
+
+	encodeAny(output: any, ctx = new Context()): Result<I> {
+		// 1. Next
+		let res: Result<any> = { success: true, output };
+		for (let i = this.pipes.length - 1; i >= 0; i--) {
+			res = this.pipes[i]!.encodeAny(res.output, ctx);
+			if (!res.success) return res;
+		}
+		// 2. Verify output
+		res = ctx.run(res.output, this.o);
+		if (!res.success) return res;
+		// 3. Transform output to input
+		if (this.o.transform) {
+			res = this.o.transform(res.output, ctx);
+			if (!res.success) return res;
+		}
+		// 4. Verify input
+		return ctx.run(res.output, this.i);
+	}
+	encode(output: O, ctx = new Context()): Result<I> {
+		return this.encodeAny(output, ctx);
+	}
+
+	register(key: PropertyKey, value: any): this {
+		const res = this.clone();
+		res.registry[key] = value;
+		return res;
+	}
+}
+
+export type Input<T extends Pipe> = Parameters<T["decode"]>[0];
+export type Output<T extends Pipe> = Parameters<T["encode"]>[0];

package/src/primitives.test.ts

@@ -0,0 +1,82 @@
+import { expect, test } from "bun:test";
+import * as v from "./index";
+
+test("number", () => {
+	const schema = v.number();
+
+	expect(schema.decode(5)).toEqual({ success: true, output: 5 });
+	expect(schema.decodeAny("5")).toEqual({
+		success: false,
+		errors: { ".": [{ input: "5", message: "not type number" }] },
+	});
+});
+
+test("custom validator", () => {
+	const schema = v.number().refine((n) => n == 5, "eq", { n: 5 });
+
+	expect(schema.decode(5)).toEqual({ success: true, output: 5 });
+	expect(schema.encode(3)).toEqual({
+		success: false,
+		errors: { ".": [{ input: 3, message: "must be 5" }] },
+	});
+});
+
+test("custom context", () => {
+	const schema = v.number().refine((n) => n == 5, "eq", { n: 5 });
+	class MyContext extends v.Context {
+		errorFmt() {
+			return "You done messed up";
+		}
+	}
+
+	expect(schema.decode(3, new MyContext())).toEqual({
+		success: false,
+		errors: { ".": [{ input: 3, message: "You done messed up" }] },
+	});
+});
+
+test("double min", () => {
+	const schema = v.number().gt(5).gt(2);
+
+	expect(schema.decode(3)).toEqual({
+		success: false,
+		errors: {
+			".": [{ input: 3, message: "must be > 5" }],
+		},
+	});
+	expect(schema.decode(1)).toEqual({
+		success: false,
+		errors: {
+			".": [
+				{ input: 1, message: "must be > 5" },
+				{ input: 1, message: "must be > 2" },
+			],
+		},
+	});
+	expect(schema.decode(10)).toEqual({
+		success: true,
+		output: 10,
+	});
+	expect(schema.decodeAny("3")).toEqual({
+		success: false,
+		errors: {
+			".": [
+				{
+					input: "3",
+					message: "not type number",
+				},
+			],
+		},
+	});
+});
+
+test("pipe", () => {
+	const schema = v.string().pipe(v.number() as v.Pipe<any, number>);
+
+	expect(schema.decode("42")).toEqual({
+		success: false,
+		errors: {
+			".": [{ input: "42", message: "not type number" }],
+		},
+	});
+});

package/src/primitives.ts

@@ -0,0 +1,111 @@
+import { HalfPipe, Pipe } from "./pipe";
+
+function primitive<T>(name: string, typeCheck: (v: T) => v is T) {
+	const half = new HalfPipe(name, typeCheck);
+	return new Pipe(half, half);
+}
+
+export function boolean() {
+	return primitive<boolean>(
+		"boolean",
+		(v): v is boolean => typeof v == "boolean",
+	);
+}
+
+// biome-ignore lint/suspicious/noShadowRestrictedNames: point of lib
+export function undefined() {
+	return primitive<undefined>(
+		"undefined",
+		(v): v is undefined => typeof v == "undefined",
+	);
+}
+
+export function any() {
+	return primitive<any>("any", (v): v is any => true);
+}
+
+function null_() {
+	return primitive<null>("null", (v): v is null => v === null);
+}
+export { null_ as null };
+
+export class Comparable<I, O> extends Pipe<I, O> {
+	gt(n: O) {
+		return this.refine((v) => v > n, "gt", { n });
+	}
+	gte(n: O) {
+		return this.refine((v) => v >= n, "gte", { n });
+	}
+	lt(n: O) {
+		return this.refine((v) => v < n, "lt", { n });
+	}
+	lte(n: O) {
+		return this.refine((v) => v <= n, "lte", { n });
+	}
+	eq(n: O) {
+		return this.refine((v) => v == n, "eq", { n });
+	}
+}
+
+class ValioNumber extends Comparable<number, number> {
+	constructor() {
+		const half = new HalfPipe("number", (v) => typeof v == "number");
+		super(half, half);
+	}
+}
+export function number() {
+	return new ValioNumber();
+}
+
+export class Arrayish<
+	I,
+	O extends {
+		length: number;
+	},
+> extends Pipe<I, O> {
+	minLength(n: number) {
+		return this.refine((v) => v.length >= n, "minLength", { n });
+	}
+	maxLength(n: number) {
+		return this.refine((v) => v.length <= n, "maxLength", { n });
+	}
+}
+
+class ValioString extends Pipe<string, string> {
+	constructor() {
+		const half = new HalfPipe("string", (v) => typeof v == "string");
+		super(half, half);
+	}
+
+	regex(re: RegExp) {
+		return this.refine((v) => !!v.match(re), "regex", { regex: re.source });
+	}
+}
+export function string(): ValioString {
+	return new ValioString();
+}
+
+export type Lit = string | number | bigint | boolean | null | undefined;
+
+class ValioLiteral<T extends Lit> extends Pipe<T, T> {
+	constructor(public literal: T) {
+		const half = new HalfPipe(`${literal}`, (v): v is T => v == literal);
+		super(half, half);
+	}
+}
+export function literal<T extends Lit>(literal: T) {
+	return new ValioLiteral(literal);
+}
+
+class ValioEnum<T extends Lit> extends Pipe<T, T> {
+	constructor(public literals: T[]) {
+		const half = new HalfPipe(`${literals.join(",")}`, (v: any): v is T =>
+			literals.includes(v),
+		);
+		super(half, half);
+	}
+}
+function enum_<T extends Lit>(literals: T[]): ValioEnum<T> {
+	return new ValioEnum(literals);
+}
+export { enum_ as enum };