JSPM

Usage • Why? • Features • Examples • Documentation

Parser

Indicative parser parses the user defined schema object to a tree of nodes. Using this, the end user can always define their rules as a flat object and it's the job of the parser to expand it to a nested object.

Usage

Install the package from npm

npm i indicative-parser

# yarn user
yarn add indicative-parser

and then usage it as follows

const { rulesParser, messagesParser } = require('indicative-parser')

console.log(rulesParser({
  'client_id': 'required',
  'settings.key': 'required',
  'users.*.email': 'required|email'
}))

// messages parser
console.log(messagesParser({
  'users.*.email.required': 'Email is required',
  'users.*.email.email': 'Invalid email address'
}))

The parser tree emits three types of nodes, which are explained below:

Literal type

The literal type is the reference to the final property or leaf in the tree. A literal node doesn't have any children.

{
  username: 'required'
}

Output

{
  username: {
    type: 'literal',
    rules: [{
      name: 'required',
      args: [],
    }],
  },
}

Object type

The object type defines an object, which will always have one or more children.

Following is an example of object node.

{
  'user.profile': 'required'
}

Output

{
  user: {
    type: 'object',
    rules: [],
    children: {
      profile: {
        rules: [
          {
            name: 'required',
            args: [],
          },
        ],
        type: 'literal',
      },
    },
  },
}

In the above code example, you can see that the properties before the dot . notation is marked as type = object and last property username is considered a literal. There is no limit to the depth of the object.

Array type

The array type detects the array expressions as shown below.

{
  'users.*.username': 'required'
}

Output

{
  users: {
    type: 'array',
    rules: [],
    each: {
      '*': {
        rules: [],
        children: {
          username: {
            type: 'literal',
            rules: [
              {
                name: 'required',
                args: [],
              },
            ],
          },
        },
      },
    },
  },
}

A node is considered as an array when it has * or numeric expressions. The each property contains a sub object for each defined index with nested children.

What's next?

The output of parser is used by compiler to create a top level function, which executes the validations on runtime data object.