grule

Um mecanismo simples e poderoso para validação de regras em JSON.

_{Construído com ❤︎ por Hiukky}

Sobre

Grule é um mecanismo mínimo para testar condições em relação a valores usando um esquema JSON. Seu principal objetivo é funcionar como um mecanismo de Rete e resolver todas as operações de forma performática e simples.

Instalação

Usando NPM

npm i grule

Usando Fio

yarn add grule

Usar

Para configurar seu esquema de regras, basta seguir as etapas abaixo.

Crie uma instância

Para criar uma instância de teste, você precisará de muitos fatos para alimentar o mecanismo.

 // Import Engine
import { Grule } from 'grule'

// Create an type
type IUser = {
  id : number
  name : string
}

// Create metadata
const metadata : IUser = {
  id : 3 ,
  name : 'test' ,
}

// Create instance
const grule = new Grule < IUser > ( metadata )

Regras de assinatura

Após criar uma instância do motor, pré-carregando os fatos, o próximo passo é cadastrar as regras. Para cadastrar as regras é necessário importar a interface IRules <T> e criar um conjunto de regras para os atributos declarados nos fatos.

As regras seguem a estrutura dos dados declarados nos fatos. Para cada atributo uma regra será executada.

A função de criação de regras oferece 2 argumentos, sendo o primeiro os attributes e o segundo os events .

Você pode usar uma expressão lógica para cada teste e executar uma ação desejada ou pode usar o evento when e then para testar e executar uma ação com base no resultado. Esta é uma boa opção para testes dinâmicos.

Após criar uma instância e registrar as regras, você pode simplesmente executar o método run passando as regras definidas como parâmetro. Ao final dos testes, caso não haja nenhum erro que interrompa o fluxo dos testes, será retornado um valor booleano.

• true todas as condições foram aprovadas.
• false uma ou todas as condições falharam.

 // ... Previous code

// Create Rules
const rules : IRules < IUser > = ( { id , name } , { when } ) => ( {
  id : when ( id . diff ( 1 ) ) . then ( ( ) => {
    throw new Error ( 'User not allowed.' )
  } ) ,
  name : name . in ( [ 'foo' , 'test' ] ) ,
} )

// Enroll rules
grule . run ( rules )

Você também pode simplificar o fluxo anterior de uma forma mais limpa. (Exemplo de código final)

 // Import Engine
import { Grule } from 'grule'

// Create an type
type IUser = {
  id : number
  name : string
}

// Create instance
new Grule < IUser > ( {
  id : 3 ,
  name : 'test' ,
} ) . run ( ( { id , name } , { when } ) => ( {
  id : when ( id . diff ( 1 ) ) . then ( ( ) => {
    throw new Error ( 'User not allowed.' )
  } ) ,
  name : name . in ( [ 'foo' , 'test' ] ) ,
} ) ) 

Métodos disponíveis

Para atributos

Cada atributo possui 9 métodos disponíveis para os testes que são.

• menos

 // Type: less(value: ILess): boolean
// Acceptable: ['number', 'bigint']

• menos ou igual

 // Type: lessOrEqual(value: ILess): boolean
// Acceptable: ['number', 'bigint']

• maior

 // Type: greater(value: IGreater): boolean
// Acceptable: ['number', 'bigint']

• maiorOrEqual

 // Type: greaterOrEqual(value: IGreater): boolean
// Acceptable: ['number', 'bigint']

• igual

 // Type: equal(value: IEqual): boolean
// Acceptable: ['bigint', 'boolean', 'number', 'string', 'date']

• diferença

 // Type: diff(value: IEqual): boolean
// Acceptable: ['bigint', 'boolean', 'number', 'string', 'date']

• em

 // Type: in(value: In): boolean
// Acceptable: ['bigint', 'boolean', 'number', 'string', 'array']

• nãoIn

 // Type: notIn(value: In): boolean
// Acceptable: ['bigint', 'boolean', 'number', 'string', 'array']

• avaliação

 // Type: eval(operator: IOperatorsList, arg1: A): boolean
// Acceptable: [Idle]

Para eventos

Grule atualmente tem apenas um evento além de when . Retorna uma promessa com um resultado booleano do teste realizado.

• quando

 // Type: when(test: boolean): Promise<boolean>
// Acceptable: ['boolean']

Contribuindo

O Grule está em uma versão inicial sem muitas funcionalidades ainda, mas você pode ficar à vontade para enviar sua sugestão ou abrir um PR.