@ai.ntellect/core 0.7.5 → 0.7.6

package/test/graph/controller.test.ts

@@ -0,0 +1,187 @@
+import { expect } from "chai";
+import { z } from "zod";
+import { GraphController } from "../../graph/controller";
+import { GraphFlow } from "../../graph/index";
+import { Node } from "../../types";
+
+describe("GraphController", () => {
+  const TestSchema = z.object({
+    counter: z.number(),
+    message: z.string(),
+  });
+
+  const createTestGraph = (name: string): GraphFlow<typeof TestSchema> => {
+    const nodes: Node<typeof TestSchema>[] = [
+      {
+        name: "start",
+        execute: async (context, params) => {
+          context.counter = params?.value ?? 0;
+          context.message = params?.prefix ? `${params.prefix}-${name}` : name;
+        },
+      },
+      {
+        name: "increment",
+        execute: async (context) => {
+          context.counter += 1;
+        },
+      },
+    ];
+
+    return new GraphFlow(name, {
+      name,
+      nodes,
+      schema: TestSchema,
+      context: { counter: 0, message: "" },
+    });
+  };
+
+  describe("Sequential Execution", () => {
+    it("should execute graphs sequentially with different params and params", async () => {
+      const graph1 = createTestGraph("graph1");
+      const graph2 = createTestGraph("graph2");
+      const graph3 = createTestGraph("graph3");
+
+      const params = [{ value: 10 }, { value: 20 }, { value: 30 }];
+
+      const params2 = [
+        { prefix: "test1" },
+        { prefix: "test2" },
+        { prefix: "test3" },
+      ];
+
+      const results = await GraphController.executeSequential(
+        [graph1, graph2, graph3],
+        ["start", "start", "start"],
+        params.map((value, i) => ({ ...value, prefix: params2[i].prefix }))
+      );
+
+      expect(results).to.have.length(3);
+      expect(results[0].counter).to.equal(10);
+      expect(results[1].counter).to.equal(20);
+      expect(results[2].counter).to.equal(30);
+      expect(results[0].message).to.equal("test1-graph1");
+      expect(results[1].message).to.equal("test2-graph2");
+      expect(results[2].message).to.equal("test3-graph3");
+    });
+
+    it("should handle missing params and params gracefully", async () => {
+      const graph1 = createTestGraph("graph1");
+      const graph2 = createTestGraph("graph2");
+
+      const results = await GraphController.executeSequential(
+        [graph1, graph2],
+        ["start", "start"]
+      );
+
+      expect(results).to.have.length(2);
+      expect(results[0].counter).to.equal(0);
+      expect(results[1].counter).to.equal(0);
+      expect(results[0].message).to.equal("graph1");
+      expect(results[1].message).to.equal("graph2");
+    });
+  });
+
+  describe("Parallel Execution", () => {
+    it("should execute graphs in parallel with concurrency limit", async () => {
+      const graphs = Array.from({ length: 5 }, (_, i) =>
+        createTestGraph(`graph${i + 1}`)
+      );
+
+      const params = Array.from({ length: 5 }, (_, i) => ({
+        value: (i + 1) * 10,
+        prefix: `test${i + 1}`,
+      }));
+
+      // Ajouter un délai dans l'exécution
+      const originalExecute = graphs[0].execute;
+      graphs[0].execute = async (...args) => {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        return originalExecute.apply(graphs[0], args);
+      };
+
+      const startTime = Date.now();
+      const results = await GraphController.executeParallel(
+        graphs,
+        Array(5).fill("start"),
+        2,
+        params
+      );
+      const executionTime = Date.now() - startTime;
+
+      expect(executionTime).to.be.greaterThan(0);
+      expect(results).to.have.length(5);
+      results.forEach((result, i) => {
+        expect(result.counter).to.equal((i + 1) * 10);
+        expect(result.message).to.equal(`test${i + 1}-graph${i + 1}`);
+      });
+    });
+
+    it("should handle errors in parallel execution", async () => {
+      const errorGraph = new GraphFlow("errorGraph", {
+        name: "errorGraph",
+        nodes: [
+          {
+            name: "start",
+            execute: async () => {
+              throw new Error("Test error");
+            },
+          },
+        ],
+        schema: TestSchema,
+        context: { counter: 0, message: "" },
+      });
+
+      const successGraph = createTestGraph("successGraph");
+
+      try {
+        await GraphController.executeParallel(
+          [errorGraph, successGraph],
+          ["start", "start"],
+          2
+        );
+        expect.fail("Should have thrown an error");
+      } catch (error: any) {
+        expect(error.message).to.equal("Test error");
+      }
+    });
+  });
+
+  describe("Complex Workflows", () => {
+    it("should handle mixed sequential and parallel execution", async () => {
+      const graphs = Array.from({ length: 4 }, (_, i) =>
+        createTestGraph(`graph${i + 1}`)
+      );
+
+      // Exécuter les deux premiers graphes en parallèle
+      const parallelResults = await GraphController.executeParallel(
+        graphs.slice(0, 2),
+        ["start", "start"],
+        2,
+        [
+          { value: 10, prefix: "parallel1" },
+          { value: 20, prefix: "parallel2" },
+        ]
+      );
+
+      // Puis exécuter les deux suivants séquentiellement
+      const sequentialResults = await GraphController.executeSequential(
+        graphs.slice(2),
+        ["start", "start"],
+        [
+          { value: 30, prefix: "seq1" },
+          { value: 40, prefix: "seq2" },
+        ]
+      );
+
+      const allResults = [...parallelResults, ...sequentialResults];
+      expect(allResults).to.have.length(4);
+      expect(allResults.map((r) => r.counter)).to.deep.equal([10, 20, 30, 40]);
+      expect(allResults.map((r) => r.message)).to.deep.equal([
+        "parallel1-graph1",
+        "parallel2-graph2",
+        "seq1-graph3",
+        "seq2-graph4",
+      ]);
+    });
+  });
+});

