At the moment, when chained, all rules have an AND relationship.

enforce(4).isNumeric().isNumber().largerThan(2);
/*
enforce that 4
is numeric AND
is of type number AND
is larger than 2
*/

It can be useful to also have OR relationships between enforcement rules such as

OR RELATIONSHIP
At least one rule must be truthy

enforce(value).any(
  enforce.isEmpty(),
  enforce.greaterThan(10)
);

This used to be difficult to achieve, but with the recent change #479 that allows for lazy evaluated enforcements (enforce.isArray()([])) it should be pretty straightforward.

Instructions:

To get this working, you need to add a new rule, you can call it any or anyOf, and have it take multiple functions. It should pass each of these functions the enforced value.

What we have at the moment is this:

enforce.isNumber() // -> returns a function that takes a value
enforce.isNumber()(5) // -> returns true
enforce.isNumber()('not_a_number') // -> returns false

The assumption is that the consumer will do this:

enforce(5).any(
  enforce.isNumber(),
  enforce.isUndefined()
);

and the any rule, will call each of the functions with 5.

See Shape for reference.

Add a new enforce rule:

enforce(5).isNull(null) // ✅
enforce(5).isNull(1) // 🚨
enforce(5).isNull(undefined) // 🚨

In the React example:
https://stackblitz.com/edit/vest-react-support-example
If an amount of 1$ is put into the the amount (which is an error - minimum of 2$ is required) - the class is still 'warning' and not 'error' (since it is also a warning - that the amount is less than 10)

Add a new enforce rule:

enforce(5).isUndefined(undefined) // ✅
enforce(5).isUndefined() // ✅
enforce(5).isUndefined(false) // 🚨

Based on this issue, #475, I realized there's a need to describe the different ways to have a cross field validation. The ways are briefly described in the issue, but they need to be turned into a documentation page.

The main scenarios:
Either/Or validations: At least one field needs to be validated
And validations: A field can only be validated if another field has been validated

Please submit a PR with the docs if you want to take it.

As mentioned here: #292

enforce(value).isNaN();

See isArray rule for reference.

 test('date', 'Just testing a date object.', () => {
    enforce(new Date())
      .isNotEmpty()
  });

This returns a validation error although new Date() is not empty. Seems like the isNotEmpty() method only works on strings, arrays and objects. How would you check if a date object exists or even is properly formatted?

Awesome project! Keep up the great work.

The PR template references a CONTRIBUTING.md file for contribution guidelines but the file is unavailable in the repository.

PR template text:

<!--
Before creating a pull request, please read our contributing guidelines:

CONTRIBUTING.md

Remember: Unless it is an urgent bugfix, please use `next` as the base for your PR

