Validator equalTo, equalNotTo, equalToWhen rules

[popovicieduard]

I think that the validator misses some trivial rules, like equalTo, equalNotTo, equalToWhen,

equalTo and equalNotTo are straightforward, field matches a value provided.

rules.equalTo('foo') -> value has to be foo

rules.equalNotTo('bar') -> value can't be bar // this rule can be skipped since blacklist exists now.

equalToWhen can act a bit like requiredWhen, if other field matches a condition, value should be equal to.

rules.equalToWhen('USD', 'country', '=', 'US') value should be USD when country fiels is US

I wrote a bit of code for equalToWhen, inspired by requiredWhen, haven't tested it yet to see if it works but could work on it a bit more if @thetutlage decides this feature is relevant.

/*
 * @adonisjs/validator
 *
 * (c) Harminder Virk <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

import { SyncValidation } from '@ioc:Adonis/Core/Validator'
import { exists, getFieldValue, wrapCompile, isRef } from '../../Validator/helpers'

const RULE_NAME = 'equalToWhen'
const DEFAULT_MESSAGE = 'equalToWhen validation failed'

/**
 * Return value of the compile function
 */
type CompileReturnType = {
  equalToValue: string,
  otherField: string,
  operator: keyof typeof OPERATORS
  field: string
  comparisonValues?: any | any[]
  ref?: string
}

/**
 * Available operators
 */
const OPERATORS = {
  /**
	 * Handles the "in" operator. Also ensures, the comparison values are an
	 * array or a ref.
	 */
  'in': {
    compile (comparisonValues: any) {
      if (!Array.isArray(comparisonValues)) {
        throw new Error(`"${RULE_NAME}": "in" operator expects an array of "comparisonValues"`)
      }
    },

    passes: (value: any,
      equalToValue: string | number,
      otherFieldValue: string | number,
      comparisonValues: any[]
    ) => {
      if(comparisonValues.includes(otherFieldValue)){
        return value === equalToValue
      }
      return true
    },
  },

  /**
	 * Handles the "notIn" operator. Also ensures, the comparison values are an
	 * array or a ref.
	 */
  'notIn': {
    compile (comparisonValues: any[]) {
      if (!Array.isArray(comparisonValues)) {
        throw new Error(`"${RULE_NAME}": "notIn" operator expects an array of "comparisonValues"`)
      }
    },

    passes: (
      value: any,
      equalToValue: string | number,
      otherFieldValue: string | number,
      comparisonValues: any[]
    ) => {
      if(!comparisonValues.includes(otherFieldValue)){
        return value === equalToValue 
      }
      return true
    },
  },

  /**
	 * Handles the "=" operator. No compile time checks are required here
	 */
  '=': {
    passes: (value: any, equalToValue: string | number, otherFieldValue: string | number, comparisonValue: any) => {
      if(otherFieldValue === comparisonValue){
        return value === equalToValue 
      }
      return true
    },
  },

  /**
	 * Handles the "!=" operator. No compile time checks are required here
	 */
  '!=': {
    passes: (value: any, equalToValue: string | number, otherFieldValue: string | number, comparisonValue: any) => {
      if(otherFieldValue !== comparisonValue){
        return value === equalToValue
      }
      return true
    },
  },
}

/**
 * Ensure the value exists when defined expectation passed.
 * `null`, `undefined` and `empty string` fails the validation.
 */
