valgen 4.0.0-alpha.6 → 4.0.0

package/esm/rules/is-array.js

@@ -1,33 +1,35 @@
-import { kValidatorFn, validator, } from '../core/index.js';
+import { validator, } from '../core/index.js';
 /**
  * Validates if value is "array" and applies validation for each item.
  * Converts input value to array if coerce option is set to 'true'.
  * @validator isArray
  */
 export function isArray(itemValidator, options) {
-    return validator('isArray', function (input, context) {
+    return validator('isArray', function (input, context, _this) {
         if (input != null && context.coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.failure(`{{label}} is not an array`);
+            context.fail(_this, `{{label}} is not an array`, input);
             return;
         }
         if (!itemValidator)
             return input;
-        const location = context.input.location || '';
-        const itemContext = context.extend(itemValidator);
+        const location = context.location || '';
+        const itemContext = context.extend();
         let i;
         let v;
         const l = input.length;
         const out = [];
         for (i = 0; i < l; i++) {
             v = input[i];
-            itemContext.input.value = v;
-            itemContext.input.label = ((context.input.label || context.input.property) || 'Item') +
-                `[${i}]`;
-            itemContext.input.property = i;
-            itemContext.input.location = location + '[' + i + ']';
-            out.push(itemValidator[kValidatorFn](v, itemContext, itemValidator));
+            itemContext.scope = input;
+            itemContext.location = location + '[' + i + ']';
+            itemContext.label = context.label
+                ? context.label + `[${i}]`
+                : `Item at (${i})`;
+            itemContext.index = i;
+            v = itemValidator(v, itemContext);
+            out.push(v);
         }
         return out;
     }, options);

package/esm/rules/is-bigint.js

@@ -5,13 +5,13 @@ import { validator } from '../core/index.js';
  * @validator isNumber
  */
 export function isBigint(options) {
-    return validator('isBigint', function (input, context) {
+    return validator('isBigint', function (input, context, _this) {
         if (input != null && typeof input !== 'bigint' && context.coerce) {
             if (typeof input === 'string' || typeof input === 'number')
                 input = BigInt(input);
         }
         if (typeof input === 'bigint')
             return input;
-        context.failure(`{{label}} is not a valid BigInt`);
+        context.fail(_this, `{{label}} is not a valid BigInt`, input);
     }, options);
 }

package/esm/rules/is-boolean.js

@@ -7,7 +7,7 @@ const FALSE_PATTERN = /^false|f|0|no|n$/i;
  * @validator isBoolean
  */
 export function isBoolean(options) {
-    return validator('isBoolean', function (input, context) {
+    return validator('isBoolean', function (input, context, _this) {
         if (input != null && typeof input !== 'boolean' && context.coerce) {
             if (typeof input === 'string') {
                 if (TRUE_PATTERN.test(input))
@@ -21,6 +21,6 @@ export function isBoolean(options) {
         }
         if (typeof input === 'boolean')
             return input;
-        context.failure(`{{label}} is not a valid boolean`);
+        context.fail(_this, `{{label}} is not a valid boolean`, input);
     }, options);
 }

package/esm/rules/is-date.js

@@ -9,7 +9,7 @@ dayjs.extend(customParseFormat);
  * @validator isDate
  */
 export function isDate(options) {
-    return validator('isDate', function (input, context) {
+    return validator('isDate', function (input, context, _this) {
         if (input != null && !(input instanceof Date) && context.coerce) {
             if (typeof input === 'string') {
                 const d = dayjs(input, options?.format);
@@ -21,13 +21,10 @@ export function isDate(options) {
         }
         if (input && input instanceof Date && !isNaN(input.getTime()))
             return input;
-        context.failure({
-            message: `{{label}} is not a valid Date instance` +
-                (context.coerce
-                    ? ` or a date formatted${options?.format ? " (" + options.format + ")" : ''} string`
-                    : ''),
-            format: options?.format
-        });
+        context.fail(_this, `{{label}} is not a valid Date instance` +
+            (context.coerce
+                ? ` or a date formatted${options?.format ? " (" + options.format + ")" : ''} string`
+                : ''), input, { format: options?.format });
     }, omitKeys(options || {}, ['format']));
 }
 /**
@@ -38,7 +35,7 @@ export function isDate(options) {
 export function isDateString(options) {
     const inputFormat = options?.format;
     const coerceFormat = Array.isArray(options?.format) ? options?.format[0] : options?.format;
-    return validator('isDateString', function (input, context) {
+    return validator('isDateString', function (input, context, _this) {
         if (input instanceof Date) {
             const d = dayjs(input);
             if (d.isValid())
@@ -52,9 +49,6 @@ export function isDateString(options) {
                 return input;
             }
         }
-        context.failure({
-            message: `{{label}} is not a valid date formatted${options?.format ? " (" + options.format + ")" : ''} string`,
-            format: options?.format
-        });
+        context.fail(_this, `{{label}} is not a valid date formatted${options?.format ? " (" + options.format + ")" : ''} string`, input, { format: options?.format });
     }, omitKeys(options || {}, ['format']));
 }

package/esm/rules/is-empty.js

@@ -4,7 +4,7 @@ import { validator } from '../core/index.js';
  * @validator isEmpty
  */
 export function isEmpty(options) {
-    return validator('isEmpty', function (input, context) {
+    return validator('isEmpty', function (input, context, _this) {
         if (input != null) {
             if (typeof input === 'string') {
                 if (!input)
@@ -27,7 +27,7 @@ export function isEmpty(options) {
                     return input;
             }
         }
-        context.failure(`{{label}} is not empty`);
+        context.fail(_this, `{{label}} is not empty`, input);
     }, options);
 }
 /**
@@ -35,7 +35,7 @@ export function isEmpty(options) {
  * @validator isNotEmpty
  */
 export function isNotEmpty(options) {
-    return validator('isNotEmpty', function (input, context) {
+    return validator('isNotEmpty', function (input, context, _this) {
         if (input != null) {
             if (typeof input === 'string') {
                 if (input)
@@ -58,6 +58,6 @@ export function isNotEmpty(options) {
                     return input;
             }
         }
-        context.failure(`{{label}} is empty`);
+        context.fail(_this, `{{label}} is empty`, input);
     }, options);
 }

package/esm/rules/is-enum.js

@@ -15,12 +15,9 @@ export function isEnum(values, options) {
             a[v] = true;
         return a;
     }, {});
-    return validator('isEnum', function (input, context) {
+    return validator('isEnum', function (input, context, _this) {
         if (input != null && valObj[typeof input === 'string' && caseInSensitive ? input.toUpperCase() : input])
             return input;
-        context.failure({
-            message: `Value must be one of enumeration member${enumName ? ` (${enumName})` : ''}`,
-            enum: enumName
-        });
+        context.fail(_this, `Value must be one of enumeration member${enumName ? ` (${enumName})` : ''}`, input, { enum: enumName });
     }, options);
 }

package/esm/rules/is-integer.js

@@ -5,7 +5,7 @@ import { validator } from '../core/index.js';
  * @validator isInteger
  */
 export function isInteger(options) {
-    return validator('isInteger', function (input, context) {
+    return validator('isInteger', function (input, context, _this) {
         if (input != null && typeof input !== 'number' && context.coerce) {
             if (typeof input === 'string')
                 input = parseFloat(input);
@@ -17,6 +17,6 @@ export function isInteger(options) {
         }
         if (typeof input === 'number' && !isNaN(input) && Number.isInteger(input))
             return input;
-        context.failure(`{{label}} is not a valid integer number`);
+        context.fail(_this, `{{label}} is not a valid integer number`, input);
     }, options);
 }

package/esm/rules/is-matches.js

@@ -6,15 +6,11 @@ import { validator } from '../core/index.js';
 export function isMatches(format, options) {
     const regExp = format instanceof RegExp ? format : new RegExp(format);
     const formatName = options?.formatName;
-    return validator('matches', function (input, context) {
+    return validator('matches', function (input, context, _this) {
         if (input == null)
             return;
         if (typeof input === 'string' && regExp.test(input))
             return input;
-        context.failure({
-            message: `{{label}} does not match ${formatName || 'requested'} format`,
-            format,
-            formatName
-        });
+        context.fail(_this, `{{label}} does not match ${formatName || 'requested'} format`, input, { format, formatName });
     }, options);
 }

package/esm/rules/is-null.js

@@ -4,10 +4,10 @@ import { validator } from '../core/index.js';
  * @validator isNull
  */
 export function isNull(options) {
-    return validator('isNull', function (input, context) {
+    return validator('isNull', function (input, context, _this) {
         if (input === null)
             return input;
-        context.failure(`{{label}} is not null`);
+        context.fail(_this, `{{label}} is not null`, input);
     }, options);
 }
 /**
@@ -15,10 +15,10 @@ export function isNull(options) {
  * @validator isDefined
  */
 export function isDefined(options) {
-    return validator('is-defined', function (input, context) {
+    return validator('is-defined', function (input, context, _this) {
         if (input !== undefined)
             return input;
-        context.failure(`{{label}} is not defined`);
+        context.fail(_this, `{{label}} is not defined`, input);
     }, options);
 }
 /**
@@ -26,9 +26,9 @@ export function isDefined(options) {
  * @validator isNotDefined
  */
 export function isUndefined(options) {
-    return validator('isUndefined', function (input, context) {
+    return validator('isUndefined', function (input, context, _this) {
         if (input === undefined)
             return;
-        context.failure(`{{label}} defined`);
+        context.fail(_this, `{{label}} defined`, input);
     }, options);
 }

package/esm/rules/is-number.js

@@ -5,7 +5,7 @@ import { validator } from '../core/index.js';
  * @validator isNumber
  */
 export function isNumber(options) {
-    return validator('isNumber', function (input, context) {
+    return validator('isNumber', function (input, context, _this) {
         if (input != null && typeof input !== 'number' && context.coerce) {
             if (typeof input === 'string')
                 input = parseFloat(input);
@@ -17,6 +17,6 @@ export function isNumber(options) {
         }
         if (typeof input === 'number' && !isNaN(input))
             return input;
-        context.failure(`{{label}} is not a valid number`);
+        context.fail(_this, `{{label}} is not a valid number`, input);
     }, options);
 }

package/esm/rules/is-object-id.js

@@ -5,14 +5,14 @@ import { validator } from '../core/index.js';
  * @validator isObjectId
  */
 export function isObjectId(options) {
-    return validator('isObjectId', function (input, context) {
+    return validator('isObjectId', function (input, context, _this) {
         if (input != null &&
             (_isObjectIdValue(input) ||
                 (typeof input === 'object' &&
                     typeof input.toHexString === 'function' &&
                     _isObjectIdValue(input.toHexString()))))
             return input;
-        context.failure(`{{label}} is not a valid ObjectId`);
+        context.fail(_this, `{{label}} is not a valid ObjectId`, input);
     }, options);
 }
 function _isObjectIdValue(input) {

package/esm/rules/is-object.js

@@ -1,4 +1,4 @@
-import { isValidator, kValidatorFn, validator } from '../core/index.js';
+import { isValidator, validator } from '../core/index.js';
 /**
  * Validates object according to schema
  * Converts properties according to schema rules if coerce option is set to 'true'.
@@ -28,9 +28,9 @@ export function isObject(schema, options) {
         else
             throw new TypeError(`Invalid definition in validation schema (${k})`);
     });
-    const _rule = validator('isObject', function (input, context) {
+    const _rule = validator('isObject', function (input, context, _this) {
         if (!(input && typeof input === 'object')) {
-            context.failure(`{{label}} must be an object`);
+            context.fail(_this, `{{label}} is not an object`, input);
             return;
         }
         const keys = [...Object.keys(input), ...Object.keys(schema)];
@@ -49,8 +49,9 @@ export function isObject(schema, options) {
                 return context.circMap.get(input);
             context.circMap.set(input, out);
         }
-        const rootName = context.root?.input.context;
-        const location = context.input.location || '';
+        if (context.root == null)
+            context.root = context.root || ctorName || '';
+        const location = context.location || '';
         const processedSchemaKeys = {};
         // Iterate object keys and perform rules
         for (i = 0; i < l; i++) {
@@ -63,23 +64,20 @@ export function isObject(schema, options) {
                 if (processedSchemaKeys[schemaKey])
                     continue;
                 processedSchemaKeys[schemaKey] = true;
-                const subCtx = context.extend(_propRule);
-                if (ctorName) {
-                    if (rootName && rootName !== ctorName)
-                        subCtx.input.root = rootName;
-                    subCtx.input.context = ctorName;
-                }
-                subCtx.input.value = v;
-                subCtx.input.label = propertyOptions[schemaKey]?.label || schemaKey;
-                subCtx.input.location = location + (location ? '.' : '') + schemaKey;
-                subCtx.input.property = schemaKey;
-                v = _propRule[kValidatorFn](v, subCtx, _propRule);
+                const subCtx = context.extend();
+                subCtx.scope = input;
+                subCtx.context = ctorName;
+                subCtx.location = location + (location ? '.' : '') + schemaKey;
+                subCtx.property = schemaKey;
+                if (propertyOptions[schemaKey]?.label)
+                    subCtx.label = propertyOptions[schemaKey]?.label;
+                v = _propRule(v, subCtx);
             }
             else if (v !== undefined) {
-                if (additionalFields === 'ignore')
-                    continue;
                 if (!additionalFields)
-                    context.failure(`${ctorName || 'Object'} has no field '${inputKey}' and does not accept additional fields`);
+                    continue;
+                if (additionalFields === 'error')
+                    context.fail(_propRule, `${ctorName || 'Object'} has no field '${inputKey}' and does not accept additional fields`, v);
             }
             if (v !== undefined)
                 out[propertyOptions[schemaKey]?.as || schemaKey] = v;

package/esm/rules/is-record.js

@@ -1,18 +1,18 @@
-import { kValidatorFn, validator, } from '../core/index.js';
+import { validator, } from '../core/index.js';
 /**
  * Validates record object according to given "key" and "value" rules
  * Converts properties according to rules if coerce option is set to 'true'.
  * @validator isRecord
  */
 export function isRecord(keyRule, valueRule, options) {
-    return validator('isRecord', function (input, context) {
+    return validator('isRecord', function (input, context, _this) {
         if (!(input && typeof input === 'object')) {
-            context.failure(`{{label}} is not an object`);
+            context.fail(_this, `{{label}} is not an object`, input);
             return;
         }
-        const location = context.input.location || '';
-        const keyContext = context.extend(keyRule);
-        const valueContext = context.extend(valueRule);
+        const keyContext = context.extend();
+        const valueContext = context.extend();
+        const location = context.location || '';
         const keys = Object.keys(input);
         const l = keys.length;
         let i;
@@ -22,14 +22,14 @@ export function isRecord(keyRule, valueRule, options) {
         for (i = 0; i < l; i++) {
             k = keys[i];
             v = input[k];
-            keyContext.input.value = k;
-            keyContext.input.property = '@' + k;
-            keyContext.input.location = location + (location ? '.@' : '@') + k;
-            k = keyRule[kValidatorFn](k, keyContext, keyRule);
-            valueContext.input.value = v;
-            valueContext.input.property = k;
-            valueContext.input.location = location + (location ? '.' : '') + k;
-            v = valueRule[kValidatorFn](v, valueContext, valueRule);
+            // Validate key
+            keyContext.property = '@' + k;
+            keyContext.location = location + (location ? '.@' : '@') + k;
+            k = keyRule(k, keyContext);
+            // Validate value
+            valueContext.property = k;
+            valueContext.location = location + (location ? '.' : '') + k;
+            v = valueRule(v, valueContext);
             out[k] = v;
         }
         return context.errors.length ? undefined : out;

package/esm/rules/is-string.js

@@ -5,7 +5,7 @@ import { validator } from '../core/index.js';
  * @validator isString
  */
 export function isString(options) {
-    return validator('isString', function (input, context) {
+    return validator('isString', function (input, context, _this) {
         if (input != null && typeof input !== 'string' && context.coerce) {
             if (typeof input === 'object') {
                 if (typeof input.toJSON === 'function')
@@ -18,7 +18,7 @@ export function isString(options) {
         }
         if (typeof input === 'string')
             return input;
-        context.failure(`{{label}} is not a string`);
+        context.fail(_this, `{{label}} is not a string`, input);
     }, options);
 }
 export function stringReplace(searchValue, replacer) {

package/esm/rules/is-tuple.js

@@ -1,27 +1,30 @@
-import { kValidatorFn, validator } from '../core/index.js';
+import { validator } from '../core/index.js';
 export function isTuple(items, options) {
-    return validator('isTuple', function (input, context) {
+    return validator('isTuple', function (input, context, _this) {
         if (input != null && context.coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.failure(`{{label}} is not a valid tuple`);
+            context.fail(_this, `{{label}} is not a tuple`, input);
             return;
         }
-        const location = context.input.location || '';
+        const location = context.location || '';
         let itemRule;
         let i;
+        let v;
         const l = input.length;
         const out = [];
         const nl = items.length;
+        const itemContext = context.extend();
         for (i = 0; i < l && i < nl; i++) {
             itemRule = items[i];
-            const itemContext = context.extend(itemRule);
-            itemContext.input.value = input[i];
-            itemContext.input.label = ((context.input.label || context.input.property) || 'Item') +
+            itemContext.scope = input;
+            itemContext.label = context.label ? context.label + `[${i}]` : undefined;
+            itemContext.index = i;
+            itemContext.location = location + '[' + i + ']';
+            itemContext.label = (itemContext.label || itemContext.property || 'Value at ') +
                 `[${i}]`;
-            itemContext.input.property = i;
-            itemContext.input.location = location + '[' + i + ']';
-            out.push(itemRule[kValidatorFn](input[i], itemContext, itemRule) ?? null);
+            v = itemRule(input[i], itemContext);
+            out.push(v);
         }
         return context.errors.length ? undefined : out;
     }, options);

package/esm/rules/length.js

@@ -6,7 +6,7 @@ import { isGte, isLte } from './range.js';
  * @validator getLength
  */
 export const extractLength = () => extractLengthRule;
-const extractLengthRule = validator('extractLength', function (input, context) {
+const extractLengthRule = validator('extractLength', function (input, context, _this) {
     if (typeof input === 'string')
         return input.length;
     if (Array.isArray(input))
@@ -17,7 +17,7 @@ const extractLengthRule = validator('extractLength', function (input, context) {
         return input.length;
     if (input && typeof input === 'object' && typeof input.size === 'number')
         return input.size;
-    context.failure(`Unable to extract length of {{label}}`);
+    context.fail(_this, `Unable to extract length of {{label}}`, input);
 });
 /**
  * Checks the length is at least "minValue"

package/esm/rules/optional.js

@@ -1,4 +1,4 @@
-import { kValidatorFn, validator } from '../core/index.js';
+import { validator } from '../core/index.js';
 /**
  * Makes sub-rule optional
  * @validator optional
@@ -7,7 +7,7 @@ export function optional(nested, options) {
     return validator('optional', function (input, context) {
         if (input == null)
             return input;
-        return nested[kValidatorFn](input, context, nested);
+        return nested(input, context);
     }, options);
 }
 /**
@@ -15,12 +15,12 @@ export function optional(nested, options) {
  * @validator required
  */
 export function required(nested, options) {
-    return validator('required', function (input, context) {
+    return validator('required', function (input, context, _this) {
         if (input == null) {
-            context.failure(`{{label}} is required`);
+            context.fail(_this, `{{label}} is required`, input);
             return;
         }
-        return nested[kValidatorFn](input, context, nested);
+        return nested(input, context);
     }, options);
 }
 /**
@@ -28,11 +28,11 @@ export function required(nested, options) {
  * @validator exists
  */
 export function exists(options) {
-    return validator('exists', function (input, context) {
+    return validator('exists', function (input, context, _this) {
         if (input !== undefined ||
-            (context.input.value && context.parent &&
-                Object.getOwnPropertyDescriptor(context.input.value, context.input.property)))
+            (context.scope &&
+                Object.getOwnPropertyDescriptor(context.scope, input)))
             return input;
-        context.failure(`{{label}} must exist`);
+        context.fail(_this, `{{label}} must exist`, input);
     }, options);
 }

package/esm/rules/pipe.js

@@ -1,4 +1,4 @@
-import { kValidatorFn, validator } from '../core/index.js';
+import { validator } from '../core/index.js';
 /**
  *
  * @validator pipe
@@ -11,8 +11,7 @@ export function pipe(...rules) {
         let v = input;
         for (i = 0; i < l; i++) {
             c = rules[i];
-            const subContext = context.extend(c);
-            v = c[kValidatorFn](v, subContext, c);
+            v = c(v, context);
             if (context.errors.length)
                 return;
         }
@@ -30,8 +29,7 @@ export function allOf(...rules) {
         const l = rules.length;
         for (i = 0; i < l; i++) {
             c = rules[i];
-            const subContext = context.extend(c);
-            c[kValidatorFn](input, subContext, c);
+            c(input, context);
         }
         return input;
     });

package/esm/rules/range.js

@@ -1,6 +1,6 @@
 import { validator } from '../core/index.js';
 export function isGt(minValue, options) {
-    return validator('isGt', function (input, context) {
+    return validator('isGt', function (input, context, _this) {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input > minValue)
@@ -11,11 +11,11 @@ export function isGt(minValue, options) {
             (input > minValue ||
                 (options?.caseInsensitive && input.toLowerCase() > minValue.toLowerCase())))
             return input;
-        context.failure(`{{label}} must be greater than ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`);
+        context.fail(_this, `{{label}} must be greater than ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`, input);
     }, options);
 }
 export function isGte(minValue, options) {
-    return validator('isGte', function (input, context) {
+    return validator('isGte', function (input, context, _this) {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input >= minValue)
@@ -26,11 +26,11 @@ export function isGte(minValue, options) {
             (input >= minValue ||
                 (options?.caseInsensitive && input.toLowerCase() >= minValue.toLowerCase())))
             return input;
-        context.failure(`{{label}} must be greater than or equal to ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`);
+        context.fail(_this, `{{label}} must be greater than or equal to ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`, input);
     }, options);
 }
 export function isLt(maxValue, options) {
-    return validator('isLt', function (input, context) {
+    return validator('isLt', function (input, context, _this) {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input < maxValue)
@@ -41,11 +41,11 @@ export function isLt(maxValue, options) {
             (input < maxValue ||
                 (options?.caseInsensitive && input.toLowerCase() < maxValue.toLowerCase())))
             return input;
-        context.failure(`{{label}} must be lover than ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`);
+        context.fail(_this, `{{label}} must be lover than ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`, input);
     }, options);
 }
 export function isLte(maxValue, options) {
-    return validator('isLt', function (input, context) {
+    return validator('isLt', function (input, context, _this) {
         if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
             input <= maxValue)
@@ -56,7 +56,7 @@ export function isLte(maxValue, options) {
             (input <= maxValue ||
                 (options?.caseInsensitive && input.toLowerCase() <= maxValue.toLowerCase())))
             return input;
-        context.failure(`{{label}} must be lover than or equal to ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`);
+        context.fail(_this, `{{label}} must be lover than or equal to ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`, input);
     }, options);
 }
 /**
@@ -64,7 +64,7 @@ export function isLte(maxValue, options) {
  * @validator range
  */
 export function range(minValue, maxValue, options) {
-    return validator('range', function (input, context) {
+    return validator('range', function (input, context, _this) {
         if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
             (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
             (typeof input === 'number' || typeof input === 'bigint') &&
@@ -76,6 +76,6 @@ export function range(minValue, maxValue, options) {
         if (typeof minValue === 'string' && typeof maxValue === 'string' &&
             typeof input === 'string' && input >= minValue && input <= maxValue)
             return input;
-        context.failure(`{{label}} must be between ${minValue} and ${maxValue}`);
+        context.fail(_this, `{{label}} must be between ${minValue} and ${maxValue}`, input);
     }, options);
 }