add examples

dist/index.d.ts

@@ -11,8 +11,7 @@ export interface NotOp {
     not: Expression;
 }
 export declare type Expression = FuncOp | AndOp | OrOp | NotOp;
-export declare type ExpressionContext = any;
-export declare type Func = (param: any, context: ExpressionContext) => boolean;
+export declare type Func = (param: any, context: any) => boolean;
 export declare type FunctionsTable = {
     [k: string]: Func;
 };

example/example.d.ts

@@ -0,0 +1 @@
+export {};

example/example.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const evaluator_1 = require("./lib/evaluator");
+const run = (expression, context) => {
+    const result = evaluator_1.evaluate(expression, context);
+    console.log(`Evaluating expression ${JSON.stringify(expression)} using context ${JSON.stringify(context)}`);
+    console.log(`Result: ${result}`);
+};
+let context = {
+    userId: 'a@b.com',
+    times: 3
+};
+let expression = {
+    user: 'a@b.com'
+};
+run(expression, context);
+expression = {
+    and: [
+        { user: 'a@b.com' },
+        { maxCount: 5 },
+    ]
+};
+run(expression, context);
+expression = {
+    and: [
+        { user: 'a@b.com' },
+        { maxCount: 1 },
+    ]
+};
+run(expression, context);
+expression = {
+    or: [
+        { user: 'a@b.com' },
+        { maxCount: 6 },
+    ]
+};
+run(expression, context);

example/example.ts

@@ -0,0 +1,51 @@
+"use strict";
+
+import {evaluate, ExpressionContext} from './lib/evaluator';
+import {Expression} from "../dist";
+
+const run = (expression: Expression, context: ExpressionContext) => {
+    const result = evaluate(expression, context);
+    console.log(`Evaluating expression ${JSON.stringify(expression)} using context ${JSON.stringify(context)}`);
+    console.log(`Result: ${result}`);
+};
+
+let context: ExpressionContext = {
+    userId: 'a@b.com',
+    times: 3
+};
+
+let expression: Expression = {
+   user: 'a@b.com'
+};
+
+run(expression, context);
+
+expression = {
+    and: [
+        { user: 'a@b.com'},
+        { maxCount: 5},
+    ]
+};
+
+run(expression, context);
+
+expression = {
+    and: [
+        { user: 'a@b.com'},
+        { maxCount: 1},
+    ]
+};
+
+run(expression, context);
+
+expression = {
+    or: [
+        { user: 'a@b.com'},
+        { maxCount: 6},
+    ]
+};
+
+run(expression, context);
+
+
+

example/lib/evaluator.d.ts

@@ -0,0 +1,6 @@
+import { Expression } from "../../dist";
+export interface ExpressionContext {
+    userId: string;
+    times: number;
+}
+export declare const evaluate: (expression: Expression, context: ExpressionContext) => boolean;

example/lib/evaluator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const functionsFactory_1 = require("./functionsFactory");
+const index_1 = require("./../../dist/index");
+exports.evaluate = (expression, context) => {
+    return index_1.evaluate(expression, context, functionsFactory_1.functionsTable);
+};

example/lib/evaluator.ts

@@ -0,0 +1,15 @@
+"use strict";
+
+import {Expression} from "../../dist";
+
+import { functionsTable } from './functionsFactory';
+import { evaluate as _evaluate } from './../../dist/index';
+
+export interface ExpressionContext {
+    userId: string;
+    times: number;
+}
+
+export const evaluate = (expression: Expression, context: ExpressionContext): boolean => {
+    return _evaluate(expression, context, functionsTable);
+};

example/lib/functions/counterFunc.d.ts

@@ -0,0 +1,2 @@
+import { FuncFactory } from "../functionsFactory";
+export declare const factory: FuncFactory;

example/lib/functions/counterFunc.js

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const desc = {
+    name: 'maxCount',
+    evaluate: (maxCount, context) => {
+        return context.times < maxCount;
+    },
+};
+exports.factory = () => {
+    return desc;
+};

example/lib/functions/counterFunc.ts

@@ -0,0 +1,14 @@
+'use strict';
+
+import {FuncFactory, FunctionDescription} from "../functionsFactory";
+
+const desc = {
+    name: 'maxCount',
+    evaluate: (maxCount: number, context: { times: number }): boolean => {
+        return context.times < maxCount;
+    },
+};
+
+export const factory: FuncFactory = (): FunctionDescription => {
+    return desc;
+};