package/test/graph/index.test.ts

@@ -181,7 +181,8 @@ describe("GraphFlow", function () {
       outputs: z.object({
         value: z.number().min(5),
       }),
-      execute: async (context, inputs: { increment: number }) => {
+      execute: async (context, inputs?: { increment: number }) => {
+        if (!inputs) throw new Error("Inputs required");
         context.value = (context.value ?? 0) + inputs.increment;
       },
       next: [],
@@ -230,30 +231,31 @@ describe("GraphFlow", function () {
    */
   it("should retry a node execution when it fails", async () => {
     let attempts = 0;
-    const nodes = new Map();
-    nodes.set("test", {
-      name: "test",
-      execute: async () => {
+    const retryNode: Node<TestSchema> = {
+      name: "retryNode",
+      execute: async (context) => {
         attempts++;
         if (attempts < 3) {
           throw new Error("Temporary failure");
         }
+        context.value = 42;
       },
       retry: {
         maxAttempts: 3,
         delay: 100,
       },
-    });
+    };
 
     const graph = new GraphFlow("test", {
       name: "test",
       schema: TestSchema,
       context: { value: 0 },
-      nodes: Array.from(nodes.values()),
+      nodes: [retryNode],
     });
 
-    await graph.execute("test");
+    await graph.execute("retryNode");
     expect(attempts).to.equal(3);
+    expect(graph.getContext().value).to.equal(42);
   });
 
   /**
@@ -300,21 +302,22 @@ describe("GraphFlow", function () {
    * Tests input validation error handling
    */
   it("should throw error when node input validation fails", async () => {
-    const InputSchema = z.object({
-      value: z.number().min(0),
-    });
+    const node: Node<TestSchema> = {
+      name: "test",
+      inputs: z.object({
+        value: z.number().min(0),
+      }),
+      execute: async (context, inputs) => {
+        if (!inputs) throw new Error("Inputs required");
+        context.value = inputs.value;
+      },
+    };
 
     const graph = new GraphFlow("test", {
       name: "test",
       schema: TestSchema,
       context: { value: 0 },
-      nodes: [
-        {
-          name: "test",
-          inputs: InputSchema,
-          execute: async () => {},
-        },
-      ],
+      nodes: [node],
     });
 
     try {
@@ -356,6 +359,13 @@ describe("GraphFlow", function () {
    * Tests successful input/output validation flow
    */
   it("should successfully validate both inputs and outputs", async function () {
+    const graph = new GraphFlow("test", {
+      name: "test",
+      schema: TestSchema,
+      context: { value: 0 },
+      nodes: [],
+    });
+
     const validatedNode: Node<TestSchema, { increment: number }> = {
       name: "validatedNode",
       inputs: z.object({
@@ -364,7 +374,8 @@ describe("GraphFlow", function () {
       outputs: z.object({
         value: z.number().min(0).max(10),
       }),
-      execute: async (context, inputs: { increment: number }) => {
+      execute: async (context, inputs?: { increment: number }) => {
+        if (!inputs) throw new Error("Inputs required");
         context.value = (context.value ?? 0) + inputs.increment;
       },
       next: [],

package/test/graph/node.test.ts

@@ -5,7 +5,7 @@ import { BehaviorSubject, Subject } from "rxjs";
 import { z } from "zod";
 import { GraphEventManager } from "../../graph/event-manager";
 import { GraphLogger } from "../../graph/logger";
-import { GraphNode } from "../../graph/node";
+import { GraphNode, NodeParams } from "../../graph/node";
 import { GraphContext } from "../../types";
 
 use(chaiAsPromised);
@@ -107,7 +107,7 @@ describe("GraphNode", () => {
     const nodes = new Map();
     nodes.set("test", {
       name: "test",
-      execute: async (_context: TestContext) => {
+      execute: async () => {
         throw new Error("Test error");
       },
     });
@@ -121,13 +121,17 @@ describe("GraphNode", () => {
     );
 
     try {
-      await node.executeNode("test", { counter: 0, message: "Hello" }, null);
-      expect.fail("Should have thrown an error");
+      await node.executeNode(
+        "test",
+        { counter: 0, message: "Hello" },
+        null,
+        false
+      );
+      expect.fail("Test error");
     } catch (error: any) {
       expect(error.message).to.equal("Test error");
       const errorEvents = events.filter((e) => e.type === "nodeError");
       expect(errorEvents).to.have.lengthOf(1);
-      expect(errorEvents[0].payload.error.message).to.equal("Test error");
     }
   });
 
@@ -175,7 +179,7 @@ describe("GraphNode", () => {
     const nodes = new Map();
     nodes.set("test", {
       name: "test",
-      execute: async (context: TestContext) => {
+      execute: async (context: TestContext, inputs?: any) => {
         context.counter = context.counter; // Même valeur
         context.message = "New"; // Nouvelle valeur
       },
@@ -194,4 +198,135 @@ describe("GraphNode", () => {
     expect(stateChanges).to.have.lengthOf(1); // Seulement pour message
     expect(stateChanges[0].payload.property).to.equal("message");
   });
+
+  it("should execute node with parameters", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      execute: async (context: TestContext, inputs?: any) => {
+        context.counter = inputs?.value ?? 0;
+        context.message = inputs?.message ?? "Default";
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    await node.executeNode(
+      "test",
+      { counter: 0, message: "Hello" },
+      { value: 5, message: "Custom" },
+      false
+    );
+
+    const stateChanges = events.filter((e) => e.type === "nodeStateChanged");
+    expect(stateChanges).to.have.lengthOf(2);
+    expect(stateChanges[0].payload.newValue).to.equal(5);
+    expect(stateChanges[1].payload.newValue).to.equal("Custom");
+  });
+
+  it("should use default values when no parameters provided", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      execute: async (
+        context: TestContext,
+        _inputs: any,
+        params?: NodeParams
+      ) => {
+        context.counter = params?.increment || 1;
+        context.message = params?.message || "Default";
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    await node.executeNode("test", { counter: 0, message: "Hello" }, null);
+
+    const stateChanges = events.filter((e) => e.type === "nodeStateChanged");
+    expect(stateChanges).to.have.lengthOf(2);
+    expect(stateChanges[0].payload.newValue).to.equal(1); // counter (default)
+    expect(stateChanges[1].payload.newValue).to.equal("Default"); // message (default)
+  });
+
+  it("should properly handle node inputs", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      execute: async (context: TestContext, inputs: any) => {
+        context.counter = inputs.value;
+        context.message = inputs.message;
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    const testInputs = {
+      value: 42,
+      message: "Test Input",
+    };
+
+    await node.executeNode(
+      "test",
+      { counter: 0, message: "Hello" },
+      testInputs
+    );
+
+    const stateChanges = events.filter((e) => e.type === "nodeStateChanged");
+    expect(stateChanges).to.have.lengthOf(2);
+    expect(stateChanges[0].payload.newValue).to.equal(42); // counter from input
+    expect(stateChanges[1].payload.newValue).to.equal("Test Input"); // message from input
+  });
+
+  it("should not emit duplicate state changes", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      execute: async (context: TestContext) => {
+        context.counter = 1; // Valeur fixe au lieu d'incrémentations
+        context.counter = 1; // Même valeur
+        context.message = "New";
+        context.message = "New"; // Même valeur
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    await node.executeNode("test", { counter: 0, message: "Hello" }, null);
+
+    // Vérifier qu'il n'y a pas de doublons dans les événements
+    const stateChanges = events.filter((e) => e.type === "nodeStateChanged");
+    const uniqueChanges = new Set(
+      stateChanges.map(
+        (e) =>
+          `${e.payload.property}-${e.payload.oldValue}-${e.payload.newValue}`
+      )
+    );
+
+    expect(stateChanges.length).to.equal(uniqueChanges.size);
+    expect(stateChanges).to.have.lengthOf(2); // Un pour counter, un pour message
+  });
 });

package/types/index.ts

@@ -86,12 +86,9 @@ export interface Node<T extends ZodSchema, I = any> {
   /** Schema for node outputs */
   outputs?: ZodSchema;
   /** Execute function for the node */
-  execute: (
-    context: GraphContext<T>,
-    inputs: I extends void ? never : I
-  ) => Promise<void>;
+  execute: (context: GraphContext<T>, params?: I) => Promise<void>;
   /** Optional condition for node execution */
-  condition?: (context: GraphContext<T>) => boolean;
+  condition?: (context: GraphContext<T>, params?: I) => boolean;
   /** Array of next node names */
   next?: string[] | ((context: GraphContext<T>) => string[]);
   /** Array of event names that trigger this node */