fig-tree-evaluator 2.8.5 → 2.9.0

package/README.md

@@ -115,9 +115,9 @@ A playground for building and testing expressions is available [here](https://ca
 
 ## Install
 
-`npm install fig-tree`\
+`npm install fig-tree-evaluator`\
 or\
-`yarn add fig-tree`
+`yarn add fig-tree-evaluator`
 
 ## Usage
 
@@ -162,6 +162,7 @@ The `options` parameter is an object with the following available properties (al
 - `excludeOperators` -- an array of operator names (or [aliases](#operator--property-aliases)) to prohibit from being used in expressions. You may wish to restrict (for example) database access via FigTree configurations, in which case these exclusions can be defined when instantiating the FigTree instance (or updated on the fly).
 - `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`)
+- `maxCacheTime` -- the maximum time (in seconds) that a result will be cached since last access (default: `1800` (30 minutes))
 - `noShorthand` -- there is a [shorthand syntax](#shorthand-syntax) available for writing expressions. Internally, this is pre-processed into the standard expression form before evaluation. If you have no use for this and you'd rather all expressions were written with full verbosity, set `noShorthand: true` to save a small amount in performance by skipping internal pre-processing.
 
 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:
@@ -1527,7 +1528,7 @@ For more examples, see `23_shorthand.test.ts`, or have a play with the [demo app
 
 ## Caching (Memoization)
 
-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.
+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 with each result being valid for half and hour, but these values can be modified using the `maxCacheSize` and `maxCacheTime` [options](#available-options).
 
 Currently, caching is only implemented for the following operators, since they perform requests to external resources, which are inherently slow:
 
@@ -1543,6 +1544,17 @@ This is different to the memoization provided by [Alias Nodes](#alias-nodes):
 
 Caching is enabled by default for most of the above operators, but this can be overridden by setting `useCache: false` in [options](#available-options), either globally or per expression. If you're querying a database or API that is likely to have a different result for the same request (i.e. data has changed), then you probably want to turn the cache off.
 
+It's possible to manually set/get the cache store, which can be used (for example) to save the cache in local storage to persist it between page reloads or new FigTree instances.
+
+Use the methods:
+
+```js
+fig.getCache() // returns key-value store
+
+fig.setCache(cache) // where "cache" is the object retrieved by .getCache()
+```
+
+
 ## Metadata
 
 Evaluator expression can be configured by hand, with [aliases](#alias-nodes), [fragments](#fragments) and [shorthand](#shorthand-syntax) available to make the job easier.
@@ -1691,6 +1703,8 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
 
 *Trivial upgrades (e.g. documentation, small re-factors, types, etc.) not included*
 
+- **v2.9.0**: Added ability to invalidate cache by time (#94)
+- **v2.8.6**: Small bug fix where `options` object would be mutated instead of replaced
 - **v2.8.5**: Small bug fix in [COUNT](#count) operator
 - **v2.8.4**: Refactor types, better compliance with [ESLint](https://eslint.org/) rules, add more tests
 - **v2.8.0**:

package/build/FigTreeEvaluator.d.ts

@@ -1,4 +1,5 @@
 import { EvaluatorNode, FigTreeOptions, OperatorMetadata, FragmentMetadata } from './types';
+import { Store } from './cache';
 declare class FigTreeEvaluator {
     private options;
     private operators;
@@ -9,6 +10,8 @@ declare class FigTreeEvaluator {
     evaluate(expression: EvaluatorNode, options?: FigTreeOptions): Promise<import("./types").EvaluatorOutput>;
     getOptions(): FigTreeOptions;
     updateOptions(options: FigTreeOptions): void;
+    getCache: () => Store;
+    setCache: (cache: Store) => Store;
     getOperators(): readonly OperatorMetadata[];
     getFragments(): readonly (FragmentMetadata & {
         name: string;

package/build/FigTreeEvaluator.js

@@ -54,17 +54,21 @@ class FigTreeEvaluator {
                 return;
             throw new Error(result);
         };
+        this.getCache = () => this.cache.getCache();
+        this.setCache = (cache) => this.cache.setCache(cache);
         this.getVersion = () => version_1.version;
         this.options = standardiseOptionNames(options);
         this.operators = (0, helpers_1.filterOperators)(operators, (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.excludeOperators) !== null && _b !== void 0 ? _b : [], operatorAliases);
         this.operatorAliases = operatorAliases;
-        this.cache = new cache_1.default(options.maxCacheSize);
+        this.cache = new cache_1.default({ maxSize: options.maxCacheSize, maxTime: options.maxCacheTime });
     }
     evaluate(expression, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const currentOptions = (0, helpers_1.mergeOptions)(this.options, standardiseOptionNames(options));
             if (currentOptions.maxCacheSize && currentOptions.maxCacheSize !== this.cache.getMax())
                 this.cache.setMax(currentOptions.maxCacheSize);
+            if (currentOptions.maxCacheTime && currentOptions.maxCacheTime !== this.cache.getMaxTime())
+                this.cache.setMaxTime(currentOptions.maxCacheTime);
             return yield (0, evaluate_1.evaluatorFunction)(expression, {
                 options: currentOptions,
                 operators: options.excludeOperators
@@ -111,8 +115,7 @@ const evaluateExpression = (expression, options) => new FigTreeEvaluator(options
 exports.evaluateExpression = evaluateExpression;
 const standardiseOptionNames = (options) => {
     if ('objects' in options) {
-        options.data = options.objects;
-        delete options.objects;
+        return Object.assign(Object.assign({}, options), { data: options.objects });
     }
     return options;
 };

package/build/cache.d.ts

@@ -1,12 +1,27 @@
 import { EvaluatorOutput, UnknownFunction } from './types';
+interface CacheOptions {
+    maxSize?: number;
+    maxTime?: number;
+}
+export interface Store {
+    [key: string]: {
+        result: EvaluatorOutput;
+        timestamp: number;
+    };
+}
 declare class FigTreeCache {
     private store;
     private queue;
     private maxSize;
-    constructor(maxSize?: number);
+    private maxTime;
+    constructor(options?: CacheOptions);
     useCache: (shouldUseCache: boolean, action: UnknownFunction, ...args: unknown[]) => Promise<EvaluatorOutput>;
     getMax: () => number;
     setMax: (size: number) => void;
+    getMaxTime: () => number;
+    setMaxTime: (time: number) => void;
+    getCache: () => Store;
+    setCache: (cache: Store) => Store;
     private resizeCache;
 }
 export default FigTreeCache;

package/build/cache.js

@@ -10,19 +10,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const MAX_CACHED_ITEMS = 50;
+const MAX_CACHE_TIME = 1800;
 class FigTreeCache {
-    constructor(maxSize) {
+    constructor(options) {
+        var _a, _b;
         this.useCache = (shouldUseCache, action, ...args) => __awaiter(this, void 0, void 0, function* () {
             if (!shouldUseCache)
                 return yield action(...args);
             const key = stringifyInput(args);
-            if (key in this.store) {
+            const keyExists = key in this.store;
+            const newTimestamp = Date.now();
+            const isExpired = keyExists && newTimestamp - this.store[key].timestamp > this.maxTime * 1000;
+            if (keyExists) {
                 this.queue = this.queue.filter((val) => val !== key);
                 this.queue.unshift(key);
-                return this.store[key];
+                this.store[key].timestamp = newTimestamp;
+                if (isExpired)
+                    this.store[key].result = yield action(...args);
+                return this.store[key].result;
             }
             const result = yield action(...args);
-            this.store[key] = result;
+            this.store[key] = { result, timestamp: newTimestamp };
             this.queue.unshift(key);
             this.resizeCache();
             return result;
@@ -32,6 +40,12 @@ class FigTreeCache {
             this.maxSize = size;
             this.resizeCache();
         };
+        this.getMaxTime = () => this.maxTime;
+        this.setMaxTime = (time) => {
+            this.maxTime = time;
+        };
+        this.getCache = () => this.store;
+        this.setCache = (cache) => (this.store = cache);
         this.resizeCache = () => {
             if (this.queue.length > this.maxSize) {
                 const keysToRemove = this.queue.slice(this.maxSize);
@@ -41,7 +55,8 @@ class FigTreeCache {
         };
         this.store = {};
         this.queue = [];
-        this.maxSize = maxSize !== null && maxSize !== void 0 ? maxSize : MAX_CACHED_ITEMS;
+        this.maxSize = (_a = options === null || options === void 0 ? void 0 : options.maxSize) !== null && _a !== void 0 ? _a : MAX_CACHED_ITEMS;
+        this.maxTime = (_b = options === null || options === void 0 ? void 0 : options.maxTime) !== null && _b !== void 0 ? _b : MAX_CACHE_TIME;
     }
 }
 exports.default = FigTreeCache;

package/build/types.d.ts

@@ -4,7 +4,7 @@ import { GraphQLConnection } from './operators';
 import operatorAliases from './operators/_operatorAliases.json';
 import { ExpectedType, 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"];
-export type Operator = typeof Operators[number];
+export type Operator = (typeof Operators)[number];
 export type OperatorAlias = keyof typeof operatorAliases;
 export type OperatorAliases = Record<OperatorAlias, Operator>;
 export type Fragments = Record<string, Fragment>;
@@ -29,6 +29,7 @@ export interface FigTreeOptions {
     excludeOperators?: OperatorAlias[];
     useCache?: boolean;
     maxCacheSize?: number;
+    maxCacheTime?: number;
     supportDeprecatedValueNodes?: boolean;
 }
 export interface FigTreeConfig {

package/build/version.d.ts

@@ -1 +1 @@
-export declare const version = "2.8.5";
+export declare const version = "2.9.0";

package/build/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
-exports.version = '2.8.5';
+exports.version = '2.9.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fig-tree-evaluator",
-  "version": "2.8.5",
+  "version": "2.9.0",
   "description": "Module to evaluate JSON-structured expression trees",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -20,10 +20,10 @@
     "@typescript-eslint/parser": "^5.57.0",
     "dotenv": "^16.0.1",
     "eslint": "^8.37.0",
-    "jest": "^28.1.0",
+    "jest": "^29.6.2",
     "pg": "^8.7.3",
     "rimraf": "^3.0.2",
-    "ts-jest": "^28.0.3",
+    "ts-jest": "^29.1.1",
     "ts-node": "^10.8.0",
     "typescript": "^4.7.2"
   },