Validation

// 1. Type-first: you supply the type, no value needed.
const isPointA = createValidateFn<Point>();

// 2. Value-first: T is inferred from a value you already have.
const origin: Point = {x: 0, y: 0};
const isPointB = createValidateFn(origin);

// 3. Run-type: pass the run-type an RT.* builder returned; T is inferred from it.
const pointRunType = RT.object({x: TF.number(), y: TF.number()});
const isPointC = createValidateFn(pointRunType);

const isUser = createValidateFn<User>();

isUser({id: 1, name: 'Ada', roles: ['admin']}); // true
isUser({id: '1', name: 'Ada', roles: ['admin']}); // false, id is not a number

// It narrows too: inside the `if`, `data` is typed.
function handle(data: unknown) {
  if (isUser(data)) data.roles; // ('admin' | 'user')[]
}

{"compilerOptions": {"types": ["node"]}}

const userErrors = createGetValidationErrorsFn<User>();

userErrors({id: 1, name: 'Ada', roles: ['admin']}); // [], all good
userErrors({id: '1', name: 42, roles: ['boss']});
// [
//   {path: ['id'], expected: 'number'},
//   {path: ['name'], expected: 'string'},
//   {path: ['roles', 0], expected: "'admin' | 'user'"},
// ]

const errors = getErrors(card);
switch (errors[0]?.format?.errorType) {
  case 'format': // not shaped like a card number at all
  case 'checksum': // right shape, the digits do not add up (a typo)
  case 'network': // a good card, just not one this field takes
}

const signUpErrors = createGetValidationErrorsFn<SignUp>();

export function explain(input: unknown): string[] {
  const messages: string[] = [];
  for (const error of signUpErrors(input)) {
    // `format.name` narrows `errorType` to that format's own modes, so a typo
    // in a mode name is a compile error.
    switch (error.format?.name) {
      case 'email':
        messages.push(
          error.format.errorType === 'localPart'
            ? 'Check the part before the @'
            : 'Check the email address'
        );
        break;
      case 'creditCard':
        messages.push(
          error.format.errorType === 'checksum'
            ? 'Check the card digits'
            : 'That is not a card we take'
        );
        break;
      default:
        messages.push(`${error.path.join('.')}: expected ${error.expected}`);
    }
  }
  return messages;
}

// accepts NaN and Infinity
const isFlagTypeofNumbers = createValidateFn<Flag>(undefined, {
  numberMode: 'typeof',
});

runtypes({validate: {numberMode: 'typeof'}})

import {createGetValidationErrorsFn, createValidateFn} from '@mionjs/run-types';

type Address = {street: string; city: string};
type User = {id: number; name: string; address: Address};

// one function, one pass: matches User and carries no extra property, at every level
const isUserStrict = createValidateFn<User>(undefined, {checkUnknowns: true});

isUserStrict({id: 1, name: 'Ada', address: {street: 'Main', city: 'Rome'}}); // true
isUserStrict({
  id: 1,
  name: 'Ada',
  address: {street: 'Main', city: 'Rome'},
  admin: true,
}); // false
isUserStrict({
  id: 1,
  name: 'Ada',
  address: {street: 'Main', city: 'Rome', zip: '00184'},
}); // false, the extra is nested

// same option on the error report: one entry per undeclared key, `expected: 'never'`
const userErrors = createGetValidationErrorsFn<User>(undefined, {
  checkUnknowns: true,
});

userErrors({
  id: 1,
  name: 'Ada',
  address: {street: 'Main', city: 'Rome', zip: '00184'},
});
// [{path: ['address', 'zip'], expected: 'never'}]

// a union needs its own option: its members share one list of property names
type Pet = {kind: 'cat'; meows: boolean} | {kind: 'dog'; barks: number};
type Something = {a: string} | Record<string, number>;

const isPetUnionStrict = createValidateFn<Pet>(undefined, {
  checkUnionUnknowns: true,
});
isPetUnionStrict({kind: 'cat', meows: true}); // true
isPetUnionStrict({kind: 'cat', meows: true, barks: 3}); // false, barks belongs to Dog

const isSomething = createValidateFn<Something>(undefined, {
  checkUnionUnknowns: true,
});
isSomething({a: 'x'}); // true
isSomething({p: 1, q: 2}); // true, it is a record
isSomething({a: 'x', evil: 'garbage'}); // false, it matches neither member

export {isUserStrict, userErrors, isPetUnionStrict, isSomething};

type Pet = {kind: 'cat'; meows: boolean} | {kind: 'dog'; barks: number};
// {kind: 'cat', meows: true, barks: 3}  ->  rejected, barks belongs to Dog, not to Cat

type Something = {a: string} | Record<string, number>;
// {a: 'x', evil: 'garbage'}  ->  rejected, it matches neither member

type Loose = {a: string} | Record<string, string>;
// {a: 'x', evil: 'garbage'}  ->  accepted, every value is a string

import {createRemoveUnknownKeysFn, createValidateFn} from '@mionjs/run-types';

type User = {id: number; name: string};

// never changes the input, so frozen inputs work
const removeUnknownKeys = createRemoveUnknownKeysFn<User>();

const dirty = {id: 1, name: 'Ada', admin: true, token: 'secret'};
const clean = removeUnknownKeys(dirty as User); // {id: 1, name: 'Ada'}, new object

// validate untrusted data first, then drop its extra keys
const isUser = createValidateFn<User>();
export function parseUser(data: unknown): User {
  if (!isUser(data)) throw new Error('not a User');
  return removeUnknownKeys(data);
}

// onClick is shared with the input: 'share' hides the warning, 'refuse' makes it a build error
type Button = {label: string; onClick: () => void};
const removeButtonKeys = createRemoveUnknownKeysFn<Button>(undefined, {
  sharedValues: 'share',
});

export {removeUnknownKeys, clean, removeButtonKeys};

// a Standard Schema v1 object: a single `~standard` property
const userSchema = createStandardSchema<User>();

// Valid input comes back under `value`.
userSchema['~standard'].validate({id: 1, name: 'Ada', roles: ['admin']});
// {value: {id: 1, name: 'Ada', roles: ['admin']}}

// Invalid input comes back as a flat list of issues, each with a message + path.
userSchema['~standard'].validate({id: '1', name: 'Ada', roles: ['admin']});
// {issues: [{message: 'Expected number', path: ['id']}]}