feat: add support for inline comparison in requiredWhen rule

src/schema/base/literal.ts

@@ -21,6 +21,9 @@ import type {
   FieldOptions,
   ParserOptions,
   ConstructableSchema,
+  ComparisonOperators,
+  ArrayComparisonOperators,
+  NumericComparisonOperators,
 } from '../../types.js'
 import { requiredWhen } from './rules.js'
 import { helpers } from '../../vine/helpers.js'
@@ -177,8 +180,68 @@ class OptionalModifier<Schema extends BaseModifiersType<any, any>> extends BaseM
    * field as required, or "false" to skip the required
    * validation
    */
-  requiredWhen(callback: (field: FieldContext) => boolean) {
-    return this.use(requiredWhen(callback))
+  requiredWhen<Operator extends ComparisonOperators>(
+    otherField: string,
+    operator: Operator,
+    expectedValue: Operator extends ArrayComparisonOperators
+      ? (string | number | boolean)[]
+      : Operator extends NumericComparisonOperators
+        ? number
+        : string | number | boolean
+  ): this
+  requiredWhen(callback: (field: FieldContext) => boolean): this
+  requiredWhen(
+    otherField: string | ((field: FieldContext) => boolean),
+    operator?: ComparisonOperators,
+    expectedValue?: any
+  ) {
+    /**
+     * The equality check if self implemented
+     */
+    if (typeof otherField === 'function') {
+      return this.use(requiredWhen(otherField))
+    }
+
+    /**
+     * Creating the checker function based upon the
+     * operator used for the comparison
+     */
+    let checker: (value: any) => boolean
+    switch (operator!) {
+      case '=':
+        checker = (value) => value === expectedValue
+        break
+      case '!=':
+        checker = (value) => value !== expectedValue
+        break
+      case 'in':
+        checker = (value) => expectedValue.includes(value)
+        break
+      case 'notIn':
+        checker = (value) => !expectedValue.includes(value)
+        break
+      case '>':
+        checker = (value) => value > expectedValue
+        break
+      case '<':
+        checker = (value) => value < expectedValue
+        break
+      case '>=':
+        checker = (value) => value >= expectedValue
+        break
+      case '<=':
+        checker = (value) => value <= expectedValue
+    }
+
+    /**
+     * Registering rule with custom implementation
+     */
+    return this.use(
+      requiredWhen((field) => {
+        const otherFieldValue = helpers.getNestedValue(otherField, field)
+        return checker(otherFieldValue)
+      })
+    )
   }
 
   /**

src/types.ts

@@ -270,3 +270,11 @@ export type ValidationOptions<MetaData extends Record<string, any> | undefined>
  * Infers the schema type
  */
 export type Infer<Schema extends { [OTYPE]: any }> = Schema[typeof OTYPE]
+
+/**
+ * Comparison operators supported by requiredWhen
+ * rule
+ */
+export type NumericComparisonOperators = '>' | '<' | '>=' | '<='
+export type ArrayComparisonOperators = 'in' | 'notIn'
+export type ComparisonOperators = ArrayComparisonOperators | NumericComparisonOperators | '=' | '!='

tests/integration/schema/conditional_required.spec.ts

@@ -9,7 +9,6 @@
 
 import { test } from '@japa/runner'
 import vine from '../../../index.js'
-import { helpers } from '../../../src/vine/helpers.js'
 
 test.group('requiredIfExists', () => {
   test('fail when value is missing but other field exists', async ({ assert }) => {
@@ -260,16 +259,11 @@ test.group('requiredIfMissingAny', () => {
   })
 })
 
-test.group('requiredWhen | optional', () => {
+test.group('requiredWhen', () => {
   test('fail when required field is missing', async ({ assert }) => {
     const schema = vine.object({
       game: vine.string().optional(),
-      teamName: vine
-        .string()
-        .optional()
-        .requiredWhen((field) => {
-          return helpers.exists(field.data.game) && field.data.game === 'volleyball'
-        }),
+      teamName: vine.string().optional().requiredWhen('game', '=', 'volleyball'),
     })
 
     const data = {
@@ -285,15 +279,25 @@ test.group('requiredWhen | optional', () => {
     ])
   })
 
+  test('pass when required condition has not been met', async ({ assert }) => {
+    const schema = vine.object({
+      game: vine.string().optional(),
+      teamName: vine.string().optional().requiredWhen('game', '=', 'volleyball'),
+    })
+
+    const data = {
+      game: 'handball',
+    }
+
+    await assert.validationOutput(vine.validate({ schema, data }), {
+      game: 'handball',
+    })
+  })
+
   test('pass when required field is defined', async ({ assert }) => {
     const schema = vine.object({
       game: vine.string().optional(),
-      teamName: vine
-        .string()
-        .optional()
-        .requiredWhen((field) => {
-          return helpers.exists(field.data.game) && field.data.game === 'volleyball'
-        }),
+      teamName: vine.string().optional().requiredWhen('game', '=', 'volleyball'),
     })
 
     const data = {
@@ -306,4 +310,161 @@ test.group('requiredWhen | optional', () => {
       teamName: 'foo',
     })
   })
+
+  test('compare using "not equal" operator', async ({ assert }) => {
+    const schema = vine.object({
+      game: vine.string().optional(),
+      teamName: vine.string().optional().requiredWhen('game', '!=', 'volleyball'),
+    })
+
+    const data = {
+      game: 'handball',
+    }
+
+    await assert.validationErrors(vine.validate({ schema, data }), [
+      {
+        field: 'teamName',
+        message: 'The teamName field must be defined',
+        rule: 'required',
+      },
+    ])
+  })
+
+  test('compare using "in" operator', async ({ assert }) => {
+    const schema = vine.object({
+      game: vine.string().optional(),
+      teamName: vine.string().optional().requiredWhen('game', 'in', ['volleyball']),
+    })
+
+    const data = {
+      game: 'volleyball',
+    }
+
+    await assert.validationErrors(vine.validate({ schema, data }), [
+      {
+        field: 'teamName',
+        message: 'The teamName field must be defined',
+        rule: 'required',
+      },
+    ])
+  })
+
+  test('compare using "not In" operator', async ({ assert }) => {
+    const schema = vine.object({
+      game: vine.string().optional(),
+      teamName: vine.string().optional().requiredWhen('game', 'notIn', ['volleyball']),
+    })
+
+    const data = {
+      game: 'handball',
+    }
+
+    await assert.validationErrors(vine.validate({ schema, data }), [
+      {
+        field: 'teamName',
+        message: 'The teamName field must be defined',
+        rule: 'required',
+      },
+    ])
+  })
+
+  test('compare using ">" operator', async ({ assert }) => {
+    const schema = vine.object({
+      age: vine.number(),
+      guardianName: vine.string().optional().requiredWhen('age', '>', 1),
+    })
+
+    const data = {
+      age: 2,
+    }
+
+    await assert.validationErrors(vine.validate({ schema, data }), [
+      {
+        field: 'guardianName',
+        message: 'The guardianName field must be defined',
+        rule: 'required',
+      },
+    ])
+  })
+
+  test('compare using "<" operator', async ({ assert }) => {
+    const schema = vine.object({
+      age: vine.number(),
+      guardianName: vine.string().optional().requiredWhen('age', '<', 19),
+    })
+
+    const data = {
+      age: 2,
+    }
+
+    await assert.validationErrors(vine.validate({ schema, data }), [
+      {
+        field: 'guardianName',
+        message: 'The guardianName field must be defined',
+        rule: 'required',
+      },
+    ])
+  })
+
+  test('compare using "<=" operator', async ({ assert }) => {
+    const schema = vine.object({
+      age: vine.number(),
+      guardianName: vine.string().optional().requiredWhen('age', '<=', 18),
+    })
+
+    const data = {
+      age: 18,
+    }
+
+    await assert.validationErrors(vine.validate({ schema, data }), [
+      {
+        field: 'guardianName',
+        message: 'The guardianName field must be defined',
+        rule: 'required',
+      },
+    ])
+  })
+
+  test('compare using ">=" operator', async ({ assert }) => {
+    const schema = vine.object({
+      age: vine.number(),
+      guardianName: vine.string().optional().requiredWhen('age', '>=', 1),
+    })
+
+    const data = {
+      age: 1,
+    }
+
+    await assert.validationErrors(vine.validate({ schema, data }), [
+      {
+        field: 'guardianName',
+        message: 'The guardianName field must be defined',
+        rule: 'required',
+      },
+    ])
+  })
+
+  test('compare using custom callback', async ({ assert }) => {
+    const schema = vine.object({
+      game: vine.string().optional(),
+      teamName: vine
+        .string()
+        .optional()
+        .requiredWhen((field) => {
+          return field.parent.game === 'volleyball'
+        }),
+    })
+
+    const data = {
+      game: 'volleyball',
+    }
+
+    await assert.validationErrors(vine.validate({ schema, data }), [
+      {
+        field: 'teamName',
+        message: 'The teamName field must be defined',
+        rule: 'required',
+      },
+    ])
+  })
 })

tsconfig.json

@@ -2,6 +2,6 @@
   "extends": "@adonisjs/tsconfig/tsconfig.package.json",
   "compilerOptions": {
     "rootDir": "./",
-    "outDir": "./build",
-  },
+    "outDir": "./build"
+  }
 }