@ai.ntellect/core 0.7.5 → 0.7.7

package/test/graph/index.test.ts

@@ -1,19 +1,27 @@
-import { expect } from "chai";
+import { expect, use } from "chai";
+import chaiAsPromised from "chai-as-promised";
 import EventEmitter from "events";
 import sinon from "sinon";
 import { z } from "zod";
 import { GraphController } from "../../graph/controller";
 import { GraphFlow } from "../../graph/index";
+import { NodeParams } from "../../graph/node";
 import { GraphContext, GraphDefinition, Node } from "../../types";
 
+use(chaiAsPromised);
+
 /**
  * Test schema definition using Zod for graph context validation
  * Defines a schema with:
  * - value: numeric value for tracking state changes
+ * - counter: numeric value for tracking state changes
+ * - message: string for tracking state changes
  * - eventPayload: optional object containing transaction metadata
  */
 const TestSchema = z.object({
   value: z.number().default(0),
+  counter: z.number().default(0),
+  message: z.string().default(""),
   eventPayload: z
     .object({
       transactionId: z.string().optional(),
@@ -172,17 +180,15 @@ describe("GraphFlow", function () {
    * - Integration between node execution and validation
    * Ensures type safety and data consistency in node interactions
    */
-  it("should execute a node with validated inputs and outputs", async function () {
+  it("should execute a node with validated params and outputs", async function () {
     const paramNode: Node<TestSchema, { increment: number }> = {
       name: "paramNode",
-      inputs: z.object({
+      params: z.object({
         increment: z.number(),
       }),
-      outputs: z.object({
-        value: z.number().min(5),
-      }),
-      execute: async (context, inputs: { increment: number }) => {
-        context.value = (context.value ?? 0) + inputs.increment;
+      execute: async (context, params?: { increment: number }) => {
+        if (!params) throw new Error("params required");
+        context.value = (context.value ?? 0) + params.increment;
       },
       next: [],
     };
@@ -230,30 +236,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 +307,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",
+      params: z.object({
+        value: z.number().min(0),
+      }),
+      execute: async (context, params) => {
+        if (!params) throw new Error("params required");
+        context.value = params.value;
+      },
+    };
 
     const graph = new GraphFlow("test", {
       name: "test",
       schema: TestSchema,
       context: { value: 0 },
-      nodes: [
-        {
-          name: "test",
-          inputs: InputSchema,
-          execute: async () => {},
-        },
-      ],
+      nodes: [node],
     });
 
     try {
@@ -324,90 +332,68 @@ describe("GraphFlow", function () {
       expect(error.message).to.include("Number must be greater than or equal");
     }
   });
-
-  /**
-   * Tests output validation error handling
-   */
-  it("should throw error when node output validation fails", async function () {
-    const nodeWithOutput: Node<TestSchema> = {
-      name: "outputNode",
-      outputs: z.object({
-        value: z.number().max(10),
-      }),
-      execute: async (context) => {
-        context.value = 20; // This will fail output validation
-      },
-      next: [],
-    };
-
-    graph.addNode(nodeWithOutput);
-
-    try {
-      await graph.execute("outputNode");
-      expect.fail("Should have thrown an error");
-    } catch (error) {
-      expect((error as Error).message).to.include(
-        "Number must be less than or equal to 10"
-      );
-    }
-  });
-
   /**
    * Tests successful input/output validation flow
    */
-  it("should successfully validate both inputs and outputs", async function () {
-    const validatedNode: Node<TestSchema, { increment: number }> = {
-      name: "validatedNode",
-      inputs: z.object({
-        increment: z.number().min(0).max(5),
-      }),
-      outputs: z.object({
-        value: z.number().min(0).max(10),
-      }),
-      execute: async (context, inputs: { increment: number }) => {
-        context.value = (context.value ?? 0) + inputs.increment;
-      },
-      next: [],
-    };
-
-    graph.addNode(validatedNode);
+  it("should successfully validate both params and outputs", async function () {
+    const graph = new GraphFlow("test", {
+      name: "test",
+      nodes: [
+        {
+          name: "validatedNode",
+          params: z.object({
+            increment: z.number().min(0).max(5),
+          }),
+          execute: async (
+            context: GraphContext<TestSchema>,
+            params?: NodeParams
+          ) => {
+            if (!params) throw new Error("params required");
+            context.value = (context.value ?? 0) + params.increment;
+          },
+        },
+      ],
+      schema: TestSchema,
+      context: { value: 0, counter: 0, message: "" },
+    });
 
-    // Test with valid input that produces valid output
+    // Test avec valeur valide
     await graph.execute("validatedNode", { increment: 3 });
     expect(graph.getContext().value).to.equal(3);
 
-    // Test with valid input that would produce invalid output
-    try {
-      await graph.execute("validatedNode", { increment: 5 }, { value: 7 });
-      expect.fail("Should have thrown an error");
-    } catch (error) {
-      expect((error as Error).message).to.include(
-        "Number must be less than or equal to 10"
-      );
-    }
+    // Test avec valeur invalide
+    await expect(
+      graph.execute("validatedNode", { increment: 10 })
+    ).to.be.rejectedWith("Number must be less than or equal to 5");
   });
 
   /**
-   * Tests handling of missing required inputs
+   * Tests handling of missing required params
    */
-  it("should throw error when required inputs are missing", async function () {
-    const nodeWithRequiredInput: Node<TestSchema, { required: string }> = {
-      name: "requiredInputNode",
-      inputs: z.object({
-        required: z.string(),
-      }),
-      execute: async () => {},
-      next: [],
-    };
-
-    graph.addNode(nodeWithRequiredInput);
+  it("should throw error when required params are missing", async function () {
+    const graph = new GraphFlow("test", {
+      name: "test",
+      nodes: [
+        {
+          name: "requiredInputNode",
+          params: z.object({
+            value: z.number(),
+          }),
+          execute: async (
+            context: GraphContext<TestSchema>,
+            params?: NodeParams
+          ) => {
+            context.counter = params?.value || 0;
+          },
+        },
+      ],
+      schema: TestSchema,
+      context: { value: 0, counter: 0, message: "" },
+    });
 
-    try {
-      await graph.execute("requiredInputNode");
-      expect.fail("Should have thrown an error");
-    } catch (error) {
-      expect((error as Error).message).to.include("Inputs required for node");
-    }
+    await expect(graph.execute("requiredInputNode")).to.be.rejectedWith(
+      "Params required for node"
+    );
   });
 
   /**
@@ -724,4 +710,59 @@ describe("GraphFlow", function () {
     const result = await resultPromise;
     expect(result.value).to.equal(6); // 1 (waitingNode) + 5 (finalNode)
   });
+
+  // Test de validation des paramètres
+  it("should successfully validate params", async () => {
+    const graph = new GraphFlow("test", {
+      name: "test",
+      nodes: [
+        {
+          name: "validationNode",
+          params: z.object({
+            value: z.number().max(10),
+          }),
+          execute: async (
+            context: GraphContext<TestSchema>,
+            params?: NodeParams
+          ) => {
+            context.counter = params?.value || 0;
+          },
+        },
+      ],
+      schema: TestSchema,
+      context: { value: 0, counter: 0, message: "" },
+    });
+
+    // Test avec valeur invalide
+    await expect(
+      graph.execute("validationNode", { value: 20 })
+    ).to.be.rejectedWith("Number must be less than or equal to 10");
+  });
+
+  // Test des paramètres requis
+  it("should throw error when required params are missing", async () => {
+    const graph = new GraphFlow("test", {
+      name: "test",
+      nodes: [
+        {
+          name: "requiredInputNode",
+          params: z.object({
+            value: z.number(),
+          }),
+          execute: async (
+            context: GraphContext<TestSchema>,
+            params?: NodeParams
+          ) => {
+            context.counter = params?.value || 0;
+          },
+        },
+      ],
+      schema: TestSchema,
+      context: { value: 0, counter: 0, message: "" },
+    });
+
+    await expect(graph.execute("requiredInputNode")).to.be.rejectedWith(
+      "Params required for node"
+    );
+  });
 });

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,313 @@ 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
+  });
+
+  it("should validate node parameters with Zod schema", async () => {
+    const paramSchema = z.object({
+      increment: z.number().min(1),
+      message: z.string().min(1),
+    });
+
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      params: paramSchema,
+      execute: async (context: TestContext, params?: NodeParams) => {
+        context.counter += params?.increment || 0;
+        context.message = params?.message || "";
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    // Test avec des paramètres valides
+    await node.executeNode(
+      "test",
+      { counter: 0, message: "Hello" },
+      { increment: 5, message: "Valid" }
+    );
+
+    // Test avec des paramètres invalides
+    await expect(
+      node.executeNode(
+        "test",
+        { counter: 0, message: "Hello" },
+        { increment: 0, message: "" }
+      )
+    ).to.be.rejected; // Enlever le .with() car le message d'erreur vient directement de Zod
+  });
+
+  it("should work without params schema", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      execute: async (context: TestContext) => {
+        context.counter++;
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    // Devrait fonctionner sans erreur même sans schema de params
+    await node.executeNode("test", { counter: 0, message: "Hello" }, null);
+  });
+
+  it("should not require params when node has no params schema", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      // Pas de schéma de params défini
+      execute: async (context: TestContext) => {
+        context.counter++;
+      },
+    });
+
+    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(1);
+    expect(stateChanges[0].payload.newValue).to.equal(1);
+  });
+
+  it("should require params only when node has params schema", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      params: z.object({
+        // Avec un schéma de params
+        value: z.number(),
+      }),
+      execute: async (context: TestContext, params?: NodeParams) => {
+        context.counter = params?.value || 0;
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    // Devrait échouer sans params
+    await expect(
+      node.executeNode("test", { counter: 0, message: "Hello" }, null)
+    ).to.be.rejectedWith("Params required for node");
+  });
+
+  it("should execute node without params when no schema is defined (real world scenario)", async () => {
+    const nodes = new Map();
+    nodes.set("incrementCounter", {
+      name: "incrementCounter",
+      execute: async (context: TestContext) => {
+        context.counter++;
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    // Simuler l'appel comme dans examples/t2.ts
+    await node.executeNode(
+      "incrementCounter",
+      { message: "Hello", counter: 0 },
+      { test: "test" } // Passer des params même si non requis
+    );
+
+    const stateChanges = events.filter((e) => e.type === "nodeStateChanged");
+    expect(stateChanges).to.have.lengthOf(1);
+    expect(stateChanges[0].payload.newValue).to.equal(1);
+  });
+
+  it("should handle optional params schema", async () => {
+    const nodes = new Map();
+    nodes.set("test", {
+      name: "test",
+      params: z
+        .object({
+          test: z.string(),
+        })
+        .optional(),
+      execute: async (context: TestContext, params?: NodeParams) => {
+        context.counter++;
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    // Devrait fonctionner avec ou sans params
+    await node.executeNode(
+      "test",
+      { counter: 0, message: "Hello" },
+      { test: "test" }
+    );
+    await node.executeNode("test", { counter: 1, message: "Hello" }, null);
+
+    const stateChanges = events.filter((e) => e.type === "nodeStateChanged");
+    expect(stateChanges).to.have.lengthOf(2);
+    expect(stateChanges[1].payload.newValue).to.equal(2);
+  });
 });