Merge pull request #2 from akmjenkins/feature/ci

CI

Author: akmjenkins

.github/workflows/test.yaml

@@ -0,0 +1,37 @@
+name: Build
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+
+      - uses: actions/cache@v2
+        with:
+          path: '**/node_modules'
+          key: ${{ runner.os }}-modules-${{ hashFiles('**/yarn.lock') }}
+
+      - name: Install packages
+        run: yarn
+
+      - name: Run Lint
+        run: yarn lint
+
+      - name: Run Tests
+        run: yarn test --coverage
+
+      - name: Coveralls
+        uses: coverallsapp/github-action@master
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}     
+
+      - name: Create Build
+        run: yarn build
+
+  

README.md

@@ -1,9 +1,22 @@
 # JSON Schema Rules Engine
 
+[![npm version](https://img.shields.io/npm/v/json-schema-rules-engine)](https://npmjs.org/package/akmjenkins/json-schema-rules-engine)
+[![Coverage Status](https://coveralls.io/repos/github/akmjenkins/json-schema-rules-engine/badge.svg)](https://coveralls.io/github/akmjenkins/json-schema-rules-engine)
+![Build Status](https://github.com/akmjenkins/json-schema-rules-engine/actions/workflows/test.yaml/badge.svg)
+[![Bundle Phobia](https://badgen.net/bundlephobia/minzip/json-schema-rules-engine)](https://bundlephobia.com/result?p=json-schema-rules-engine)
+
 A highly configurable rules engine based on [JSON Schema](https://json-schema.org/). Inspired by the popular [JSON rules engine](https://github.com/CacheControl/json-rules-engine).
 
 _NBD: It actually doesn't **have** to use JSON Schema, but it's suggested_
 
+## Why?
+
+Three reasons:
+
+1. Schema validation of a data structure can be used to implement boolean logic
+2. Tools for JSON schema are everywhere and support is wide
+3. Custom operators (like those in JSON rules engine) aren't sustainable. You can either make a PR for a new operator that may or may not get merged OR you have to take on the ownership in your own codebase of building and maintaining custom operators. With `json-schema-rules-engine`, you can implement new logic immediately whenever the spec is published (thanks to very actively maintained projects like [AJV](https://github.com/ajv-validator/ajv)).
+
 ## Features
 
 - Highly configurable - use any type of schema to express your logic (we strongly suggest JSON Schema)

jest.config.js

@@ -4,11 +4,12 @@ module.exports = {
     '^.+\\.ts?$': 'ts-jest',
   },
   transformIgnorePatterns: ['node_modules/(?!(node-fetch|fetch-blob)/)'],
+  collectCoverageFrom: ['./src/*.js'],
   coverageThreshold: {
     global: {
-      branches: 90,
-      functions: 90,
-      lines: 90,
+      branches: 50,
+      functions: 75,
+      lines: 75,
     },
   },
 };

package.json

@@ -1,27 +1,24 @@
 {
   "name": "json-schema-rules-engine",
-  "version": "0.0.1",
+  "version": "1.0.0",
   "description": "Rules engine based on JSON Schema",
   "main": "build/index.js",
   "author": "Adam Jenkins",
   "license": "MIT",
   "browser": "build/bundle.min.js",
-  "types": "index.d.ts",
+  "types": "build/index.d.ts",
   "keywords": [
     "json schema",
     "rules engine"
   ],
   "files": [
-    "build",
-    "index.d.ts"
+    "build"
   ],
   "scripts": {
-    "dist": "yarn lint && yarn test && yarn build",
     "clean": "rimraf build",
     "build": "yarn clean && yarn babel && rollup -c",
     "babel": "babel src -d build --copy-files --no-copy-ignored",
     "lint": "eslint src/",
-    "test:ci": "yarn test --coverage --coverageReporters=text-lcov | coveralls",
     "test": "jest"
   },
   "devDependencies": {
@@ -39,7 +36,6 @@
     "babel-jest": "^27.1.0",
     "benchmark": "^2.1.4",
     "benchmarkjs": "^0.1.8",
-    "coveralls": "^3.1.1",
     "eslint": "^7.32.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-import-resolver-typescript": "^2.4.0",

src/engine.js

@@ -26,14 +26,17 @@ export const createRulesEngine = (
     setRules: (next) => (rules = patch(next, rules)),
     run: async (context = {}) => {
       emit('start', { context, facts, rules, actions });
-      const execute = createJob(validator, {
-        ...options,
-        context,
-        facts,
-        rules,
-        actions,
+      const execute = createJob(
+        validator,
+        {
+          ...options,
+          context,
+          facts,
+          rules,
+          actions,
+        },
         emit,
-      });
+      );
 
       const results = await execute();
       emit('complete', { context, results });

src/evaluator.js

@@ -1,15 +1,37 @@
 export const createEvaluator =
   (validator, opts, emit, rule) =>
-  (factMapId) =>
+  (mapId) =>
   async ([factName, { params, path, is }]) => {
-    const onError = (params) => emit('error', { ...params, rule, factMapId });
+    emit('debug', { type: 'STARTING_FACT', rule, mapId, factName });
+    const onError = (params) =>
+      emit('error', { ...params, factName, rule, mapId });
 
     const fact = opts.facts[factName] || opts.context[factName];
     try {
       const value = await (typeof fact === 'function' ? fact(params) : fact);
       const resolved = path ? opts.resolver(value, path) : value;
+      emit('debug', {
+        type: 'EXECUTED_FACT',
+        rule,
+        mapId,
+        path,
+        factName,
+        value,
+        resolved,
+      });
       try {
         const result = await validator(resolved, is);
+        emit('debug', {
+          type: 'EVALUATED_FACT',
+          rule,
+          mapId,
+          path,
+          factName,
+          value,
+          resolved,
+          is,
+          result,
+        });
         return { factName, ...result, value, resolved };
       } catch (error) {
         onError({ type: 'FactEvaluationError', path, is, resolved });

src/fact.map.processor.js

@@ -3,6 +3,8 @@ import { createEvaluator } from './evaluator';
 export const createFactMapProcessor = (validator, opts, emit) => (rule) => {
   const evaluator = createEvaluator(validator, opts, emit, rule);
   return async (factMap, id) => {
+    emit('debug', { type: 'STARTING_FACT_MAP', rule, mapId: id });
+
     // flags for if there was an error processing the fact map
     // and if all evaluations in the fact map passed
     let error = false;
@@ -18,6 +20,8 @@ export const createFactMapProcessor = (validator, opts, emit) => (rule) => {
       return acc;
     }, {});
 
+    emit('debug', { type: 'FINISHED_FACT_MAP', rule, mapId: id, results });
+
     // return the results in the same form they were passed in
     return {
       [id]: {

src/index.d.ts

@@ -60,28 +60,32 @@ export type JobConstruct = EngineOptions & {
 type StartingFactMapEvent = {
   type: 'STARTING_FACT_MAP';
   rule: string;
-  index: number;
+  mapId: string | number;
 };
 
 type StartingFactEvent = {
   type: 'STARTING_FACT';
   rule: string;
-  index: number;
+  mapId: string | number;
+  factName: string;
 };
 
 type ExecutedFactEvent = {
   type: 'EXECUTED_FACT';
   rule: string;
-  index: number;
-  params: any;
+  mapId: string | number;
+  factName: string;
+  params?: any;
+  path?: string;
   value: any;
   resolved: any;
 };
 
 type EvaluatedFactEvent = {
   type: 'EVALUATED_FACT';
   rule: string;
-  index: number;
+  mapId: string | number;
+  factName: string;
   value: any;
   resolved: any;
   is: Record<string, any>;
@@ -91,6 +95,8 @@ type EvaluatedFactEvent = {
 type FactEvaluationError = {
   type: 'FactEvaluationError';
   rule: string;
+  mapId: string | number;
+  factName: string;
   error: Error;
   context: Context;
   factName: string;
@@ -103,7 +109,8 @@ type FactEvaluationError = {
 type FactExecutionError = {
   type: 'FactExecutionError';
   rule: string;
-  index: number;
+  mapId: string | number;
+  factName: string;
   error: Error;
   context: Context;
   factName: string;

src/rule.runner.js

@@ -14,11 +14,13 @@ export const createRuleRunner = (validator, opts, emit) => {
       opts.resolver,
     );
 
+    const process = processor(rule);
+
     const ruleResults = await Promise.all(
       Array.isArray(interpolated)
-        ? interpolated.map(processor(rule))
+        ? interpolated.map(process)
         : Object.entries(interpolated).map(([factMap, id]) =>
-            processor(rule)(factMap, id),
+            process(factMap, id),
           ),
     );