@mappedin/typebox-fast-transform

A replacement for Value.Decode / Value.Encode that improves performance by avoiding traversing a value if the associated schema doesn't contain a transform within it.

Usage

For runtime validation (previously using Value.*):

import { Value } from '@sinclair/typebox/value';
import { FastDecode } from '@mappedin/typebox-fast-transform/decode';
import { FastEncode } from '@mappedin/typebox-fast-transform/encode';

// old:
const decoded = Value.Decode(schema, references, value);
const encoded = Value.Encode(schema, references, decoded);

// new:
const decoded = FastDecode(schema, references, value);
const encoded = FastEncode(schema, references, decoded);

If you are already making use of TypeCompiler, you likely do not want to use FastDecode/FastEncode directly, as it relies on using Value.Check to validate your data before it attempts to decode it. Instead, you should do the check yourself with your compiled version of the schema, and then use FastTransformDecode/FastTransformEncode directly:

import { TypeCompiler } from '@sinclair/typebox/compiler';
import { FastTransformDecode } from '@mappedin/typebox-fast-transform/fast-decode';
import { FastTransformEncode } from '@mappedin/typebox-fast-transform/fast-encode';

const compiled = TypeCompiler.Compile(/* ... */);

// old:
const decoded = TypeCompiler.Decode(value);
const encoded = TypeCompiler.Encode(value);

// new:
const Decode = (value: unknown): StaticDecode<Schema> => {
	if (!compiled.Check(value)) {
		/* ... */
	}
	return FastTransformDecode(value);
}
const decoded = Decode(value);

const Encode = (value: unknown): StaticDecode<Schema> => {
	const enc = FastTransformEncode(value);
	if (!compiled.Check(enc)) {
		/* ... */
	}
	return enc;
}
const encoded = Encode(decoded);

Tests

The test suite here in src/tests/ is ported directly from the v0.33.22 tag of the @sinclair/typebox repo, and checks FastDecode/FastEncode against their respective reference implementations to make sure there are no differences in behaviour.