fig-tree-evaluator 2.7.0 → 2.8.3

package/build/operators/_operatorUtils.d.ts

@@ -1,17 +1,24 @@
-import { GenericObject, EvaluatorNode, EvaluatorOutput, FigTreeConfig } from '../types';
-export declare const evaluateArray: (nodes: EvaluatorNode[], params: FigTreeConfig) => Promise<EvaluatorOutput[]>;
+import { AxiosRequestConfig } from 'axios';
+import { EvaluatorNode, EvaluatorOutput, FigTreeConfig, Parameter } from '../types';
+export declare const getPropertyAliases: (parameters: Parameter[]) => Record<string, string>;
+export declare const getTypeCheckInput: (parameterDefinitions: Parameter[], params: Record<string, unknown>) => ({
+    name: string;
+    value: unknown;
+    expectedType: {
+        literal: (string | undefined)[];
+    };
+} | {
+    name: string;
+    value: unknown;
+    expectedType: import("../typeCheck").BasicType | import("../typeCheck").BasicType[];
+})[];
+export declare const evaluateArray: (nodes: EvaluatorNode[] | EvaluatorNode, params: FigTreeConfig) => Promise<EvaluatorOutput[]>;
 export declare const zipArraysToObject: <T>(keys: string[], values: T[]) => {
     [x: string]: T;
 };
-export declare const singleArrayToObject: (elements: any[]) => any;
-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 singleArrayToObject: <T>(elements: unknown[]) => Record<string, T>;
+export declare const simplifyObject: (item: unknown) => any;
+export declare const extractAndSimplify: (data: object | object[], returnProperty: string | undefined, fallback?: unknown) => 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>;
+export declare const axiosRequest: ({ url, params, data, headers, method, }: AxiosRequestConfig) => Promise<any>;

package/build/operators/_operatorUtils.js

@@ -12,11 +12,34 @@ 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.singleArrayToObject = exports.zipArraysToObject = exports.evaluateArray = void 0;
+exports.axiosRequest = exports.joinUrlParts = exports.isFullUrl = exports.extractAndSimplify = exports.simplifyObject = exports.singleArrayToObject = exports.zipArraysToObject = exports.evaluateArray = exports.getTypeCheckInput = exports.getPropertyAliases = void 0;
 const axios_1 = __importDefault(require("axios"));
 const extract_1 = __importDefault(require("object-property-extractor/build/extract"));
 const evaluate_1 = require("../evaluate");
+const helpers_1 = require("../helpers");
 const typeCheck_1 = require("../typeCheck");