export const equalToWhen: SyncValidation<CompileReturnType> = {
  compile: wrapCompile<CompileReturnType>(RULE_NAME, [], ([
    equalToValue,
    otherField,
    field,
    operator,
    comparisonValues,
  ]) => {
    /**
		 * Ensure "field", "operator" and "comparisonValues" are defined
		 */
    if (!field || !equalToValue || !otherField || !operator || comparisonValues === undefined) {
      throw new Error(`"${RULE_NAME}": expects a "field", "operator", "equalToValue", "otherField", and "comparisonValue"`)
    }

    /**
		 * Ensure "operator" is defined
		 */
    if (!OPERATORS[operator]) {
      throw new Error(`"${RULE_NAME}": expects "operator" to be one of the whitelisted operators`)
    }

    /**
		 * Value is a ref
		 */
    if (isRef(comparisonValues)) {
      return {
        allowUndefineds: true,
        compiledOptions: {
          operator,
          field,
          ref: comparisonValues.key,
        },
      }
    }

    /**
		 * Compile the options for a given operator when they
		 * implement a compile function
		 */
    if (typeof OPERATORS[operator].compile === 'function') {
      OPERATORS[operator].compile(comparisonValues)
    }

    return {
      allowUndefineds: true,
      compiledOptions: {
        equalToValue,
        otherField,
        operator,
        field,
        comparisonValues,
      },
    }
  }),
  validate (
    value,
    compiledOptions,
    { errorReporter, pointer, arrayExpressionPointer, root, tip, refs }
  ) {
    let comparisonValues: any

    /**
		 * Resolve comparisonValues
		 */
    if (compiledOptions.ref) {
      comparisonValues = refs[compiledOptions.ref].value
    } else {
      comparisonValues = compiledOptions.comparisonValues
    }

    /**
		 * Finding if field should be required
		 */
    const shouldBeEqual = OPERATORS[compiledOptions.operator].passes(
      getFieldValue(compiledOptions.field, root, tip),
      compiledOptions.equalToValue,
      getFieldValue(compiledOptions.otherField, root, tip),
      comparisonValues
    )

    /**
		 * Validation
		 */
    if (shouldBeEqual && !exists(value)) {
      errorReporter.report(pointer, RULE_NAME, DEFAULT_MESSAGE, arrayExpressionPointer, {
        operator: compiledOptions.operator,
        otherField: compiledOptions.otherField,
        values: comparisonValues,
      })
    }
  },
}

[RomainLanz]

Hey! 👋

What's the goal of having equalTo? If your value must be X, then there's no need to send the value from the client, you can hard-code it directly.

[popovicieduard]

@RomainLanz ye, true, I first tought about equalToWhen as a rule and tought that maybe equalTo and equalNotTo can be added aswell, but that is right, you can hard-code it. A use case for equalTo would be when you have a project with multiple languages support and need a country to be specific for that project, you can set a rule inside rules and not add default values inside db migrations. But this is a stretched use case that I tought about now, not the best.

[thetutlage]

I was thinking about this proposal and I think, all we need is just the equalTo rule. Here's the explanation.

• The equalTo rule with a static value is useless.
• However equalTo with a dynamic value is very useful and can serve the purpose of equalToWhen.

In your equalToWhen example, you showcased forcing currency based upon the user country. I imagine, in a real world you may end up writing this rule for multiple times. For example:

rules.equalToWhen('USD', 'country', '=', 'United states')
rules.equalToWhen('INR', 'country', '=', 'India')
rules.equalToWhen('EUR', 'country', 'in', ['Germany', 'France', 'and so on'])

As you notice, you are running redundant validations (one for each country). Whereas, in the perfect world, we first want to know the user country and then enforce a currency. Something as follows:

const userCountry = this.ctx.request.input('country')

const currencies = {
  'United states': 'USD',
  'INR': 'India'
}

rules.equalTo(currencies[userCountry])

[thetutlage]

This will create another variation of types of rules. I suggest going with the simplest approach possible.

[popovicieduard]

I think that the equalTo proposed by you would work out great, for my use case, I implemented a custom rule. I'll try and make a PR today or tommorow for your approach.

[thetutlage]

Cool. Looking forward to it

[RomainLanz]

For me, it's still the same as static value.

What's the goal of letting the user decide it's currency if there's only one valid choice?
I mean, if someone from France and Germany should always be Euro, this shouldn't be verified and should be handled by the code that create the record.

[popovicieduard]

Let's say i have a country input and a currency input, EU countries have EUR, US has USD, GB has GBP. You want to specify the currency because on that currency there are other inputs that depend on it,if the currency is USD some fields are required or maybe in the future I will want to allow multiple currencies per country and have other validations based on that currency.

In my use case, I want to provide an api that let's other people create records, the logic is a bit more complicated when creating the records, there are rules, I want to provide them validation errors based on the input provided by them, so that they understand the error messages better, they get a better grasp of how things are related. Enforcing a value would just add more complexity in my case if in the future I would like to provide other currencies for countries.

It makes more sense in my case to enforce a value based on another field, rather than handling the logic outside of the validation.