fig-tree-evaluator 2.8.0 → 2.8.3

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.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.8.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": {