+const getPropertyAliases = (parameters) => {
+    const propertyAliases = {};
+    parameters.forEach((param) => {
+        param.aliases.forEach((alias) => (propertyAliases[alias] = param.name));
+    });
+    return propertyAliases;
+};
+exports.getPropertyAliases = getPropertyAliases;
+const getTypeCheckInput = (parameterDefinitions, params) => parameterDefinitions.map(({ name, required, type }) => {
+    if ((0, typeCheck_1.isLiteralType)(type)) {
+        const literal = [...type.literal];
+        if (!required)
+            literal.push(undefined);
+        return { name, value: params[name], expectedType: { literal } };
+    }
+    const allTypes = Array.isArray(type) ? type : [type];
+    if (!required)
+        allTypes.push('undefined');
+    const expectedType = allTypes.length === 1 ? allTypes[0] : allTypes;
+    return { name, value: params[name], expectedType };
+});
+exports.getTypeCheckInput = getTypeCheckInput;
 const evaluateArray = (nodes, params) => __awaiter(void 0, void 0, void 0, function* () {
     if (!Array.isArray(nodes))
         return (yield (0, evaluate_1.evaluatorFunction)(nodes, params));
@@ -47,24 +70,19 @@ const singleArrayToObject = (elements) => {
 };
 exports.singleArrayToObject = singleArrayToObject;
 const simplifyObject = (item) => {
-    return item instanceof Object && Object.keys(item).length === 1 ? Object.values(item)[0] : item;
+    return (0, helpers_1.isObject)(item) && 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;
+    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;
 };
 exports.extractAndSimplify = extractAndSimplify;
 const isFullUrl = (url) => /^https?:\/\/.+/.test(url);

package/build/operators/index.d.ts

@@ -1,24 +1,24 @@
-export * from './logicalOr';
-export { AND, type BasicExtendedNode } from './logicalAnd';
-export * from './equal';
-export * from './notEqual';
-export * from './plus';
-export * from './subtract';
-export * from './multiply';
-export * from './divide';
-export * from './greaterThan';
-export * from './lessThan';
-export * from './conditional';
-export * from './regex';
-export * from './objectProperties';
-export * from './stringSubstitution';
-export * from './count';
-export * from './split';
-export * from './pgSQL';
-export * from './graphQL';
-export { GET, type APINode } from './getRequest';
-export * from './postRequest';
-export * from './buildObject';
-export * from './match';
-export * from './customFunctions';
-export * from './passThru';
+export * from './AND';
+export * from './OR';
+export * from './EQUAL';
+export * from './NOT_EQUAL';
+export * from './PLUS';
+export * from './SUBTRACT';
+export * from './MULTIPLY';
+export * from './DIVIDE';
+export * from './GREATER_THAN';
+export * from './LESS_THAN';
+export * from './CONDITIONAL';
+export * from './REGEX';
+export * from './OBJECT_PROPERTIES';
+export * from './STRING_SUBSTITUTION';
+export * from './COUNT';
+export * from './SPLIT';
+export * from './PG_SQL';
+export * from './GRAPHQL';
+export * from './GET';
+export * from './POST';
+export * from './BUILD_OBJECT';
+export * from './MATCH';
+export * from './CUSTOM_FUNCTIONS';
+export * from './PASSTHRU';

package/build/operators/index.js

@@ -14,30 +14,27 @@ 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 });
-exports.GET = exports.AND = void 0;
-__exportStar(require("./logicalOr"), exports);
-var logicalAnd_1 = require("./logicalAnd");
-Object.defineProperty(exports, "AND", { enumerable: true, get: function () { return logicalAnd_1.AND; } });
-__exportStar(require("./equal"), exports);
-__exportStar(require("./notEqual"), exports);
-__exportStar(require("./plus"), exports);
-__exportStar(require("./subtract"), exports);
-__exportStar(require("./multiply"), exports);
-__exportStar(require("./divide"), exports);
-__exportStar(require("./greaterThan"), exports);
-__exportStar(require("./lessThan"), exports);
-__exportStar(require("./conditional"), exports);
-__exportStar(require("./regex"), exports);
-__exportStar(require("./objectProperties"), exports);
-__exportStar(require("./stringSubstitution"), exports);
-__exportStar(require("./count"), exports);
-__exportStar(require("./split"), exports);
-__exportStar(require("./pgSQL"), exports);
-__exportStar(require("./graphQL"), exports);
-var getRequest_1 = require("./getRequest");
-Object.defineProperty(exports, "GET", { enumerable: true, get: function () { return getRequest_1.GET; } });
-__exportStar(require("./postRequest"), exports);
-__exportStar(require("./buildObject"), exports);
-__exportStar(require("./match"), exports);
-__exportStar(require("./customFunctions"), exports);
-__exportStar(require("./passThru"), exports);
+__exportStar(require("./AND"), exports);
+__exportStar(require("./OR"), exports);
+__exportStar(require("./EQUAL"), exports);
+__exportStar(require("./NOT_EQUAL"), exports);
+__exportStar(require("./PLUS"), exports);
+__exportStar(require("./SUBTRACT"), exports);
+__exportStar(require("./MULTIPLY"), exports);
+__exportStar(require("./DIVIDE"), exports);
+__exportStar(require("./GREATER_THAN"), exports);
+__exportStar(require("./LESS_THAN"), exports);
+__exportStar(require("./CONDITIONAL"), exports);
+__exportStar(require("./REGEX"), exports);
+__exportStar(require("./OBJECT_PROPERTIES"), exports);
+__exportStar(require("./STRING_SUBSTITUTION"), exports);
+__exportStar(require("./COUNT"), exports);
+__exportStar(require("./SPLIT"), exports);
+__exportStar(require("./PG_SQL"), exports);
+__exportStar(require("./GRAPHQL"), exports);
+__exportStar(require("./GET"), exports);
+__exportStar(require("./POST"), exports);
+__exportStar(require("./BUILD_OBJECT"), exports);
+__exportStar(require("./MATCH"), exports);
+__exportStar(require("./CUSTOM_FUNCTIONS"), exports);
+__exportStar(require("./PASSTHRU"), exports);

