fig-tree-evaluator 2.2.3 → 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)
@@ -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
@@ -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:
 {
@@ -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,7 @@ 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)

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/index.d.ts

@@ -3,6 +3,7 @@ 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

@@ -79,6 +79,7 @@ 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 FigTreeEvaluator = (function () {
     function FigTreeEvaluator(options) {
@@ -97,6 +98,7 @@ var FigTreeEvaluator = (function () {
         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 = {}; }
@@ -106,12 +108,15 @@ var FigTreeEvaluator = (function () {
                 switch (_a.label) {
                     case 0:
                         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()];
                 }

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, data, 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, data = _b.data, 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)(data, 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()];
+                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/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"];
@@ -22,6 +23,8 @@ export interface FigTreeOptions {
     allowJSONStringInput?: boolean;
     skipRuntimeTypeCheck?: boolean;
     evaluateFullObject?: boolean;
+    useCache?: boolean;
+    maxCacheSize?: number;
 }
 export interface FigTreeConfig {
     options: FigTreeOptions;
@@ -33,6 +36,7 @@ export interface FigTreeConfig {
     resolvedAliasNodes: {
         [key: string]: EvaluatorOutput;
     };
+    cache: FigTreeCache;
 }
 export type OutputType = 'string' | 'number' | 'boolean' | 'bool' | 'array';
 export interface BaseOperatorNode {
@@ -40,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.3",
+  "version": "2.3.0",
   "description": "Module to evaluate JSON-structured expression trees",
   "main": "build/index.js",
   "types": "build/index.d.ts",