fig-tree-evaluator 2.2.2 → 2.2.3

package/README.md

@@ -135,7 +135,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.
@@ -659,16 +659,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 +688,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 +701,7 @@ Here is the result of various values of `expression:`
 // => "Peter"
 
 {
-  operator: 'getProperty',
+  operator: 'getData',
   path: 'user.friends[1]',
 }
 // => "MJ"
@@ -721,7 +721,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 +734,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' } },
@@ -1178,8 +1178,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"
 
 ```
 
@@ -1411,6 +1411,7 @@ Please open an issue: https://github.com/CarlosNZ/fig-tree-evaluator/issues
 
 ## Changelog
 
+- **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/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,5 +1,4 @@
 import { EvaluatorNode, FigTreeOptions } from './types';
-export declare const getVersion: () => any;
 declare class FigTreeEvaluator {
     private options;
     private operators;

package/build/index.js

@@ -73,15 +73,13 @@ 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 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,8 +93,8 @@ 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;
     }
@@ -107,7 +105,7 @@ 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));
                         return [4, (0, evaluate_1.evaluatorFunction)(expression, {
                                 options: currentOptions,
                                 operators: this.operators,
@@ -124,7 +122,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 +131,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,7 +80,7 @@ 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 _a, functionPath, args, _b, data, functions, func;
     var _c, _d;
     return __generator(this, function (_e) {
         switch (_e.label) {
@@ -88,8 +88,8 @@ var evaluate = function (expression, config) { return __awaiter(void 0, void 0,
             case 1:
                 _a = (_e.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));
+                _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()];
         }

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

@@ -6,6 +6,7 @@ export type GenericObject = {
     [key: string]: any;
 };
 export interface FigTreeOptions {
+    data?: GenericObject;
     objects?: GenericObject;
     functions?: {
         [key: string]: Function;

package/package.json

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