package/build/shorthandSyntax.d.ts

@@ -0,0 +1,2 @@
+import { EvaluatorNode, Fragments, FragmentNode } from './types';
+export declare const preProcessShorthand: (expression: EvaluatorNode, fragments?: Fragments, useShorthand?: boolean) => EvaluatorNode | FragmentNode;

package/build/shorthandSyntax.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preProcessShorthand = void 0;
+const helpers_1 = require("./helpers");
+const _operatorAliases_json_1 = __importDefault(require("./operators/_operatorAliases.json"));
+const operatorAliases = _operatorAliases_json_1.default;
+const functionStringRegex = /(\$[^()]+)\((.*)\)/;
+const preProcessShorthand = (expression, fragments = {}, useShorthand = true) => {
+    if (!useShorthand)
+        return expression;
+    if (typeof expression === 'string')
+        return processString(expression, fragments);
+    if ((0, helpers_1.isObject)(expression))
+        return processObject(expression, fragments);
+    return expression;
+};
+exports.preProcessShorthand = preProcessShorthand;
+const processString = (expString, fragments) => {
+    const match = functionStringRegex.exec(expString);
+    if (!match)
+        return expString;
+    const method = match[1].trim();
+    const params = match[2].split(',').map((p) => (0, exports.preProcessShorthand)(p.trim(), fragments));
+    return buildNodeElements(method, params, fragments);
+};
+const processObject = (expObject, fragments) => {
+    if ((0, helpers_1.isOperatorNode)(expObject) || (0, helpers_1.isFragmentNode)(expObject))
+        return expObject;
+    const keyVals = Object.entries(expObject);
+    const aliasParams = keyVals.filter(([key]) => (0, helpers_1.isAliasString)(key));
+    const otherParams = keyVals.filter(([key]) => !(0, helpers_1.isAliasString)(key));
+    const newKeyVals = aliasParams.reduce((accObj, [alias, params]) => {
+        accObj = Object.assign(Object.assign({}, accObj), buildNodeElements(alias, params, fragments));
+        return accObj;
+    }, {});
+    return Object.assign(Object.assign({}, newKeyVals), Object.fromEntries(otherParams));
+};
+const buildNodeElements = (alias, params, fragments) => {
+    const aliasName = alias.slice(1);
+    const operator = (0, helpers_1.getOperatorName)(aliasName, operatorAliases);
+    if (operator) {
+        if (Array.isArray(params))
+            return { operator, children: params };
+        if ((0, helpers_1.isObject)(params) && !Object.keys(params).some((key) => (0, helpers_1.isAliasString)(key)))
+            return Object.assign({ operator }, params);
+        return { operator, children: [params] };
+    }
+    if (aliasName in fragments) {
+        return { fragment: aliasName, parameters: Object.assign({}, params) };
+    }
+    return { [alias]: params };
+};

package/build/typeCheck.d.ts

@@ -1,8 +1,12 @@
-export type ExpectedType = 'string' | 'boolean' | 'number' | 'array' | 'undefined' | 'null' | 'object';
+export type BasicType = 'any' | 'string' | 'boolean' | 'number' | 'array' | 'object' | 'null' | 'undefined';
+export type LiteralType = {
+    literal: (string | undefined)[];
+};
+export type ExpectedType = BasicType | LiteralType | BasicType[];
 export type TypeCheckInput = {
-    value: unknown;
     name?: string;
-    not?: boolean;
-    expectedType: ExpectedType | ExpectedType[];
+    value: unknown;
+    expectedType: ExpectedType;
 };
+export declare const isLiteralType: (typeDefinition: ExpectedType) => typeDefinition is LiteralType;
 export declare const typeCheck: (...args: TypeCheckInput[]) => true | string;

package/build/typeCheck.js

@@ -1,22 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeCheck = void 0;
+exports.typeCheck = exports.isLiteralType = void 0;
 const helpers_1 = require("./helpers");
