@ai.ntellect/core 0.8.2 → 0.8.3

package/test/graph/controller.test.ts

@@ -2,21 +2,29 @@ import { expect } from "chai";
 import { z } from "zod";
 import { GraphController } from "../../graph/controller";
 import { GraphFlow } from "../../graph/index";
-import { GraphNodeConfig } from "../../types";
+import { GraphContext, GraphNodeConfig } from "../../types";
 
 describe("GraphController", () => {
   const TestSchema = z.object({
     counter: z.number(),
     message: z.string(),
+    value: z.number().optional(),
+    prefix: z.string().optional(),
   });
 
   const createTestGraph = (name: string): GraphFlow<typeof TestSchema> => {
     const nodes: GraphNodeConfig<typeof TestSchema>[] = [
       {
         name: "start",
-        execute: async (context, params) => {
-          context.counter = params?.value ?? 0;
-          context.message = params?.prefix ? `${params.prefix}-${name}` : name;
+        execute: async (context) => {
+          if (context.value !== undefined) {
+            context.counter = context.value;
+          }
+          if (context.prefix) {
+            context.message = `${context.prefix}-${name}`;
+          } else {
+            context.message = name;
+          }
         },
       },
       {
@@ -36,23 +44,21 @@ describe("GraphController", () => {
   };
 
   describe("Sequential Execution", () => {
-    it("should execute graphs sequentially with different params and params", async () => {
+    it("should execute graphs sequentially with different contexts", 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 contexts = [
+        { value: 10, prefix: "test1" },
+        { value: 20, prefix: "test2" },
+        { value: 30, prefix: "test3" },
       ];
 
       const results = await GraphController.executeSequential(
         [graph1, graph2, graph3],
         ["start", "start", "start"],
-        params.map((value, i) => ({ ...value, prefix: params2[i].prefix }))
+        contexts
       );
 
       expect(results).to.have.length(3);
@@ -66,7 +72,7 @@ describe("GraphController", () => {
       expect(results[0].nodeName).to.equal("start");
     });
 
-    it("should handle missing params and params gracefully", async () => {
+    it("should handle missing contexts gracefully", async () => {
       const graph1 = createTestGraph("graph1");
       const graph2 = createTestGraph("graph2");
 
@@ -89,7 +95,7 @@ describe("GraphController", () => {
         createTestGraph(`graph${i + 1}`)
       );
 
-      const params = Array.from({ length: 5 }, (_, i) => ({
+      const contexts = Array.from({ length: 5 }, (_, i) => ({
         value: (i + 1) * 10,
         prefix: `test${i + 1}`,
       }));
@@ -106,7 +112,7 @@ describe("GraphController", () => {
         graphs,
         Array(5).fill("start"),
         2,
-        params
+        contexts
       );
       const executionTime = Date.now() - startTime;
 
@@ -188,4 +194,43 @@ describe("GraphController", () => {
       ]);
     });
   });
+
+  it("should wait for correlated events", async function () {
+    const graph = new GraphFlow({
+      name: "test",
+      schema: TestSchema,
+      nodes: [
+        {
+          name: "correlatedEventsNode",
+          when: {
+            events: ["eventA", "eventB"],
+            timeout: 1000,
+            strategy: {
+              type: "correlate",
+              correlation: (events) => {
+                const eventA = events.find((e) => e.type === "eventA");
+                const eventB = events.find((e) => e.type === "eventB");
+                return eventA?.payload?.id === eventB?.payload?.id;
+              },
+            },
+          },
+          execute: async (context: GraphContext<typeof TestSchema>) => {
+            context.message = "Correlated events received";
+          },
+        },
+      ],
+      context: { value: 0, counter: 0, message: "" },
+    });
+
+    const execution = graph.execute("correlatedEventsNode");
+
+    // Émettre les événements corrélés
+    setTimeout(() => {
+      graph.emit("eventA", { id: "123", status: "completed" });
+      graph.emit("eventB", { id: "123", status: "available" });
+    }, 100);
+
+    await execution;
+    expect(graph.getContext().message).to.equal("Correlated events received");
+  });
 });

package/test/graph/index.test.ts

@@ -5,7 +5,6 @@ import sinon from "sinon";
 import { z } from "zod";
 import { GraphController } from "../../graph/controller";
 import { GraphFlow } from "../../graph/index";
-import { NodeParams } from "../../graph/node";
 import { GraphConfig, GraphContext, GraphNodeConfig } from "../../types";
 
 use(chaiAsPromised);
@@ -19,7 +18,7 @@ use(chaiAsPromised);
  * - eventPayload: optional object containing transaction metadata
  */
 const TestSchema = z.object({
-  value: z.number().default(0),
+  value: z.number().min(0).default(0),
   counter: z.number().default(0),
   message: z.string().default(""),
   eventPayload: z
@@ -165,10 +164,9 @@ describe("GraphFlow", function () {
 
       graph.addNode(simpleNode);
       await graph.execute("simpleNode", invalidContext as any);
-    } catch (error) {
-      expect((error as Error & { errors: any[] }).errors[0].message).to.include(
-        "Expected number"
-      );
+      expect.fail("Should have thrown an error");
+    } catch (error: any) {
+      expect(error.message).to.include("Expected number");
     }
   });
 
@@ -181,23 +179,22 @@ describe("GraphFlow", function () {
    * Ensures type safety and data consistency in node interactions
    */
   it("should execute a node with validated params and outputs", async function () {
-    const paramNode: GraphNodeConfig<TestSchema, { increment: number }> = {
-      name: "paramNode",
-      params: z.object({
-        increment: z.number(),
-      }),
-      execute: async (context, params?: { increment: number }) => {
-        if (!params) throw new Error("params required");
-        context.value = (context.value ?? 0) + params.increment;
-      },
-      next: [],
-    };
-
-    graph.addNode(paramNode);
-    await graph.execute("paramNode", { increment: 5 });
+    const graph = new GraphFlow({
+      name: "test",
+      schema: TestSchema,
+      nodes: [
+        {
+          name: "validatedNode",
+          execute: async (context: GraphContext<TestSchema>) => {
+            context.value = 5;
+          },
+        },
+      ],
+      context: { value: 0, counter: 0, message: "" },
+    });
 
-    const context = graph.getContext();
-    expect(context.value).to.equal(5);
+    await graph.execute("validatedNode");
+    expect(graph.getContext().value).to.equal(5);
   });
 
   /**
@@ -307,93 +304,107 @@ describe("GraphFlow", function () {
    * Tests input validation error handling
    */
   it("should throw error when node input validation fails", async () => {
-    const node: GraphNodeConfig<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({
       name: "test",
       schema: TestSchema,
-      context: { value: 0 },
-      nodes: [node],
+      nodes: [
+        {
+          name: "test",
+          execute: async (context: GraphContext<TestSchema>) => {
+            context.value = -1;
+          },
+        },
+      ],
+      context: { value: 0, counter: 0, message: "" },
     });
 
     try {
       await graph.execute("test", { value: -1 });
       expect.fail("Should have thrown an error");
     } catch (error: any) {
-      expect(error.message).to.include("Number must be greater than or equal");
+      expect(error.message).to.include(
+        "Number must be greater than or equal to 0"
+      );
     }
   });
+
   /**
    * Tests successful input/output validation flow
    */
-  it("should successfully validate both params and outputs", async function () {
+  it("should execute a node with validated context", async function () {
     const graph = new GraphFlow({
       name: "test",
       schema: TestSchema,
       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;
+          execute: async (context: GraphContext<TestSchema>) => {
+            context.value = 5;
           },
         },
       ],
       context: { value: 0, counter: 0, message: "" },
     });
 
-    // Test avec valeur valide
-    await graph.execute("validatedNode", { increment: 3 });
-    expect(graph.getContext().value).to.equal(3);
-
-    // Test avec valeur invalide
-    await expect(
-      graph.execute("validatedNode", { increment: 10 })
-    ).to.be.rejectedWith("Number must be less than or equal to 5");
+    await graph.execute("validatedNode");
+    expect(graph.getContext().value).to.equal(5);
   });
 
-  /**
-   * Tests handling of missing required params
-   */
-  it("should throw error when required params are missing", async function () {
+  it("should throw error when required context values are missing", async function () {
     const graph = new GraphFlow({
       name: "test",
       schema: TestSchema,
       nodes: [
         {
           name: "requiredInputNode",
-          params: z.object({
-            value: z.number(),
-          }),
-          execute: async (
-            context: GraphContext<TestSchema>,
-            params?: NodeParams
-          ) => {
-            context.counter = params?.value || 0;
+          execute: async (context: GraphContext<TestSchema>) => {
+            if (context.value === undefined) {
+              throw new Error("Value is required");
+            }
+            context.counter = context.value;
           },
         },
       ],
       context: { value: 0, counter: 0, message: "" },
     });
 
-    await expect(graph.execute("requiredInputNode")).to.be.rejectedWith(
-      "Params required for node"
-    );
+    try {
+      graph["context"].value = undefined;
+      await graph.execute("requiredInputNode");
+      throw new Error("Should have thrown an error");
+    } catch (error: any) {
+      expect(error.message).to.equal("Value is required");
+    }
+  });
+
+  it("should validate context against schema constraints", async () => {
+    const graph = new GraphFlow({
+      name: "test",
+      schema: TestSchema,
+      nodes: [
+        {
+          name: "validationNode",
+          execute: async (context: GraphContext<TestSchema>) => {
+            const newContext = { ...context, value: -1 };
+            const validationResult = TestSchema.safeParse(newContext);
+            if (!validationResult.success) {
+              throw new Error(validationResult.error.errors[0].message);
+            }
+            graph["context"] = newContext;
+          },
+        },
+      ],
+      context: { value: 0, counter: 0, message: "" },
+    });
+
+    try {
+      await graph.execute("validationNode");
+      throw new Error("Should have thrown an error");
+    } catch (error: any) {
+      expect(error.message).to.include(
+        "Number must be greater than or equal to 0"
+      );
+    }
   });
 
   /**
@@ -629,58 +640,42 @@ describe("GraphFlow", function () {
     expect(result.value).to.equal(6); // 1 (waitingNode) + 5 (finalNode)
   });
 
-  // Test de validation des paramètres
-  it("should successfully validate params", async () => {
+  it("should wait for correlated events", async function () {
     const graph = new GraphFlow({
       name: "test",
       schema: TestSchema,
       nodes: [
         {
-          name: "validationNode",
-          params: z.object({
-            value: z.number().max(10),
-          }),
-          execute: async (
-            context: GraphContext<TestSchema>,
-            params?: NodeParams
-          ) => {
-            context.counter = params?.value || 0;
+          name: "correlatedEventsNode",
+          when: {
+            events: ["eventA", "eventB"],
+            timeout: 1000,
+            strategy: {
+              type: "correlate",
+              correlation: (events) => {
+                const eventA = events.find((e) => e.type === "eventA");
+                const eventB = events.find((e) => e.type === "eventB");
+                return eventA?.payload?.id === eventB?.payload?.id;
+              },
+            },
+          },
+          execute: async (context: GraphContext<TestSchema>) => {
+            context.message = "Correlated events received";
           },
         },
       ],
       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");
-  });
+    const execution = graph.execute("correlatedEventsNode");
 
-  // Test des paramètres requis
-  it("should throw error when required params are missing", async () => {
-    const graph = new GraphFlow({
-      name: "test",
-      schema: TestSchema,
-      nodes: [
-        {
-          name: "requiredInputNode",
-          params: z.object({
-            value: z.number(),
-          }),
-          execute: async (
-            context: GraphContext<TestSchema>,
-            params?: NodeParams
-          ) => {
-            context.counter = params?.value || 0;
-          },
-        },
-      ],
-      context: { value: 0, counter: 0, message: "" },
-    });
+    // Émettre les événements corrélés
+    setTimeout(() => {
+      graph.emit("eventA", { id: "123", status: "completed" });
+      graph.emit("eventB", { id: "123", status: "available" });
+    }, 100);
 
-    await expect(graph.execute("requiredInputNode")).to.be.rejectedWith(
-      "Params required for node"
-    );
+    await execution;
+    expect(graph.getContext().message).to.equal("Correlated events received");
   });
 });