example/lib/functions/userFunc.d.ts

@@ -0,0 +1,2 @@
+import { FuncFactory } from "../functionsFactory";
+export declare const factory: FuncFactory;

example/lib/functions/userFunc.js

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const desc = {
+    name: 'user',
+    evaluate: (user, context) => {
+        return context.userId === user;
+    },
+};
+exports.factory = () => {
+    return desc;
+};

example/lib/functions/userFunc.ts

@@ -0,0 +1,14 @@
+'use strict';
+
+import {FuncFactory, FunctionDescription} from "../functionsFactory";
+
+const desc = {
+    name: 'user',
+    evaluate: (user: string, context: { userId: string }): boolean => {
+        return context.userId === user;
+    },
+};
+
+export const factory: FuncFactory = (): FunctionDescription => {
+    return desc;
+};

example/lib/functionsFactory.d.ts

@@ -0,0 +1,8 @@
+import { Func, FunctionsTable } from "../../dist";
+export interface FunctionDescription {
+    name: string;
+    evaluate: Func;
+}
+export declare type FuncFactory = () => FunctionDescription;
+declare const functionsTable: FunctionsTable;
+export { functionsTable };

example/lib/functionsFactory.js

@@ -0,0 +1,17 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const functionsDir = path.join(__dirname, '/functions');
+const functionsTable = {};
+exports.functionsTable = functionsTable;
+fs.readdirSync(functionsDir).forEach((file) => {
+    if (file.endsWith('.js')) {
+        const data = require(path.join(functionsDir, file)).factory;
+        const description = data();
+        if (functionsTable[description.name]) {
+            throw new Error(`Function with name ${description.name} already exists`);
+        }
+        functionsTable[description.name] = description.evaluate;
+    }
+});

example/lib/functionsFactory.ts

@@ -0,0 +1,29 @@
+'use strict';
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {Func, FunctionsTable} from "../../dist";
+
+export interface FunctionDescription {
+    name: string;
+    evaluate: Func;
+}
+
+export type FuncFactory = () => FunctionDescription;
+
+const functionsDir = path.join(__dirname, '/functions');
+
+const functionsTable: FunctionsTable = {};
+
+fs.readdirSync(functionsDir).forEach((file) => {
+  if (file.endsWith('.js')) {
+    const data = require(path.join(functionsDir, file)).factory as FuncFactory;
+    const description = data();
+    if (functionsTable[description.name]) {
+      throw new Error(`Function with name ${description.name} already exists`);
+    }
+    functionsTable[description.name] = description.evaluate;
+  }
+});
+
+export { functionsTable };

example/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "none",
+    "moduleResolution": "node",
+    "declaration": true,
+    "strict": true,
+    "lib": [
+      "es6",
+      "dom"
+    ]
+  }
+}

package.json

@@ -34,6 +34,7 @@
   "devDependencies": {
     "@types/chai": "^4.1.3",
     "@types/mocha": "^5.2.1",
+    "@types/node": "^10.3.2",
     "@types/underscore": "^1.8.8",
     "chai": "^4.1.2",
     "coveralls": "^3.0.1",

src/index.ts

@@ -20,9 +20,7 @@ export interface NotOp {
 
 export type Expression = FuncOp | AndOp | OrOp | NotOp;
 
-export type ExpressionContext = any;
-
-export type Func = (param: any, context: ExpressionContext) => boolean;
+export type Func = (param: any, context: any) => boolean;
 
 export type FunctionsTable = { [k: string]: Func };
 
@@ -38,7 +36,7 @@ function isNotOp(expression: Expression): expression is NotOp {
     return (<NotOp>expression).not !== undefined;
 }
 
-export const evaluate = (expression: Expression, context: ExpressionContext, functionsTable: FunctionsTable): boolean => {
+export const evaluate = (expression: Expression, context: any, functionsTable: FunctionsTable): boolean => {
     const _evaluate = (_expression: Expression): boolean => {
         const keys = Object.keys(_expression);
         if (keys.length !== 1) {

tsconfig.json

@@ -5,7 +5,11 @@
     "moduleResolution": "node",
     "declaration": true,
     "outDir": "./dist",
-    "strict": true
+    "strict": true,
+    "lib": [
+      "es6",
+      "dom"
+    ]
   },
   "include": [
     "src/**/*.ts"