fig-tree-evaluator 2.8.0 → 2.8.4

package/build/operators/_operatorUtils.js

@@ -12,13 +12,12 @@ 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 = exports.getTypeCheckInput = exports.getPropertyAliases = exports.getRequiredProperties = 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 getRequiredProperties = (parameters) => parameters.filter((p) => p.required).map((p) => p.name);
-exports.getRequiredProperties = getRequiredProperties;
 const getPropertyAliases = (parameters) => {
     const propertyAliases = {};
     parameters.forEach((param) => {
@@ -28,6 +27,12 @@ const getPropertyAliases = (parameters) => {
 };
 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');
@@ -65,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/shorthandSyntax.js

@@ -7,7 +7,7 @@ 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 functionStringRegex = /(\$[^()]+)\((.*)\)/;
 const preProcessShorthand = (expression, fragments = {}, useShorthand = true) => {
     if (!useShorthand)
         return expression;

package/build/typeCheck.d.ts

@@ -1,8 +1,12 @@
-export type ExpectedType = 'string' | 'boolean' | 'number' | 'array' | 'undefined' | 'null' | 'object' | 'any';
+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,19 +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,
-    any: (value) => value !== undefined,
+    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,22 +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 { 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 Functions = Record<string, Function>;
+export type UnknownFunction = (...args: any[]) => EvaluatorOutput;
 export interface FigTreeOptions {
-    data?: GenericObject;
-    objects?: GenericObject;
-    functions?: Functions;
+    data?: object;
+    objects?: object;
+    functions?: Record<string, UnknownFunction>;
     fragments?: Fragments;
-    pgConnection?: PGConnection;
+    pgConnection?: Client;
     graphQLConnection?: GraphQLConnection;
     baseEndpoint?: string;
     headers?: {
@@ -28,7 +26,7 @@ export interface FigTreeOptions {
     noShorthand?: boolean;
     skipRuntimeTypeCheck?: boolean;
     evaluateFullObject?: boolean;
-    excludeOperators?: string[];
+    excludeOperators?: OperatorAlias[];
     useCache?: boolean;
     maxCacheSize?: number;
     supportDeprecatedValueNodes?: boolean;
@@ -37,48 +35,46 @@ 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 interface FragmentMetadata {
+    description?: string;
+    parameters?: Record<string, {
+        type: string | string[];
+        required: boolean;
+    }>;
+}
 export type Fragment = (EvaluatorNode & {
-    metadata?: {
-        description?: string;
-        parameters?: Record<string, {
-            type: string | string[];
-            required: boolean;
-        }>;
-    };
+    metadata?: FragmentMetadata;
 }) | null;
-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 | APINode | PGNode | GraphQLNode | BuildObjectNode | MatchNode | FunctionNode | PassThruNode;
-export type EvaluatorOutput = string | boolean | number | GenericObject | null | undefined | any[];
-export type EvaluatorNode = CombinedOperatorNode | FragmentNode | EvaluatorOutput;
+export type EvaluatorOutput = string | boolean | number | object | null | undefined | Array<EvaluatorOutput>;
+export type EvaluatorNode = OperatorNode | FragmentNode | EvaluatorOutput;
 export type OperatorObject = {
-    requiredProperties: readonly string[];
     propertyAliases: Record<string, string>;
     operatorData: OperatorData;
-    evaluate: (expression: CombinedOperatorNode, config: FigTreeConfig) => Promise<EvaluatorOutput>;
-    parseChildren: (expression: CombinedOperatorNode, config: FigTreeConfig) => OperatorNodeUnion | Promise<OperatorNodeUnion>;
+    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;
 };
@@ -87,10 +83,13 @@ export type Parameter = {
     description: string;
     aliases: string[];
     required: boolean;
-    type: ExpectedType | ExpectedType[];
+    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.4";

package/build/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fig-tree-evaluator",
-  "version": "2.8.0",
+  "version": "2.8.4",
   "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": {