graphai 0.4.1 → 0.4.3

package/lib/graphai.js

@@ -20,7 +20,7 @@ class GraphAI {
                 _nodes[nodeId] = new node_1.ComputedNode(this.graphId, nodeId, nodeData, this);
             }
             else {
-                throw new Error("Unknown node: " + nodeId);
+                throw new Error("Unknown node type (neither value nor agent): " + nodeId);
             }
             return _nodes;
         }, {});
@@ -33,7 +33,7 @@ class GraphAI {
                         nodes[pending].waitlist.add(nodeId); // previousNode
                     }
                     else {
-                        console.error(`--- invalid input ${pending} for node, ${nodeId}`);
+                        throw new Error(`createNode: invalid input ${pending} for node, ${nodeId}`);
                     }
                 });
             }
@@ -68,11 +68,11 @@ class GraphAI {
         this.onLogCallback = (__log, __isUpdate) => { };
         this.repeatCount = 0;
         if (!data.version && !options.taskManager) {
-            console.log("------------ missing version number");
+            console.warn("------------ missing version number");
         }
         this.version = data.version ?? latestVersion;
         if (this.version < latestVersion) {
-            console.log(`------------ upgrade to ${latestVersion}!`);
+            console.warn(`------------ upgrade to ${latestVersion}!`);
         }
         this.retryLimit = data.retry; // optional
         this.graphId = URL.createObjectURL(new Blob()).slice(-36);
@@ -83,7 +83,7 @@ class GraphAI {
         this.loop = data.loop;
         this.verbose = data.verbose === true;
         this.onComplete = () => {
-            console.error("-- SOMETHING IS WRONG: onComplete is called without run()");
+            throw new Error("SOMETHING IS WRONG: onComplete is called without run()");
         };
         (0, validator_1.validateGraphData)(data, Object.keys(agentFunctionInfoDictionary));
         this.nodes = this.createNodes(data);
@@ -93,6 +93,7 @@ class GraphAI {
         if (agentId && this.agentFunctionInfoDictionary[agentId]) {
             return this.agentFunctionInfoDictionary[agentId];
         }
+        // We are not supposed to hit this error because the validator will catch it.
         throw new Error("No agent: " + agentId);
     }
     asString() {
@@ -154,7 +155,7 @@ class GraphAI {
     // Public API
     async run(all = false) {
         if (this.isRunning()) {
-            console.error("-- Already Running");
+            throw new Error("This GraphUI instance is already running");
         }
         this.pushReadyNodesIntoQueue();
         if (!this.isRunning()) {
@@ -201,7 +202,7 @@ class GraphAI {
                 const source = (0, utils_1.parseNodeName)(loop.while, this.version);
                 const value = this.getValueFromResults(source, this.results(true));
                 // NOTE: We treat an empty array as false.
-                if (Array.isArray(value) ? value.length === 0 : !value) {
+                if (!(0, utils_1.isLogicallyTrue)(value)) {
                     return false; // while condition is not met
                 }
             }
@@ -232,8 +233,7 @@ class GraphAI {
             node.injectValue(value, injectFrom);
         }
         else {
-            console.error("-- Inject Error: Invalid nodeId", nodeId);
-            console.error("InjectionTo can only specify static nodes");
+            throw new Error(`injectValue with Invalid nodeId, ${nodeId}`);
         }
     }
     resultsOf(sources) {

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import { GraphAI } from "./graphai";
-export { GraphAI };
-export { AgentFunction, AgentFunctionInfoDictonary, GraphData, ResultDataDictonary, ResultData, NodeState } from "./type";
+export { GraphAI } from "./graphai";
+export { AgentFunction, AgentFunctionInfo, AgentFunctionInfoDictionary, AgentFunctionContext, GraphData, ResultDataDictionary, ResultData, NodeState, AgentFilterFunction, AgentFilterInfo, } from "./type";
 export type { TransactionLog } from "./transaction_log";
+export { agentFilterRunnerBuilder } from "./utils/runner";

package/lib/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeState = exports.GraphAI = void 0;
-const graphai_1 = require("./graphai");
+exports.agentFilterRunnerBuilder = exports.NodeState = exports.GraphAI = void 0;
+var graphai_1 = require("./graphai");
 Object.defineProperty(exports, "GraphAI", { enumerable: true, get: function () { return graphai_1.GraphAI; } });
 var type_1 = require("./type");
 Object.defineProperty(exports, "NodeState", { enumerable: true, get: function () { return type_1.NodeState; } });
+var runner_1 = require("./utils/runner");
+Object.defineProperty(exports, "agentFilterRunnerBuilder", { enumerable: true, get: function () { return runner_1.agentFilterRunnerBuilder; } });

package/lib/node.d.ts

@@ -1,4 +1,4 @@
-import type { GraphAI, GraphData } from "./graphai";
+import type { GraphAI, GraphData } from "./index";
 import { NodeDataParams, ResultData, DataSource, ComputedNodeData, StaticNodeData, NodeState } from "./type";
 import { TransactionLog } from "./transaction_log";
 export declare class Node {
@@ -18,7 +18,7 @@ export declare class ComputedNode extends Node {
     readonly params: NodeDataParams;
     private readonly filterParams;
     private readonly dynamicParams;
-    readonly nestedGraph?: GraphData;
+    readonly nestedGraph?: GraphData | DataSource;
     readonly retryLimit: number;
     retryCount: number;
     private readonly agentId?;
@@ -31,6 +31,8 @@ export declare class ComputedNode extends Node {
     dataSources: Array<DataSource>;
     pendings: Set<string>;
     private ifSource?;
+    private unlessSource?;
+    private console;
     readonly isStaticNode = false;
     readonly isComputedNode = true;
     constructor(graphId: string, nodeId: string, data: ComputedNodeData, graph: GraphAI);

package/lib/node.js

@@ -38,8 +38,8 @@ class ComputedNode extends Node {
         this.isComputedNode = true;
         this.graphId = graphId;
         this.params = data.params ?? {};
+        this.console = data.console ?? {};
         this.filterParams = data.filterParams ?? {};
-        this.nestedGraph = data.graph;
         if (typeof data.agent === "string") {
             this.agentId = data.agent;
         }
@@ -57,11 +57,25 @@ class ComputedNode extends Node {
         this.anyInput = data.anyInput ?? false;
         this.dataSources = (data.inputs ?? []).map((input) => (0, utils_2.parseNodeName)(input, graph.version));
         this.pendings = new Set(this.dataSources.filter((source) => source.nodeId).map((source) => source.nodeId));
+        if (typeof data.graph === "string") {
+            const source = (0, utils_2.parseNodeName)(data.graph, graph.version);
+            (0, utils_2.assert)(!!source.nodeId, `Invalid data source ${data.graph}`);
+            this.pendings.add(source.nodeId);
+            this.nestedGraph = source;
+        }
+        else if (data.graph) {
+            this.nestedGraph = data.graph;
+        }
         if (data.if) {
             this.ifSource = (0, utils_2.parseNodeName)(data.if, graph.version);
             (0, utils_2.assert)(!!this.ifSource.nodeId, `Invalid data source ${data.if}`);
             this.pendings.add(this.ifSource.nodeId);
         }
+        if (data.unless) {
+            this.unlessSource = (0, utils_2.parseNodeName)(data.unless, graph.version);
+            (0, utils_2.assert)(!!this.unlessSource.nodeId, `Invalid data source ${data.unless}`);
+            this.pendings.add(this.unlessSource.nodeId);
+        }
         this.dynamicParams = Object.keys(this.params).reduce((tmp, key) => {
             const dataSource = (0, utils_2.parseNodeName)(this.params[key], graph.version < 0.3 ? 0.3 : graph.version);
             if (dataSource.nodeId) {
@@ -88,12 +102,19 @@ class ComputedNode extends Node {
             if (!this.anyInput || counter > 0) {
                 if (this.ifSource) {
                     const [condition] = this.graph.resultsOf([this.ifSource]);
-                    if (!condition) {
+                    if (!(0, utils_2.isLogicallyTrue)(condition)) {
+                        this.state = type_1.NodeState.Skipped;
+                        this.log.onSkipped(this, this.graph);
+                        return false;
+                    }
+                }
+                if (this.unlessSource) {
+                    const [condition] = this.graph.resultsOf([this.unlessSource]);
+                    if ((0, utils_2.isLogicallyTrue)(condition)) {
                         this.state = type_1.NodeState.Skipped;
                         this.log.onSkipped(this, this.graph);
                         return false;
                     }
-                    return true;
                 }
                 return true;
             }
@@ -149,7 +170,7 @@ class ComputedNode extends Node {
     // and attempt to retry (if specified).
     executeTimeout(transactionId) {
         if (this.state === type_1.NodeState.Executing && this.isCurrentTransaction(transactionId)) {
-            console.log(`-- ${this.nodeId}: timeout ${this.timeout}`);
+            console.warn(`-- timeout ${this.timeout} with ${this.nodeId}`);
             this.retry(type_1.NodeState.TimedOut, Error("Timeout"));
         }
     }
@@ -226,17 +247,29 @@ class ComputedNode extends Node {
             if (this.nestedGraph) {
                 this.graph.taskManager.prepareForNesting();
                 context.taskManager = this.graph.taskManager;
-                context.graphData = this.nestedGraph;
+                if ("nodes" in this.nestedGraph) {
+                    context.graphData = this.nestedGraph;
+                }
+                else {
+                    const [graphData] = this.graph.resultsOf([this.nestedGraph]);
+                    context.graphData = graphData; // HACK: compiler work-around
+                }
                 context.agents = this.graph.agentFunctionInfoDictionary;
             }
+            if (this.console.before) {
+                console.log(this.console.before === true ? JSON.stringify(context.inputs, null, 2) : this.console.before);
+            }
             const result = await this.agentFilterHandler(context, agentFunction);
+            if (this.console.after) {
+                console.log(this.console.after === true ? (typeof result === "string" ? result : JSON.stringify(result, null, 2)) : this.console.after);
+            }
             if (this.nestedGraph) {
                 this.graph.taskManager.restoreAfterNesting();
             }
             if (!this.isCurrentTransaction(transactionId)) {
                 // This condition happens when the agent function returns
                 // after the timeout (either retried or not).
-                console.log(`-- ${this.nodeId}: transactionId mismatch`);
+                console.log(`-- transactionId mismatch with ${this.nodeId} (probably timeout)`);
                 return;
             }
             this.state = type_1.NodeState.Completed;
@@ -261,19 +294,19 @@ class ComputedNode extends Node {
     // the retry if specified.
     errorProcess(error, transactionId) {
         if (error instanceof Error && error.message !== utils_1.strIntentionalError) {
-            console.error(`<-- ${this.nodeId}, ${this.agentId}`);
-            console.log(error);
-            console.log("-->");
+            console.error(`<-- NodeId: ${this.nodeId}, Agent: ${this.agentId}`);
+            console.error(error);
+            console.error("-->");
         }
         if (!this.isCurrentTransaction(transactionId)) {
-            console.log(`-- ${this.nodeId}: transactionId mismatch(error)`);
+            console.warn(`-- transactionId mismatch with ${this.nodeId} (not timeout)`);
             return;
         }
         if (error instanceof Error) {
             this.retry(type_1.NodeState.Failed, error);
         }
         else {
-            console.error(`-- ${this.nodeId}: Unexpecrted error was caught`);
+            console.error(`-- NodeId: ${this.nodeId}: Unknown error was caught`);
             this.retry(type_1.NodeState.Failed, Error("Unknown"));
         }
     }

package/lib/transaction_log.d.ts

@@ -14,6 +14,7 @@ export declare class TransactionLog {
     injectFrom?: string;
     errorMessage?: string;
     result?: ResultData;
+    resultKeys?: string[];
     mapIndex?: number;
     isLoop?: boolean;
     repeatCount?: number;

package/lib/transaction_log.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionLog = void 0;
 const type_1 = require("./type");
+const utils_1 = require("./utils/utils");
 class TransactionLog {
     constructor(nodeId) {
         this.nodeId = nodeId;
@@ -29,6 +30,7 @@ class TransactionLog {
     }
     onComplete(node, graph, localLog) {
         this.result = node.result;
+        this.resultKeys = (0, utils_1.debugResultKey)(this.agentId || "", node.result);
         this.state = node.state;
         this.endTime = Date.now();
         graph.setLoopLog(this);

package/lib/type.d.ts

@@ -13,7 +13,7 @@ export declare enum NodeState {
 export type DefaultResultData = Record<string, any> | string | number | boolean | Array<DefaultResultData>;
 export type DefaultInputData = Record<string, any>;
 export type ResultData<ResultType = DefaultResultData> = ResultType | undefined;
-export type ResultDataDictonary<ResultType = DefaultResultData> = Record<string, ResultData<ResultType>>;
+export type ResultDataDictionary<ResultType = DefaultResultData> = Record<string, ResultData<ResultType>>;
 export type DefaultParamsType = Record<string, any>;
 export type NodeDataParams<ParamsType = DefaultParamsType> = ParamsType;
 export type DataSource = {
@@ -26,10 +26,10 @@ export type StaticNodeData = {
     update?: string;
     isResult?: boolean;
 };
-export type AgentNamelessFunction = (...param: any[]) => unknown;
+export type AgentAnonymousFunction = (...params: any[]) => unknown;
 export type AgentFilterParams = Record<string, any>;
 export type ComputedNodeData = {
-    agent: string | AgentNamelessFunction;
+    agent: string | AgentAnonymousFunction;
     inputs?: Array<any>;
     anyInput?: boolean;
     params?: NodeDataParams;
@@ -37,9 +37,11 @@ export type ComputedNodeData = {
     retry?: number;
     timeout?: number;
     if?: string;
-    graph?: GraphData;
+    unless?: string;
+    graph?: GraphData | string;
     isResult?: boolean;
     priority?: number;
+    console?: Record<string, string | boolean>;
 };
 export type NodeData = StaticNodeData | ComputedNodeData;
 export type LoopData = {
@@ -64,7 +66,7 @@ export type AgentFunctionContext<ParamsType = DefaultParamsType, InputDataType =
         agentId?: string;
     };
     graphData?: GraphData | string;
-    agents?: AgentFunctionInfoDictonary;
+    agents?: AgentFunctionInfoDictionary;
     taskManager?: TaskManager;
     filterParams: AgentFilterParams;
     agentFilters?: AgentFilterInfo[];
@@ -87,6 +89,7 @@ export type AgentFunctionInfo = {
         inputs: any;
         params: DefaultParamsType;
         result: any;
+        graph?: GraphData;
     }[];
     skipTest?: boolean;
     description: string;
@@ -94,5 +97,8 @@ export type AgentFunctionInfo = {
     author: string;
     repository: string;
     license: string;
+    stream?: boolean;
+    apiKeys?: string[];
+    npms?: string[];
 };
-export type AgentFunctionInfoDictonary = Record<string, AgentFunctionInfo>;
+export type AgentFunctionInfoDictionary = Record<string, AgentFunctionInfo>;

package/lib/utils/runner.d.ts

@@ -0,0 +1,2 @@
+import { AgentFunctionContext, AgentFunction, AgentFilterInfo, ResultData } from "../type";
+export declare const agentFilterRunnerBuilder: (__agentFilters: AgentFilterInfo[]) => (context: AgentFunctionContext, agent: AgentFunction) => Promise<ResultData>;

package/lib/utils/runner.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentFilterRunnerBuilder = void 0;
+// for test and server.
+const agentFilterRunnerBuilder = (__agentFilters) => {
+    const agentFilters = __agentFilters;
+    const agentFilterRunner = (context, agent) => {
+        let index = 0;
+        const next = (context) => {
+            const agentFilter = agentFilters[index++];
+            if (agentFilter) {
+                return agentFilter.agent(context, next);
+            }
+            return agent(context);
+        };
+        return next(context);
+    };
+    return agentFilterRunner;
+};
+exports.agentFilterRunnerBuilder = agentFilterRunnerBuilder;

package/lib/utils/test_agents.d.ts

@@ -1,2 +1,2 @@
-import { AgentFunctionInfoDictonary } from "../graphai";
-export declare const defaultTestAgents: AgentFunctionInfoDictonary;
+import { AgentFunctionInfoDictionary } from "../index";
+export declare const defaultTestAgents: AgentFunctionInfoDictionary;

package/lib/utils/test_utils.d.ts

@@ -1,19 +1,4 @@
-import { AgentFunctionInfo, AgentFunctionContext, AgentFunction, AgentFilterInfo, ResultData } from "../type";
-export declare const getAgentInfo: (agent: AgentFunction<any, any, any>) => {
-    name: string;
-    samples: {
-        inputs: never[];
-        params: {};
-        result: {};
-    }[];
-    description: string;
-    category: never[];
-    author: string;
-    repository: string;
-    license: string;
-    agent: AgentFunction<any, any, any>;
-    mock: AgentFunction<any, any, any>;
-};
+import { AgentFunctionInfo } from "../type";
 export declare const defaultTestContext: {
     debugInfo: {
         nodeId: string;
@@ -26,4 +11,3 @@ export declare const defaultTestContext: {
     log: never[];
 };
 export declare const agentTestRunner: (agentInfo: AgentFunctionInfo) => Promise<void>;
-export declare const agentFilterRunnerBuilder: (__agentFilters: AgentFilterInfo[]) => (context: AgentFunctionContext, agent: AgentFunction) => Promise<ResultData>;

package/lib/utils/test_utils.js

@@ -3,11 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.agentFilterRunnerBuilder = exports.agentTestRunner = exports.defaultTestContext = exports.getAgentInfo = void 0;
-const utils_1 = require("../utils/utils");
+exports.agentTestRunner = exports.defaultTestContext = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = __importDefault(require("node:test"));
-exports.getAgentInfo = utils_1.agentInfoWrapper;
 exports.defaultTestContext = {
     debugInfo: {
         nodeId: "test",
@@ -28,11 +26,12 @@ const agentTestRunner = async (agentInfo) => {
     else {
         for await (const sampleKey of samples.keys()) {
             (0, node_test_1.default)(`test ${agentInfo.name} ${sampleKey}`, async () => {
-                const { params, inputs, result } = samples[sampleKey];
+                const { params, inputs, result, graph } = samples[sampleKey];
                 const actual = await agent({
                     ...exports.defaultTestContext,
                     params,
                     inputs,
+                    graphData: graph,
                 });
                 node_assert_1.default.deepStrictEqual(actual, result);
             });
@@ -40,20 +39,3 @@ const agentTestRunner = async (agentInfo) => {
     }
 };
 exports.agentTestRunner = agentTestRunner;
-// for agent and agent filter.
-const agentFilterRunnerBuilder = (__agentFilters) => {
-    const agentFilters = __agentFilters;
-    const agentFilterRunner = (context, agent) => {
-        let index = 0;
-        const next = (context) => {
-            const agentFilter = agentFilters[index++];
-            if (agentFilter) {
-                return agentFilter.agent(context, next);
-            }
-            return agent(context);
-        };
-        return next(context);
-    };
-    return agentFilterRunner;
-};
-exports.agentFilterRunnerBuilder = agentFilterRunnerBuilder;

package/lib/utils/utils.d.ts

@@ -33,3 +33,5 @@ export declare const agentInfoWrapper: (agent: AgentFunction<any, any, any>) =>
     agent: AgentFunction<any, any, any>;
     mock: AgentFunction<any, any, any>;
 };
+export declare const debugResultKey: (agentId: string, result: any) => string[];
+export declare const isLogicallyTrue: (value: any) => boolean;

package/lib/utils/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.agentInfoWrapper = exports.defaultAgentInfo = exports.strIntentionalError = exports.getDataFromSource = exports.isObject = exports.assert = exports.parseNodeName = exports.sleep = void 0;
+exports.isLogicallyTrue = exports.debugResultKey = exports.agentInfoWrapper = exports.defaultAgentInfo = exports.strIntentionalError = exports.getDataFromSource = exports.isObject = exports.assert = exports.parseNodeName = exports.sleep = void 0;
 const sleep = async (milliseconds) => {
     return await new Promise((resolve) => setTimeout(resolve, milliseconds));
 };
@@ -109,3 +109,47 @@ const agentInfoWrapper = (agent) => {
     };
 };
 exports.agentInfoWrapper = agentInfoWrapper;
+const objectToKeyArray = (innerData) => {
+    const ret = [];
+    Object.keys(innerData).forEach((key) => {
+        ret.push([key]);
+        if (Object.keys(innerData[key]).length > 0) {
+            objectToKeyArray(innerData[key]).forEach((tmp) => {
+                ret.push([key, ...tmp]);
+            });
+        }
+    });
+    return ret;
+};
+const debugResultKey = (agentId, result) => {
+    return objectToKeyArray({ [agentId]: debugResultKeyInner(result) }).map((objectKeys) => {
+        return ":" + objectKeys.join(".");
+    });
+};
+exports.debugResultKey = debugResultKey;
+const debugResultKeyInner = (result) => {
+    if (result === null || result === undefined) {
+        return {};
+    }
+    if (typeof result === "string") {
+        return {};
+    }
+    if (Array.isArray(result)) {
+        return Array.from(result.keys()).reduce((tmp, index) => {
+            tmp["$" + String(index)] = debugResultKeyInner(result[index]);
+            return tmp;
+        }, {});
+    }
+    return Object.keys(result).reduce((tmp, key) => {
+        tmp[key] = debugResultKeyInner(result[key]);
+        return tmp;
+    }, {});
+};
+const isLogicallyTrue = (value) => {
+    // Notice that empty aray is not true under GraphAI
+    if (Array.isArray(value) ? value.length === 0 : !value) {
+        return false;
+    }
+    return true;
+};
+exports.isLogicallyTrue = isLogicallyTrue;

package/lib/validators/agent_validator.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.agentValidator = void 0;
+const common_1 = require("../validators/common");
 const agentValidator = (graphAgentIds, agentIds) => {
     graphAgentIds.forEach((agentId) => {
         if (!agentIds.has(agentId)) {
-            throw new Error("Invalid Agent : " + agentId + " is not in callbackDictonary.");
+            throw new common_1.ValidationError("Invalid Agent : " + agentId + " is not in AgentFunctionInfoDictionary.");
         }
     });
     return true;

package/lib/validators/common.d.ts

@@ -1,3 +1,6 @@
 export declare const graphDataAttributeKeys: string[];
 export declare const computedNodeAttributeKeys: string[];
 export declare const staticNodeAttributeKeys: string[];
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}

package/lib/validators/common.js

@@ -1,6 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.staticNodeAttributeKeys = exports.computedNodeAttributeKeys = exports.graphDataAttributeKeys = void 0;
+exports.ValidationError = exports.staticNodeAttributeKeys = exports.computedNodeAttributeKeys = exports.graphDataAttributeKeys = void 0;
 exports.graphDataAttributeKeys = ["nodes", "concurrency", "agentId", "loop", "verbose", "version"];
-exports.computedNodeAttributeKeys = ["inputs", "anyInput", "params", "retry", "timeout", "agent", "graph", "isResult", "priority", "if", "filterParams"];
+exports.computedNodeAttributeKeys = [
+    "inputs",
+    "anyInput",
+    "params",
+    "retry",
+    "timeout",
+    "agent",
+    "graph",
+    "isResult",
+    "priority",
+    "if",
+    "unless",
+    "filterParams",
+    "console",
+];
 exports.staticNodeAttributeKeys = ["value", "update", "isResult"];
+class ValidationError extends Error {
+    constructor(message) {
+        super(`\x1b[41m${message}\x1b[0m`); // Pass the message to the base Error class
+        // Set the prototype explicitly to ensure correct prototype chain
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+exports.ValidationError = ValidationError;

package/lib/validators/computed_node_validator.js

@@ -5,7 +5,7 @@ const common_1 = require("../validators/common");
 const computedNodeValidator = (nodeData) => {
     Object.keys(nodeData).forEach((key) => {
         if (!common_1.computedNodeAttributeKeys.includes(key)) {
-            throw new Error("Computed node does not allow " + key);
+            throw new common_1.ValidationError("Computed node does not allow " + key);
         }
     });
     return true;

package/lib/validators/graph_data_validator.js

@@ -4,20 +4,20 @@ exports.graphDataValidator = exports.graphNodesValidator = void 0;
 const common_1 = require("../validators/common");
 const graphNodesValidator = (data) => {
     if (data.nodes === undefined) {
-        throw new Error("Invalid Graph Data: no nodes");
+        throw new common_1.ValidationError("Invalid Graph Data: no nodes");
     }
     if (typeof data.nodes !== "object") {
-        throw new Error("Invalid Graph Data: invalid nodes");
+        throw new common_1.ValidationError("Invalid Graph Data: invalid nodes");
     }
     if (Array.isArray(data.nodes)) {
-        throw new Error("Invalid Graph Data: nodes must be object");
+        throw new common_1.ValidationError("Invalid Graph Data: nodes must be object");
     }
     if (Object.keys(data.nodes).length === 0) {
-        throw new Error("Invalid Graph Data: nodes is empty");
+        throw new common_1.ValidationError("Invalid Graph Data: nodes is empty");
     }
     Object.keys(data).forEach((key) => {
         if (!common_1.graphDataAttributeKeys.includes(key)) {
-            throw new Error("Graph Data does not allow " + key);
+            throw new common_1.ValidationError("Graph Data does not allow " + key);
         }
     });
 };
@@ -25,18 +25,18 @@ exports.graphNodesValidator = graphNodesValidator;
 const graphDataValidator = (data) => {
     if (data.loop) {
         if (data.loop.count === undefined && data.loop.while === undefined) {
-            throw new Error("Loop: Either count or while is required in loop");
+            throw new common_1.ValidationError("Loop: Either count or while is required in loop");
         }
         if (data.loop.count !== undefined && data.loop.while !== undefined) {
-            throw new Error("Loop: Both count and while cannot be set");
+            throw new common_1.ValidationError("Loop: Both count and while cannot be set");
         }
     }
     if (data.concurrency !== undefined) {
         if (!Number.isInteger(data.concurrency)) {
-            throw new Error("Concurrency must be an integer");
+            throw new common_1.ValidationError("Concurrency must be an integer");
         }
         if (data.concurrency < 1) {
-            throw new Error("Concurrency must be a positive integer");
+            throw new common_1.ValidationError("Concurrency must be a positive integer");
         }
     }
 };

package/lib/validators/nodeValidator.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeValidator = void 0;
+const common_1 = require("../validators/common");
 const nodeValidator = (nodeData) => {
     if (nodeData.agent && nodeData.value) {
-        throw new Error("Cannot set both agent and value");
+        throw new common_1.ValidationError("Cannot set both agent and value");
     }
     if (!("agent" in nodeData) && !("value" in nodeData)) {
-        throw new Error("Either agent or value is required");
+        throw new common_1.ValidationError("Either agent or value is required");
     }
     return true;
 };