fig-tree-evaluator 2.7.0 → 2.8.3

package/build/operators/{objectProperties.js → OBJECT_PROPERTIES/operator.js}

@@ -1,4 +1,27 @@
 "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) {
@@ -14,41 +37,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OBJECT_PROPERTIES = void 0;
 const object_property_extractor_1 = __importDefault(require("object-property-extractor"));
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['property'];
-const operatorAliases = [
-    'dataProperties',
-    'data',
-    'getData',
-    'objectProperties',
-    'objProps',
-    'getProperty',
-    'getObjProp',
-];
-const propertyAliases = {
-    path: 'property',
-    propertyName: 'property',
-    additional: 'additionalData',
-    objects: 'additionalData',
-    data: 'additionalData',
-    additionalObjects: 'additionalData',
-};
+const _operatorUtils_1 = require("../_operatorUtils");
+const data_1 = __importStar(require("./data"));
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d;
     const [property, additionalData] = (yield (0, _operatorUtils_1.evaluateArray)([expression.property, expression.additionalData], config));
-    config.typeChecker({ name: 'property', value: property, expectedType: 'string' }, { name: 'additionalData', value: additionalData, expectedType: ['object', 'undefined'] });
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { property, additionalData }));
     const inputObject = additionalData
         ? Object.assign(Object.assign({}, ((_b = (_a = config.options) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : {})), additionalData) : (_d = (_c = config.options) === null || _c === void 0 ? void 0 : _c.data) !== null && _d !== void 0 ? _d : {};
     return (0, object_property_extractor_1.default)(inputObject, property);
 });
 const parseChildren = (expression) => {
     const [property, fallback] = expression.children;
-    return Object.assign(Object.assign({}, expression), { property, fallback });
+    const returnValue = Object.assign(Object.assign({}, expression), { property });
+    if (fallback !== undefined)
+        returnValue.fallback = fallback;
+    return returnValue;
 };
 exports.OBJECT_PROPERTIES = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
     parseChildren,
 };

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

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

package/build/operators/OR/data.js

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

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

@@ -0,0 +1 @@
+export * from './operator';

package/build/operators/OR/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operator"), exports);

package/build/operators/OR/operator.d.ts

@@ -0,0 +1,2 @@
+import { OperatorObject } from '../../types';
+export declare const OR: OperatorObject;

package/build/operators/OR/operator.js

@@ -0,0 +1,49 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OR = void 0;
+const operator_1 = require("../AND/operator");
+const _operatorUtils_1 = require("../_operatorUtils");
+const data_1 = __importStar(require("./data"));
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { values }));
+    return values.reduce((acc, val) => acc || !!val, false);
+});
+exports.OR = {
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
+    evaluate,
+    parseChildren: operator_1.parseChildren,
+};

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

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

package/build/operators/PASSTHRU/data.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Pass through a value unchanged (or change its type)';
+const aliases = ['_', 'passThru', 'passthru', 'pass', 'ignore', 'coerce', 'convert'];
+const parameters = [
+    {
+        name: 'value',
+        description: 'Value to pass through',
+        aliases: ['_', 'data'],
+        required: true,
+        type: 'any',
+    },
+];
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

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

@@ -0,0 +1 @@
+export * from './operator';

package/build/operators/PASSTHRU/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operator"), exports);

package/build/operators/PASSTHRU/operator.d.ts

@@ -0,0 +1,2 @@
+import { OperatorObject } from '../../types';
+export declare const PASSTHRU: OperatorObject;

package/build/operators/PASSTHRU/operator.js

@@ -0,0 +1,53 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PASSTHRU = void 0;
+const evaluate_1 = require("../../evaluate");
+const _operatorUtils_1 = require("../_operatorUtils");
+const data_1 = __importStar(require("./data"));
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { value: expression.value }));
+    return yield (0, evaluate_1.evaluatorFunction)(expression.value, config);
+});
+const parseChildren = (expression) => {
+    const [...children] = expression.children;
+    const value = (children === null || children === void 0 ? void 0 : children.length) === 1 ? children[0] : children;
+    return Object.assign(Object.assign({}, expression), { value });
+};
+exports.PASSTHRU = {
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
+    evaluate,
+    parseChildren,
+};

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

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

package/build/operators/PG_SQL/data.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Query a Postgres database using node-postgres';
+const aliases = ['pgSql', 'sql', 'postgres', 'pg', 'pgDb'];
+const parameters = [
+    {
+        name: 'query',
+        description: 'A SQL query string, with parameterised replacements (i.e. $1, $2, etc)',
+        aliases: [],
+        required: true,
+        type: 'string',
+    },
+    {
+        name: 'values',
+        description: 'An array of values to replace in the SQL string parameters',
+        aliases: ['replacements'],
+        required: false,
+        type: 'array',
+    },
+    {
+        name: 'type',
+        description: 'Determines the shape of the resulting data (see documentation)',
+        aliases: ['queryType'],
+        required: false,
+        type: { literal: ['array', 'string', 'number'] },
+    },
+    {
+        name: 'useCache',
+        description: 'Whether or not the FigTree cache is used',
+        aliases: [],
+        required: false,
+        type: 'boolean',
+    },
+];
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

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

@@ -0,0 +1 @@
+export * from './operator';

package/build/operators/PG_SQL/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operator"), exports);

package/build/operators/PG_SQL/operator.d.ts

@@ -0,0 +1,2 @@
+import { OperatorObject } from '../../types';
+export declare const PG_SQL: OperatorObject;

package/build/operators/PG_SQL/operator.js

