mizchi / lizod

lightweight zod-like validator

lizod

Lightweight zod-like validator (about 600bytes with full features)

$ npm install lizod -S

typescript >=5 required.

Concepts

• Spiritual successor of zod but for bundle size.
  • No method-chaining
  • No string utils like .email()
  • Very simple error reporter
• Bare TypeScript's type expression helpers

How to use

// Pick validators for treeshake
import {
  $any,
  $array,
  $boolean,
  $const,
  $enum,
  $intersection,
  $null,
  $number,
  $object,
  $opt,
  $regexp,
  $string,
  $symbol,
  $undefined,
  $union,
  $void,
  $record,
  type Infer,
  type Validator,
} from "lizod";

const validate = $object({
  name: $string,
  age: $number,
  familyName: $opt($string),
  abc: $enum(["a", "b", "c"]),
  nested: $object({
    age: $number,
  }),
  static: $const("static"),
  items: $array($object({
    a: $string,
    b: $boolean,
  })),
  complex: $array($union([
    $object({ a: $string }),
    $object({ b: $number }),
  ])),
  sec: $intersection([$string, $const("x")]),
  record: $record($string, $number)
});

const v: Infer<typeof validate> = {
  name: "aaa",
  age: 1,
  familyName: null,
  abc: "b",
  nested: {
    age: 1,
  },
  static: "static",
  items: [
    {
      a: "",
      b: true,
    },
    {
      a: "",
      b: false,
    },
  ],
  complex: [
    { a: "" },
    { b: 1 },
  ],
  sec: "x",
  record: {
    "a": 1,
    "b": 2
  }
};

if (validate(v)) {
  const _1: string = v.name;
  const _2: number = v.age;
  const _3: string | void = v.familyName;
  const _4: "a" | "b" | "c" = v.abc;
  const _5: { age: number } = v.nested;
  const _6: "static" = v.static;
  const _7: Array<{
    a: string;
    b: boolean;
  }> = v.items;
}

exact | loose object

Allow unchecked params on object

import {$object, $string} from "lizod";

// default exact
const ret1 = $object({a: $string}, /* default */ true)({a: "", b: ""}); // => false
// loose
const ret2 = $object({a: $string}, false)({a: "", b: ""}) // => true;

default mode is exact.

Error Reporter

import { $object, $string, access } from "lizod";

// your validator
const validate = $object({ a: $string });

const input = { a: 1 };

// check with context mutation
const ctx = { errors: [] };
const ret = validate(input, ctx);

// report errors
for (const errorPath of ctx.errors) {
  console.log("error at", errorPath, access(input, errorPath));
}

Do not reuse ctx.

With custom validator

import type { Validator, ValidatorContext } from "lizod";

// simple validator
const isA: Validator<"A"> = (input: any): input is "A" => input === "A";
const myValidator = $object({
  a: isA,
});

// create wrapper validator
// you should pass context args to next validator for error reporter
const wrap: (child: Validator<string>) => Validator<string> =
  (input: any, ctx: ValidatorContext, path = []): input is string => child(input, ctx, path);

Relations

• https://github.com/colinhacks/zod

ChangeLog

v0.2.6

• added: $record
• added: $numberString

v0.2.5

• fix: $intersection return type #13

LICENSE

MIT

lizod's Issues

ValidatorContext is not exported

This example https://github.com/mizchi/lizod?tab=readme-ov-file#with-custom-validator does not work due to the following error:

Module '"lizod"' declares 'ValidatorContext' locally, but it is not exported.

Need a export here:

lizod/src/index.ts

Lines 4 to 6 in f0279fd

	type ValidatorContext = {
	errors: Array<AccessPath>;
	};

Missing transform, default function and some basic validate like string().url(), string().email()...

Hi Mizchi, could you share the way to use z.string().transfrom().optional().default() ? Thank you <3.

type of intersection of loose objects is invalid

Problem

I used $intersection to define the types baseType & (typeA | typeB), but type inference does not work.

const baseType = $object({ common: $string }, false);
const typeA = $object({
    type: $const("a"),
    data: $number,
  }, false),
  typeB = $object({
    type: $const("b"),
    data: $string,
  }, false);

const validate = $intersection([$union([typeA, typeB]), baseType]); // expect: (typeA | typeB) & baseType
const x: Infer<typeof validate> = { type: "a", data: 42, common: "" }; // type error (because Infer<typeof validate> is {common: string})

validate itself is working as intended.

console.log(validate({ type: "a", data: 42, common: "" }) === true);
console.log(validate({ type: "b", data: "str", common: "" }) === true);

console.log(validate({ type: "a", data: 42 }) === false);
console.log(validate({ type: "a", data: "str", common: "" }) === false);
console.log(validate({ type: "b", data: 42, common: "" }) === false);

Expected Behavior

Infer<typeof validate> should be ({ type: 'a'; data: number } | { type: 'b'; data: string }) & { common: string }.

arbitrary keys with validated value

How do you validate an object with arbitrary keys but known value?
eg:

let a: {[key: string]: number} = {
  a: 123,
  b: 456,
}

a & b can be arbitrary, but the value is always a $number.

$object({}, false) accepts arbitrary keys, but has no way to verify values.

Data masking: Parse, not only Validate

Briant library! Replaced zod in a couple of minutes and greatly reduced bundle size.

The only one moment is missing a little bit - "data masking"

• with zod if you declare object with a given shape
  • then on z.parse you will get only the fields you've requested
• lizod just checks that the object matches expectations
  • so you always operate with the real object

There is not a big problem to do data masking, however information about "selected fields" is hidden inside $object. So step 1 is to provide access to this information.

What do you think about extra helper to extract the configuration from $object, it can be just a property on a return function as well(example), to provide runtime access to fields to be picked for the external tool?

`$enum` for values apart from strings?

It's common to use numbers for enums in APIs in addition to regular strings, so $enum should support that too?

$union([$const(...), $const(...), ...]) is a lot more verbose :/

discussion: 破壊的変更により$enumでconst type parameterを利用せずにas constを取り除く

現在のAPIにおいては，const type parameterを用いるほかに$enumにリテラル型のValidatorをつけることはできません．とくに，<S extends string>などとした場合も同様です．これは，（as constやconst type paramterなしで）配列リテラルを定義した時点（関数の引数として渡す前）に型が推論されてしまうためです．

いま，enumsを1つの引数としてではなく，残余引数を用いて複数の引数として得た場合，リテラルが直接関数に渡されるため，<S extends string>とするだけでリテラル型に推論することが可能です．

そこで，APIを変更して，typescript@<5.0でも$enumを利用できるようにすることを提案します：

export const $enum =
  <S extends string>(...enums: S[]): Validator<S> => (
    input: any,
  ): input is S => {
    return enums.includes(input);
  };

破壊的変更を含むため，PRの前に一旦issueとして提案する次第です．

array with known shape

How do you validate an array with an exact known shape?
eg:

let a: [number, number, string] = [1, 2, "3"];

$array($union([$number, $string])) would also accept [1, 2, 3] or ["1", "2", 3].

Potentially (didn't test) $object could work as a workaround? But I'd prefer $array([$number, $number, $string]) over $object({0: $number, 1: $number, 2: $string}) (didn't test if this works)