fig-tree-evaluator 2.2.2 → 2.3.0

package/README.md

@@ -47,6 +47,7 @@ A range of built-in operators are available, from simple logic, arithmetic and s
   - [PASSTHRU](#passthru)
   - [CUSTOM\_FUNCTIONS](#custom_functions)
 - [Alias Nodes](#alias-nodes)
+- [Caching (Memoization)](#caching-memoization)
 - [More examples](#more-examples)
 - [Development environment](#development-environment)
 - [Tests](#tests)
@@ -135,7 +136,7 @@ const result = await exp.evaluate(expression, [options])
 
 The `options` parameter is an object with the following available properties (all optional):
 
-- `objects` -- a single object containing any *objects* in your application that may wish to be inspected using the [objectProperties](#object_properties) operator. (See [playground](LINK) for examples). If these objects are regularly changing, you'll probably want to pass them into each separate evaluation rather than with the initial constructor.
+- `data` -- a single object containing any *objects* in your application that may wish to be inspected using the [objectProperties](#object_properties) operator. (See [playground](LINK) for examples). If these objects are regularly changing, you'll probably want to pass them into each separate evaluation rather than with the initial constructor.
 - `functions` -- a single object containing any *custom functions* available for use by the [customFunctions](#custom_functions) operator.
 - `pgConnection` -- if you wish to make calls to a Postgres database using the [`pgSQL` operator](#pg_sql), pass a [node-postres](https://node-postgres.com/) connection object here.
 - `graphQLConnection` -- a GraphQL connection object, if using the [`graphQL` operator](#graphql). See operator details below.
@@ -146,6 +147,8 @@ The `options` parameter is an object with the following available properties (al
 - `skipRuntimeTypeCheck` -- we perform comprehensive type checking at runtime to ensure that each operator only performs its operation on valid inputs. If type checking fails, we throw an error detailing the explicit problem. However, if `skipRuntimeTypeCheck` is set to `true`, then all inputs are passed to the operator regardless, and any errors will come from whatever standard javascript errors might be encountered (e.g. trying to pass a primitive value when an array is expected => `.map is not a function`)
 - `nullEqualsUndefined` -- this only affects the [`equal`/`notEqual` operators](#equal) (see there for more detail). 
 - `evaluateFullObject` -- by default, FigTree expects the root of an input expression to be an [Operator Node](#operator-nodes), and if not, will return the input unmodified. However, you may have cases where the evaluation expressions are deep within a larger structure (such as a JSON schema, for example). In this case, you can set `evaluateFullObject` to `true` and the evaluator will find *any* operator nodes within the structure and evaluate them in place.
+- `useCache` -- caches the results from certain operators to avoid repeated network requests with the same input values. By default, this is set to `true`, and it can be overridden for specific nodes. See [Memoization/Caching section](#caching-memoization) for more detail
+- `maxCacheSize` -- the maximum number of results that will be held in the aforementioned cache (default: `50`)
 
 As mentioned above, `options` can be provided as part of the constructor as part of each separate evaluation. You can also change the options permanently for a given evaluator instance with:
 
@@ -207,6 +210,7 @@ In each operator node, as well as the operator-specific properties, the followin
 
 - `fallback`: if the operation throws an error, the `fallback` value will be returned instead. The `fallback` property can be provided at any level of the expression tree and bubbled up from where errors are caught to parent nodes.
 - `outputType` (or `type`): will convert the result of the current node to the specified `outputType`. Valid values are `string`, `number`, `boolean` (or `bool`), and `array`. You can experiment in the [demo app](https://carlosnz.github.io/fig-tree-evaluator/) to see the outcome of applying different `outputType` values to various results.
+- `useCache`: Overrides the global `useCache` value (from [options](#available-options)) for this node only. See [Caching/Memoization](#caching-memoization) below for more info.
 
 Remember that *all* operator node properties can themselves be operator nodes, *including* the `fallback` and `outputType` properties.
 
@@ -304,7 +308,7 @@ Aliases: `=`, `eq`, `equal`, `equals`
 #### Properties
 
 - `values`<sup>*</sup>: (array) -- any number of elements; will be compared for strict equality. This includes simple types as well as deep equality of objects and arrays.
-- `nullEqualsUndefined`: (boolean, default `false`) -- there are times when it is convenient for `null` to be considered equal to `undefined`. If this is desiered, set this property to `true`, otherwise all equality checks will be "strict" equality. If you find that you want this setting enabled globally, then you can set it in the overall [evaluator options](#available-options) instead of having to add this additional property to every equality expression.
+- `nullEqualsUndefined`: (boolean, default `false`) -- there are times when it is convenient for `null` to be considered equal to `undefined`. If this is desired, set this property to `true`, otherwise all equality checks will be "strict" equality. If you find that you want this setting enabled globally, then you can set it in the overall [evaluator options](#available-options) instead of having to add this additional property to every equality expression.
 
 e.g.
 ```js
@@ -659,16 +663,16 @@ e.g.
 ----
 ### OBJECT_PROPERTIES
 
-*Extracts values from objects in your application*
+*Extracts values from data objects in your application*
 
-Aliases: `objectProperties`, `objProps`, `getProperty`, `getObjProp`
+Aliases: `objectProperties`, `dataProperties`,`data`, `getData`, `objProps`, `getProperty`, `getObjProp`
 
 #### Properties
 
 - `property` (or `path`, `propertyName`)<sup>*</sup>: (string) -- the path to the required property in the object
-- `additionalObjects` (or `objects`, `additional`): (object) -- any other objects whose properties can be referenced in `property` (see below)
+- `additionalData` (or `additionalObjects`, `additional`, `data`): (object) -- any other objects whose properties can be referenced in `property` (see below)
 
-Objects are normamlly expected to be passed in to the evaluator as part of the [options](#available-options), not as part of the expression itself. The reason for this is that the source objects are expected to be values internal to your application, whereas the evaluator provides an externally configurable mechanism to extract (and process) application data. (However, it is possible to pass objects directly as part of the expression using the `additionalObjects` property, so (in theory) objects could be dynamically generated from other expressions.)
+Data objects are normally expected to be passed in to the evaluator as part of the [options](#available-options), not as part of the expression itself. This is because the source objects are expected to be values internal to your application, whereas the evaluator provides an externally configurable mechanism to extract (and process) application data. (However, it is possible to pass data objects directly as part of the expression using the `additionalObjects` property, so (in theory) data objects could be dynamically generated from other expressions.)
 
 For example, consider a `user` object and an fig-tree evaluator instance: 
 
@@ -688,7 +692,7 @@ const exp = new FigTreeEvaluator()
 
 const expression = getExpressionFromConfig()
 
-exp.evaluate(expression, { objects: { user } })
+exp.evaluate(expression, { data: { user } })
 ```
 
 Here is the result of various values of `expression:`
@@ -701,7 +705,7 @@ Here is the result of various values of `expression:`
 // => "Peter"
 
 {
-  operator: 'getProperty',
+  operator: 'getData',
   path: 'user.friends[1]',
 }
 // => "MJ"
@@ -721,7 +725,7 @@ result.map((e) => e.name)
 
 The "objectProperties" operator uses [`object-property-extractor`](https://www.npmjs.com/package/object-property-extractor) internally, so please see the documentation of that package for more information.
 
-The "objectProperties" operator will throw an error if an invalid path is provided, so it is recommended to provide a `fallback` value for the expression:
+The "objectProperties" operator will throw an error if an invalid path is provided, so it is recommended to provide a [`fallback`](#other-common-properties) value for the expression:
 ```js
 {
   operator: 'objectProperties',
@@ -734,13 +738,13 @@ The "objectProperties" operator will throw an error if an invalid path is provid
 `children` array: `[property]`
 
 
-Example using "objects" passed in dynamically as part of expression:
+Example using "data" passed in dynamically as part of expression:
 
 ```js
 {
   operator: 'objectProperties',
   property: 'user.name',
-  additionalObjects: {
+  additionalData: {
     operator: '?',
     condition: { operator: '=', values: [{ operator: '+', values: [7, 8, 9] }, 25] },
     valueIfTrue: { user: { name: 'Bilbo' } },
@@ -760,7 +764,7 @@ Aliases: `stringSubstitution`, `substitute`, `stringSub`, `replace`
 #### Properties
 
 - `string`<sup>*</sup>: (string) -- a parameterized (`%1`, `%2`) string, where the parameters are to be replaced by dynamic values. E.g. `"My name is %1 (age %2)"`
-- `substitutions` (or `replacments`)<sup>*</sup>: (array) -- the values to be substituted into `string`
+- `substitutions` (or `replacements`)<sup>*</sup>: (array) -- the values to be substituted into `string`
 
 The values in the `substitutions` array are replaced in the original `string` by matching their order to the numerical order of the parameters.
 
@@ -783,7 +787,7 @@ e.g.
   operator: 'replace',
   string: '%1 is actually %2 %3',
   substitutions: [
-    // Using the 'user' object from above
+    // Using the 'user' object from above (OBJECT_PROPERTIES operator)
     {
       operator: 'objectProperties',
       property: 'user.alias',
@@ -798,7 +802,7 @@ e.g.
     },
   ],
 }
-// => "Spiderman is actually Peter Parker"
+// => "Spider-man is actually Peter Parker"
 
 // Parameters can be repeated:
 {
@@ -1178,8 +1182,8 @@ e.g.
   },
 }
 // With:
-// objects = { weather: "sunny", humidity: "high" } => "NO"
-// objects = { weather: "rainy", wind: "weak" } => "YES"
+// data = { weather: "sunny", humidity: "high" } => "NO"
+// data = { weather: "rainy", wind: "weak" } => "YES"
 
 ```
 
@@ -1379,6 +1383,18 @@ Like all expression nodes, alias nodes can themselves contain complex expression
 
 (If an alias reference does not having a matching definition, the reference value will just be returned as a literal string, e.g. `"$getCountry"`)
 
+## 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.
+
+Currently, caching is only implemented for the following operators, since they perform requests to external resources, which are inherently slow:
+
+- GET (`useCache` default: `true`)
+- POST (`useCache` default: `true`)
+- PG_SQL (`useCache` default: `true`)
+- GRAPH_QL (`useCache` default: `true`)
+- CUSTOM_FUNCTIONS (`useCache` default: `false`)
+
 ## 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).
@@ -1411,6 +1427,8 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
 
 ## Changelog
 
+- **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)
 - **v2.2.1**: More efficient branch evaluation for condition/match operators (#63)
 - **v2.2.0**:

package/build/cache.d.ts

@@ -0,0 +1,10 @@
+declare class FigTreeCache {
+    private store;
+    private queue;
+    private maxSize;
+    constructor(maxSize?: number);
+    useCache: (shouldUseCache: boolean, action: Function, ...args: unknown[]) => Promise<any>;
+    getMax: () => number;
+    setMax: (size: number) => void;
+}
+export default FigTreeCache;

package/build/cache.js

@@ -0,0 +1,96 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var MAX_CACHED_ITEMS = 50;
+var FigTreeCache = (function () {
+    function FigTreeCache(maxSize) {
+        var _this = this;
+        this.useCache = function (shouldUseCache, action) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            return __awaiter(_this, void 0, void 0, function () {
+                var key, result, keysToRemove;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!!shouldUseCache) return [3, 2];
+                            return [4, action.apply(void 0, args)];
+                        case 1: return [2, _a.sent()];
+                        case 2:
+                            key = stringifyInput(args);
+                            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)];
+                        case 3:
+                            result = _a.sent();
+                            this.store[key] = result;
+                            if (this.queue.length >= this.maxSize) {
+                                keysToRemove = this.queue.slice(this.maxSize - 1);
+                                keysToRemove.forEach(function (key) { return delete _this.store[key]; });
+                                this.queue = this.queue.slice(0, this.maxSize - 1);
+                            }
+                            this.queue.unshift(key);
+                            return [2, result];
+                    }
+                });
+            });
+        };
+        this.getMax = function () { return _this.maxSize; };
+        this.setMax = function (size) {
+            _this.maxSize = size;
+        };
+        this.store = {};
+        this.queue = [];
+        this.maxSize = maxSize !== null && maxSize !== void 0 ? maxSize : MAX_CACHED_ITEMS;
+    }
+    return FigTreeCache;
+}());
+exports.default = FigTreeCache;
+var stringifyInput = function (args) {
+    return args.reduce(function (outputString, arg, index) {
+        var part = typeof arg === 'object' ? JSON.stringify(arg) : arg;
+        return index === 0 ? "".concat(part) : "".concat(outputString, "_").concat(part);
+    }, '');
+};

package/build/helpers.js

@@ -142,8 +142,8 @@ var checkRequiredNodes = function (requiredProps, expression) {
 exports.checkRequiredNodes = checkRequiredNodes;
 var mergeOptions = function (origOptions, newOptions) {
     var combinedOptions = __assign(__assign({}, origOptions), newOptions);
-    if (origOptions.objects || newOptions.objects)
-        combinedOptions.objects = __assign(__assign({}, origOptions.objects), newOptions.objects);
+    if (origOptions.data || newOptions.data)
+        combinedOptions.data = __assign(__assign({}, origOptions.data), newOptions.data);
     if (origOptions.functions || newOptions.functions)
         combinedOptions.functions = __assign(__assign({}, origOptions.functions), newOptions.functions);
     if (origOptions.headers || newOptions.headers)

package/build/index.d.ts

@@ -1,9 +1,9 @@
 import { EvaluatorNode, FigTreeOptions } from './types';
-export declare const getVersion: () => any;
 declare class FigTreeEvaluator {
     private options;
     private operators;
     private operatorAliases;
+    private cache;
     constructor(options?: FigTreeOptions);
     private typeChecker;
     evaluate(expression: EvaluatorNode, options?: FigTreeOptions): Promise<import("./types").EvaluatorOutput>;

package/build/index.js

@@ -73,15 +73,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateExpression = exports.getVersion = void 0;
+exports.evaluateExpression = void 0;
 var evaluate_1 = require("./evaluate");
 var typeCheck_1 = require("./typeCheck");
 var _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
 var operators = __importStar(require("./operators"));
 var helpers_1 = require("./helpers");
+var cache_1 = __importDefault(require("./cache"));
 var pkg = require('../package.json');
-var getVersion = function () { return pkg.version; };
-exports.getVersion = getVersion;
 var FigTreeEvaluator = (function () {
     function FigTreeEvaluator(options) {
         if (options === void 0) { options = {}; }
@@ -95,10 +94,11 @@ var FigTreeEvaluator = (function () {
                 return;
             throw new Error(result);
         };
-        this.getVersion = exports.getVersion;
-        this.options = options;
+        this.getVersion = function () { return pkg.version; };
+        this.options = standardiseOptionNames(options);
         this.operators = operators;
         this.operatorAliases = _operatorAliases_json_1.default;
+        this.cache = new cache_1.default(options.maxCacheSize);
     }
     FigTreeEvaluator.prototype.evaluate = function (expression, options) {
         if (options === void 0) { options = {}; }
@@ -107,13 +107,16 @@ var FigTreeEvaluator = (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        currentOptions = (0, helpers_1.mergeOptions)(this.options, options);
+                        currentOptions = (0, helpers_1.mergeOptions)(this.options, standardiseOptionNames(options));
+                        if (currentOptions.maxCacheSize && currentOptions.maxCacheSize !== this.cache.getMax())
+                            this.cache.setMax(currentOptions.maxCacheSize);
                         return [4, (0, evaluate_1.evaluatorFunction)(expression, {
                                 options: currentOptions,
                                 operators: this.operators,
                                 operatorAliases: this.operatorAliases,
                                 typeChecker: currentOptions.skipRuntimeTypeCheck ? function () { } : this.typeChecker,
                                 resolvedAliasNodes: {},
+                                cache: this.cache,
                             })];
                     case 1: return [2, _a.sent()];
                 }
@@ -124,7 +127,7 @@ var FigTreeEvaluator = (function () {
         return this.options;
     };
     FigTreeEvaluator.prototype.updateOptions = function (options) {
-        this.options = __assign(__assign({}, this.options), options);
+        this.options = __assign(__assign({}, this.options), standardiseOptionNames(options));
     };
     return FigTreeEvaluator;
 }());
@@ -133,3 +136,10 @@ var evaluateExpression = function (expression, options) {
     return new FigTreeEvaluator(options).evaluate(expression);
 };
 exports.evaluateExpression = evaluateExpression;
+var standardiseOptionNames = function (options) {
+    if ('objects' in options) {
+        options.data = options.objects;
+        delete options.objects;
+    }
+    return options;
+};

package/build/operators/_operatorAliases.json

@@ -45,6 +45,9 @@
     "patternMatch": "REGEX",
     "regexp": "REGEX",
     "matchPattern": "REGEX",
+    "dataProperties": "OBJECT_PROPERTIES",
+    "data": "OBJECT_PROPERTIES",
+    "getData": "OBJECT_PROPERTIES",
     "objectProperties": "OBJECT_PROPERTIES",
     "objProps": "OBJECT_PROPERTIES",
     "getProperty": "OBJECT_PROPERTIES",

package/build/operators/customFunctions.js

@@ -80,18 +80,37 @@ var propertyAliases = {
     variables: 'args',
 };
 var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, functionPath, args, _b, objects, functions, func;
-    var _c, _d;
-    return __generator(this, function (_e) {
-        switch (_e.label) {
+    var _a, functionPath, args, _b, data, functions, func, shouldUseCache, result;
+    var _c;
+    var _d, _e, _f, _g;
+    return __generator(this, function (_h) {
+        switch (_h.label) {
             case 0: return [4, (0, _operatorUtils_1.evaluateArray)(__spreadArray([expression.functionPath], (expression.args || []), true), config)];
             case 1:
-                _a = (_e.sent()), functionPath = _a[0], args = _a.slice(1);
+                _a = (_h.sent()), functionPath = _a[0], args = _a.slice(1);
                 config.typeChecker({ name: 'functionPath', value: functionPath, expectedType: 'string' });
-                _b = config.options, objects = _b.objects, functions = _b.functions;
-                func = ((_d = (_c = (0, object_property_extractor_1.default)(functions, functionPath, null)) !== null && _c !== void 0 ? _c : (0, object_property_extractor_1.default)(objects, functionPath, null)) !== null && _d !== void 0 ? _d : (0, object_property_extractor_1.default)(config.options, functionPath));
-                return [4, func.apply(void 0, args)];
-            case 2: return [2, _e.sent()];
+                _b = config.options, data = _b.data, functions = _b.functions;
+                func = ((_e = (_d = (0, object_property_extractor_1.default)(functions, functionPath, null)) !== null && _d !== void 0 ? _d : (0, object_property_extractor_1.default)(data, functionPath, null)) !== null && _e !== void 0 ? _e : (0, object_property_extractor_1.default)(config.options, functionPath));
+                shouldUseCache = (_g = (_f = expression.useCache) !== null && _f !== void 0 ? _f : config.options.useCache) !== null && _g !== void 0 ? _g : false;
+                return [4, (_c = config.cache).useCache.apply(_c, __spreadArray([shouldUseCache,
+                        function (_) {
+                            var args = [];
+                            for (var _i = 1; _i < arguments.length; _i++) {
+                                args[_i - 1] = arguments[_i];
+                            }
+                            return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4, func.apply(void 0, args)];
+                                        case 1: return [2, _a.sent()];
+                                    }
+                                });
+                            });
+                        },
+                        functionPath], args, false))];
+            case 2:
+                result = _h.sent();
+                return [2, result];
         }
     });
 }); };

package/build/operators/getRequest.js

@@ -53,25 +53,36 @@ var requiredProperties = ['url'];
 var operatorAliases = ['get', 'api'];
 var propertyAliases = { endpoint: 'url', outputProperty: 'returnProperty' };
 var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, urlObj, params, returnProperty, headers, _b, url, headersObj, baseUrl, httpHeaders, response;
-    var _c, _d;
-    return __generator(this, function (_e) {
-        switch (_e.label) {
+    var _a, urlObj, params, returnProperty, headers, _b, url, headersObj, baseUrl, httpHeaders, shouldUseCache, result;
+    var _c, _d, _e, _f;
+    return __generator(this, function (_g) {
+        switch (_g.label) {
             case 0: return [4, (0, _operatorUtils_1.evaluateArray)([expression.url, expression.parameters, expression.returnProperty, expression.headers], config)];
             case 1:
-                _a = (_e.sent()), urlObj = _a[0], params = _a[1], returnProperty = _a[2], headers = _a[3];
+                _a = (_g.sent()), urlObj = _a[0], params = _a[1], returnProperty = _a[2], headers = _a[3];
                 _b = urlObj instanceof Object ? urlObj : { url: urlObj, headers: null }, url = _b.url, headersObj = _b.headers;
                 config.typeChecker({ name: 'url', value: url, expectedType: 'string' }, { name: 'headers', value: headersObj, expectedType: ['object', 'null'] }, { name: 'headers', value: headers, expectedType: ['object', 'undefined'] }, { name: 'parameters', value: params, expectedType: ['object', 'undefined'] }, { name: 'returnProperty', value: returnProperty, expectedType: ['string', 'undefined'] });
                 baseUrl = (_c = config.options.baseEndpoint) !== null && _c !== void 0 ? _c : '';
                 httpHeaders = __assign(__assign(__assign({}, (_d = config.options) === null || _d === void 0 ? void 0 : _d.headers), headersObj), headers);
-                return [4, (0, _operatorUtils_1.axiosRequest)({
-                        url: (0, _operatorUtils_1.isFullUrl)(url) ? url : (0, _operatorUtils_1.joinUrlParts)(baseUrl, url),
-                        params: params,
-                        headers: httpHeaders,
-                    })];
+                shouldUseCache = (_f = (_e = expression.useCache) !== null && _e !== void 0 ? _e : config.options.useCache) !== null && _f !== void 0 ? _f : true;
+                return [4, config.cache.useCache(shouldUseCache, function (url, params, headers, returnProperty) { return __awaiter(void 0, void 0, void 0, function () {
+                        var response;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4, (0, _operatorUtils_1.axiosRequest)({
+                                        url: url,
+                                        params: params,
+                                        headers: headers,
+                                    })];
+                                case 1:
+                                    response = _a.sent();
+                                    return [2, (0, _operatorUtils_1.extractAndSimplify)(response, returnProperty)];
+                            }
+                        });
+                    }); }, (0, _operatorUtils_1.isFullUrl)(url) ? url : (0, _operatorUtils_1.joinUrlParts)(baseUrl, url), params, httpHeaders, returnProperty)];
             case 2:
-                response = _e.sent();
-                return [2, (0, _operatorUtils_1.extractAndSimplify)(response, returnProperty)];
+                result = _g.sent();
+                return [2, result];
         }
     });
 }); };

package/build/operators/graphQL.js

@@ -53,10 +53,10 @@ var requiredProperties = ['query'];
 var operatorAliases = ['graphQl', 'graphql', 'gql'];
 var propertyAliases = { endpoint: 'url', outputNode: 'returnNode', returnProperty: 'returnNode' };
 var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, query, urlObj, variables, returnNode, headers, _b, url, headersObj, endpoint, baseEndpoint, fullUrl, data, response;
-    var _c, _d, _e, _f, _g;
-    return __generator(this, function (_h) {
-        switch (_h.label) {
+    var _a, query, urlObj, variables, returnNode, headers, _b, url, headersObj, endpoint, baseEndpoint, fullUrl, data, shouldUseCache, result;
+    var _c, _d, _e, _f, _g, _h, _j;
+    return __generator(this, function (_k) {
+        switch (_k.label) {
             case 0: return [4, (0, _operatorUtils_1.evaluateArray)([
                     expression.query,
                     expression.url,
@@ -65,22 +65,28 @@ var evaluate = function (expression, config) { return __awaiter(void 0, void 0,
                     expression.headers,
                 ], config)];
             case 1:
-                _a = (_h.sent()), query = _a[0], urlObj = _a[1], variables = _a[2], returnNode = _a[3], headers = _a[4];
+                _a = (_k.sent()), query = _a[0], urlObj = _a[1], variables = _a[2], returnNode = _a[3], headers = _a[4];
                 _b = urlObj instanceof Object ? urlObj : { url: urlObj, headers: null }, url = _b.url, headersObj = _b.headers;
                 config.typeChecker({ name: 'url', value: url, expectedType: ['string', 'undefined', 'null'] }, { name: 'query', value: query, expectedType: 'string' }, { name: 'headers', value: headersObj, expectedType: ['object', 'null'] }, { name: 'variables', value: variables, expectedType: ['object', 'undefined'] }, { name: 'returnNode', value: returnNode, expectedType: ['string', 'undefined'] });
                 endpoint = !url || url.toLowerCase() === 'graphqlendpoint' ? '' : url;
                 baseEndpoint = (_e = (_d = (_c = config.options.graphQLConnection) === null || _c === void 0 ? void 0 : _c.endpoint) !== null && _d !== void 0 ? _d : config.options.baseEndpoint) !== null && _e !== void 0 ? _e : '';
                 fullUrl = (0, _operatorUtils_1.isFullUrl)(endpoint) ? endpoint : (0, _operatorUtils_1.joinUrlParts)(baseEndpoint, endpoint);
                 data = { query: query, variables: variables };
-                return [4, (0, _operatorUtils_1.axiosRequest)({
-                        url: fullUrl,
-                        method: 'post',
-                        data: data,
-                        headers: __assign(__assign(__assign(__assign({}, (_f = config.options.graphQLConnection) === null || _f === void 0 ? void 0 : _f.headers), (_g = config.options) === null || _g === void 0 ? void 0 : _g.headers), headersObj), headers),
-                    })];
+                shouldUseCache = (_g = (_f = expression.useCache) !== null && _f !== void 0 ? _f : config.options.useCache) !== null && _g !== void 0 ? _g : true;
+                return [4, config.cache.useCache(shouldUseCache, function (url, data, headers, returnNode) { return __awaiter(void 0, void 0, void 0, function () {
+                        var response;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4, (0, _operatorUtils_1.axiosRequest)({ url: url, method: 'post', data: data, headers: headers })];
+                                case 1:
+                                    response = _a.sent();
+                                    return [2, (0, _operatorUtils_1.extractAndSimplify)(response.data, returnNode)];
+                            }
+                        });
+                    }); }, fullUrl, data, __assign(__assign(__assign(__assign({}, (_h = config.options.graphQLConnection) === null || _h === void 0 ? void 0 : _h.headers), (_j = config.options) === null || _j === void 0 ? void 0 : _j.headers), headersObj), headers), returnNode)];
             case 2:
-                response = _h.sent();
-                return [2, (0, _operatorUtils_1.extractAndSimplify)(response.data, returnNode)];
+                result = _k.sent();
+                return [2, result];
         }
     });
 }); };

package/build/operators/objectProperties.d.ts

@@ -3,7 +3,7 @@ declare const requiredProperties: string[];
 export type ObjPropNode = {
     [key in typeof requiredProperties[number]]: EvaluatorNode;
 } & BaseOperatorNode & {
-    additionalObjects: object;
+    additionalData: object;
 };
 export declare const OBJECT_PROPERTIES: OperatorObject;
 export {};

package/build/operators/objectProperties.js

@@ -54,24 +54,34 @@ exports.OBJECT_PROPERTIES = void 0;
 var object_property_extractor_1 = __importDefault(require("object-property-extractor"));
 var _operatorUtils_1 = require("./_operatorUtils");
 var requiredProperties = ['property'];
-var operatorAliases = ['objectProperties', 'objProps', 'getProperty', 'getObjProp'];
+var operatorAliases = [
+    'dataProperties',
+    'data',
+    'getData',
+    'objectProperties',
+    'objProps',
+    'getProperty',
+    'getObjProp',
+];
 var propertyAliases = {
     path: 'property',
     propertyName: 'property',
-    additional: 'additionalObjects',
-    objects: 'additionalObjects',
+    additional: 'additionalData',
+    objects: 'additionalData',
+    data: 'additionalData',
+    additionalObjects: 'additionalData',
 };
 var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, property, additionalObjects, inputObject;
+    var _a, property, additionalData, inputObject;
     var _b, _c, _d, _e;
     return __generator(this, function (_f) {
         switch (_f.label) {
-            case 0: return [4, (0, _operatorUtils_1.evaluateArray)([expression.property, expression.additionalObjects], config)];
+            case 0: return [4, (0, _operatorUtils_1.evaluateArray)([expression.property, expression.additionalData], config)];
             case 1:
-                _a = (_f.sent()), property = _a[0], additionalObjects = _a[1];
-                config.typeChecker({ name: 'property', value: property, expectedType: 'string' }, { name: 'additionalObjects', value: additionalObjects, expectedType: ['object', 'undefined'] });
-                inputObject = additionalObjects
-                    ? __assign(__assign({}, ((_c = (_b = config.options) === null || _b === void 0 ? void 0 : _b.objects) !== null && _c !== void 0 ? _c : {})), additionalObjects) : (_e = (_d = config.options) === null || _d === void 0 ? void 0 : _d.objects) !== null && _e !== void 0 ? _e : {};
+                _a = (_f.sent()), property = _a[0], additionalData = _a[1];
+                config.typeChecker({ name: 'property', value: property, expectedType: 'string' }, { name: 'additionalData', value: additionalData, expectedType: ['object', 'undefined'] });
+                inputObject = additionalData
+                    ? __assign(__assign({}, ((_c = (_b = config.options) === null || _b === void 0 ? void 0 : _b.data) !== null && _c !== void 0 ? _c : {})), additionalData) : (_e = (_d = config.options) === null || _d === void 0 ? void 0 : _d.data) !== null && _e !== void 0 ? _e : {};
                 return [2, (0, object_property_extractor_1.default)(inputObject, property)];
         }
     });

package/build/operators/pgSQL.js

@@ -62,25 +62,41 @@ var requiredProperties = ['query'];
 var operatorAliases = ['pgSql', 'sql', 'postgres', 'pg', 'pgDb'];
 var propertyAliases = { replacements: 'values' };
 var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, query, values, err_1;
+    var _a, query, values, shouldUseCache, result;
     var _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
+    var _c, _d, _e;
+    return __generator(this, function (_f) {
+        switch (_f.label) {
             case 0: return [4, (0, _operatorUtils_1.evaluateArray)(__spreadArray([expression.query], (expression.values || []), true), config)];
             case 1:
-                _a = (_c.sent()), query = _a[0], values = _a.slice(1);
+                _a = (_f.sent()), query = _a[0], values = _a.slice(1);
                 config.typeChecker({ name: 'query', value: query, expectedType: 'string' }, { name: 'values', value: values, expectedType: 'array' });
-                if (!((_b = config.options) === null || _b === void 0 ? void 0 : _b.pgConnection))
+                if (!((_c = config.options) === null || _c === void 0 ? void 0 : _c.pgConnection))
                     throw new Error('No Postgres database connection provided');
-                _c.label = 2;
-            case 2:
-                _c.trys.push([2, 4, , 5]);
-                return [4, processPgSQL(__spreadArray([query], values, true), config.options.pgConnection, expression === null || expression === void 0 ? void 0 : expression.type)];
-            case 3: return [2, _c.sent()];
-            case 4:
-                err_1 = _c.sent();
-                throw err_1;
-            case 5: return [2];
+                shouldUseCache = (_e = (_d = expression.useCache) !== null && _d !== void 0 ? _d : config.options.useCache) !== null && _e !== void 0 ? _e : true;
+                try {
+                    result = (_b = config.cache).useCache.apply(_b, __spreadArray([shouldUseCache,
+                        function (query) {
+                            var values = [];
+                            for (var _i = 1; _i < arguments.length; _i++) {
+                                values[_i - 1] = arguments[_i];
+                            }
+                            return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4, processPgSQL(__spreadArray([query], values, true), config.options.pgConnection, expression === null || expression === void 0 ? void 0 : expression.type)];
+                                        case 1: return [2, _a.sent()];
+                                    }
+                                });
+                            });
+                        },
+                        query], values, false));
+                    return [2, result];
+                }
+                catch (err) {
+                    throw err;
+                }
+                return [2];
         }
     });
 }); };
@@ -89,7 +105,7 @@ var parseChildren = function (expression) {
     return __assign(__assign({}, expression), { query: query, values: values });
 };
 var processPgSQL = function (queryArray, connection, queryType) { return __awaiter(void 0, void 0, void 0, function () {
-    var expression, res, result, err_2;
+    var expression, res, result, err_1;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
@@ -119,8 +135,8 @@ var processPgSQL = function (queryArray, connection, queryType) { return __await
                 }
                 return [3, 4];
             case 3:
-                err_2 = _a.sent();
-                throw err_2;
+                err_1 = _a.sent();
+                throw err_1;
             case 4: return [2];
         }
     });

package/build/operators/postRequest.js

@@ -54,26 +54,37 @@ var requiredProperties = ['url'];
 var operatorAliases = ['post'];
 var propertyAliases = { endpoint: 'url', outputProperty: 'returnProperty' };
 var evaluate = function (expression, config) { return __awaiter(void 0, void 0, void 0, function () {
-    var _a, urlObj, data, returnProperty, headers, _b, url, headersObj, baseUrl, httpHeaders, response;
-    var _c, _d;
-    return __generator(this, function (_e) {
-        switch (_e.label) {
+    var _a, urlObj, data, returnProperty, headers, _b, url, headersObj, baseUrl, httpHeaders, shouldUseCache, result;
+    var _c, _d, _e, _f;
+    return __generator(this, function (_g) {
+        switch (_g.label) {
             case 0: return [4, (0, _operatorUtils_1.evaluateArray)([expression.url, expression.parameters, expression.returnProperty, expression.headers], config)];
             case 1:
-                _a = (_e.sent()), urlObj = _a[0], data = _a[1], returnProperty = _a[2], headers = _a[3];
+                _a = (_g.sent()), urlObj = _a[0], data = _a[1], returnProperty = _a[2], headers = _a[3];
                 _b = urlObj instanceof Object ? urlObj : { url: urlObj, headers: null }, url = _b.url, headersObj = _b.headers;
                 config.typeChecker({ name: 'url', value: url, expectedType: 'string' }, { name: 'headers', value: headersObj, expectedType: ['object', 'null'] }, { name: 'data', value: data, expectedType: ['object', 'undefined'] }, { name: 'returnProperty', value: returnProperty, expectedType: ['string', 'undefined'] });
                 baseUrl = (_c = config.options.baseEndpoint) !== null && _c !== void 0 ? _c : '';
                 httpHeaders = __assign(__assign(__assign({}, (_d = config.options) === null || _d === void 0 ? void 0 : _d.headers), headersObj), headers);
-                return [4, (0, _operatorUtils_1.axiosRequest)({
-                        url: (0, _operatorUtils_1.isFullUrl)(url) ? url : (0, _operatorUtils_1.joinUrlParts)(baseUrl, url),
-                        data: data,
-                        headers: httpHeaders,
-                        method: 'post',
-                    })];
+                shouldUseCache = (_f = (_e = expression.useCache) !== null && _e !== void 0 ? _e : config.options.useCache) !== null && _f !== void 0 ? _f : true;
+                return [4, config.cache.useCache(shouldUseCache, function (url, data, headers, returnProperty) { return __awaiter(void 0, void 0, void 0, function () {
+                        var response;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4, (0, _operatorUtils_1.axiosRequest)({
+                                        url: url,
+                                        data: data,
+                                        headers: headers,
+                                        method: 'post',
+                                    })];
+                                case 1:
+                                    response = _a.sent();
+                                    return [2, (0, _operatorUtils_1.extractAndSimplify)(response, returnProperty)];
+                            }
+                        });
+                    }); }, (0, _operatorUtils_1.isFullUrl)(url) ? url : (0, _operatorUtils_1.joinUrlParts)(baseUrl, url), data, httpHeaders, returnProperty)];
             case 2:
-                response = _e.sent();
-                return [2, (0, _operatorUtils_1.extractAndSimplify)(response, returnProperty)];
+                result = _g.sent();
+                return [2, result];
         }
     });
 }); };

package/build/types.d.ts

@@ -1,3 +1,4 @@
+import FigTreeCache from './cache';
 import { BasicExtendedNode, SubtractionNode, DivisionNode, ComparatorNode, ConditionalNode, RegexNode, StringSubNode, SplitNode, ObjPropNode, APINode, PGNode, GraphQLNode, BuildObjectNode, MatchNode, FunctionNode, PassThruNode, PGConnection, GraphQLConnection } from './operators';
 import { TypeCheckInput } from './typeCheck';
 export declare const Operators: readonly ["AND", "OR", "EQUAL", "NOT_EQUAL", "PLUS", "SUBTRACT", "MULTIPLY", "DIVIDE", "GREATER_THAN", "LESS_THAN", "CONDITIONAL", "REGEX", "OBJECT_PROPERTIES", "STRING_SUBSTITUTION", "SPLIT", "COUNT", "GET", "POST", "PG_SQL", "GRAPHQL", "BUILD_OBJECT", "MATCH", "CUSTOM_FUNCTIONS", "PASSTHRU"];
@@ -6,6 +7,7 @@ export type GenericObject = {
     [key: string]: any;
 };
 export interface FigTreeOptions {
+    data?: GenericObject;
     objects?: GenericObject;
     functions?: {
         [key: string]: Function;
@@ -21,6 +23,8 @@ export interface FigTreeOptions {
     allowJSONStringInput?: boolean;
     skipRuntimeTypeCheck?: boolean;
     evaluateFullObject?: boolean;
+    useCache?: boolean;
+    maxCacheSize?: number;
 }
 export interface FigTreeConfig {
     options: FigTreeOptions;
@@ -32,6 +36,7 @@ export interface FigTreeConfig {
     resolvedAliasNodes: {
         [key: string]: EvaluatorOutput;
     };
+    cache: FigTreeCache;
 }
 export type OutputType = 'string' | 'number' | 'boolean' | 'bool' | 'array';
 export interface BaseOperatorNode {
@@ -39,6 +44,7 @@ export interface BaseOperatorNode {
     outputType?: OutputType;
     children?: Array<EvaluatorNode>;
     fallback?: any;
+    useCache?: boolean;
     [key: string]: EvaluatorNode;
 }
 export type CombinedOperatorNode = BaseOperatorNode & BasicExtendedNode & SubtractionNode & DivisionNode & ComparatorNode & ConditionalNode & RegexNode & StringSubNode & SplitNode & ObjPropNode & APINode & PGNode & GraphQLNode & BuildObjectNode & MatchNode & FunctionNode & PassThruNode;

package/package.json

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