Feature: function argument specific error messages

[andykais]

This may be getting into the territory of custom error reporting (io-ts#error-reporting for example). But it could also just be a special assertion generator. The idea is that I would like to validate a function's parameters. typescript-is provides all the validation I need to make that happen, but the errors it gives back are not as helpful to an end user. This is easier shown than explained:

type ArgumentTypes<F extends Function> = F extends (...args: infer A) => any ? A : never
type Fn = (a: number, b: string) => boolean
type Args = ArgumentTypes<Fn>

const validateFn = createAssertType<ArgumentTypes<Fn>>()
const fn: Fn = (...args) => {
    validateFn(args)
    const [a, b] = args
    return true
}


fn() // TypeGuardError: validation failed at $: expected an array of length 2
// could be: TypeGuardError: validation failed at $: expected 2 arguments

fn(1, 2) // TypeGuardError: validation failed at $.[1]: expected a string
// could be TypeGuardError: validation failed at argument 2: expected a string

fn(1, 'b') // correct usage

I think a wrapAssertFunctionParams<T> would be handy, as a higher order function. Usage would look like:

// generic type argument could be optional
const fnWithValidation = wrapAssertFunctionParams<Fn>(fn)

For the time being I will be writing something myself for my library which does just this. I can post the implementation here if it is interesting

[andykais]

I dont believe I have a way to iterate over args in a array type generically, so I dont believe this is something I can build outside this library 😿. This is about as far as I got:

const wrapFunctionAssertParams = <T extends (...args: any[]) => any>(fn: T) => {
  type Args = ArgumentTypes<typeof fn>

  // cannot transform `Args` into an array of validators

  return (...args: any[]): ReturnType<typeof fn> => {
    return fn(...args)
  }
}

I can still write a non-generic solution to the problem though, where I hardcode a validator for each parameter of the function I want validated.

[woutervh-]

Hi @andykais,

As I understand it you want to give some custom error message based on the reason the validation failed.
The current error messages are not sufficient information for you.

The problem with error message in your situation is that the way the type is used is unknown to typescript-is:

type ArgumentTypes<F extends Function> = F extends (...args: infer A) => any ? A : never
type Fn = (a: number, b: string) => boolean
type Args = ArgumentTypes<Fn> // is identical to type Args = [number, string]

const validateFn = createAssertType<ArgumentTypes<Fn>>()
// typescript-is doesn't know if [number, string] comes from function arguments or is just declared as such a tuple

It would be difficult for typescript-is to find out if the type argument comes from a function signature declaration or not.

What I can propose is that typescript-is gives you more information about the reason why the validation failed. It could do so in a structured manner, so that you can programmatically generate your own error messages, e.g.:

const validateFn = createAssertType<[number, string]>();
try {
  validateFn(args)
} catch (error) {
  // error has information about the path of the error and the expected type
  console.log(error.path); // could print: ['$', 1]
  console.log(error.expected); // could print: 'string'
  // construct custom error message:
  throw new Error(`Argument ${error.path[1] + 1} expected ${error.expected}.`);
}

This is something that could be done more easily and also will allow more flexibility.
What do you think?

[andykais]

I think that looks spiffy! What I had suggested was definitely specific to my use case. If you provide those fields on the thrown error though, I can easily build custom error reports coupled to the types themselves.

[woutervh-]

Hi @andykais

It took a while but I finally made some time to work on this.
I've release v0.14.1 for this.
It will now support getting path: string[] and reason: Reason properties from the error that is thrown.
You can read about it here as well: https://github.com/woutervh-/typescript-is/releases/tag/v0.14.0

Example:

const validateFn = createAssertType<[number, string]>();
try {
  validateFn(args)
} catch (error) {
  // error has information about the path of the error and the expected type
  console.log(error.path); // prints: ['$', 1]
  console.log(error.reason); // prints: { type: 'string' }
}

For all possible values for error.reason you can check:

typescript-is/index.d.ts

Line 251 in 029deb9

type Reason = ExpectedString

[andykais]

Thats awesome @woutervh-! This is going to make building pretty error messages a lot easier now (I had briefly messed around with parsing error strings to get what I wanted). I'm going to close this issue since my problem is solved. Thanks again for this awesome library!