@ai.ntellect/core 0.8.0 → 0.8.2

package/test/graph/index.test.ts

@@ -51,11 +51,11 @@ describe("GraphFlow", function () {
 
   beforeEach(() => {
     eventEmitter = new EventEmitter();
-    graph = new GraphFlow("TestGraph", {
+    graph = new GraphFlow({
       name: "TestGraph",
+      schema: TestSchema,
       nodes: [],
       context: { value: 0 },
-      schema: TestSchema,
       eventEmitter: eventEmitter,
     });
   });
@@ -251,8 +251,8 @@ describe("GraphFlow", function () {
       },
     };
 
-    const graph = new GraphFlow("test", {
-      name: "test",
+    const graph = new GraphFlow({
+      name: "retryGraph",
       schema: TestSchema,
       context: { value: 0 },
       nodes: [retryNode],
@@ -292,10 +292,10 @@ describe("GraphFlow", function () {
 
     const newDefinition: GraphConfig<TestSchema> = {
       name: "TestGraph",
-      entryNode: "A",
+      schema: TestSchema,
       nodes: [nodeA, nodeB],
       context: { value: 0 },
-      schema: TestSchema,
+      entryNode: "A",
     };
 
     graph.load(newDefinition);
@@ -318,7 +318,7 @@ describe("GraphFlow", function () {
       },
     };
 
-    const graph = new GraphFlow("test", {
+    const graph = new GraphFlow({
       name: "test",
       schema: TestSchema,
       context: { value: 0 },
@@ -336,8 +336,9 @@ describe("GraphFlow", function () {
    * Tests successful input/output validation flow
    */
   it("should successfully validate both params and outputs", async function () {
-    const graph = new GraphFlow("test", {
+    const graph = new GraphFlow({
       name: "test",
+      schema: TestSchema,
       nodes: [
         {
           name: "validatedNode",
@@ -353,7 +354,6 @@ describe("GraphFlow", function () {
           },
         },
       ],
-      schema: TestSchema,
       context: { value: 0, counter: 0, message: "" },
     });
 
@@ -371,8 +371,9 @@ describe("GraphFlow", function () {
    * Tests handling of missing required params
    */
   it("should throw error when required params are missing", async function () {
-    const graph = new GraphFlow("test", {
+    const graph = new GraphFlow({
       name: "test",
+      schema: TestSchema,
       nodes: [
         {
           name: "requiredInputNode",
@@ -387,7 +388,6 @@ describe("GraphFlow", function () {
           },
         },
       ],
-      schema: TestSchema,
       context: { value: 0, counter: 0, message: "" },
     });
 
@@ -483,11 +483,11 @@ describe("GraphFlow", function () {
    */
   it("should handle parallel workflows using GraphController", async function () {
     // Graph 1
-    const graph1 = new GraphFlow("Graph1", {
+    const graph1 = new GraphFlow({
       name: "Graph1",
-      nodes: [],
-      context: { value: 0 },
       schema: TestSchema,
+      context: { value: 0 },
+      nodes: [],
     });
 
     const processNode1: GraphNodeConfig<TestSchema> = {
@@ -506,11 +506,11 @@ describe("GraphFlow", function () {
     };
 
     // Graph 2
-    const graph2 = new GraphFlow("Graph2", {
+    const graph2 = new GraphFlow({
       name: "Graph2",
-      nodes: [],
-      context: { value: 0 },
       schema: TestSchema,
+      context: { value: 0 },
+      nodes: [],
     });
 
     const processNode2: GraphNodeConfig<TestSchema> = {
@@ -549,11 +549,11 @@ describe("GraphFlow", function () {
    */
   it("should handle sequential workflows using GraphController", async function () {
     // Graph 1
-    const graph1 = new GraphFlow("Graph1", {
+    const graph1 = new GraphFlow({
       name: "Graph1",
-      nodes: [],
-      context: { value: 1 },
       schema: TestSchema,
+      context: { value: 1 },
+      nodes: [],
     });
 
     const startNode1: GraphNodeConfig<TestSchema> = {
@@ -564,11 +564,11 @@ describe("GraphFlow", function () {
     };
 
     // Graph 2
-    const graph2 = new GraphFlow("Graph2", {
+    const graph2 = new GraphFlow({
       name: "Graph2",
-      nodes: [],
-      context: { value: 3 },
       schema: TestSchema,
+      context: { value: 3 },
+      nodes: [],
     });
 
     const startNode2: GraphNodeConfig<TestSchema> = {
@@ -631,8 +631,9 @@ describe("GraphFlow", function () {
 
   // Test de validation des paramètres
   it("should successfully validate params", async () => {
-    const graph = new GraphFlow("test", {
+    const graph = new GraphFlow({
       name: "test",
+      schema: TestSchema,
       nodes: [
         {
           name: "validationNode",
@@ -647,7 +648,6 @@ describe("GraphFlow", function () {
           },
         },
       ],
-      schema: TestSchema,
       context: { value: 0, counter: 0, message: "" },
     });
 
@@ -659,8 +659,9 @@ describe("GraphFlow", function () {
 
   // Test des paramètres requis
   it("should throw error when required params are missing", async () => {
-    const graph = new GraphFlow("test", {
+    const graph = new GraphFlow({
       name: "test",
+      schema: TestSchema,
       nodes: [
         {
           name: "requiredInputNode",
@@ -675,7 +676,6 @@ describe("GraphFlow", function () {
           },
         },
       ],
-      schema: TestSchema,
       context: { value: 0, counter: 0, message: "" },
     });
 

package/test/graph/observer.test.ts

@@ -33,7 +33,7 @@ describe("GraphObserver", () => {
   let observer: GraphObserver<typeof TestSchema>;
 
   beforeEach(() => {
-    graph = new GraphFlow("TestGraph", {
+    graph = new GraphFlow({
       name: "TestGraph",
       nodes: [],
       context: { value: 0 },
@@ -50,7 +50,8 @@ describe("GraphObserver", () => {
       graph,
       eventSubject,
       stateSubject,
-      destroySubject
+      destroySubject,
+      graph["eventManager"]
     );
   });
 
@@ -319,33 +320,27 @@ describe("GraphObserver", () => {
      * - Events are captured in correct order
      */
     it("should wait for correlated events", async () => {
-      // Create test events
-      const eventA = {
+      const promise = observer.waitForCorrelatedEvents(
+        ["eventA", "eventB"],
+        1000,
+        (events) => events.every((e) => e.payload?.status === "success")
+      );
+
+      // Emit events immediately
+      eventSubject.next({
         type: "eventA",
-        payload: { eventPayload: { status: "success" } },
+        payload: { status: "success" },
         timestamp: Date.now(),
-      } as GraphEvent<typeof TestSchema>;
+      });
 
-      const eventB = {
+      eventSubject.next({
         type: "eventB",
-        payload: { eventPayload: { status: "success" } },
+        payload: { status: "success" },
         timestamp: Date.now(),
-      } as GraphEvent<typeof TestSchema>;
-
-      // Emit events after a short delay
-      setTimeout(() => {
-        eventSubject.next(eventA);
-        eventSubject.next(eventB);
-      }, 100);
-
-      const events = await observer.waitForCorrelatedEvents(
-        ["eventA", "eventB"],
-        2000,
-        (events) =>
-          events.every((e) => e.payload.eventPayload?.status === "success")
-      );
+      });
 
-      expect(events.length).to.equal(2);
+      const events = await promise;
+      expect(events).to.have.length(2);
       expect(events[0].type).to.equal("eventA");
       expect(events[1].type).to.equal("eventB");
     });

package/types/index.ts

@@ -77,13 +77,45 @@ export type GraphContext<T extends ZodSchema> = {
 };
 
 /**
- * Configuration for event handling in a node
+ * Configuration for event handling strategies in nodes
+ * @typedef {Object} EventStrategy
+ * @property {"single" | "all" | "correlate"} type - The type of event handling strategy
+ * - single: Waits for any single event from the specified events
+ * - all: Waits for all specified events to occur
+ * - correlate: Uses a correlation function to match related events
+ * @property {(events: any[]) => boolean} [correlation] - Optional correlation function for "correlate" strategy
  */
 export type EventStrategy = {
   type: "single" | "all" | "correlate";
   correlation?: (events: any[]) => boolean;
 };
 
+/**
+ * Configuration for event handling in nodes
+ * @typedef {Object} EventConfig
+ * @property {string[]} events - Array of event names to wait for
+ * @property {number} [timeout] - Optional timeout in milliseconds
+ * @property {EventStrategy} strategy - Strategy for handling multiple events
+ * @property {(events: any[]) => Promise<void>} [onSuccess] - Optional callback when events are successfully received
+ * @property {() => Promise<void>} [onTimeout] - Optional callback when event waiting times out
+ * @example
+ * ```typescript
+ * const eventConfig: EventConfig = {
+ *   events: ["payment.received", "order.validated"],
+ *   timeout: 5000,
+ *   strategy: {
+ *     type: "correlate",
+ *     correlation: (events) => events.every(e => e.transactionId === events[0].transactionId)
+ *   },
+ *   onSuccess: async (events) => {
+ *     console.log("Correlated events received:", events);
+ *   },
+ *   onTimeout: async () => {
+ *     console.log("Event waiting timed out");
+ *   }
+ * };
+ * ```
+ */
 export type EventConfig = {
   events: string[];
   timeout?: number;
@@ -92,12 +124,62 @@ export type EventConfig = {
   onTimeout?: () => Promise<void>;
 };
 
+/**
+ * Represents an event in the graph system
+ * @template T - Schema type for context validation
+ * @property {string} type - The type/name of the event
+ * @property {any} [payload] - Optional payload data
+ * @property {number} timestamp - Unix timestamp of when the event occurred
+ * @example
+ * ```typescript
+ * const event: GraphEvent<MySchema> = {
+ *   type: "payment.received",
+ *   payload: {
+ *     transactionId: "tx123",
+ *     amount: 100,
+ *     currency: "USD"
+ *   },
+ *   timestamp: Date.now()
+ * };
+ * ```
+ */
+export type GraphEvent<T extends ZodSchema> = {
+  type: string;
+  payload?: any;
+  timestamp: number;
+};
+
+/**
+ * Configuration for waiting on multiple events
+ * @template T - Schema type for context validation
+ * @property {string[]} events - Array of event names to wait for
+ * @property {number} [timeout] - Optional timeout in milliseconds
+ * @property {"all" | "any" | "race"} strategy - Strategy for handling multiple events
+ * @property {(context: GraphContext<T>) => Promise<void>} [onSuccess] - Optional success callback
+ * @example
+ * ```typescript
+ * const config: WaitForEvents<MySchema> = {
+ *   events: ["event1", "event2"],
+ *   timeout: 5000,
+ *   strategy: "all",
+ *   onSuccess: async (context) => {
+ *     console.log("All events received");
+ *   }
+ * };
+ * ```
+ */
+export type WaitForEvents<T extends ZodSchema> = {
+  events: string[];
+  timeout?: number;
+  strategy: "all" | "any" | "race";
+  onSuccess?: <T extends ZodSchema>(context: GraphContext<T>) => Promise<void>;
+};
+
 /**
  * Interface representing a node in the graph
  * @interface
  * @template T - Schema type
- * @template I - Input schema type
- * @template O - Output schema type
+ * @template P - Parameters type
  */
 export interface GraphNodeConfig<T extends ZodSchema, P = any> {
   /** Name of the node */
@@ -112,10 +194,9 @@ export interface GraphNodeConfig<T extends ZodSchema, P = any> {
     params?: P,
     tools?: { eventEmitter: IEventEmitter }
   ) => Promise<void>;
-  /** Optional condition for node start execution */
+  /** Optional condition for node execution */
   condition?: (context: GraphContext<T>, params?: P) => boolean;
-
-  /** Array of next node names or objects with conditions for the next node */
+  /** Array of next node names or objects with conditions */
   next?:
     | Array<
         | string
@@ -129,13 +210,9 @@ export interface GraphNodeConfig<T extends ZodSchema, P = any> {
   when?: EventConfig;
   /** Retry configuration */
   retry?: {
-    /** Maximum number of retry attempts */
     maxAttempts: number;
-    /** Delay between retries in milliseconds */
     delay: number;
-    /** Error handler function */
     onRetryFailed?: (error: Error, context: GraphContext<T>) => Promise<void>;
-    /** Continue execution on failed retry */
     continueOnFailed?: boolean;
   };
   /** Error handler function */
@@ -151,12 +228,12 @@ export interface GraphNodeConfig<T extends ZodSchema, P = any> {
 export type GraphConfig<T extends ZodSchema> = {
   /** Name of the graph */
   name: string;
-  /** Array of nodes in the graph */
-  nodes: GraphNodeConfig<T, any>[];
-  /** Initial context */
-  context: SchemaType<T>;
   /** Schema for validation */
   schema: T;
+  /** Initial context */
+  context: SchemaType<T>;
+  /** Array of nodes in the graph */
+  nodes: GraphNodeConfig<T, any>[];
   /** Global error handler */
   onError?: (error: Error, context: GraphContext<T>) => void;
   /** Entry node name */
@@ -205,19 +282,6 @@ export type MeilisearchSettings = {
   sortableAttributes?: string[];
 };
 
-export type GraphEvent<T extends ZodSchema> = {
-  type: string;
-  payload?: any;
-  timestamp: number;
-};
-
-export type WaitForEvents<T extends ZodSchema> = {
-  events: string[];
-  timeout?: number;
-  strategy: "all" | "any" | "race";
-  onSuccess?: <T extends ZodSchema>(context: GraphContext<T>) => Promise<void>;
-};
-
 /**
  * Configuration interface for NLP Engine
  * @interface NLPConfig