@ai.ntellect/core 0.7.6 → 0.7.8

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,18 +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 }) => {
-        if (!inputs) throw new Error("Inputs required");
-        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: [],
     };
@@ -304,12 +309,12 @@ describe("GraphFlow", function () {
   it("should throw error when node input validation fails", async () => {
     const node: Node<TestSchema> = {
       name: "test",
-      inputs: z.object({
+      params: z.object({
         value: z.number().min(0),
       }),
-      execute: async (context, inputs) => {
-        if (!inputs) throw new Error("Inputs required");
-        context.value = inputs.value;
+      execute: async (context, params) => {
+        if (!params) throw new Error("params required");
+        context.value = params.value;
       },
     };
 
@@ -327,98 +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 () {
+  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 },
-      nodes: [],
+      context: { value: 0, counter: 0, message: "" },
     });
 
-    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 }) => {
-        if (!inputs) throw new Error("Inputs required");
-        context.value = (context.value ?? 0) + inputs.increment;
-      },
-      next: [],
-    };
-
-    graph.addNode(validatedNode);
-
-    // 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"
+    );
   });
 
   /**
@@ -616,90 +591,6 @@ describe("GraphFlow", function () {
     expect(results[1].value).to.equal(5); // Graph2: 3 + 2
   });
 
-  /**
-   * Tests event correlation functionality
-   * Demonstrates:
-   * - Event correlation based on transaction ID
-   * - Timeout handling
-   * - Multiple event synchronization
-   * - Context updates after correlation
-   * Critical for integrating with external event sources
-   */
-  it("should handle correlated events correctly", async function () {
-    this.timeout(10000);
-    const graph = new GraphFlow("test", {
-      name: "test",
-      nodes: [],
-      context: { value: 0 },
-      schema: TestSchema,
-      eventEmitter: new EventEmitter(),
-    });
-
-    let eventsReceived = 0;
-    const node = {
-      name: "testNode",
-      waitForEvents: {
-        events: ["eventA", "eventB"],
-        timeout: 5000,
-        strategy: "all" as const,
-      },
-      execute: async (context: GraphContext<typeof TestSchema>) => {
-        eventsReceived = 2;
-        context.value = 42;
-      },
-    };
-
-    graph.addNode(node);
-
-    graph.execute("testNode");
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-
-    await graph.emit("eventA", { eventPayload: { status: "A" } });
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    await graph.emit("eventB", { eventPayload: { status: "B" } });
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(eventsReceived).to.equal(2);
-    expect(graph.getContext().value).to.equal(42);
-  });
-
-  /**
-   * Tests multiple event waiting functionality
-   */
-  it("should wait for multiple events before continuing", async function () {
-    this.timeout(10000);
-    const graph = new GraphFlow("test", {
-      name: "test",
-      nodes: [],
-      context: { value: 0 },
-      schema: TestSchema,
-      eventEmitter: new EventEmitter(),
-    });
-
-    const node = {
-      name: "testNode",
-      waitForEvents: {
-        events: ["event1", "event2"],
-        timeout: 5000,
-        strategy: "all" as const,
-      },
-      execute: async (context: GraphContext<typeof TestSchema>) => {
-        context.value = 42; // Ajouter une modification du contexte
-      },
-    };
-
-    graph.addNode(node);
-    graph.execute("testNode");
-
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    await graph.emit("event1", { eventPayload: { status: "1" } });
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    await graph.emit("event2", { eventPayload: { status: "2" } });
-    expect(graph.getContext().value).to.equal(42);
-  });
-
   /**
    * Tests single event waiting functionality
    */
@@ -735,4 +626,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

@@ -329,4 +329,327 @@ describe("GraphNode", () => {
     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);
+  });
+
+  it("should wait for events before executing node", async () => {
+    const nodes = new Map();
+    nodes.set("waitForEventsNode", {
+      name: "waitForEventsNode",
+      waitForEvents: {
+        events: ["event1", "event2"],
+        timeout: 1000,
+        strategy: "all",
+      },
+      execute: async (context: TestContext) => {
+        context.message = "Events received";
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    // Lancer l'exécution du nœud
+    const execution = node.executeNode(
+      "waitForEventsNode",
+      { counter: 0, message: "Hello" },
+      null
+    );
+
+    // Simuler les événements après un court délai
+    setTimeout(() => {
+      eventEmitter.emit("event1", { data: "test1" });
+      eventEmitter.emit("event2", { data: "test2" });
+    }, 100);
+
+    await execution;
+
+    const stateChanges = events.filter((e) => e.type === "nodeStateChanged");
+    expect(stateChanges).to.have.lengthOf(1);
+    expect(stateChanges[0].payload.newValue).to.equal("Events received");
+  });
+
+  it("should timeout if events are not received", async () => {
+    const nodes = new Map();
+    nodes.set("timeoutNode", {
+      name: "timeoutNode",
+      waitForEvents: {
+        events: ["event1", "event2"],
+        timeout: 100,
+        strategy: "all",
+      },
+      execute: async (context: TestContext) => {
+        context.message = "Should not execute";
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    await expect(
+      node.executeNode("timeoutNode", { counter: 0, message: "Hello" }, null)
+    ).to.be.rejectedWith("Timeout waiting for events");
+  });
+
+  it("should handle partial event reception", async () => {
+    const nodes = new Map();
+    nodes.set("partialEventsNode", {
+      name: "partialEventsNode",
+      waitForEvents: {
+        events: ["event1", "event2"],
+        timeout: 1000,
+        strategy: "all",
+      },
+      execute: async (context: TestContext) => {
+        context.message = "All events received";
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    const execution = node.executeNode(
+      "partialEventsNode",
+      { counter: 0, message: "Hello" },
+      null
+    );
+
+    // N'émettre qu'un seul événement
+    setTimeout(() => {
+      eventEmitter.emit("event1", { data: "test1" });
+    }, 100);
+
+    await expect(execution).to.be.rejectedWith("Timeout waiting for events");
+  });
+
+  it("should handle correlated events", (done) => {
+    const nodes = new Map();
+    nodes.set("correlatedEventsNode", {
+      name: "correlatedEventsNode",
+      correlateEvents: {
+        events: ["payment", "stock"],
+        timeout: 1000,
+        correlation: (events: Array<{ type: string; payload?: any }>) => {
+          const paymentEvent = events.find((e) => e.type === "payment");
+          const stockEvent = events.find((e) => e.type === "stock");
+          return paymentEvent?.payload?.id === stockEvent?.payload?.id;
+        },
+      },
+      execute: (context: TestContext) => {
+        context.message = "Correlated events received";
+        done();
+        return Promise.resolve();
+      },
+    });
+
+    node = new GraphNode(
+      nodes,
+      logger,
+      eventManager,
+      eventSubject,
+      stateSubject
+    );
+
+    node.executeNode(
+      "correlatedEventsNode",
+      { counter: 0, message: "Hello" },
+      null
+    );
+
+    setTimeout(() => {
+      eventEmitter.emit("payment", { id: "123", status: "completed" });
+      eventEmitter.emit("stock", { id: "123", status: "available" });
+    }, 100);
+  });
 });