fig-tree-evaluator 2.3.0 → 2.3.2

package/README.md

@@ -1314,7 +1314,7 @@ e.g.
 
 ## Alias Nodes
 
-If you have a node that is used more than once in a complex expression, it's possible to just evaluate the repeated node once, and refer to it throughout using an "alias" reference. This allows for a simpler expression (reduces duplication) as well as a performance improvement, since the aliased node is only evaluated once, providing a simple [memoization](https://en.wikipedia.org/wiki/Memoization) mechanism.
+If you have a node that is used more than once in a complex expression, it's possible to just evaluate the repeated node once, and refer to it throughout using an "alias" reference. This allows for a simpler expression (reduces code duplication) as well as a performance improvement, since the aliased node is only evaluated once, providing a simple [memoization](https://en.wikipedia.org/wiki/Memoization) mechanism. (See also [Caching/Memoization](#caching-memoization))
 
 For example, if you have the expression:
 ```js
@@ -1385,7 +1385,7 @@ Like all expression nodes, alias nodes can themselves contain complex expression
 
 ## Caching (Memoization)
 
-FigTree Evaluator has basic memoization functionality for certain nodes to speed up re-evaluation of previously evaluated nodes. There is a single cache store per FigTree instance which persists for the lifetime of the instance. By default, it remembers the last 50 results, but this can be modified using the `maxCacheSize` option.
+FigTree Evaluator has basic [memoization](https://en.wikipedia.org/wiki/Memoization)  functionality for certain nodes to speed up re-evaluation when the input parameters haven't changed. There is a single cache store per FigTree instance which persists for the lifetime of the instance. By default, it remembers the last 50 results, but this can be modified using the `maxCacheSize` option.
 
 Currently, caching is only implemented for the following operators, since they perform requests to external resources, which are inherently slow:
 
@@ -1395,6 +1395,10 @@ Currently, caching is only implemented for the following operators, since they p
 - GRAPH_QL (`useCache` default: `true`)
 - CUSTOM_FUNCTIONS (`useCache` default: `false`)
 
+This is different to the memoization provided by [Alias Nodes](#alias-nodes):
+- Alias nodes are still evaluated once for every evaluation -- they're more for re-use *within* a complex expression.
+- Cached nodes will persist *between* different evaluations as long as the input values are the same as a previously evaluated node.
+
 ## More examples
 
 More examples, included large, complex expressions can be found within the test suites in the [repository](https://github.com/CarlosNZ/fig-tree-evaluator).
@@ -1427,6 +1431,7 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
 
 ## Changelog
 
+- **v2.3.2**: Bug fix: alias nodes not working with `evaluateFullObject` (#72)
 - **v2.3.0**: Implement [caching/memoization](#caching-memoization) (#68)
 - **v2.2.3**: Change option `objects` name to `data` (but keep backward compatibility) (#66)
 - **v2.2.2**: Option to evaluate whole object if operator nodes are deep within it (#64)

package/build/cache.js

@@ -59,7 +59,6 @@ var FigTreeCache = (function () {
                             if (key in this.store) {
                                 this.queue = this.queue.filter(function (val) { return val !== key; });
                                 this.queue.unshift(key);
-                                console.log('Using cached result:', this.store[key]);
                                 return [2, this.store[key]];
                             }
                             return [4, action.apply(void 0, args)];

package/build/evaluate.js

@@ -51,99 +51,100 @@ exports.evaluatorFunction = void 0;
 var _operatorUtils_1 = require("./operators/_operatorUtils");
 var helpers_1 = require("./helpers");
 var evaluatorFunction = function (input, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var options, operators, operatorAliases, expression, fallback, returnErrorAsString, operator, _a, _b, requiredProperties, propertyAliases, evaluate, parseChildren, _c, _d, validationError, _e, _f, _g, result, err_1, _h, outputType, evaluatedOutputType, _j, err_2, _k;
-    var _l, _m;
-    return __generator(this, function (_o) {
-        switch (_o.label) {
+    var options, operators, operatorAliases, expression, _a, fallback, returnErrorAsString, operator, _b, _c, requiredProperties, propertyAliases, evaluate, parseChildren, _d, _e, validationError, _f, _g, _h, result, err_1, _j, outputType, evaluatedOutputType, _k, err_2, _l;
+    var _m, _o;
+    return __generator(this, function (_p) {
+        switch (_p.label) {
             case 0:
                 options = config.options, operators = config.operators, operatorAliases = config.operatorAliases;
                 expression = (options === null || options === void 0 ? void 0 : options.allowJSONStringInput) ? (0, helpers_1.parseIfJson)(input) : input;
                 if (!Array.isArray(expression)) return [3, 2];
                 return [4, (0, _operatorUtils_1.evaluateArray)(expression, config)];
             case 1:
-                expression = _o.sent();
-                _o.label = 2;
+                expression = _p.sent();
+                _p.label = 2;
             case 2:
                 if (!(options.evaluateFullObject && !(0, helpers_1.isOperatorNode)(expression))) return [3, 4];
+                _a = helpers_1.replaceAliasNodeValues;
                 return [4, (0, helpers_1.evaluateObject)(expression, config)];
-            case 3: return [2, _o.sent()];
+            case 3: return [2, _a.apply(void 0, [_p.sent(), config])];
             case 4:
                 if (!(0, helpers_1.isOperatorNode)(expression))
                     return [2, (0, helpers_1.replaceAliasNodeValues)(expression, config)];
                 fallback = expression.fallback;
-                returnErrorAsString = (_l = options === null || options === void 0 ? void 0 : options.returnErrorAsString) !== null && _l !== void 0 ? _l : false;
-                _o.label = 5;
+                returnErrorAsString = (_m = options === null || options === void 0 ? void 0 : options.returnErrorAsString) !== null && _m !== void 0 ? _m : false;
+                _p.label = 5;
             case 5:
-                _o.trys.push([5, 26, , 28]);
+                _p.trys.push([5, 26, , 28]);
                 operator = (0, helpers_1.getOperatorName)(expression.operator, operatorAliases);
                 if (!!operator) return [3, 7];
-                _a = helpers_1.fallbackOrError;
+                _b = helpers_1.fallbackOrError;
                 return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 6: return [2, _a.apply(void 0, [_o.sent(), "Invalid operator: ".concat(expression.operator), returnErrorAsString])];
+            case 6: return [2, _b.apply(void 0, [_p.sent(), "Invalid operator: ".concat(expression.operator), returnErrorAsString])];
             case 7:
-                _b = operators[operator], requiredProperties = _b.requiredProperties, propertyAliases = _b.propertyAliases, evaluate = _b.evaluate, parseChildren = _b.parseChildren;
+                _c = operators[operator], requiredProperties = _c.requiredProperties, propertyAliases = _c.propertyAliases, evaluate = _c.evaluate, parseChildren = _c.parseChildren;
                 expression = (0, helpers_1.mapPropertyAliases)(propertyAliases, expression);
-                _c = config;
-                _d = [__assign({}, config.resolvedAliasNodes)];
+                _d = config;
+                _e = [__assign({}, config.resolvedAliasNodes)];
                 return [4, (0, helpers_1.evaluateNodeAliases)(expression, config)];
             case 8:
-                _c.resolvedAliasNodes = __assign.apply(void 0, _d.concat([(_o.sent())]));
+                _d.resolvedAliasNodes = __assign.apply(void 0, _e.concat([(_p.sent())]));
                 validationError = (0, helpers_1.checkRequiredNodes)(requiredProperties, expression);
                 if (!validationError) return [3, 10];
-                _e = helpers_1.fallbackOrError;
+                _f = helpers_1.fallbackOrError;
                 return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 9: return [2, _e.apply(void 0, [_o.sent(), "Operator: ".concat(operator, "\n- ").concat(validationError), returnErrorAsString])];
+            case 9: return [2, _f.apply(void 0, [_p.sent(), "Operator: ".concat(operator, "\n- ").concat(validationError), returnErrorAsString])];
             case 10:
                 if (!('children' in expression)) return [3, 16];
                 if (!!Array.isArray(expression.children)) return [3, 12];
-                _f = expression;
+                _g = expression;
                 return [4, (0, exports.evaluatorFunction)(expression.children, config)];
             case 11:
-                _f.children = _o.sent();
-                _o.label = 12;
+                _g.children = _p.sent();
+                _p.label = 12;
             case 12:
                 if (!!Array.isArray(expression.children)) return [3, 14];
-                _g = helpers_1.fallbackOrError;
+                _h = helpers_1.fallbackOrError;
                 return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 13: return [2, _g.apply(void 0, [_o.sent(), "Operator: ".concat(operator, "\n- Property \"children\" is not of type: array"), returnErrorAsString])];
+            case 13: return [2, _h.apply(void 0, [_p.sent(), "Operator: ".concat(operator, "\n- Property \"children\" is not of type: array"), returnErrorAsString])];
             case 14: return [4, parseChildren(expression, config)];
             case 15:
-                expression = _o.sent();
-                _o.label = 16;
+                expression = _p.sent();
+                _p.label = 16;
             case 16:
                 result = void 0;
-                _o.label = 17;
+                _p.label = 17;
             case 17:
-                _o.trys.push([17, 19, , 21]);
+                _p.trys.push([17, 19, , 21]);
                 return [4, evaluate(expression, config)];
             case 18:
-                result = _o.sent();
+                result = _p.sent();
                 return [3, 21];
             case 19:
-                err_1 = _o.sent();
-                _h = helpers_1.fallbackOrError;
+                err_1 = _p.sent();
+                _j = helpers_1.fallbackOrError;
                 return [4, (0, exports.evaluatorFunction)(fallback, config)];
             case 20:
-                result = _h.apply(void 0, [_o.sent(), "Operator: ".concat(operator, "\n").concat((0, helpers_1.errorMessage)(err_1)), returnErrorAsString]);
+                result = _j.apply(void 0, [_p.sent(), "Operator: ".concat(operator, "\n").concat((0, helpers_1.errorMessage)(err_1)), returnErrorAsString]);
                 return [3, 21];
             case 21:
-                outputType = (_m = expression === null || expression === void 0 ? void 0 : expression.outputType) !== null && _m !== void 0 ? _m : expression === null || expression === void 0 ? void 0 : expression.type;
+                outputType = (_o = expression === null || expression === void 0 ? void 0 : expression.outputType) !== null && _o !== void 0 ? _o : expression === null || expression === void 0 ? void 0 : expression.type;
                 if (!outputType)
                     return [2, result];
                 return [4, (0, exports.evaluatorFunction)(outputType, config)];
             case 22:
-                evaluatedOutputType = (_o.sent());
+                evaluatedOutputType = (_p.sent());
                 if (!!(evaluatedOutputType in helpers_1.convertOutputMethods)) return [3, 24];
-                _j = helpers_1.fallbackOrError;
+                _k = helpers_1.fallbackOrError;
                 return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 23: return [2, _j.apply(void 0, [_o.sent(), "Operator: ".concat(operator, "\n- Invalid output type: ").concat(evaluatedOutputType), returnErrorAsString])];
+            case 23: return [2, _k.apply(void 0, [_p.sent(), "Operator: ".concat(operator, "\n- Invalid output type: ").concat(evaluatedOutputType), returnErrorAsString])];
             case 24: return [2, helpers_1.convertOutputMethods[evaluatedOutputType](result)];
             case 25: return [3, 28];
             case 26:
-                err_2 = _o.sent();
-                _k = helpers_1.fallbackOrError;
+                err_2 = _p.sent();
+                _l = helpers_1.fallbackOrError;
                 return [4, (0, exports.evaluatorFunction)(fallback, config)];
-            case 27: return [2, _k.apply(void 0, [_o.sent(), (0, helpers_1.errorMessage)(err_2),
+            case 27: return [2, _l.apply(void 0, [_p.sent(), (0, helpers_1.errorMessage)(err_2),
                     returnErrorAsString])];
             case 28: return [2];
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fig-tree-evaluator",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "Module to evaluate JSON-structured expression trees",
   "main": "build/index.js",
   "types": "build/index.d.ts",