-const typeCheckItem = ({ value, name, not = false, expectedType, }) => {
-    let result;
-    if (Array.isArray(expectedType)) {
-        result = expectedType.some((type) => typeCheckItem({ value, name, expectedType: type }) === true);
-        if (not)
-            result = !result;
-        return result ? true : makeErrorString(name, value, expectedType.join('|'), not);
+const isLiteralType = (typeDefinition) => (0, helpers_1.isObject)(typeDefinition) && 'literal' in typeDefinition;
+exports.isLiteralType = isLiteralType;
+const typeCheckItem = ({ value, name, expectedType }) => {
+    if ((0, exports.isLiteralType)(expectedType)) {
+        const { literal } = expectedType;
+        return literal.includes(value)
+            ? true
+            : makeErrorString(name, value, `Literal(${literal
+                .map((val) => (val === undefined ? `undefined` : `"${val}"`))
+                .join(', ')})`);
     }
-    else {
-        const checker = typeCheckMap[expectedType];
-        result = checker(value);
-        if (not)
-            result = !result;
-        return result ? true : makeErrorString(name, value, expectedType, not);
+    if (Array.isArray(expectedType)) {
+        return expectedType.some((type) => typeCheckItem({ value, name, expectedType: type }) === true)
+            ? true
+            : makeErrorString(name, value, expectedType.join('|'));
     }
+    const checker = typeCheckMap[expectedType];
+    return checker(value) ? true : makeErrorString(name, value, expectedType);
 };
 const typeCheck = (...args) => {
     const errorStrings = [];
@@ -29,18 +32,21 @@ const typeCheck = (...args) => {
 };
 exports.typeCheck = typeCheck;
 const typeCheckMap = {
+    any: (value) => value !== undefined,
     string: (value) => typeof value === 'string',
     number: (value) => typeof value === 'number',
     boolean: (value) => typeof value === 'boolean',
     array: (value) => Array.isArray(value),
-    undefined: (value) => value === undefined,
     null: (value) => value === null,
-    object: (value) => typeof value === 'object' && !Array.isArray(value) && value !== null,
+    object: (value) => (0, helpers_1.isObject)(value),
+    undefined: (value) => value === undefined,
 };
-const makeErrorString = (name, value, type, not) => {
+const makeErrorString = (name, value, type) => {
+    if (value === undefined && !!name)
+        return `- Missing required property "${name}" (type: ${type})`;
     if (name !== undefined)
-        return `- Property "${name}" (value: ${stringifyValue(value)}) is not of type: ${not ? `!(${type})` : type}`;
-    return `- ${stringifyValue(value)} is not of type: ${not ? `!(${type})` : type}`;
+        return `- Property "${name}" (value: ${stringifyValue(value)}) is not of type: ${type}`;
+    return `- ${stringifyValue(value)} is not of type: ${type}`;
 };
 const stringifyValue = (value) => {
     const stringValue = value === undefined || Number.isNaN(value) ? String(value) : JSON.stringify(value);

package/build/types.d.ts

@@ -1,24 +1,20 @@
 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 { Client } from 'pg';
+import { GraphQLConnection } from './operators';
 import operatorAliases from './operators/_operatorAliases.json';
-import { TypeCheckInput } from './typeCheck';
+import { ExpectedType, 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 type Fragments = Record<string, Fragment>;
+export type UnknownFunction = (...args: any[]) => EvaluatorOutput;
 export interface FigTreeOptions {
-    data?: GenericObject;
-    objects?: GenericObject;
-    functions?: {
-        [key: string]: Function;
-    };
-    fragments?: {
-        [key: string]: EvaluatorNode;
-    };
-    pgConnection?: PGConnection;
+    data?: object;
+    objects?: object;
+    functions?: Record<string, UnknownFunction>;
+    fragments?: Fragments;
+    pgConnection?: Client;
     graphQLConnection?: GraphQLConnection;
     baseEndpoint?: string;
     headers?: {
@@ -27,9 +23,10 @@ export interface FigTreeOptions {
     returnErrorAsString?: boolean;
     nullEqualsUndefined?: boolean;
     allowJSONStringInput?: boolean;
+    noShorthand?: boolean;
     skipRuntimeTypeCheck?: boolean;
     evaluateFullObject?: boolean;
-    excludeOperators?: string[];
+    excludeOperators?: OperatorAlias[];
     useCache?: boolean;
     maxCacheSize?: number;
     supportDeprecatedValueNodes?: boolean;
@@ -38,41 +35,61 @@ export interface FigTreeConfig {
     options: FigTreeOptions;
     operators: OperatorReference;
     operatorAliases: OperatorAliases;
-    typeChecker: (...input: TypeCheckInput[]) => void;
+    typeChecker: (...args: TypeCheckInput[] | [TypeCheckInput[]]) => void;
     resolvedAliasNodes: {
         [key: string]: EvaluatorOutput;
     };
     cache: FigTreeCache;
 }
 export type OutputType = 'string' | 'number' | 'boolean' | 'bool' | 'array';
-export interface BaseOperatorNode {
-    operator: Operator;
+export interface OperatorNode {
+    operator: OperatorAlias;
     outputType?: OutputType;
-    children?: Array<EvaluatorNode>;
-    fallback?: any;
+    children?: EvaluatorNode[];
+    fallback?: EvaluatorNode;
     useCache?: boolean;
     [key: string]: EvaluatorNode;
 }
 export interface FragmentNode {
     fragment: string;
-    parameters?: {
-        [key: string]: EvaluatorNode;
-    };
+    parameters?: Record<string, EvaluatorNode>;
     [key: string]: EvaluatorNode;
 }
-export type CombinedOperatorNode = BaseOperatorNode & BasicExtendedNode & SubtractionNode & DivisionNode & ComparatorNode & ConditionalNode & RegexNode & StringSubNode & SplitNode & ObjPropNode & APINode & PGNode & GraphQLNode & BuildObjectNode & MatchNode & FunctionNode & PassThruNode;
-export type OperatorNodeUnion = BasicExtendedNode | SubtractionNode | DivisionNode | ComparatorNode | ConditionalNode | RegexNode | StringSubNode | SplitNode | ObjPropNode | PGNode | GraphQLNode | APINode | BuildObjectNode | MatchNode | FunctionNode | PassThruNode;
-export type EvaluatorOutput = string | boolean | number | GenericObject | null | undefined | any[];
-export type EvaluatorNode = CombinedOperatorNode | FragmentNode | EvaluatorOutput;
+export interface FragmentMetadata {
+    description?: string;
+    parameters?: Record<string, {
+        type: string | string[];
+        required: boolean;
+    }>;
+}
+export type Fragment = (EvaluatorNode & {
+    metadata?: FragmentMetadata;
+}) | null;
+export type EvaluatorOutput = string | boolean | number | object | null | undefined | Array<EvaluatorOutput>;
+export type EvaluatorNode = OperatorNode | FragmentNode | EvaluatorOutput;
 export type OperatorObject = {
-    requiredProperties: readonly string[];
-    operatorAliases: string[];
-    propertyAliases: {
-        [key: string]: string;
-    };
-    evaluate: (expression: CombinedOperatorNode, config: FigTreeConfig) => Promise<EvaluatorOutput>;
-    parseChildren: (expression: CombinedOperatorNode, config: FigTreeConfig) => OperatorNodeUnion | Promise<OperatorNodeUnion>;
+    propertyAliases: Record<string, string>;
+    operatorData: OperatorData;
+    evaluate: EvaluateMethod;
+    parseChildren: ParseChildrenMethod;
 };
+export type EvaluateMethod = (expression: OperatorNode, config: FigTreeConfig) => Promise<EvaluatorOutput>;
+export type ParseChildrenMethod = (expression: OperatorNode, config: FigTreeConfig) => OperatorNode | Promise<OperatorNode>;
 export type OperatorReference = {
     [key in Operator]: OperatorObject;
 };
+export type Parameter = {
+    name: string;
+    description: string;
+    aliases: string[];
+    required: boolean;
+    type: ExpectedType;
+};
+export interface OperatorData {
+    description: string;
+    aliases: string[];
+    parameters: Parameter[];
+}
+export interface OperatorMetadata extends OperatorData {
+    operator: Operator;
+}

package/build/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "2.8.3";

package/build/version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+exports.version = '2.8.3';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fig-tree-evaluator",
-  "version": "2.7.0",
+  "version": "2.8.3",
   "description": "Module to evaluate JSON-structured expression trees",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -16,7 +16,10 @@
     "@types/jest": "^27.5.1",
     "@types/node": "^17.0.38",
     "@types/pg": "^8.6.5",
+    "@typescript-eslint/eslint-plugin": "^5.57.0",
+    "@typescript-eslint/parser": "^5.57.0",
     "dotenv": "^16.0.1",
+    "eslint": "^8.37.0",
     "jest": "^28.1.0",
     "pg": "^8.7.3",
     "rimraf": "^3.0.2",
@@ -28,9 +31,13 @@
     "setup": "yarn install && cd demo && yarn install",
     "test": "jest",
     "generate": "ts-node ./codegen/buildOperatorAliasReference.ts",
-    "build": "yarn generate && rimraf ./build && tsc",
+    "generateMassiveQuery": "ts-node ./codegen/generateMassiveQuery.ts",
+    "getVersion": "ts-node ./codegen/getVersion.ts",
+    "lint": "eslint . --ext .ts",
+    "build": "rimraf ./build && tsc",
+    "prebuild": "yarn generate && yarn getVersion",
     "dev": "cp -n src/dev/playground_example.ts src/dev/playground.ts || ts-node src/dev/playground.ts",
-    "demo": "cd demo && yarn start",
+    "demo": "yarn getVersion && cd demo && yarn start",
     "prepublishOnly": "yarn build"
   },
   "dependencies": {

package/build/operators/buildObject.d.ts

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

package/build/operators/conditional.d.ts

@@ -1,7 +0,0 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["condition", "valueIfTrue", "valueIfFalse"];
-export type ConditionalNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BaseOperatorNode;
-export declare const CONDITIONAL: OperatorObject;
-export {};

package/build/operators/conditional.js

@@ -1,33 +0,0 @@
-"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.CONDITIONAL = void 0;
-const evaluate_1 = require("../evaluate");
-const requiredProperties = ['condition', 'valueIfTrue', 'valueIfFalse'];
-const operatorAliases = ['?', 'conditional', 'ifThen'];
-const propertyAliases = { ifTrue: 'valueIfTrue', ifFalse: 'valueIfFalse', ifNot: 'valueIfFalse' };
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const condition = yield (0, evaluate_1.evaluatorFunction)(expression.condition, config);
-    return !!condition
-        ? yield (0, evaluate_1.evaluatorFunction)(expression.valueIfTrue, config)
-        : yield (0, evaluate_1.evaluatorFunction)(expression.valueIfFalse, config);
-});
-const parseChildren = (expression) => {
-    const [condition, valueIfTrue, valueIfFalse] = expression.children;
-    return Object.assign(Object.assign({}, expression), { condition, valueIfTrue, valueIfFalse });
-};
-exports.CONDITIONAL = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren,
-};

package/build/operators/count.d.ts

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

package/build/operators/count.js

@@ -1,29 +0,0 @@
-"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.COUNT = void 0;
-const logicalAnd_1 = require("./logicalAnd");
-const _operatorUtils_1 = require("./_operatorUtils");
-const requiredProperties = ['values'];
-const operatorAliases = ['count', 'length'];
-const propertyAliases = {};
-const evaluate = (expression, config) => __awaiter(void 0, void 0, void 0, function* () {
-    const values = yield (0, _operatorUtils_1.evaluateArray)(expression.values, config);
-    config.typeChecker({ name: 'values', value: values, expectedType: 'array' });
-    return values.length;
-});
-exports.COUNT = {
-    requiredProperties,
-    operatorAliases,
-    propertyAliases,
-    evaluate,
-    parseChildren: logicalAnd_1.parseChildren,
-};

package/build/operators/customFunctions.d.ts

@@ -1,9 +0,0 @@
-import { BaseOperatorNode, EvaluatorNode, OperatorObject } from '../types';
-declare const requiredProperties: readonly ["functionPath"];
-export type FunctionNode = {
-    [key in typeof requiredProperties[number]]: EvaluatorNode;
-} & BaseOperatorNode & {
-    args: EvaluatorNode[];
-};
-export declare const CUSTOM_FUNCTIONS: OperatorObject;
-export {};