Standalone Validator Usage

[mastermunj]

Hi,

We are making standalone usage of validator as follow:

• Create a validator with the command make:validator
• Provide with schema and messages.

Now, at the time of validation, the code goes like

const profileValidator = new ProfileValidator();
profileValidator.data = params;
await validator.validate(profileValidator);

Please note the line profileValidator.data = params.

The current default validator class does not have a data attribute, nor does it accept it through the constructor.

If it were accepting data through the constructor, like this

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

export default class ProfileValidator {
  constructor(private ctx: HttpContextContract, public data: {}) {}

  public schema = schema.create({
  });

  public cacheKey = this.ctx.routeKey;

  public messages = {};
}

the above code could have been simplified as

const profileValidator = new ProfileValidator(null, params);
await validator.validate(profileValidator);

I know, the current constructor accepts ctx as the parameter, which can again be used for cacheKey.

My query is:
Would it be better to have data attributes added to Validator classes and accept it in the constructor, maybe as the second parameter for not breaking the current usage?

Another alternate usage could be

const profileValidator = new ProfileValidator();
await validator.validate({ data: params, ...profileValidator} );

Is there any other better approach?

[mastermunj]

Hi, @thetutlage Please help with your thoughts whenever you get time.

[thetutlage]

What you are looking for is a validator that is not hardly tied with HTTP requests only. In this case, I will recommend getting rid of ctx altogether (since outside HTTP requests, you will not have access to it) and accept just the data inside the constructor.

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

export default class ProfileValidator {
  constructor (public data: any) {
  }

  public schema = schema.create({
  })

  public messages = {}
}

Now, you can use it as follows

import { validator } from '@ioc:Adonis/Core/Validator'
validator.validate(new ProfileValidator({}))

And during HTTP requests

request.validate(new ProfileValidator(request.all()))

[mastermunj]

Any suggestions on the best way to specify cacheKey in such a scenario?

I am thinking to use the md5 hash of file path for the validator class.

[thetutlage]

Yeah it is hard to come up with a cache key in such a scenario. If you don't care for every millisecond, then simply disable caching. Another option is to generate a hash of the schema. Following is an example of same (little bit dirty though)

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

let cacheKey: string

export default class ProfileValidator {
  constructor (public data: any) {
  }

  public schema = schema.create({
    username: schema.string(),
    age: schema.enum(['a', 'b']),
  })

  public messages = {}

  public cacheKey = cacheKey || crypto
    .createHash('md5')
    .update(JSON.stringify(this.schema.tree))
    .digest('hex')
}

[mastermunj]

Wouldn't JSON.stringify(this.schema.tree) be costlier than

crypto
  .createHash('md5')
  .update([__dirname, this.constructor.name].join('/'))
  .digest('hex')

OR there are scenarios where a simple file path based cacheKey could create conflict?

Also, Will the cache be destroyed and recreated on restart of the server?

[thetutlage]

Since the key is created only once, I don't think it JSON.stringify will make a much difference. But yes it will be slow in comparison with to the file path.

OR there are scenarios where a simple file path based cacheKey could create conflict?

Nope

Also, Will the cache be destroyed and recreated on restart of the server?

Yes. It is just an in-memory cache

[mastermunj]

That's great! Thank you.