I just ran into this library, while looking for a library to do data sanitization for one of my apps. It looks very promising. I just have one question though. I noticed that each "as" function has a second "path" argument. What exactly is this argument? Or, what do I pass in to it? The docs in the README do not really go over the arguments.

Thanks.

asAnyOf takes 2 or more sanitizers and returns a sanitizer that goes through them and returns the first that succeeds.

It's very common to expect integers in URL path, e.g. /users/123 to access user by Id.
With using asNumber sanitizer, request /users/3.14 would be still valid while not being a correct Id.

This is a list of all "nice-to-have" features for Restless:

• Basic auth
• Streaming responses
• Support for rendering templates as in express
• Integration with third-party middleware libraries

In my personal project I have this usage of restless solutions:
my point of Route, method post:

route.post('/login', asyncHandler( sanitize({
    body: asObject({
      username: asString,
      password: asString,
    })
  }),
  (reqData) => {
  const {username, password} = reqData.body;
  findUser('user', username)
    .then((user: User) => {
      if(user.password === password) {
        responseOf(user, 200)
      }
      else {
        responseOf('user not found', 400)
      }
    })
    .catch(err => {
      responseOf('internal server error', 500)
    })
  }
));

TypeScript compiler error:
Type void is not assignable to type ResponseFunction | Promise<ResponseFunction>

When I change code to marked returns type like belowe
... function(reqData): ResponseFunction | Promise<ResponseFunction> { ...
I have another ts compiler warrning

Does anyone have any idea how to solve this issue?

It seems it is not yet possible to use an async sanitizer function inside cast, do i mistake ?

If not, would it be possible to add support for this ?

Example

Sanitizer

import { Result } from '@restless/sanitizers';

export const asCertificate = async (value, path: string) => {
  const errors = (await validate(value)) as any[];
  
  if (Object.keys(errors).length) {
    const resultError = flatten(
      Object.values(errors).map((error) => {
        return error.map((error) => ({
          path: `${path}${error.path}`,
          expected: error.expected || '',
        }));
      })
    );

    console.log(resultError);
    return Result.error(resultError);
  }
  return Result.ok(value as Certificate);
};

Cast

import {cast} from '@restless/sanitizers';
import {asCertificate} from './somewhere';

const certificate = {};
const value = cast(certificate, asCertificate);

It would be nice to have short circuiting for responses. Current implementation idea is to throw a custom class.