@@ -0,0 +1,83 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PG_SQL = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const data_1 = __importStar(require("./data"));
+const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const [query, type, values, useCache] = (yield (0, _operatorUtils_1.evaluateArray)([expression.query, expression.type, expression.values || [], expression.useCache], config));
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, { query, type, values, useCache }));
+    if (!((_a = config.options) === null || _a === void 0 ? void 0 : _a.pgConnection))
+        throw new Error('No Postgres database connection provided');
+    const shouldUseCache = (_c = (_b = expression.useCache) !== null && _b !== void 0 ? _b : config.options.useCache) !== null && _c !== void 0 ? _c : true;
+    {
+        const result = config.cache.useCache(shouldUseCache, (query, type, values) => __awaiter(void 0, void 0, void 0, function* () {
+            return yield processPgSQL(query, values, config.options.pgConnection, type);
+        }), query, type, values);
+        return result;
+    }
+});
+const parseChildren = (expression) => {
+    const [query, ...values] = expression.children;
+    return Object.assign(Object.assign({}, expression), { query, values });
+};
+const processPgSQL = (query, values, connection, queryType) => __awaiter(void 0, void 0, void 0, function* () {
+    const expression = {
+        text: query,
+        values: values,
+        rowMode: queryType ? 'array' : '',
+    };
+    const res = yield connection.query(expression);
+    if (res === null || res === void 0 ? void 0 : res.error)
+        throw new Error(res.error);
+    switch (queryType) {
+        case 'array':
+            return res.rows.flat();
+        case 'string':
+            return res.rows.flat().join(' ');
+        case 'number': {
+            const result = res.rows.flat();
+            return Number.isNaN(Number(result)) ? result : Number(result);
+        }
+        default:
+            return res.rows;
+    }
+});
+exports.PG_SQL = {
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
+    evaluate,
+    parseChildren,
+};

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

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

package/build/operators/PLUS/data.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'Add, concatenate or merge multiple values';
+const aliases = ['+', 'plus', 'add', 'concat', 'join', 'merge'];
+const 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: { literal: ['string', 'array', 'number', 'boolean', 'bool'] },
+    },
+];
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

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

@@ -0,0 +1 @@
+export * from './operator';

package/build/operators/PLUS/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operator"), exports);

package/build/operators/PLUS/operator.d.ts

@@ -0,0 +1,2 @@
+import { OperatorObject } from '../../types';
+export declare const PLUS: OperatorObject;

package/build/operators/{plus.js → PLUS/operator.js}

@@ -1,4 +1,27 @@
 "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) {
@@ -10,30 +33,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PLUS = void 0;
-const _operatorUtils_1 = require("./_operatorUtils");
-const logicalAnd_1 = require("./logicalAnd");
-const requiredProperties = ['values'];
-const operatorAliases = ['+', 'plus', 'add', 'concat', 'join', 'merge'];
-const propertyAliases = {};
+const operator_1 = require("../AND/operator");
+const _operatorUtils_1 = require("../_operatorUtils");
+const data_1 = __importStar(require("./data"));
+const helpers_1 = require("../../helpers");
 const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    if (expression.values.length === 0)
-        return expression.values;
     const values = (yield (0, _operatorUtils_1.evaluateArray)(expression.values, config));
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
+    config.typeChecker((0, _operatorUtils_1.getTypeCheckInput)(data_1.default.parameters, {
+        values,
+        type: expression.type,
+    }));
+    if (values.length === 0)
+        return values;
     if ((expression === null || expression === void 0 ? void 0 : expression.type) === 'string')
         return values.reduce((acc, child) => acc.concat(child), '');
     if ((expression === null || expression === void 0 ? void 0 : expression.type) === 'array')
         return values.reduce((acc, child) => acc.concat(child), []);
     if (values.every((child) => typeof child === 'string' || Array.isArray(child)))
         return values.reduce((acc, child) => acc.concat(child));
-    if (values.every((child) => child instanceof Object && !Array.isArray(child)))
+    if (values.every((child) => (0, helpers_1.isObject)(child)))
         return values.reduce((acc, child) => (Object.assign(Object.assign({}, acc), child)), {});
     return values.reduce((acc, child) => acc + child);
 });
 exports.PLUS = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
+    propertyAliases: data_1.propertyAliases,
+    operatorData: data_1.default,
     evaluate,
-    parseChildren: logicalAnd_1.parseChildren,
+    parseChildren: operator_1.parseChildren,
 };

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

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

package/build/operators/POST/data.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyAliases = void 0;
+const _operatorUtils_1 = require("../_operatorUtils");
+const description = 'HTTP POST Request';
+const aliases = ['post'];
+const parameters = [
+    {
+        name: 'url',
+        description: 'Endpoint URL',
+        aliases: ['endpoint'],
+        required: true,
+        type: 'string',
+    },
+    {
+        name: 'returnProperty',
+        description: 'Property path from request result',
+        aliases: ['outputProperty'],
+        required: false,
+        type: 'string',
+    },
+    {
+        name: 'headers',
+        description: 'HTTP Headers',
+        aliases: [],
+        required: false,
+        type: 'object',
+    },
+    {
+        name: 'data',
+        description: 'JSON Body parameters (key-value)',
+        aliases: [],
+        required: false,
+        type: 'object',
+    },
+    {
+        name: 'useCache',
+        description: 'Whether or not the FigTree cache is used',
+        aliases: [],
+        required: false,
+        type: 'boolean',
+    },
+];
+exports.propertyAliases = (0, _operatorUtils_1.getPropertyAliases)(parameters);
+const operatorData = {
+    description,
+    aliases,
+    parameters,
+};
+exports.default = operatorData;

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

@@ -0,0 +1 @@
+export * from './operator';