fig-tree-evaluator 2.6.0 → 2.8.0

package/README.md

@@ -50,7 +50,9 @@ A range of built-in operators are available, from simple logic, arithmetic and s
   - [CUSTOM\_FUNCTIONS](#custom_functions)
 - [Alias Nodes](#alias-nodes)
 - [Fragments](#fragments)
+- [Shorthand syntax](#shorthand-syntax)
 - [Caching (Memoization)](#caching-memoization)
+- [Metadata](#metadata)
 - [More examples](#more-examples)
 - [Development environment](#development-environment)
 - [Tests](#tests)
@@ -123,16 +125,16 @@ or\
 import FigTreeEvaluator from 'fig-tree-evaluator'
 
 // New evaluator instance
-const exp = new FigTreeEvaluator([ options ]) // See available options below
+const fig = new FigTreeEvaluator([ options ]) // See available options below
 
 // Evaluate expressions
-exp.evaluate(expression, [options]) // Options over-ride initial options for this evaluation
+fig.evaluate(expression, [options]) // Options over-ride initial options for this evaluation
     .then((result) => { // "evaluate" is async method
         // Do something with result
     })
 
 // Or within async function:
-const result = await exp.evaluate(expression, [options])
+const result = await fig.evaluate(expression, [options])
 ```
 
 FigTreeEvaluator is written in **Typescript**, and the following types are available to import from the package:
@@ -157,16 +159,18 @@ 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`)
+- `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:
 
-`exp.updateOptions(options)`
+`fig.updateOptions(options)`
 
 You can also retrieve the current options state at any time with:
 
-`exp.getOptions()`
+`fig.getOptions()`
 
 It's also possible to run one-off evaluations by importing the evaluation method directly rather than using the constructor:
 
@@ -700,11 +704,11 @@ const user = {
   ],
 }
 
-const exp = new FigTreeEvaluator()
+const fig = new FigTreeEvaluator()
 
 const expression = getExpressionFromConfig()
 
-exp.evaluate(expression, { data: { user } })
+fig.evaluate(expression, { data: { user } })
 ```
 
 Here is the result of various values of `expression:`
@@ -731,7 +735,7 @@ Here is the result of various values of `expression:`
 Notice the last example pulls multiple values out of an array of objects, in this case the "name". This is essentially a shorthand for:
 
 ```js
-exp.evaluate(
+fig.evaluate(
     { operator: 'getProperty', path: 'user.enemies' },
     { data: { user } }
   ).map((e) => e.name)
@@ -911,7 +915,7 @@ e.g.
 `children` array: `[urlObject, parameterKeys, ...values, returnProperty]`
 
 - `urlObject`: either a url string, or an object structured as `{url: <string>, headers: <object>}` (if additional headers are required)
-- `parameterKeys`: an array of strings representing the keys of any query parameters
+- `parameterKeys`: an array of strings representing the keys of any query parameters (or just a single string if only one)
 - `...values`: one value for each key specified in `parameterKeys`
 - `returnProperty` (optional): as above
 
@@ -1062,7 +1066,7 @@ const pgConnect = new Client(pgConfig) // pgConfig = database details, see node-
 
 pgConnect.connect()
 
-const exp = new FigTreeEvaluator({ pgConnection: pgConnect })
+const fig = new FigTreeEvaluator({ pgConnection: pgConnect })
 ```
 
 The following examples query a default installation of the [Northwind](https://github.com/pthom/northwind_psql) demo database.
@@ -1279,7 +1283,7 @@ Custom functions are stored in the evaluator `options`, in the `functions` prope
 
 For examples, consider the following fig-tree instance:
 ```js
-const exp = new FigTreeEvaluator({
+const fig = new FigTreeEvaluator({
   functions: {
     double: (x) => x * 2,
     getCurrentYear: () => new Date().toLocaleString('en', { year: 'numeric' }),
@@ -1420,7 +1424,7 @@ The idea is that you can "hard-code" some common expressions into your app, so t
 The syntax is similar to [Alias Nodes](#alias-nodes), in that any string values prefixed with `$` will be treated as "parameters" that will be replaced during evaluation. In the above example, you would define the fragment when instantiating the evaluator like so:
 
 ```js
-const exp = new FigTreeEvaluator({
+const fig = new FigTreeEvaluator({
   fragments: {
     getCapital: {
       operator: 'GET',
@@ -1431,6 +1435,11 @@ const exp = new FigTreeEvaluator({
       },
       returnProperty: '[0].capital',
       outputType: 'string',
+      metadata: {
+        // Not required, but useful for external consumers -- see Metadata below
+        description: "Fetches the capital city of a country",
+        parameters: { $country: { type: 'string', required: true } },
+      }
     },
   },
 })
@@ -1458,6 +1467,63 @@ See `22_fragments.test.ts` for more complex examples.
 
 Unlike Alias Nodes, which are evaluated *once* and then the result re-used whenever the alias is referenced, Fragments are evaluated every time, as the input parameters may differ.
 
+## Shorthand syntax
+
+It's possible to express FigTree expressions in a more compact syntax, as follows:
+
+- Fragment and Operator nodes can be represented by putting the name of the fragment or operator as a property name (prefixed by `$`), then putting the parameters in an object as the property value. For example:  
+  ```js
+  {
+    operator: 'regex',
+    string: "home@myplace.com",
+    pattern: '^[A-Za-z0-9.]+@[A-Za-z0-9]+\\.[A-Za-z0-9.]+$' 
+  }
+  ```
+  can be written as:
+  ```js
+  {
+    $regex:
+      {
+        string: 'home@myplace.com',
+        pattern: '^[A-Za-z0-9.]+@[A-Za-z0-9]+\\.[A-Za-z0-9.]+$'
+      },
+  }
+  ```
+
+- For operator nodes (not fragments, as they always require named parameters), parameters can be represented positionally (equivalent to the `children` property in normal operator nodes) in an array. The above example could also be expressed as:  
+  ```js
+  {
+    $regex: [ 'home@myplace.com', '^[A-Za-z0-9.]+@[A-Za-z0-9]+\\.[A-Za-z0-9.]+$' ]
+  }
+  ```
+
+- Operator nodes with a single parameter can just be placed directly as the single property value. For example:  
+  ```js
+  {
+    operator: "getData",
+    property: "user.firstName"
+  }
+  ```
+  can become, simply:
+  ```js
+  { $getData: "user.firstName" }
+  ```
+
+- Operator nodes can even be represented as strings, written to resemble functions. The above example can be reduced further to just:  
+  ```js
+  "$getData(user.firstName)"
+  ```  
+  Multiple parameters are interpreted positionally, as above. These string-functions *can* be nested, although it is generally recommended to limit them to "leaf" nodes for readability.
+
+  Fragments can also be represented in this "string-function" syntax, but only if they have no parameters, for example:
+  ```js
+  "$myFragment()"
+  ```
+  would be replaced with the fragment `myFragment`.
+
+For more examples, see `23_shorthand.test.ts`, or have a play with the [demo app](https://carlosnz.github.io/fig-tree-evaluator/) 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.
@@ -1476,6 +1542,120 @@ 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.
 
+## Metadata
+
+Evaluator expression can be configured by hand, with [aliases](#alias-nodes), [fragments](#fragments) and [shorthand](#shorthand-syntax) available to make the job easier.
+
+However, you may wish to build an external UI for building FigTree expression. To this end, the FigTree instance provides three methods that could be useful for populating your configuration UI:
+
+#### New FigTree instance
+
+Containing fragments and [custom functions](#custom_functions).
+
+```js
+const fig = new FigTreeEvaluator({
+  fragments: {
+    getCapital: {
+      operator: 'GET',
+      url: {
+        operator: 'stringSubstitution',
+        string: 'https://restcountries.com/v3.1/name/%1',
+        replacements: [ "$country" ],
+      },
+      returnProperty: '[0].capital',
+      outputType: 'string',
+      // Metadata used by getFragments() (below)
+      metadata: {
+        description: "Fetches the capital city of a country",
+        parameters: { $country: { type: 'string', required: true } },
+      }
+    },
+    ... // More fragments
+  },
+  functions: {
+    doubleArray: (...args) => args.map((e) => e + e),
+    getDate: (dateString) => new Date(dateString),
+    ... // More functions
+  }
+  ... // More options
+})
+```
+
+#### Retrieve Operator info
+
+```js
+fig.getOperators()
+```
+
+This will return an array of operators with detailed info about their [aliases](#operator--property-aliases), and parameter requirements:
+
+```js
+[
+  ...
+  {
+    operator: 'PLUS',
+    description: 'Add, concatenate or merge multiple values',
+    aliases: ['+', 'plus', 'add', 'concat', 'join', 'merge'],
+    parameters: [
+      {
+        name: 'values',
+        description: 'Array of values to check to add together',
+        aliases: [],
+        required: true,
+        type: 'array',
+      },
+      {
+        name: 'type',
+        description: 'Data type to coerce input values to before addition',
+        aliases: [],
+        required: false,
+        type: 'string',
+      },
+    ],
+  },
+  ... // More operators
+]
+```
+
+#### Retrieve Fragment info
+
+Because Fragments are defined within the FigTree instance, optional metadata can be provided to make working with these fragments easier in a configuration UI:
+
+```js
+fig.getOperators()
+```
+
+This will return something like:
+
+```js
+[
+  {
+    name: 'getCapital',
+    description: 'Fetches the capital city of a country',
+    parameters: { $country: { type: 'string', required: true } },
+  },
+  { name: 'simpleFragment' }, // No metadata provided
+  ... // More fragments
+]
+```
+
+#### Retrieve customFunction info
+
+Similarly, we can fetch basic info about custom functions in the current FigTree instance, although with more limited detail:
+```js
+fig.getCustomFunctions()
+```
+
+Returns:
+
+```js
+[
+  { name: 'doubleArray', numRequiredArgs: 0 },
+  { name: 'getDate', numRequiredArgs: 1 },
+  ... // More functions
+]
+```
+
 ## 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).
@@ -1510,6 +1690,10 @@ 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.8.0**:
+  - [Shorthand syntax](#shorthand-syntax) (#80)
+  - Methods to retrieve [metadata](#metadata) about operators, fragments and functions (#82)
+- **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)

package/build/FigTreeEvaluator.d.ts

@@ -9,6 +9,24 @@ declare class FigTreeEvaluator {
     evaluate(expression: EvaluatorNode, options?: FigTreeOptions): Promise<import("./types").EvaluatorOutput>;
     getOptions(): FigTreeOptions;
     updateOptions(options: FigTreeOptions): void;
+    getOperators(): {
+        description: string;
+        aliases: string[];
+        parameters: import("./types").Parameter[];
+        operator: string;
+    }[];
+    getFragments(): {
+        description?: string | undefined;
+        parameters?: Record<string, {
+            type: string | string[];
+            required: boolean;
+        }> | undefined;
+        name: string;
+    }[];
+    getCustomFunctions(): {
+        name: string;
+        numRequiredArgs: number;
+    }[];
     getVersion: () => any;
 }
 export default FigTreeEvaluator;

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,25 @@ 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);
+    }
+    getOperators() {
+        const validOperators = this.options.excludeOperators
+            ? (0, helpers_1.filterOperators)(operators, this.options.excludeOperators, operatorAliases)
+            : this.operators;
+        return Object.entries(validOperators).map(([key, value]) => (Object.assign({ operator: key }, value.operatorData)));
+    }
+    getFragments() {
+        var _a;
+        return Object.entries((_a = this.options.fragments) !== null && _a !== void 0 ? _a : {}).map(([key, value]) => (Object.assign({ name: key }, value === null || value === void 0 ? void 0 : value.metadata)));
+    }
+    getCustomFunctions() {
+        var _a;
+        return Object.entries((_a = this.options.functions) !== null && _a !== void 0 ? _a : {}).map(([name, value]) => ({
+            name,
+            numRequiredArgs: value.length,
+        }));
     }
 }
 exports.default = FigTreeEvaluator;

package/build/evaluate.js

@@ -11,11 +11,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluatorFunction = void 0;
 const _operatorUtils_1 = require("./operators/_operatorUtils");
+const shorthandSyntax_1 = require("./shorthandSyntax");
 const helpers_1 = require("./helpers");
 const evaluatorFunction = (input, config) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const { options, operators, operatorAliases } = config;
     let expression = (options === null || options === void 0 ? void 0 : options.allowJSONStringInput) ? (0, helpers_1.parseIfJson)(input) : input;
+    expression = (0, shorthandSyntax_1.preProcessShorthand)(expression, (_a = config.options) === null || _a === void 0 ? void 0 : _a.fragments, !options.noShorthand);
     if (Array.isArray(expression)) {
         expression = yield (0, _operatorUtils_1.evaluateArray)(expression, config);
     }
@@ -29,14 +31,14 @@ const evaluatorFunction = (input, config) => __awaiter(void 0, void 0, void 0, f
         return (0, helpers_1.replaceAliasNodeValues)(expression, config);
     }
     const { fallback } = expression;
-    const returnErrorAsString = (_a = options === null || options === void 0 ? void 0 : options.returnErrorAsString) !== null && _a !== void 0 ? _a : false;
+    const returnErrorAsString = (_b = options === null || options === void 0 ? void 0 : options.returnErrorAsString) !== null && _b !== void 0 ? _b : false;
     if (isFragment) {
         const [fragment, parameters] = (yield (0, _operatorUtils_1.evaluateArray)([expression.fragment, expression.parameters], config));
-        const fragmentReplacement = (_b = options === null || options === void 0 ? void 0 : options.fragments) === null || _b === void 0 ? void 0 : _b[fragment];
+        const fragmentReplacement = (0, shorthandSyntax_1.preProcessShorthand)((_c = options === null || options === void 0 ? void 0 : options.fragments) === null || _c === void 0 ? void 0 : _c[fragment], options.fragments, !options.noShorthand);
         if (fragmentReplacement === undefined)
             return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Fragment not defined: ${fragment}`, returnErrorAsString);
         if (!(0, helpers_1.isOperatorNode)(fragmentReplacement))
-            return fragmentReplacement;
+            return (0, helpers_1.replaceAliasNodeValues)(fragmentReplacement, config);
         expression = Object.assign(Object.assign(Object.assign({}, expression), fragmentReplacement), parameters);
         delete expression.fragment;
         delete expression.parameters;
@@ -45,27 +47,33 @@ 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)));
+        const newAliasNodes = yield (0, helpers_1.evaluateNodeAliases)(expression, config);
+        if (!isFragment)
+            Object.entries(newAliasNodes).forEach(([alias, result]) => (config.resolvedAliasNodes[alias] = result));
+        const childConfig = isFragment
+            ? Object.assign(Object.assign({}, config), { resolvedAliasNodes: Object.assign(Object.assign({}, config.resolvedAliasNodes), newAliasNodes) }) : config;
         const validationError = (0, helpers_1.checkRequiredNodes)(requiredProperties, expression);
         if (validationError)
-            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- ${validationError}`, returnErrorAsString);
+            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, childConfig), `Operator: ${operator}\n- ${validationError}`, returnErrorAsString);
         if ('children' in expression) {
             if (!Array.isArray(expression.children))
-                expression.children = yield (0, exports.evaluatorFunction)(expression.children, config);
+                expression.children = yield (0, exports.evaluatorFunction)(expression.children, childConfig);
             if (!Array.isArray(expression.children))
                 return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- Property "children" is not of type: array`, returnErrorAsString);
-            expression = yield parseChildren(expression, config);
+            expression = yield parseChildren(expression, childConfig);
         }
         let result;
         try {
-            result = yield evaluate(expression, config);
+            result = yield evaluate(expression, childConfig);
         }
         catch (err) {
             result = (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(expression.fallback, config), `Operator: ${operator}\n${(0, helpers_1.errorMessage)(err)}`, returnErrorAsString);
         }
-        const outputType = (_c = expression === null || expression === void 0 ? void 0 : expression.outputType) !== null && _c !== void 0 ? _c : expression === null || expression === void 0 ? void 0 : expression.type;
+        const outputType = (_d = expression === null || expression === void 0 ? void 0 : expression.outputType) !== null && _d !== void 0 ? _d : expression === null || expression === void 0 ? void 0 : expression.type;
         if (!outputType)
             return result;
         const evaluatedOutputType = (yield (0, exports.evaluatorFunction)(outputType, config));

package/build/helpers.d.ts

@@ -1,15 +1,40 @@
-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: {
     [key: string]: string;
 }, expression: CombinedOperatorNode) => CombinedOperatorNode;
+export declare const isAliasString: (value: string) => boolean;
 export declare const evaluateNodeAliases: (expression: OperatorNodeUnion, config: FigTreeConfig) => Promise<{
     [x: string]: EvaluatorOutput;
 }>;

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.isAliasString = 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) => {
@@ -54,8 +65,9 @@ const mapObjectKeys = (inputObj, mapFunction) => {
     return Object.fromEntries(mappedKeys);
 };
 const isAliasString = (value) => /^\$.+/.test(value);
+exports.isAliasString = isAliasString;
 const evaluateNodeAliases = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const aliasKeys = Object.keys(expression).filter(isAliasString);
+    const aliasKeys = Object.keys(expression).filter(exports.isAliasString);
     if (aliasKeys.length === 0)
         return {};
     const evaluations = [];
@@ -65,7 +77,7 @@ const evaluateNodeAliases = (expression, config) => __awaiter(void 0, void 0, vo
 exports.evaluateNodeAliases = evaluateNodeAliases;
 const replaceAliasNodeValues = (value, { resolvedAliasNodes }) => {
     var _a;
-    if (typeof value !== 'string' || !isAliasString(value))
+    if (typeof value !== 'string' || !(0, exports.isAliasString)(value))
         return value;
     return (_a = resolvedAliasNodes === null || resolvedAliasNodes === void 0 ? void 0 : resolvedAliasNodes[value]) !== null && _a !== void 0 ? _a : value;
 };
@@ -118,7 +130,7 @@ const evaluateObject = (input, config) => __awaiter(void 0, void 0, void 0, func
     const newObjectEntries = [];
     const newAliases = [];
     Object.entries(input).forEach(([key, value]) => {
-        if (isAliasString(key)) {
+        if ((0, exports.isAliasString)(key)) {
             newAliases.push(key, (0, evaluate_1.evaluatorFunction)(value, config));
             delete input[key];
         }

package/build/operators/AND/data.d.ts

@@ -0,0 +1,5 @@
+import { OperatorData } from '../../types';
+export declare const requiredProperties: string[];
+export declare const propertyAliases: Record<string, string>;
+declare const operatorData: OperatorData;
+export default operatorData;

package/build/operators/AND/data.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = exports.requiredProperties = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Logical AND';
+const aliases = ['and', '&', '&&'];
+const parameters = [
+    {
+        name: 'values',
+        description: 'Returns true if all values are true',
+        aliases: [],
+        required: true,
+        type: 'array',
+    },
+];
+exports.requiredProperties = (0, _operatorUtils_1.getRequiredProperties)(parameters);
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

package/build/operators/AND/index.d.ts

@@ -0,0 +1 @@
+export { AND, type BasicExtendedNode } from './operator';

package/build/operators/AND/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AND = void 0;
+var operator_1 = require("./operator");
+Object.defineProperty(exports, "AND", { enumerable: true, get: function () { return operator_1.AND; } });

package/build/operators/{logicalAnd.d.ts → AND/operator.d.ts}

@@ -1,8 +1,7 @@
-import { EvaluatorNode, BaseOperatorNode, CombinedOperatorNode, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["values"];
+import { EvaluatorNode, BaseOperatorNode, CombinedOperatorNode, OperatorObject } from '../../types';
+import { requiredProperties } from './data';
 export type BasicExtendedNode = {
     [key in typeof requiredProperties[number]]: EvaluatorNode[];
 } & BaseOperatorNode;
 export declare const parseChildren: (expression: CombinedOperatorNode) => BasicExtendedNode;
 export declare const AND: OperatorObject;
-export {};