checkSchema support for multiple custom validators/sanitisers

[gustavohenke]

Description

This PR addresses #552 by adding support for multiple custom validators/sanitisers to checkSchema().

checkSchema({
	email: {
		isEmail: true,
		isAllowedDomain: {
			bail: true,
			custom: value => value.endsWith('@gmail.com')
		},
		removeEmailAttribute: {
			// converts e.g. john+doe@gmail.com to john@gmail.com
			customSanitizer: value => value.replace(/(\+.+)?@/, '@'),
		},
		isExistingEmail: {
			custom: value => Users.findByEmail(value).then(/* do something */),
		},
	},
});

These names aren't used for anything but to allow placing the validators/sanitisers in different places in the resulting chain.

This is an advantage over using an array with custom/ customSanitizer, which wouldn't be too flexible.
For example, the following would run the custom validators in sequence, which may not be desired:

checkSchema({
	email: {
		customSanitizer: { options: removeEmailAttribute },
		custom: [
			{ options: isAllowedDomain },
			{ options: isExistingEmail },
		]
	}
})

To-do list

• Add tests for new custom validator syntax
• Add tests for new custom sanitiser syntax
• Add tests for mixing custom validator/sanitiser syntax with standard syntax
• Add TS tests with @ts-expect-error for mixing custom validator/sanitiser syntax with standard syntax
• Update docs
• This pull request is ready to merge.

[coveralls]

Coverage: 100.0%. Remained the same when pulling 79e09cf on schema-multi-custom into 10ecbd1 on master.

[fedeci]

Reviewing this later today!

[gustavohenke]

Just so that it fits better with the validated schema below.

[gustavohenke]

ditto

[Grubba27]

Implementation wise looks really good!
My only comments are on the types part but if it works things are awesome

[Grubba27]

I would format this if else segment type. Something like this:

export type ParamSchema<T extends string = DefaultSchemaKeys> =
  BaseParamSchema &
  ValidatorsSchema &
  SanitizersSchema & {
  [K in T]?: K extends keyof BaseParamSchema
    ? BaseParamSchema[K]
    : K extends keyof ValidatorsSchema
      ? ValidatorsSchema[K]
      : K extends keyof SanitizersSchema
        ? SanitizersSchema[K]
        : CustomSanitizerSchemaOptions | CustomValidatorSchemaOptions;
};

also I would put the options you think will be used first, as it will generally make the typescript checker quicker.

Another option to this, if it makes sense, could be making things more narrow:

export type ParamSchema<T extends string = DefaultSchemaKeys> =
  BaseParamSchema &
  ValidatorsSchema &
  SanitizersSchema & {
  [K in T]?: K extends keyof BaseParamSchema
    ? BaseParamSchema[K]
    : K extends keyof ValidatorsSchema
      ? ValidatorsSchema[K]
      : K extends keyof SanitizersSchema
        ? SanitizersSchema[K]
        : K extends keyof CustomSanitizerSchemaOptions ?
          CustomSanitizerSchemaOptions[K]
          : K extends keyof CustomValidatorSchemaOptions ? 
            CustomValidatorSchemaOptions[K] 
            : never;
};

Note that I've made having CustomSanitizerSchemaOptions or CustomValidatorSchemaOptions a must otherwise, it will throw a never.

Maybe to work as the first example it maybe needing to add CustomSanitizerSchemaOptions
& CustomValidatorSchemaOptions to the begin of the type, like this:

export type ParamSchema<T extends string = DefaultSchemaKeys> =
 BaseParamSchema &
 ValidatorsSchema &
 SanitizersSchema &
 CustomSanitizerSchemaOptions & 
 CustomValidatorSchemaOptions &
{
 [K in T]?: K extends keyof BaseParamSchema
   ? BaseParamSchema[K]
   : K extends keyof ValidatorsSchema
     ? ValidatorsSchema[K]
     : K extends keyof SanitizersSchema
       ? SanitizersSchema[K]
       : K extends keyof CustomSanitizerSchemaOptions ?
         CustomSanitizerSchemaOptions[K]
         : K extends keyof CustomValidatorSchemaOptions ? 
           CustomValidatorSchemaOptions[K] 
           : never;
};

if for some reason CustomSanitizerSchemaOptions
& CustomValidatorSchemaOptions are nullable and you want to prevent that you can use this utilitary type like this:

type IfNullThen<IF, THEN> = IF extends null ? THEN : IF;

export type ParamSchema<T extends string = DefaultSchemaKeys> =
  BaseParamSchema &
  ValidatorsSchema &
  IfNullThen<CustomValidatorSchemaOptions, ValidatorsSchema> & // if CustomValidatorSchemaOptions is null it returns ValidatorsSchema. ValidatorsSchema & ValidatorsSchema is equal to just ValidatorsSchema
  SanitizersSchema & {
  [K in T]?: K extends keyof BaseParamSchema
    ? BaseParamSchema[K]
    : K extends keyof ValidatorsSchema
      ? ValidatorsSchema[K]
      : K extends keyof SanitizersSchema
        ? SanitizersSchema[K]
        : K extends keyof CustomSanitizerSchemaOptions ?
          CustomSanitizerSchemaOptions[K]
          : K extends keyof CustomValidatorSchemaOptions ?
            CustomValidatorSchemaOptions[K]
            : never;
};

if this is too much sorry about this :/ as you asked me on twitter but I only got the chance to review it closely now.
This was how I understood the problem that you wanted to solve. If all worlds but it seems too complex maybe making it simpler is okay or making a doc to this pr where we explain the decisions is a good call.

[gustavohenke]

Thanks for the ideas!
Can't do much formatting because of prettier 😛

Don't know if the performance wins will be obvious if I change things around. Maybe it's coincidentally at its optimal already 😄

The other suggestions are probably not going to work.
CustomSanitizerSchemaOptions | CustomValidatorSchemaOptions represents the value really, not a dictionary of possible keys/values that K might be in, so I have to dismiss your suggestion :(

But thanks again!!!

[gustavohenke]

@fedeci do you have any thoughts?