fig-tree-evaluator 1.9.0

package/build/FigTreeEvaluator.d.ts

@@ -0,0 +1,13 @@
+import { EvaluatorNode, FigTreeOptions } from './types';
+declare class FigTreeEvaluator {
+    private options;
+    private operators;
+    private operatorAliases;
+    constructor(options?: FigTreeOptions);
+    private typeChecker;
+    evaluate(expression: EvaluatorNode, options?: FigTreeOptions): Promise<import("./types").EvaluatorOutput>;
+    getOptions(): FigTreeOptions;
+    updateOptions(options: FigTreeOptions): void;
+}
+export default FigTreeEvaluator;
+export declare const evaluateExpression: (expression: EvaluatorNode, options?: FigTreeOptions) => Promise<import("./types").EvaluatorOutput>;

package/build/FigTreeEvaluator.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateExpression = void 0;
+const evaluate_1 = require("./evaluate");
+const typeCheck_1 = require("./typeCheck");
+const _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
+const operators = __importStar(require("./operators"));
+class FigTreeEvaluator {
+    constructor(options = {}) {
+        this.typeChecker = (...args) => {
+            const result = (0, typeCheck_1.typeCheck)(...args);
+            if (result === true)
+                return;
+            throw new Error(result);
+        };
+        this.options = options;
+        this.operators = operators;
+        this.operatorAliases = _operatorAliases_json_1.default;
+    }
+    evaluate(expression, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instanceOptions = Object.assign(Object.assign({}, this.options), options);
+            return yield (0, evaluate_1.evaluatorFunction)(expression, {
+                options: instanceOptions,
+                operators: this.operators,
+                operatorAliases: this.operatorAliases,
+                typeChecker: instanceOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
+            });
+        });
+    }
+    getOptions() {
+        return this.options;
+    }
+    updateOptions(options) {
+        this.options = Object.assign(Object.assign({}, this.options), options);
+    }
+}
+exports.default = FigTreeEvaluator;
+const evaluateExpression = (expression, options) => new FigTreeEvaluator(options).evaluate(expression);
+exports.evaluateExpression = evaluateExpression;

package/build/evaluate.d.ts

@@ -0,0 +1,2 @@
+import { FigTreeConfig, EvaluatorNode, EvaluatorOutput } from './types';
+export declare const evaluatorFunction: (input: EvaluatorNode, config: FigTreeConfig) => Promise<EvaluatorOutput>;

package/build/evaluate.js

