fig-tree-evaluator 2.5.2 → 2.7.0

package/README.md

@@ -157,6 +157,7 @@ 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 within the object tree.
+- `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`)
 
@@ -1510,6 +1511,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.7.0**: Add `excludeOperators` option to allow certain operators to be prohibited (e.g. database lookups) (#54)
+- **v2.6.0**: Resolve alias nodes that are not part of an Operator node when `evaluateFullObject` is enabled (#78)
 - **v2.5.0**:
   - Bug fixes for edge cases (mainly related to backwards compatibility)
   - More backwards compatibility for very old (pre-v1) syntax (undocumented)

package/build/FigTreeEvaluator.js

@@ -43,8 +43,10 @@ const operators = __importStar(require("./operators"));
 const helpers_1 = require("./helpers");
 const cache_1 = __importDefault(require("./cache"));
 const pkg = require('../package.json');
+const operatorAliases = _operatorAliases_json_1.default;
 class FigTreeEvaluator {
     constructor(options = {}) {
+        var _a, _b;
         this.typeChecker = (...args) => {
             const result = (0, typeCheck_1.typeCheck)(...args);
             if (result === true)
@@ -53,8 +55,8 @@ class FigTreeEvaluator {
         };
         this.getVersion = () => pkg.version;
         this.options = standardiseOptionNames(options);
-        this.operators = operators;
-        this.operatorAliases = _operatorAliases_json_1.default;
+        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);
     }
     evaluate(expression, options = {}) {
@@ -64,7 +66,9 @@ class FigTreeEvaluator {
                 this.cache.setMax(currentOptions.maxCacheSize);
             return yield (0, evaluate_1.evaluatorFunction)(expression, {
                 options: currentOptions,
-                operators: this.operators,
+                operators: options.excludeOperators
+                    ? (0, helpers_1.filterOperators)(operators, options.excludeOperators, operatorAliases)
+                    : this.operators,
                 operatorAliases: this.operatorAliases,
                 typeChecker: currentOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
                 resolvedAliasNodes: {},
@@ -77,6 +81,8 @@ class FigTreeEvaluator {
     }
     updateOptions(options) {
         this.options = (0, helpers_1.mergeOptions)(this.options, standardiseOptionNames(options));
+        if (this.options.excludeOperators)
+            this.operators = (0, helpers_1.filterOperators)(operators, this.options.excludeOperators, operatorAliases);
     }
 }
 exports.default = FigTreeEvaluator;

package/build/evaluate.js

@@ -45,6 +45,8 @@ const evaluatorFunction = (input, config) => __awaiter(void 0, void 0, void 0, f
         const operator = (0, helpers_1.getOperatorName)(expression.operator, operatorAliases);
         if (!operator)
             return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Invalid operator: ${expression.operator}`, returnErrorAsString);
+        if (!config.operators[operator])
+            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Excluded operator: ${expression.operator}`, returnErrorAsString);
         const { requiredProperties, propertyAliases, evaluate, parseChildren } = operators[operator];
         expression = (0, helpers_1.mapPropertyAliases)(propertyAliases, expression);
         config.resolvedAliasNodes = Object.assign(Object.assign({}, config.resolvedAliasNodes), (yield (0, helpers_1.evaluateNodeAliases)(expression, config)));

package/build/helpers.d.ts

@@ -1,10 +1,34 @@
-import { OutputType, EvaluatorNode, CombinedOperatorNode, Operator, EvaluatorOutput, FigTreeOptions, OperatorNodeUnion, FigTreeConfig } from './types';
+import { OutputType, EvaluatorNode, CombinedOperatorNode, EvaluatorOutput, FigTreeOptions, OperatorNodeUnion, FigTreeConfig, OperatorReference, OperatorAliases } from './types';
 export declare const parseIfJson: (input: EvaluatorNode) => any;
 export declare const isOperatorNode: (input: EvaluatorNode) => boolean;
 export declare const isFragmentNode: (input: EvaluatorNode) => boolean;
-export declare const getOperatorName: (operator: string, operatorAliases: {
-    [key: string]: "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";
-}) => "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 declare const getOperatorName: (operator: string, operatorAliases: OperatorAliases) => "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 declare const filterOperators: (operators: OperatorReference, exclusions: string[], operatorAliases: OperatorAliases) => {
+    AND: import("./types").OperatorObject;
+    OR: import("./types").OperatorObject;
+    EQUAL: import("./types").OperatorObject;
+    NOT_EQUAL: import("./types").OperatorObject;
+    PLUS: import("./types").OperatorObject;
+    SUBTRACT: import("./types").OperatorObject;
+    MULTIPLY: import("./types").OperatorObject;
+    DIVIDE: import("./types").OperatorObject;
+    GREATER_THAN: import("./types").OperatorObject;
+    LESS_THAN: import("./types").OperatorObject;
+    CONDITIONAL: import("./types").OperatorObject;
+    REGEX: import("./types").OperatorObject;
+    OBJECT_PROPERTIES: import("./types").OperatorObject;
+    STRING_SUBSTITUTION: import("./types").OperatorObject;
+    SPLIT: import("./types").OperatorObject;
+    COUNT: import("./types").OperatorObject;
+    GET: import("./types").OperatorObject;
+    POST: import("./types").OperatorObject;
+    PG_SQL: import("./types").OperatorObject;
+    GRAPHQL: import("./types").OperatorObject;
+    BUILD_OBJECT: import("./types").OperatorObject;
+    MATCH: import("./types").OperatorObject;
+    CUSTOM_FUNCTIONS: import("./types").OperatorObject;
+    PASSTHRU: import("./types").OperatorObject;
+};
 export declare const truncateString: (string: string, length?: number) => string;
 export declare const fallbackOrError: (fallback: any, errorMessage: string, returnErrorAsString?: boolean) => any;
 export declare const mapPropertyAliases: (propertyAliases: {

package/build/helpers.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateObject = exports.isObject = exports.errorMessage = exports.convertOutputMethods = exports.mergeOptions = exports.checkRequiredNodes = exports.replaceAliasNodeValues = exports.evaluateNodeAliases = exports.mapPropertyAliases = exports.fallbackOrError = exports.truncateString = exports.getOperatorName = exports.isFragmentNode = exports.isOperatorNode = exports.parseIfJson = void 0;
+exports.evaluateObject = exports.isObject = exports.errorMessage = exports.convertOutputMethods = exports.mergeOptions = exports.checkRequiredNodes = exports.replaceAliasNodeValues = exports.evaluateNodeAliases = exports.mapPropertyAliases = exports.fallbackOrError = exports.truncateString = exports.filterOperators = exports.getOperatorName = exports.isFragmentNode = exports.isOperatorNode = exports.parseIfJson = void 0;
 const change_case_1 = require("change-case");
 const evaluate_1 = require("./evaluate");
 const _operatorUtils_1 = require("./operators/_operatorUtils");
@@ -35,6 +35,17 @@ const standardiseOperatorName = (name) => {
 };
 const getOperatorName = (operator, operatorAliases) => operatorAliases[standardiseOperatorName(operator)];
 exports.getOperatorName = getOperatorName;
+const filterOperators = (operators, exclusions, operatorAliases) => {
+    const filteredOperators = Object.assign({}, operators);
+    exclusions.forEach((exclusion) => {
+        const operator = operatorAliases[standardiseOperatorName(exclusion)];
+        if (!operator)
+            console.warn(`Invalid operator exclusion: ${exclusion}`);
+        delete filteredOperators[operatorAliases[standardiseOperatorName(exclusion)]];
+    });
+    return filteredOperators;
+};
+exports.filterOperators = filterOperators;
 const truncateString = (string, length = 200) => string.length < length ? string : `${string.slice(0, length - 2).trim()}...`;
 exports.truncateString = truncateString;
 const fallbackOrError = (fallback, errorMessage, returnErrorAsString = false) => {
@@ -116,8 +127,19 @@ const evaluateObject = (input, config) => __awaiter(void 0, void 0, void 0, func
     if (!(0, exports.isObject)(input))
         return input;
     const newObjectEntries = [];
-    Object.entries(input).forEach(([key, value]) => newObjectEntries.push(key, (0, evaluate_1.evaluatorFunction)(value, config)));
-    const result = yield Promise.all(newObjectEntries);
-    return (0, _operatorUtils_1.singleArrayToObject)(result);
+    const newAliases = [];
+    Object.entries(input).forEach(([key, value]) => {
+        if (isAliasString(key)) {
+            newAliases.push(key, (0, evaluate_1.evaluatorFunction)(value, config));
+            delete input[key];
+        }
+    });
+    const aliasArray = yield Promise.all(newAliases);
+    config.resolvedAliasNodes = Object.assign(Object.assign({}, config.resolvedAliasNodes), (0, _operatorUtils_1.singleArrayToObject)(aliasArray));
+    Object.entries(input).forEach(([key, value]) => {
+        newObjectEntries.push(key, (0, evaluate_1.evaluatorFunction)(value, config));
+    });
+    const results = yield Promise.all(newObjectEntries);
+    return (0, exports.replaceAliasNodeValues)((0, _operatorUtils_1.singleArrayToObject)(results), config);
 });
 exports.evaluateObject = evaluateObject;

package/build/types.d.ts

@@ -1,11 +1,14 @@
 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 operatorAliases from './operators/_operatorAliases.json';
 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"];
 export type Operator = typeof Operators[number];
 export type GenericObject = {
     [key: string]: any;
 };
+export type OperatorAlias = keyof typeof operatorAliases;
+export type OperatorAliases = Record<OperatorAlias, Operator>;
 export interface FigTreeOptions {
     data?: GenericObject;
     objects?: GenericObject;
@@ -26,6 +29,7 @@ export interface FigTreeOptions {
     allowJSONStringInput?: boolean;
     skipRuntimeTypeCheck?: boolean;
     evaluateFullObject?: boolean;
+    excludeOperators?: string[];
     useCache?: boolean;
     maxCacheSize?: number;
     supportDeprecatedValueNodes?: boolean;
@@ -33,9 +37,7 @@ export interface FigTreeOptions {
 export interface FigTreeConfig {
     options: FigTreeOptions;
     operators: OperatorReference;
-    operatorAliases: {
-        [key: string]: Operator;
-    };
+    operatorAliases: OperatorAliases;
     typeChecker: (...input: TypeCheckInput[]) => void;
     resolvedAliasNodes: {
         [key: string]: EvaluatorOutput;

package/package.json

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