enhance type checking

dist/index.js

@@ -1,5 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+function isGtOp(op, key) {
+    return op[key].gt !== undefined;
+}
+function isGteOp(op, key) {
+    return op[key].gte !== undefined;
+}
+function isLteOp(op, key) {
+    return op[key].lte !== undefined;
+}
+function isLtOp(op, key) {
+    return op[key].lt !== undefined;
+}
+function isEqOp(op, key) {
+    return op[key].eq !== undefined;
+}
+function isNeqOp(op, key) {
+    return op[key].neq !== undefined;
+}
 function isAndOp(expression) {
     return expression.and !== undefined;
 }
@@ -9,35 +27,40 @@ function isOrOp(expression) {
 function isNotOp(expression) {
     return expression.not !== undefined;
 }
+function isFuncOp(expression, key, functionsTable) {
+    return key in functionsTable;
+}
 const _isObject = (obj) => {
     const type = typeof obj;
     return type === 'function' || type === 'object' && !!obj;
 };
-const _evaluateCompareOp = (op, param) => {
-    if (!_isObject(op)) {
-        return param === op;
+const _evaluateCompareOp = (op, key, param) => {
+    if (!_isObject(op[key])) {
+        return param === op[key];
     }
-    const keys = Object.keys(op);
+    const keys = Object.keys(op[key]);
     if (keys.length !== 1) {
         throw new Error('Invalid expression - too may keys');
     }
-    const key = keys[0];
-    const value = op[key];
-    switch (key) {
-        case 'gt':
-            return param > value;
-        case 'gte':
-            return param >= value;
-        case 'lt':
-            return param < value;
-        case 'lte':
-            return param <= value;
-        case 'eq':
-            return param === value;
-        case 'neq':
-            return param !== value;
+    if (isGtOp(op, key)) {
+        return param > op[key].gt;
+    }
+    else if (isGteOp(op, key)) {
+        return param >= op[key].gte;
+    }
+    else if (isLteOp(op, key)) {
+        return param <= op[key].lte;
+    }
+    else if (isLtOp(op, key)) {
+        return param < op[key].lt;
+    }
+    else if (isEqOp(op, key)) {
+        return param === op[key].eq;
+    }
+    else if (isNeqOp(op, key)) {
+        return param !== op[key].neq;
     }
-    throw new Error(`Invalid expression - unknown op ${key}`);
+    throw new Error(`Invalid expression - unknown op ${keys[0]}`);
 };
 exports.evaluate = (expression, context, functionsTable) => {
     const _evaluate = (_expression) => {
@@ -74,11 +97,11 @@ exports.evaluate = (expression, context, functionsTable) => {
             const notExpression = _expression.not;
             return !_evaluate(notExpression);
         }
-        else if (key in functionsTable) {
+        else if (isFuncOp(_expression, key, functionsTable)) {
             return functionsTable[key](_expression[key], context);
         }
         else if (key in context) {
-            return _evaluateCompareOp(_expression[key], context[key]);
+            return _evaluateCompareOp(_expression, key, context[key]);
         }
         throw new Error(`Invalid expression - unknown function ${key}`);
     };

example/example.js

@@ -11,7 +11,7 @@ let context = {
     times: 3
 };
 let expression = {
-    user: '[email protected]'
+    user: '[email protected]',
 };
 run(expression, context);
 expression = {

example/example.ts

@@ -15,7 +15,7 @@ let context: ExpressionContext = {
 };
 
 let expression: Expression = {
-   user: '[email protected]'
+    user: '[email protected]',
 };
 
 run(expression, context);

example/lib/evaluator.d.ts

@@ -1,4 +1,4 @@
-import { Expression } from "../../dist";
+import { Expression } from '../../dist';
 export interface ExpressionContext {
     userId: string;
     times: number;

example/lib/evaluator.js

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

example/lib/evaluator.ts

@@ -1,9 +1,7 @@
 "use strict";
 
-import {Expression} from "../../dist";
-
-import { functionsTable } from './functionsFactory';
-import { evaluate as _evaluate } from './../../dist/index';
+import {functionsTable} from './functionsFactory';
+import {evaluate as _evaluate, Expression} from '../../dist';
 
 export interface ExpressionContext {
     userId: string;

example/lib/functions/counterFunc.d.ts

@@ -1,2 +1,3 @@
-import { FuncFactory } from "../functionsFactory";
-export declare const factory: FuncFactory;
+export declare const counterFunc: (maxCount: number, context: {
+    times: number;
+}) => boolean;

example/lib/functions/counterFunc.js

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

example/lib/functions/counterFunc.ts

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

example/lib/functions/userFunc.d.ts

@@ -1,2 +1,3 @@
-import { FuncFactory } from "../functionsFactory";
-export declare const factory: FuncFactory;
+export declare const userFunc: (user: string, context: {
+    userId: string;
+}) => boolean;

example/lib/functions/userFunc.js

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

example/lib/functions/userFunc.ts

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

example/lib/functionsFactory.d.ts

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

example/lib/functionsFactory.js

@@ -2,13 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const userFunc_1 = require("./functions/userFunc");
 const counterFunc_1 = require("./functions/counterFunc");
-const functionsTable = {};
-exports.functionsTable = functionsTable;
-const _addFunction = (description) => {
-    if (functionsTable[description.name]) {
-        throw new Error(`Function with name ${description.name} already exists`);
-    }
-    functionsTable[description.name] = description.evaluate;
+const functionsTable = {
+    user: userFunc_1.userFunc,
+    maxCount: counterFunc_1.counterFunc,
 };
-_addFunction(userFunc_1.factory());
-_addFunction(counterFunc_1.factory());
+exports.functionsTable = functionsTable;

example/lib/functionsFactory.ts

@@ -1,27 +1,14 @@
 'use strict';
 
-import {Func, FunctionsTable} from "../../dist";
+import {FunctionsTable} from "../../dist";
 import {ExpressionContext} from "./evaluator";
-import {factory as userFuncFactory} from './functions/userFunc';
-import {factory as counterFuncFactory} from './functions/counterFunc';
+import {userFunc} from './functions/userFunc';
+import {counterFunc} from './functions/counterFunc';
 
-export interface FunctionDescription {
-    name: string;
-    evaluate: Func<ExpressionContext>;
-}
 
-export type FuncFactory = () => FunctionDescription;
-
-const functionsTable: FunctionsTable<ExpressionContext> = {};
-
-const _addFunction = (description: FunctionDescription) : void => {
-    if (functionsTable[description.name]) {
-        throw new Error(`Function with name ${description.name} already exists`);
-    }
-    functionsTable[description.name] = description.evaluate;
+const functionsTable: FunctionsTable<ExpressionContext> = {
+    user: userFunc,
+    maxCount: counterFunc,
 };
 
-_addFunction(userFuncFactory());
-_addFunction(counterFuncFactory());
-
-export { functionsTable };
+export {functionsTable};

package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-expression-eval",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "evaluate a json described boolean expression using dynamic functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",