@@ -0,0 +1,63 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluatorFunction = void 0;
+const _operatorUtils_1 = require("./operators/_operatorUtils");
+const helpers_1 = require("./helpers");
+const evaluatorFunction = (input, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { options, operators, operatorAliases } = config;
+    let expression = (options === null || options === void 0 ? void 0 : options.allowJSONStringInput) ? (0, helpers_1.parseIfJson)(input) : input;
+    if (Array.isArray(expression)) {
+        expression = yield (0, _operatorUtils_1.evaluateArray)(expression, config);
+    }
+    if (!(0, helpers_1.isOperatorNode)(expression))
+        return expression;
+    const { fallback } = expression;
+    const returnErrorAsString = (_a = options === null || options === void 0 ? void 0 : options.returnErrorAsString) !== null && _a !== void 0 ? _a : false;
+    try {
+        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);
+        const { requiredProperties, propertyAliases, evaluate, parseChildren } = operators[operator];
+        expression = (0, helpers_1.mapPropertyAliases)(propertyAliases, expression);
+        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);
+        if ('children' in expression) {
+            if (!Array.isArray(expression.children))
+                expression.children = yield (0, exports.evaluatorFunction)(expression.children, config);
+            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);
+        }
+        let result;
+        try {
+            result = yield evaluate(expression, config);
+        }
+        catch (err) {
+            result = (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n${(0, helpers_1.errorMessage)(err)}`, returnErrorAsString);
+        }
+        const outputType = (_b = expression === null || expression === void 0 ? void 0 : expression.outputType) !== null && _b !== void 0 ? _b : expression === null || expression === void 0 ? void 0 : expression.type;
+        if (!outputType)
+            return result;
+        const evaluatedOutputType = (yield (0, exports.evaluatorFunction)(outputType, config));
+        if (!(evaluatedOutputType in helpers_1.convertOutputMethods))
+            return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), `Operator: ${operator}\n- Invalid output type: ${evaluatedOutputType}`, returnErrorAsString);
+        else {
+            return helpers_1.convertOutputMethods[evaluatedOutputType](result);
+        }
+    }
+    catch (err) {
+        return (0, helpers_1.fallbackOrError)(yield (0, exports.evaluatorFunction)(fallback, config), (0, helpers_1.errorMessage)(err), returnErrorAsString);
+    }
+});
+exports.evaluatorFunction = evaluatorFunction;

package/build/evaluator.d.ts

@@ -0,0 +1,13 @@
+import { EvaluatorNode, EvaluatorOptions } from './types';
+declare class ExpressionEvaluator {
+    private options;
+    private operators;
+    private operatorAliases;
+    constructor(options?: EvaluatorOptions);
+    private typeChecker;
+    evaluate(expression: EvaluatorNode, options?: EvaluatorOptions): Promise<import("./types").EvaluatorOutput>;
+    getOptions(): EvaluatorOptions;
+    updateOptions(options: EvaluatorOptions): void;
+}
+export default ExpressionEvaluator;
+export declare const evaluateExpression: (expression: EvaluatorNode, options?: EvaluatorOptions) => Promise<import("./types").EvaluatorOutput>;

package/build/evaluator.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateExpression = void 0;
+const evaluate_1 = require("./evaluate");
+const typeCheck_1 = require("./typeCheck");
+const _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
+const operators = __importStar(require("./operators"));
+class ExpressionEvaluator {
+    constructor(options = {}) {
+        this.typeChecker = (...args) => {
+            const result = (0, typeCheck_1.typeCheck)(...args);
+            if (result === true)
+                return;
+            throw new Error(result);
+        };
+        this.options = options;
+        this.operators = operators;
+        this.operatorAliases = _operatorAliases_json_1.default;
+    }
+    evaluate(expression, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instanceOptions = Object.assign(Object.assign({}, this.options), options);
+            return yield (0, evaluate_1.evaluatorFunction)(expression, {
+                options: instanceOptions,
+                operators: this.operators,
+                operatorAliases: this.operatorAliases,
+                typeChecker: instanceOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
+            });
+        });
+    }
+    getOptions() {
+        return this.options;
+    }
+    updateOptions(options) {
+        this.options = Object.assign(Object.assign({}, this.options), options);
+    }
+}
+exports.default = ExpressionEvaluator;
+const evaluateExpression = (expression, options) => new ExpressionEvaluator(options).evaluate(expression);
+exports.evaluateExpression = evaluateExpression;

package/build/helpers.d.ts

@@ -0,0 +1,16 @@
+import { OutputType, EvaluatorNode, CombinedOperatorNode, Operator, EvaluatorOutput } from './types';
+export declare const parseIfJson: (input: EvaluatorNode) => any;
+export declare const isOperatorNode: (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" | "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" | "CUSTOM_FUNCTIONS" | "PASSTHRU";
+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 checkRequiredNodes: (requiredProps: readonly string[], expression: CombinedOperatorNode) => string | false;
+export declare const convertOutputMethods: {
+    [key in OutputType]: <T>(value: T) => EvaluatorOutput | T[];
+};
+export declare const errorMessage: (err: unknown) => string;

package/build/helpers.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMessage = exports.convertOutputMethods = exports.checkRequiredNodes = exports.mapPropertyAliases = exports.fallbackOrError = exports.truncateString = exports.getOperatorName = exports.isOperatorNode = exports.parseIfJson = void 0;
+const lodash_1 = require("lodash");
+const parseIfJson = (input) => {
+    if (typeof input !== 'string')
+        return input;
+    try {
+        const parsedInput = JSON.parse(input);
+        return (0, exports.isOperatorNode)(parsedInput) ? parsedInput : input;
+    }
+    catch (err) {
+        return input;
+    }
+};
+exports.parseIfJson = parseIfJson;
+const isOperatorNode = (input) => input instanceof Object && 'operator' in input;
+exports.isOperatorNode = isOperatorNode;
+const standardiseOperatorName = (name) => {
+    const camelCaseName = (0, lodash_1.camelCase)(name);
+    return camelCaseName ? camelCaseName : name;
+};
+const getOperatorName = (operator, operatorAliases) => operatorAliases[standardiseOperatorName(operator)];
+exports.getOperatorName = getOperatorName;
+const truncateString = (string, length = 200) => string.length < length ? string : `${string.slice(0, length - 2).trim()}...`;
+exports.truncateString = truncateString;
+const fallbackOrError = (fallback, errorMessage, returnErrorAsString = false) => {
+    if (fallback !== undefined)
+        return fallback;
+    if (returnErrorAsString)
+        return (0, exports.truncateString)(errorMessage);
+    else
+        throw new Error((0, exports.truncateString)(errorMessage));
+};
+exports.fallbackOrError = fallbackOrError;
+const mapPropertyAliases = (propertyAliases, expression) => (0, lodash_1.mapKeys)(expression, (_, key) => key in propertyAliases ? propertyAliases[key] : key);
+exports.mapPropertyAliases = mapPropertyAliases;
+const checkRequiredNodes = (requiredProps, expression) => {
+    const missingProps = requiredProps.filter((prop) => !(prop in expression));
+    if (missingProps.length === 0)
+        return false;
+    if (!('children' in expression))
+        return `Missing properties: ${missingProps}`;
+    return false;
+};
+exports.checkRequiredNodes = checkRequiredNodes;
+exports.convertOutputMethods = {
+    number: (value) => extractNumber(value),
+    string: (value) => String(value),
+    array: (value) => (Array.isArray(value) ? value : [value]),
+    boolean: (value) => Boolean(value),
+    bool: (value) => Boolean(value),
+};
+const errorMessage = (err) => err.message;
+exports.errorMessage = errorMessage;
+const extractNumber = (input) => {
+    if (typeof input !== 'string')
+        return Number.isNaN(Number(input)) ? input : Number(input);
+    const numberMatch = input.match(/(-?(\d+\.\d+))|(-?((?<!\.)\.\d+))|(-?\d+)/gm);
+    if (!numberMatch)
+        return 0;
+    return Number(numberMatch[0]);
+};

package/build/index.d.ts

@@ -0,0 +1,13 @@
+import { EvaluatorNode, FigTreeOptions } from './types';
+declare class FigTreeEvaluator {
+    private options;
+    private operators;
+    private operatorAliases;
+    constructor(options?: FigTreeOptions);
+    private typeChecker;
+    evaluate(expression: EvaluatorNode, options?: FigTreeOptions): Promise<import("./types").EvaluatorOutput>;
+    getOptions(): FigTreeOptions;
+    updateOptions(options: FigTreeOptions): void;
+}
+export default FigTreeEvaluator;
+export declare const evaluateExpression: (expression: EvaluatorNode, options?: FigTreeOptions) => Promise<import("./types").EvaluatorOutput>;

package/build/index.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateExpression = void 0;
+const evaluate_1 = require("./evaluate");
+const typeCheck_1 = require("./typeCheck");
+const _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
+const operators = __importStar(require("./operators"));
+class FigTreeEvaluator {
+    constructor(options = {}) {
+        this.typeChecker = (...args) => {
+            const result = (0, typeCheck_1.typeCheck)(...args);
+            if (result === true)
+                return;
+            throw new Error(result);
+        };
+        this.options = options;
+        this.operators = operators;
+        this.operatorAliases = _operatorAliases_json_1.default;
+    }
+    evaluate(expression, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instanceOptions = Object.assign(Object.assign({}, this.options), options);
+            return yield (0, evaluate_1.evaluatorFunction)(expression, {
+                options: instanceOptions,
+                operators: this.operators,
+                operatorAliases: this.operatorAliases,
+                typeChecker: instanceOptions.skipRuntimeTypeCheck ? () => { } : this.typeChecker,
+            });
+        });
+    }
+    getOptions() {
+        return this.options;
+    }
+    updateOptions(options) {
+        this.options = Object.assign(Object.assign({}, this.options), options);
+    }
+}
+exports.default = FigTreeEvaluator;
+const evaluateExpression = (expression, options) => new FigTreeEvaluator(options).evaluate(expression);
+exports.evaluateExpression = evaluateExpression;

package/build/operators/_operatorAliases.json

@@ -0,0 +1,86 @@
+{
+    "and": "AND",
+    "&": "AND",
+    "&&": "AND",
+    "or": "OR",
+    "|": "OR",
+    "||": "OR",
+    "=": "EQUAL",
+    "eq": "EQUAL",
+    "equal": "EQUAL",
+    "equals": "EQUAL",
+    "!=": "NOT_EQUAL",
+    "!": "NOT_EQUAL",
+    "ne": "NOT_EQUAL",
+    "notEqual": "NOT_EQUAL",
+    "+": "PLUS",
+    "plus": "PLUS",
+    "add": "PLUS",
+    "concat": "PLUS",
+    "join": "PLUS",
+    "merge": "PLUS",
+    "-": "SUBTRACT",
+    "subtract": "SUBTRACT",
+    "minus": "SUBTRACT",
+    "takeaway": "SUBTRACT",
+    "*": "MULTIPLY",
+    "x": "MULTIPLY",
+    "multiply": "MULTIPLY",
+    "times": "MULTIPLY",
+    "/": "DIVIDE",
+    "divide": "DIVIDE",
+    "÷": "DIVIDE",
+    ">": "GREATER_THAN",
+    "greaterThan": "GREATER_THAN",
+    "higher": "GREATER_THAN",
+    "larger": "GREATER_THAN",
+    "<": "LESS_THAN",
+    "lessThan": "LESS_THAN",
+    "lower": "LESS_THAN",
+    "smaller": "LESS_THAN",
+    "?": "CONDITIONAL",
+    "conditional": "CONDITIONAL",
+    "ifThen": "CONDITIONAL",
+    "regex": "REGEX",
+    "patternMatch": "REGEX",
+    "regexp": "REGEX",
+    "matchPattern": "REGEX",
+    "objectProperties": "OBJECT_PROPERTIES",
+    "objProps": "OBJECT_PROPERTIES",
+    "getProperty": "OBJECT_PROPERTIES",
+    "getObjProp": "OBJECT_PROPERTIES",
+    "stringSubstitution": "STRING_SUBSTITUTION",
+    "substitute": "STRING_SUBSTITUTION",
+    "stringSub": "STRING_SUBSTITUTION",
+    "replace": "STRING_SUBSTITUTION",
+    "split": "SPLIT",
+    "arraySplit": "SPLIT",
+    "count": "COUNT",
+    "length": "COUNT",
+    "get": "GET",
+    "api": "GET",
+    "post": "POST",
+    "pgSql": "PG_SQL",
+    "sql": "PG_SQL",
+    "postgres": "PG_SQL",
+    "pg": "PG_SQL",
+    "pgDb": "PG_SQL",
+    "graphQl": "GRAPHQL",
+    "graphql": "GRAPHQL",
+    "gql": "GRAPHQL",
+    "buildObject": "BUILD_OBJECT",
+    "build": "BUILD_OBJECT",
+    "object": "BUILD_OBJECT",
+    "customFunctions": "CUSTOM_FUNCTIONS",
+    "customFunction": "CUSTOM_FUNCTIONS",
+    "objectFunctions": "CUSTOM_FUNCTIONS",
+    "function": "CUSTOM_FUNCTIONS",
+    "functions": "CUSTOM_FUNCTIONS",
+    "runFunction": "CUSTOM_FUNCTIONS",
+    "_": "PASSTHRU",
+    "passThru": "PASSTHRU",
+    "pass": "PASSTHRU",
+    "ignore": "PASSTHRU",
+    "coerce": "PASSTHRU",
+    "convert": "PASSTHRU"
+}

package/build/operators/_operatorUtils.d.ts

@@ -0,0 +1,16 @@
+import { GenericObject, EvaluatorNode, EvaluatorOutput, FigTreeConfig } from '../types';
+export declare const evaluateArray: (nodes: EvaluatorNode[], params: FigTreeConfig) => Promise<EvaluatorOutput[]>;
+export declare const zipArraysToObject: <T>(keys: string[], values: T[]) => {
+    [x: string]: T;
+};
+export declare const simplifyObject: (item: number | string | boolean | GenericObject) => any;
+export declare const extractAndSimplify: (data: GenericObject | GenericObject[], returnProperty: string | undefined, fallback?: any) => any;
+export declare const isFullUrl: (url: string) => boolean;
+export declare const joinUrlParts: (...urls: string[]) => string;
+export declare const axiosRequest: ({ url, params, data, headers, method, }: {
+    url: string;
+    params?: GenericObject | undefined;
+    data?: GenericObject | undefined;
+    headers?: GenericObject | undefined;
+    method?: "get" | "post" | undefined;
+}) => Promise<any>;

package/build/operators/_operatorUtils.js

@@ -0,0 +1,83 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.axiosRequest = exports.joinUrlParts = exports.isFullUrl = exports.extractAndSimplify = exports.simplifyObject = exports.zipArraysToObject = exports.evaluateArray = void 0;
+const axios_1 = __importDefault(require("axios"));
+const extract_1 = __importDefault(require("object-property-extractor/build/extract"));
+const evaluate_1 = require("../evaluate");
+const evaluateArray = (nodes, params) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!Array.isArray(nodes))
+        return (yield (0, evaluate_1.evaluatorFunction)(nodes, params));
+    return yield Promise.all(nodes.map((node) => (0, evaluate_1.evaluatorFunction)(node, params)));
+});
+exports.evaluateArray = evaluateArray;
+const zipArraysToObject = (keys, values) => {
+    const pairs = keys.map((key, index) => [key, values[index]]);
+    return Object.fromEntries(pairs);
+};
+exports.zipArraysToObject = zipArraysToObject;
+const simplifyObject = (item) => {
+    return item instanceof Object && Object.keys(item).length === 1 ? Object.values(item)[0] : item;
+};
+exports.simplifyObject = simplifyObject;
+const extractAndSimplify = (data, returnProperty, fallback = undefined) => {
+    try {
+        const selectedProperty = returnProperty ? (0, extract_1.default)(data, returnProperty, fallback) : data;
+        if (Array.isArray(selectedProperty))
+            return selectedProperty.map((item) => (0, exports.simplifyObject)(item));
+        if (returnProperty) {
+            if (selectedProperty === null)
+                return null;
+            return (0, exports.simplifyObject)(selectedProperty);
+        }
+        return selectedProperty;
+    }
+    catch (err) {
+        throw err;
+    }
+};
+exports.extractAndSimplify = extractAndSimplify;
+const isFullUrl = (url) => /^https?:\/\/.+/.test(url);
+exports.isFullUrl = isFullUrl;
+const joinUrlParts = (...urls) => {
+    return urls.reduce((acc, curr, index) => {
+        const startSliceIndex = curr[0] === '/' ? 1 : 0;
+        const endSliceIndex = curr.slice(-1) === '/' ? -1 : undefined;
+        const newPart = curr.slice(startSliceIndex, endSliceIndex);
+        return acc + (index === 0 ? '' : '/') + newPart;
+    }, '');
+};
+exports.joinUrlParts = joinUrlParts;
+const axiosRequest = ({ url, params = {}, data = {}, headers = {}, method = 'get', }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const response = yield (0, axios_1.default)({
+            method,
+            url,
+            headers: Object.assign({ 'Content-Type': 'application/json', Accept: 'application/json' }, headers),
+            params,
+            data,
+        });
+        return response.data;
+    }
+    catch (err) {
+        if (axios_1.default.isAxiosError(err)) {
+            if (!(err === null || err === void 0 ? void 0 : err.response))
+                throw new Error('Network Error');
+            console.log((_a = err.response) === null || _a === void 0 ? void 0 : _a.data);
+        }
+        throw err;
+    }
+});
+exports.axiosRequest = axiosRequest;

package/build/operators/buildObject.d.ts

@@ -0,0 +1,11 @@
+import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
+declare const requiredProperties: readonly ["properties"];
+export declare type BuildObjectNode = {
+    [key in typeof requiredProperties[number]]: BuildObjectElement[];
+} & BaseOperatorNode;
+declare type BuildObjectElement = {
+    key: EvaluatorNode;
+    value: EvaluatorNode;
+};
+export declare const BUILD_OBJECT: OperatorObject;
+export {};