Please fill the following form (leave what's relevant)
-->

Hi 👋🏻

I'm adding sync/async validation mode to react-hook-form's vest resolver and at the same time, I'm updating from V2 to V3, thanks for your great work 👏🏻

I tried to use promisify but I get TypeScript errors.
You can find here a reproduction: https://codesandbox.io/s/pedantic-pond-15zuc

Hi,

I was trying to write some code to test the experimental vest/schema updates we discussed a couple of weeks ago (finally got to it at work). Not sure why but my Typescript project refuses to use vest/schema because it simply says it is an interface type. The error I get is:

'schema' only refers to a type, but is being used as a value here.

I cannot get typescript to import the file in vest/schema.js for the life of me. Any ideas?

At the moment you can use vest.get(suiteName) to get the suite's state, and vest.reset(suiteName) to erase it.

It could be nice to be able to access those without having to hold a reference to the suite name:

// validate.js

import vest from 'vest';

export default vest.create('suite-name', () => {
 /* ... */
});

// app.js

import v from './validate.js';

const res = v.get();

v.reset();

Can probably be added here:
https://github.com/ealush/vest/blob/latest/packages/vest/src/core/createSuite/index.js#L44-L58

Add __DEV__ global that will be true only in the development build. In all other builds it will be set to false.

This will allow providing more runtime metrics for development build.

https://github.com/ealush/vest/blob/latest/config/builds/vest.js#L56-L59

Steps to reproduce:

1. Type in a password with more than 1 char.
2. Focus out of the field

Expected:
Field should pass validation
Actual:
Field fails on validation

I did not check yet wether the issue is due to the example code or the actual library.

enforce.shape() supports defining an object schema, but it requires an exact match of an object. If the object contains extra keys, it will throw an error.

enforce.loose should implement the same behaviour of enforce.shape, but also allow extra keys to be present in the data object.

See Shape for reference.

At first I didn't think vest had a TypeScript declaration file but double checked the repo and found the types. I dug into node_modules/vest and the declaration file seems to be missing.

In each call to collectFailureMessage (https://github.com/ealush/vest/blob/latest/packages/vest/src/core/produce/collectFailureMessages.js#L14-L36) we go and recalculate all the values. This can be prevented if we cache it by the testObjects array.

Cache module is here: https://github.com/ealush/vest/blob/latest/packages/vest/src/lib/cache.js

Add a new enforce rule:

enforce(-5).isNegative() // ✅
enforce(5).isNegative() // 🚨

enforce(5).isPositive() // ✅
enforce(-5).isPositive() // 🚨

Similar to anyOf, we need an AND relationship rule: allOf.

In the following example value must both be a string and longer than 10.

enforce(value).allOf(
  enforce.longerThan(10),
  enforce.isString,
);

This can be even more useful when combined with templates and shape validations:

const User = enforce.template(
  enforce.loose({
    id: enforce.isNumber()
    name: enforce.shape({
      first: enforce.isString(),
      last: enforce.isString(),
      middle: enforce.optional(enforce.isString()),
    }),
  })
);

const DisabledAccount = enforce.template(
  enforce.loose({
    disabled: enforce.equals(true)
  })
)

enforce(value).allOf(
  User,
  DisabledAccount
);

Developer guidelines

1. Create a new file called allOf right next to anyOf. It should be pretty much the same, implementing the rules.some logic with some other counter mechanism.

2. To actually have it used by enforce, add it to this compounds export

3. Add a new test file here and test different scenarios

4. Add suitable types here and here (basically duplicate anyOf).

5. If you feel like it, also add suitable docs for this feature here

I'm not very good at English, so I'm sorry if my sentences aren't right.

I get the following error when I try to use from TypeScript:

import vest, { test } from 'vest'
import enforce from 'vest/enforceExtended'

const validate = vest.create('form', (data: { message: string }) => {
  test('message', 'message is Required', () => {
    enforce(data.message).isNotEmpty()
  })
})

export default validate

# yarn run tsc
src/validate.ts:6:27 - error TS2339: Property 'isNotEmpty' does not exist on type 'EnforceExtendMap<ExtendedRules>'.

6     enforce(data.message).isNotEmpty()
                            ~~~~~~~~~~

This is just a suggestion, but we'll fix vest.d.ts:

type EnforceExtendMap<T> = IEnforceRules<T> & {
  [K in keyof T]: (...args: any[]) => EnforceExtendMap<T>;
};

And replace this code:

IEnforceRules<T> & EnforceExtendMap<T> → EnforceExtendMap<T>

If it's OK, I'll create a pull-request.

Hello.

I'm using vest with React, and can't get some tests to work.
Could you please take a look?

  const validationSuite = vest.create((data = {}) => {
    // works
    test('password', 'Password must be at least 8 chars', () => {
      enforce(data.password).longerThanOrEquals(8);
    });
    //works
    test('password', 'Password must contain a digit', () => {
      enforce(data.password).matches(/[0-9]/);
    });

    // does not work
    test('password', 'Password must contain an uppercase symbol', () => {
      enforce(data.password).matches(/[^A-Z]/);
    });

    // does not work
    test('password', 'Password must contain an lowercase symbol', () => {
      enforce(data.password).matches(/[^a-z]/);
    });

    // does not work
    test('password', 'Password must contain a special character', () => {
      enforce(data.password.replace(/[^a-zA-Z0-9]/g, '')).lengthNotEquals(0);
    });
  });

  // react-hook-form
  const signUpForm = useForm({
    reValidateMode: 'onChange',
    resolver: vestResolver(validationSuite),
  });

Vest is still a relatively small library compared to its feature-set and also compared to other libraries in that space, but I believe its size could be reduced further down if we better structure the project.

This issue is here so we remember to prioritize for size.

Implement test.each (described here: #356 (comment)).

Similar to jest's each function, but slightly different. It can be discussed if we should support the printf formatting, or find an alternative.

The version published in npm contains only the minified code intended for browsers, so the sample code in the docs doesn't work in node.

import vest, { test, enforce } from 'vest'
               ^^^^
SyntaxError: The requested module 'vest' does not provide an export named 'test'

Hi,
Thanks for your work and this package.

I would like to validate objects with a lot of nested structure, like this:

{
	foos: [{ bar: '...' }, { bar: '...' }, { bar: '...' }, ...]
}

Do you recommend a particular way to write the validation tests with vest?

I tought about something basic like this, but maybe is there a better way?

const validate = vest.create('form', (formData) => {
	formData.foos.forEach((fooObject) => {
		test('bar', 'Must be between 2 and 10 chars', () => {
	        enforce(fooObject.bar).longerThanOrEquals(2).shorterThan(10);
	    });
	})
});

Thanks,
Mathieu.

At the moment we can access all suite methods via suite.get(). Alternatively, it would be very simple to add all the suite methods directly on top of suite:

Functions should be added here: https://github.com/ealush/vest/blob/latest/packages/vest/src/core/suite/createSuite.js#L60
They can all rely internally on suite.get().

Types should be added here: https://github.com/ealush/vest/blob/latest/packages/vest/src/typings/vest.d.ts#L168

Type summary:

hasErrors: (fieldName?: string) => boolean;

hasWarnings: (fieldName?: string) => boolean;

getErrors(): { [fieldName: string]: string[] };
getErrors(fieldName: string): string[];

getWarnings(): { [fieldName: string]: string[] };
getWarnings(fieldName: string): string[];

hasErrorsByGroup(groupName: string): boolean;
hasErrorsByGroup(groupName: string, fieldName: string): boolean;

hasWarningsByGroup(groupName: string): boolean;
hasWarningsByGroup(groupName: string, fieldName: string): boolean;

getErrorsByGroup(groupName: string): { [fieldName: string]: string[] };
getErrorsByGroup(groupName: string, fieldName: string): string[];

getWarningsByGroup(groupName: string): { [fieldName: string]: string[] };
getWarningsByGroup(groupName: string, fieldName: string): string[];

Will allow an at least one relationship between enforce assertions.

enforce(value).anyOf(enforce.longerThan(5), enforce.isEmpty())

This requires quite a big change to the way enforce currently works.

This rule can be quite useful when a future schema validation rule will be added to enforce.

The general idea is quite similar to the enforce.any rule:

enforce(value).isArrayOf(
  enforce.isString(),
  enforce.isNumber(),
 enforce.isArrayOf(...) // Yeah, why not? A recursive call should be pretty simple here
)

The idea is that at least one needs to be truthy in order for the condition to be met - alternatively, an empty array should probably be valid as well unless explicitly mentioned:

enforce(value).isArrayOf(
  enforce.isString()
).isNotEmpty()

See Shape for reference.

At the moment, validation rules are simple functions that return a boolean. If the rule's return value is false, enforce will throw an Error.

Rule example:

And where it throws:

This means that the thrown error is always a generic one, not indicating the rule thrown, or the expected behavior of the rule.

Jest has a nicer interface for constructing matchers that also includes a custom failure message for that rule:
https://jestjs.io/docs/en/expect#expectextendmatchers

This can be very beneficial for Vest DEV_MODE that's being planned. A debug dump could log all the failed rules and their failure messages.

I would like to preserve the current behavior of Vest rules to prevent a breaking change, but also support the more verbose failure style of:

{
	message: (ruleName, enforceValue, ...args) => ``, // someErrorMessage
    pass: true/false
}

The idea is to move all the modules that directly relate to a suite and put them in the same directory: packages/vest/src/core/suite.

• create core/suite directory
  • move createSuite to suite/create
  • move validate to suite/validate
  • move registerSuite to suite/register
  • move reset to suite/reset
  • move remove to suite/remove
  • move getSuiteState to suite/getState
  • move patch to suite/patch
  • move cleanupCompletedSuite to suite/cleanupCompleted
  • move getSuite to suite/getSuite (maybe just get? need to see how it feels to actually use it)
  • move setSuite to suite/setSuite (maybe just set? need to see how it feels to actually use it)
  • Move hasRemainingTests to suite/hasRemainingTests

Add a new enforce rule:

enforce('hello').startsWith('hell') // ✅
enforce('Hi').startsWith('t') // 🚨

Improve the documentation by adding a Vuejs sandbox.

Similar to anyOf, we need a mutual exclusion rule: oneOf.

In the following example value must either be shorter than five OR longer than 10, but never both.

enforce(value).oneOf(
  enforce.longerThan(10),
  enforce.shorterThan(5),
);

This can be even more useful when combined with templates and shape validations:

const User = enforce.template(
  enforce.shape({
    id: enforce.isNumber(),
    name: enforce.shape({
      first: enforce.isString(),
      last: enforce.isString(),
      middle: enforce.optional(enforce.isString()),
    }),
  })
);
const Group = enforce.template(
  enforce.shape({
    id: enforce.isNumber(),
    name: enforce.isString(),
  })
);

enforce(value).oneOf(
  User,
  Group
);

Improve the documentation by adding an Angular sandbox.

Hi. ✋🏿
I'm trying to create custom rule with return value, according to https://ealush.com/vest/#/./n4s/custom?id=custom-rules-return-value
But I got typescript error 😭

I think that problem is here:
https://github.com/ealush/vest/blob/latest/packages/vest/src/typings/enforce.d.ts#L129
Returned value should be like:

boolean | { pass: boolean, message: () => string }

It would be cool to have something like this: enforcer(10).not.greaterThan(20). this could allow that if you are writing a custom rule you don't have to write also the negative way.

https://jestjs.io/docs/en/expect#not

In the next branch, there seems to be a problem with test results not updating after failure. Might be related to the cache feature?

"typescript": "~3.8.3",

The idea is to have the option to run the tests in serially to force those tests not to run parallely.
The idea is from ava framework(https://openbase.io/js/ava-tf/documentation)
By adding .serial after the tests you can enforce it

import vest, { test } from 'vest';
import enforce from 'vest/enforceExtended';

export default vest.create('user_form', (data = {}, currentField) => {
  vest.only(currentField);

  test.serial('username', 'Username is required', () => {
    enforce(data.username).isNotEmpty();
  });

  test.serial('username', 'Username is too short', () => {
    enforce(data.username).longerThanOrEquals(3);
  });

  test.serial('password', 'Password is required', () => {
    enforce(data.password).isNotEmpty();
  });

  test.serial('password', 'Password already used', async () => {
    const response = await axios.post('http://localhost:3000/auth')
    enforce(response.code).matches(/200/);
  });

  if (data.password) {
    test.serial('confirm_password', 'Passwords do not match', () => {
      enforce(data.confirm_password).equals(data.password);
    });
  }

  test.serial('email', 'Email Address is not valid', () => {
    enforce(data.email).isEmail();
  });

  test.serial('tos', () => {
    enforce(data.tos).isTruthy();
  });
});

What do you think?

Thanks,
Ziv

Are cross field validations possible? Eg "either email or phone must be set".

Add a new enforce rule:

enforce('hello').endsWith('lo') // ✅
enforce('Hi').endsWith('H') // 🚨

Hi and thanks for the a great library!

I have trouble importing enforceExtended for some reason. Is the file missing or am I missing something?

Things I've tried:

// nope
import enforceExtended from 'vest/enforceExtented'; 

// installed n4s separately and tried this without success
import enforce from 'n4s/enforceExtended';

https://ealush.com/n4s/#/./business_rules

Is the documentation lagging behind? Should I install and use validator.js to solve email validation?

https://ealush.com/vest/#/./n4s/external

Same thing when trying to import promisify looks like.

import promisify from 'vest/promisify';
// Package "vest" exists but package.json "exports" does not include entry for "./promisify".

I am using Snowpack as the bundler btw, but my gut feeling it's package related and not bundler specific.

Update: I can import promisify from vest/promisify so it might be bundler specific after all 🤔

Also, this in Snowpack.

// fails
import { test, enforce, create } from 'vest';
// [chrome]: The requested module '../../web_modules/vest.js' does not provide an export named 'test'
// [firefox]: Uncaught SyntaxError: import not found: enforce

// this works in both Chrome and FF
import vest from 'vest';
const { create, enforce, test } = vest;

Very strange. Any ideas? Is this maybe affected by how the final package is generated? I am just brainstorming here.

Add a new enforce rule:

enforce(5).isBetween(0, 5) // ✅
enforce(5).isBetween(0, 10) // ✅
enforce(5).isBetween(0, 2) // 🚨

Currently enforceExtended is 29kb due to the validator.js rules. If we export each rule individually and let consumers mix and match it will make it way smaller.

import { enforce } from 'vest';
import isEmail from 'vest/enforce/isEmail;

enforce.extend({ isEmail })

Free internet points!
suite.remove(https://github.com/ealush/vest/blob/latest/packages/vest/src/core/suite/createSuite.js#L60) is missing a type, should be added here: https://github.com/ealush/vest/blob/latest/packages/vest/src/typings/vest.d.ts#L168

Type should be: reset: (fieldName: string) => void;