Fixing not operation

Author: mavarazy

README.md

@@ -37,7 +37,7 @@ let rules = [{
     event: {
         type: "remove",
         params: { 
-            fields: [ "password" ]
+            field: "password"
         },
     }
 }];
@@ -60,11 +60,42 @@ engine
 
 ```
 
-## Schema and rules validation on construction
+Rules engine expects to know all the rules in advance, it effectively drops builder pattern, but keeps the interface.
+
+## Validation
 
 In order to prevent most common errors, `Engine` does initial validation on the schema, during construction.
-If no `schema` is provided to the constructor 
+Validation is done automatically if you specify `schema` during construction.
+ 
+```js
+let rules = [{
+    conditions: {
+      firstName: "empty"
+    },
+    event: {
+        type: "remove",
+        params: { field: "password" },
+    }
+}];
+
+let schema = {
+    properties: {
+        firstName: { type: "string" },
+        lastName: { type: "string" }
+    }
+}
+
+let engine = new Engine(rules, schema);
+```
+### Types of errors
+
+- Conditions field validation (conditions use fields that are not part of the schema)
+- Predicate validation (used predicates are not part of the
+ [predicates](https://github.com/landau/predicate) library and most likely wrong)
+
+Validation is done only during development, validation is disabled by default in `production`. 
 
+WARNING!!! Currently validation does not support nested structures, so be extra careful, when using those.
 
 ## Conditional logic
 
@@ -73,44 +104,119 @@ with boolean logic extension.
 
 [Predicate](https://github.com/landau/predicate) library has a lot of predicates that we found more, than sufficient for our use cases.
 
+To showcase conditional logic, we'll be using simple `registration` schema
+
+```js
+let schema = {
+  definitions: {
+    hobby: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        durationInMonth: { type: "integer" },
+      }
+    }
+  },
+  title: "A registration form",
+  description: "A simple form example.",
+  type: "object",
+  required: [
+    "firstName",
+    "lastName"
+  ],
+  properties: {
+    firstName: {
+      type: "string",
+      title: "First name"
+    },
+    lastName: {
+      type: "string",
+      title: "Last name"
+    },
+    age: {
+      type: "integer",
+      title: "Age",
+    },
+    bio: {
+      type: "string",
+      title: "Bio",
+    },
+    country: {
+      type: "string",
+      title: "Country" 
+    },
+    state: {
+      type: "string",
+      title: "State" 
+    },
+    zip: {
+      type: "string",
+      title: "ZIP" 
+    },
+    password: {
+      type: "string",
+      title: "Password",
+      minLength: 3
+    },
+    telephone: {
+      type: "string",
+      title: "Telephone",
+      minLength: 10
+    },
+    work: { "$ref": "#/definitions/hobby" },
+    hobbies: {
+        type: "array",
+        items: { "$ref": "#/definitions/hobby" }
+    }
+  }
+}
+```
+Assuming action part is taken from [react-jsonschema-form-conditionals](https://github.com/RxNT/react-jsonschema-form-conditionals)
+
 ### Single line conditionals
 
-Let's say we need to `remove` `password`, when `firstName` is missing, this can be expressed like this:
+Let's say we want to `remove` `password` , when `firstName` is missing, we can expressed it like this:
 
 ```js
 let rules = [{
     conditions: {
       firstName: "empty"
     },
     event: {
-        type: "remove",
-        params: { fields: [ "password" ] },
+      type: "remove",
+      params: {
+        field: "password"
+      }
     }
 }]
 ```
 
 This translates into -
-when `firstName` is `empty`, perform `remove` of `password`, pretty straightforward. 
+when `firstName` is `empty`, trigger `remove` `event`. 
 
 `Empty` keyword is [equal in predicate library](https://landau.github.io/predicate/#equal) and required 
-action will be performed only when `predicate.empty(registration.firstName)` is `true`. 
+event will be performed only when `predicate.empty(registration.firstName)` is `true`. 
 
 ### Conditionals with arguments
 
-Let's say we need to `remove` `telephone`, when `age` is `less` than `5`  
+Let's say we need to `require` `zip`, when `age` is `less` than `16`,
+because the service we are using is legal only after `16` in some countries   
 
 ```js
 let rules = [{
-    conditions: { age: { less : 5 } },
+    conditions: {
+      age: { less : 16 }
+    },
     event: {
-      type: "remove",
-      params: { fields: [ "telephone" ] }
+      type: "require",
+      params: {
+        field: "zip"
+      }
     }
 }]
 ```
 
-This translates into -  
-when `age` is `less` than 5, `remove` `telephone` field from the schema.
+This translates into -  when `age` is `less` than `16`, `require` zip.
 
 [Less](https://landau.github.io/predicate/#less) keyword is [less in predicate](https://landau.github.io/predicate/#less) and required 
 event will be returned only when `predicate.empty(registration.age, 5)` is `true`. 
@@ -121,73 +227,80 @@ event will be returned only when `predicate.empty(registration.age, 5)` is `true
 
 For the field AND is a default behavior.
 
