How create conditional Validator?

[cawa-93]

In my application there is a form in which some fields depend on others:

URL is always required
Type - always required (There may actually be many such types, but for example only 2: Image or Timeout)

If type === Image
The template.src url field must be required

If type === Timeout
The template.timeout number must be required

How do I describe such a scheme? Should I do some validators? Or a few separate forms?

So far, I've tried to create several separate validators, but I'm getting a type error

    const {url, type} = await request.validate(TypeValidator)
    const v = getValidatorByType(type)
    const {template} = await request.validate(v) // <--

TS2345: Argument of type 'typeof TimeoutTextValidator | typeof ImageValidator' is not assignable to parameter of type 'RequestValidatorNode<ParsedTypedSchema<{ template: { t: { timeout: number; }; getTree(): SchemaObject; }; }>>'. 
    Type 'typeof ImageValidator' is not assignable to type 'RequestValidatorNode<ParsedTypedSchema<{ template: { t: { timeout: number; }; getTree(): SchemaObject; }; }>>'. 
      Types of construct signatures are incompatible. 
        Type 'new (ctx: HttpContextContract) => ImageValidator' is not assignable to type 'new (ctx: HttpContextContract) => WithOptional<ValidatorNode<ParsedTypedSchema<{ template: { t: { timeout: number; }; getTree(): SchemaObject; }; }>>, "data">'. 
          Type 'ImageValidator' is not assignable to type 'WithOptional<ValidatorNode<ParsedTypedSchema<{ template: { t: { timeout: number; }; getTree(): SchemaObject; }; }>>, "data">'. 
            Type 'ImageValidator' is not assignable to type 'Omit<ValidatorNode<ParsedTypedSchema<{ template: { t: { timeout: number; }; getTree(): SchemaObject; }; }>>, "data">'. 
              The types of 'schema.props.template' are incompatible between these types. 
                Type '{ src: string; }' is not assignable to type '{ timeout: number; }'.

[thetutlage]

Please share the Validator class

[cawa-93]

// TypeValidator
export default class TypeValidator {
  constructor (protected ctx: HttpContextContract) {
  }

  public schema = schema.create({
    'original-url': schema.string({trim: true}, [
      rules.url(),
    ]),
    type: schema.enum(Validators.map(v => v.type)), // Validators described below
  })

  // public get schema () {
  //  Getters not working :(
  // }
}

// TimeoutTextValidator
export default class TimeoutTextValidator {
  public static type = 'timeout-text' as const

  public schema = schema.create({
    template: schema.object().members({
      timeout: schema.number()
    })
  })
}

// ImageValidator 
export default class ImageValidator {
  public static type = 'image' as const

  public schema = schema.create({
    template: schema.object().members({
      src: schema.string({trim: true}, [
        rules.url()
      ])
    })
  })
}

// getValidatorByType
export const Validators = [TimeoutTextValidator, ImageValidator]
export type Validators = (typeof Validators)[number]

type ValidatorsMap = {
  [T in Validators['type']]: Validators extends infer V ? V extends {type: T} ? V : never : never;
};

export function getValidatorByType<T extends Validators['type']>(type: T): ValidatorsMap[T] {
  const V = Validators.find((v): v is ValidatorsMap[T] => v.type === type)
  if (!V) {
    throw new Error("Didn't expect to get here")
  }
  return V;
}

[feniljariwala82]

import { schema, rules } from '@ioc:Adonis/Core/Validator'
import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'

export default class TempValidator {
  constructor(protected ctx: HttpContextContract) {}

  public schema = schema.create({
    URL: schema.string({ trim: true }, [rules.required(), rules.url()]),
    Type: schema.enum(['Timeout', 'Image', 'OtherType'] as const, [rules.required()]),
    template: schema.object().members({
      timeout: schema.number.optional([rules.requiredWhen('Type', '=', 'Timeout')]),
      src: schema.number.optional([rules.requiredWhen('Type', '=', 'Image')]),
    }),
  })

  public messages = {
    // Your custom error messages here
  }
}

Try this out!

[cawa-93]

I was thinking about this option. But, as I said, there can be many types (10, 20, 40 ... a lot). And it is very difficult to manage all fields for all types in the way you specify. So, I'm looking for some way to organize all this validation rules and make it TypeScript-friendly

[thetutlage]

Alright, so there are a few things here with sub-schemas or passing a union of schemas to the request.validate method.

The request.validate method cannot work with a union of schemas ( yes, it is a shortcoming ) as it aims to return a single type after validation vs a union of types.

I have been hesitant to add support for union of schemas because this leads to branching post validation and makes the controllers full of if/else statements.

Let's assume that request.validate(v) would have worked and it will return the template property with a union of

template = { src: string } | { timeout: number }

Now at some stage within your code you will have to write the if/else condition to check if template has src or timeout. This condition may appear later or earlier based upon the schema design you have.

Instead, what I propose is branching your code into services. Here I have created a sample repo for the same https://github.com/thetutlage/sub-schema-validation.

So the idea is.

• You perform the initial validation within the controller and find out the type from it.
• Then each type has its own service that performs the validation + handles any other logic related to that type. It can be writing to database, sending email. Basically, the normal stuff controller would do.
• The service performs the sub-schema validation within the service. No more unions. Just a single source of truth.

I think this leads to more maintainable code.

[cawa-93]

You saved my day

[bartosjiri]

Alternative solution:

TemplateSchemas.ts

import {schema, rules} from '@ioc:Adonis/Core/Validator'

const timeoutSchema = {
  timeout: schema.number()
}

const imageSchema = {
  src: schema.string({trim: true}, [rules.url()])
}

export const TemplateSchemas = {
  timeout: timeoutSchema,
  image: imageSchema 
}

(file managing the validation)

import {schema, rules} from '@ioc:Adonis/Core/Validator'

import {TemplateSchemas} from 'path/to/TemplateSchemas.ts'

public schema = schema.create({
  'original-url': schema.string({trim: true}, [rules.url()]),
  type: schema.enum(["timeout", "image"]),
  template: schema.object().members({
    ...TemplateSchemas[this.ctx.request.input("type")]
  })
})