-Looking at previous rule, we decide that we want to change the rule and `remove` a `telephone`, 
-when `age` is between `5` and `70`, so it would be available only to people older, than `70` and younger than `5`.
+Looking at previous rule, we decide that we want to change the rule and `require` `zip`, 
+when `age` is between `16` and `70`, so it would be available
+only to people older, than `16` and younger than `70`.
 
 ```js
 let rules = [{
     conditions: {
         age: {
-          greater: 5,
+          greater: 16,
           less : 70,
         }
     },
     event: {
-      type: "remove",
-      params: { fields: [ "telephone" ] }
+      type: "require",
+      params: {
+        field: "zip"
+      }
     }
 }]
 ```
 
 By default action will be applied only when both field conditions are true.
-In this case, when age is `greater` than 5 and `less` than 70.
+In this case, when age is `greater` than `16` and `less` than `70`.
 
 #### NOT
 
-Let's say we want to change the logic to opposite, and remove telephone when 
-age is greater, `less`er then `5` or `greater` than `70`, 
+Let's say we want to change the logic to opposite, and trigger event only when 
+`age` is `less`er then `16` or `greater` than `70`, 
 
 ```js
 let rules = [{
   conditions: {
     age: {
       not: {
-          greater: 5,
+          greater: 16,
           less : 70,
       }
     }
   },
   event: {
-    type: "remove",
-    params: { fields: "telephone"}
+    type: "require",
+    params: {
+      field: "zip"
+    }
   }
 }]
 ```
 
-This does it, since the final result will be opposite of the previous result.
+This does it, since the final result will be opposite of the previous condition.
 
 #### OR
 
-The previous example works, but it's a bit hard to understand, luckily we can express it in more natural way
+The previous example works, but it's a bit hard to understand, luckily we can express it differently
 with `or` conditional.
 
 ```js
 let rules = [{
   conditions: { age: { 
       or: [
-        { less : 5 },
-        { greater: 70 }
+        { lessEq : 5 },
+        { greaterEq: 70 }
       ]
     }
   },
   event: {
-    type: "remove",
-    params: { fields: "telephone" }
+    type: "require",
+    params: {
+      field: "zip"
+    }
   }
 }]
 ```
 
-This is the same as `NOT`, but easier to grasp.
+The result is the same as `NOT`, but easier to grasp.
 
 ### Boolean operations on multi fields
 
@@ -196,7 +309,7 @@ multi fields boolean operations.
 
 #### Default AND operation
 
-Let's say we want to `require` `bio`, when `age` is less than 70 and `country` is `USA`
+Let's say, when `age` is less than 70 and `country` is `USA` we want to `require` `bio`.
 
 ```js
 let rules = [{
@@ -266,9 +379,30 @@ let rules = [{
 
 ### Nested object queries
 
+Rules engine supports querying inside nested objects, with [selectn](https://github.com/wilmoore/selectn.js),
+any data query that works in [selectn](https://github.com/wilmoore/selectn.js), will work in here
+
+Let's say we need to require `state`, when `work` has a `name` `congressman`, this is how we can do this:
+
+```js
+let rules = [{
+    conditions: {
+      "work.name": {
+        name: { equals: "congressman" },
+      }
+    },
+    event: { 
+      type: "require",
+      params: { fields: [ "state" ]}
+    }
+}]
+```
+
+### Nested arrays object queries
+
 Sometimes we need to make changes to the form if some nested condition is true. 
 
-For example if one of the `hobbies` is "baseball", make `state` `required`.
+For example if one of the `hobbies` is `baseball`, we need to make `state` `required`.
 This can be expressed like this:
 
 ```js
@@ -285,10 +419,7 @@ let rules = [{
 }]
 ``` 
 
-## Contribute
-
-- Issue Tracker: github.com/RxNT/json-rules-engine-simplified/issues
-- Source Code: github.com/RxNT/json-rules-engine-simplified
+Rules engine will go through all the elements in the array and trigger `require` if `any` of the elements meet the criteria 
 
 ## Support
 
@@ -297,5 +428,4 @@ We have a mailing list located at: ...
 
 ## License
 
-The project is licensed under the ... license.
-
+The project is licensed under the Apache Licence 2.0.

src/Engine.js

@@ -10,14 +10,14 @@ class Engine {
       if (schema !== undefined && schema !== null) {
         if (isObject(schema)) {
           validatePredicates(conditions, schema);
-          validateConditionFields(conditions, schema)
+          validateConditionFields(conditions, schema);
         } else {
-          toError(`Expected valid schema object, but got - ${schema}`)
+          toError(`Expected valid schema object, but got - ${schema}`);
         }
       }
     }
   }
-  run = (formData) => Promise.resolve(applicableActions(this.rules, formData));
+  run = formData => Promise.resolve(applicableActions(this.rules, formData));
 }
 
 export default Engine;