@ai.ntellect/core 0.7.8 → 1.0.0

package/test/graph/observer.test.ts

@@ -1,398 +0,0 @@
-import { expect } from "chai";
-import { BehaviorSubject, Subject } from "rxjs";
-import { z } from "zod";
-import { GraphFlow } from "../../graph";
-import { GraphObserver } from "../../graph/observer";
-import { GraphContext, GraphEvent, Node } from "../../types";
-
-/**
- * Test schema definition for observer tests
- * Defines a schema with:
- * - value: numeric value for tracking state changes
- * - status: enum representing node execution status
- */
-const TestSchema = z.object({
-  value: z.number().default(0),
-  status: z.enum(["pending", "completed", "failed"]).optional(),
-});
-
-/**
- * Test suite for the GraphObserver implementation
- * This suite validates the reactive observation capabilities:
- * - State observation (global and node-specific)
- * - Property observation (single and multiple)
- * - Event observation and correlation
- * - Workflow monitoring
- * - Node execution triggers
- */
-describe("GraphObserver", () => {
-  let graph: GraphFlow<typeof TestSchema>;
-  let eventSubject: Subject<GraphEvent<typeof TestSchema>>;
-  let stateSubject: BehaviorSubject<GraphContext<typeof TestSchema>>;
-  let destroySubject: Subject<void>;
-  let observer: GraphObserver<typeof TestSchema>;
-
-  beforeEach(() => {
-    graph = new GraphFlow("TestGraph", {
-      name: "TestGraph",
-      nodes: [],
-      context: { value: 0 },
-      schema: TestSchema,
-    });
-
-    // Initialize subjects
-    eventSubject = new Subject();
-    stateSubject = new BehaviorSubject(graph.getContext());
-    destroySubject = new Subject();
-
-    // Create observer instance
-    observer = new GraphObserver(
-      graph,
-      eventSubject,
-      stateSubject,
-      destroySubject
-    );
-  });
-
-  /**
-   * Test suite for state observation functionality
-   * Validates the ability to track and react to state changes
-   * in the graph context
-   */
-  describe("State Observation", () => {
-    /**
-     * Tests sequential state change observation
-     * Validates that:
-     * - All state changes are captured in order
-     * - Multiple state changes in a single node are tracked
-     * - Initial state is included in observations
-     */
-    it("should observe state changes", async () => {
-      const states: any[] = [];
-      const testNode: Node<typeof TestSchema> = {
-        name: "testNode",
-        execute: async (context) => {
-          context.value = 1;
-          context.value = 2;
-          context.value = 3;
-        },
-      };
-
-      graph.addNode(testNode);
-      const subscription = graph
-        .observe()
-        .state()
-        .subscribe((state) => {
-          if (state.value !== undefined) {
-            states.push(state.value);
-          }
-        });
-
-      await graph.execute("testNode");
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      subscription.unsubscribe();
-
-      expect(states).to.deep.equal([0, 1, 2, 3]);
-    });
-
-    /**
-     * Tests node-specific state observation
-     * Validates that:
-     * - State changes for specific nodes are tracked
-     * - Status transitions are captured correctly
-     * - Async state changes are properly observed
-     */
-    it("should observe specific node state changes", async () => {
-      const states: any[] = [];
-      const testNode: Node<typeof TestSchema> = {
-        name: "testNode",
-        execute: async (context) => {
-          context.status = "pending";
-          await new Promise((resolve) => setTimeout(resolve, 10));
-          context.status = "completed";
-        },
-      };
-
-      graph.addNode(testNode);
-      const subscription = graph
-        .observe()
-        .node("testNode")
-        .subscribe((state) => state.status && states.push(state.status));
-
-      await graph.execute("testNode");
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      subscription.unsubscribe();
-
-      expect(states).to.deep.equal(["pending", "completed"]);
-    });
-
-    /**
-     * Tests multi-node state observation
-     * Validates that:
-     * - Multiple nodes can be observed simultaneously
-     * - State changes are correctly attributed to nodes
-     * - Sequential execution is properly tracked
-     */
-    it("should observe multiple nodes", async () => {
-      const states: any[] = [];
-      const node1: Node<typeof TestSchema> = {
-        name: "node1",
-        execute: async (context) => {
-          context.value = 1;
-        },
-      };
-      const node2: Node<typeof TestSchema> = {
-        name: "node2",
-        execute: async (context) => {
-          context.value = 2;
-        },
-      };
-
-      graph.addNode(node1);
-      graph.addNode(node2);
-
-      const subscription = graph
-        .observe()
-        .nodes(["node1", "node2"])
-        .subscribe((state) => state.value && states.push(state.value));
-
-      await graph.execute("node1");
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      await graph.execute("node2");
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      subscription.unsubscribe();
-
-      expect(states).to.deep.equal([1, 2]);
-    });
-  });
-
-  /**
-   * Test suite for property observation functionality
-   * Validates the ability to track specific properties
-   * of the graph context
-   */
-  describe("Property Observation", () => {
-    /**
-     * Tests single property observation
-     * Validates that:
-     * - Individual property changes are tracked
-     * - Initial property value is captured
-     * - Property updates trigger observations
-     */
-    it("should observe single property", async () => {
-      const values: any[] = [];
-      const testNode: Node<typeof TestSchema> = {
-        name: "testNode",
-        execute: async (context) => {
-          context.value = 42;
-        },
-      };
-
-      graph.addNode(testNode);
-      const subscription = graph
-        .observe()
-        .property("value")
-        .subscribe((state) => values.push(state.value));
-
-      await graph.execute("testNode");
-      subscription.unsubscribe();
-
-      expect(values).to.deep.equal([0, 42]);
-    });
-
-    /**
-     * Tests multiple property observation
-     * Validates that:
-     * - Multiple properties can be tracked simultaneously
-     * - Changes to any observed property trigger updates
-     * - Final state contains all tracked properties
-     */
-    it("should observe multiple properties", async () => {
-      const values: any[] = [];
-      const testNode: Node<typeof TestSchema> = {
-        name: "testNode",
-        execute: async (context) => {
-          context.value = 42;
-          context.status = "completed";
-        },
-      };
-
-      graph.addNode(testNode);
-      const subscription = graph
-        .observe()
-        .property(["value", "status"])
-        .subscribe((change) => {
-          const { name, ...rest } = change;
-          values.push(rest);
-        });
-
-      await graph.execute("testNode");
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      subscription.unsubscribe();
-
-      expect(values[values.length - 1]).to.deep.equal({
-        value: 42,
-        status: "completed",
-      });
-    });
-
-    /**
-     * Tests condition-based observation
-     * Validates that:
-     * - Multiple conditions can be combined
-     * - Observation completes when conditions are met
-     * - State reflects all required changes
-     */
-    it("should wait for multiple conditions", async () => {
-      const testNode: Node<typeof TestSchema> = {
-        name: "testNode",
-        execute: async (context) => {
-          context.value = 42;
-          context.status = "completed";
-        },
-      };
-
-      graph.addNode(testNode);
-      const promise = graph
-        .observe()
-        .until(
-          graph.observe().property(["value", "status"]),
-          (state) => state.value === 42 && state.status === "completed"
-        );
-
-      await graph.execute("testNode");
-      await promise;
-
-      const context = graph.getContext();
-      expect(context.value).to.equal(42);
-      expect(context.status).to.equal("completed");
-    });
-  });
-
-  /**
-   * Test suite for event observation functionality
-   * Validates the handling of events and event correlation
-   */
-  describe("Event Observation", () => {
-    /**
-     * Tests specific event observation
-     */
-    it("should observe specific events", async () => {
-      const events: GraphEvent<typeof TestSchema>[] = [];
-      const subscription = graph
-        .observe()
-        .event("testEvent")
-        .subscribe((e) => events.push(e));
-
-      await graph.emit("testEvent", { value: 1 });
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      subscription.unsubscribe();
-
-      expect(events.length).to.equal(1);
-      expect(events[0].type).to.equal("testEvent");
-    });
-
-    /**
-     * Tests debounced event handling
-     */
-    it("should handle debounced events", async () => {
-      const events: GraphEvent<typeof TestSchema>[] = [];
-      const subscription = graph
-        .observe()
-        .event("event1")
-        .subscribe((e) => events.push(e));
-
-      await graph.emit("event1", { value: 1 });
-      await graph.emit("event1", { value: 2 });
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      subscription.unsubscribe();
-
-      expect(events.length).to.equal(2);
-    });
-
-    /**
-     * Tests event correlation functionality
-     * Validates that:
-     * - Multiple events can be correlated
-     * - Correlation conditions are properly evaluated
-     * - Timeout handling works correctly
-     * - Events are captured in correct order
-     */
-    it("should wait for correlated events", async () => {
-      // Create test events
-      const eventA = {
-        type: "eventA",
-        payload: { eventPayload: { status: "success" } },
-        timestamp: Date.now(),
-      } as GraphEvent<typeof TestSchema>;
-
-      const eventB = {
-        type: "eventB",
-        payload: { eventPayload: { 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);
-      expect(events[0].type).to.equal("eventA");
-      expect(events[1].type).to.equal("eventB");
-    });
-
-    afterEach(() => {
-      destroySubject.next();
-      destroySubject.complete();
-      eventSubject.complete();
-      stateSubject.complete();
-    });
-  });
-
-  /**
-   * Test suite for workflow observation functionality
-   * Validates the ability to monitor complete workflow execution
-   */
-  describe("Workflow Observation", () => {
-    /**
-     * Tests complete workflow observation
-     * Validates that:
-     * - Entire workflow execution is tracked
-     * - State transitions are captured
-     * - Final state reflects completed workflow
-     */
-    it("should observe complete workflow", async () => {
-      const states: any[] = [];
-      const node: Node<typeof TestSchema> = {
-        name: "testNode",
-        execute: async (context) => {
-          context.status = "pending";
-          await new Promise((resolve) => setTimeout(resolve, 10));
-          context.status = "completed";
-        },
-      };
-
-      graph.addNode(node);
-      const subscription = graph
-        .observe()
-        .node("testNode")
-        .subscribe((state) => states.push(state));
-
-      await graph.execute("testNode");
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      subscription.unsubscribe();
-
-      expect(states.length).to.be.greaterThan(0);
-      expect(states[states.length - 1].status).to.equal("completed");
-    });
-  });
-});

package/test/modules/agenda/node-cron.test.ts

@@ -1,307 +0,0 @@
-import { expect } from "chai";
-import sinon from "sinon";
-import { Agenda } from "../../../modules/agenda";
-import { NodeCronAdapter } from "../../../modules/agenda/adapters/node-cron";
-import { Memory } from "../../../modules/memory";
-import { InMemoryAdapter } from "../../../modules/memory/adapters/in-memory";
-
-before(function () {
-  this.timeout(10000);
-});
-
-describe("Agenda Service", () => {
-  let agenda: Agenda;
-  const scheduledIds: string[] = []; // Track all scheduled request IDs
-
-  beforeEach(() => {
-    const cronService = new NodeCronAdapter();
-    const inMemory = new InMemoryAdapter();
-    const memory = new Memory(inMemory);
-    agenda = new Agenda(cronService, memory);
-  });
-
-  afterEach(async () => {
-    // Cancel all scheduled requests by their IDs
-    scheduledIds.forEach((id) => agenda.cancelScheduledRequest(id));
-    scheduledIds.length = 0; // Clear the array
-
-    // Ensure all tasks are stopped
-    await agenda.stop();
-
-    await agenda.cancel({});
-
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  });
-
-  describe("Request Scheduling", () => {
-    it("should schedule a new request and return an id", async () => {
-      const request = {
-        originalRequest: "test request",
-        cronExpression: "0 0 * * *",
-      };
-
-      const id = await agenda.scheduleRequest(request);
-      scheduledIds.push(id); // Track the ID
-
-      expect(id).to.be.a("string");
-      expect(await agenda.getScheduledRequests()).to.have.lengthOf(1);
-
-      const scheduledRequest = (await agenda.getScheduledRequests())[0];
-      expect(scheduledRequest.originalRequest).to.equal(
-        request.originalRequest
-      );
-      expect(scheduledRequest.cronExpression).to.equal(request.cronExpression);
-      expect(scheduledRequest.isRecurring).to.be.false;
-
-      agenda.cancelScheduledRequest(id);
-    });
-
-    it("should execute callbacks when scheduling and executing", async function () {
-      this.timeout(5000);
-
-      const onScheduledSpy = sinon.spy();
-      const onExecutedSpy = sinon.spy();
-
-      const request = {
-        originalRequest: "test request",
-        cronExpression: `${(new Date().getSeconds() + 1) % 60} * * * * *`,
-      };
-
-      const id = await agenda.scheduleRequest(request, {
-        onScheduled: onScheduledSpy,
-        onExecuted: onExecutedSpy,
-      });
-      scheduledIds.push(id);
-
-      expect(onScheduledSpy.calledOnce).to.be.true;
-
-      await new Promise<void>((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error("Callback execution timeout"));
-        }, 4000);
-
-        const checkExecution = () => {
-          if (onExecutedSpy.calledOnce) {
-            clearTimeout(timeout);
-            agenda.cancelScheduledRequest(id);
-            resolve();
-            return;
-          }
-          setTimeout(checkExecution, 100);
-        };
-        checkExecution();
-      });
-
-      expect(onExecutedSpy.calledOnce).to.be.true;
-    });
-  });
-
-  describe("Request Management", () => {
-    it("should cancel a scheduled request", async () => {
-      const request = {
-        originalRequest: "test request",
-        cronExpression: "*/1 * * * *",
-      };
-
-      const id = await agenda.scheduleRequest(request);
-      scheduledIds.push(id);
-      expect(await agenda.getScheduledRequests()).to.have.lengthOf(1);
-
-      const cancelled = await agenda.cancelScheduledRequest(id);
-      expect(cancelled).to.be.true;
-      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
-    });
-
-    it("should return false when cancelling non-existent request", async () => {
-      const cancelled = await agenda.cancelScheduledRequest("non-existent-id");
-      expect(cancelled).to.be.false;
-    });
-
-    it("should get all scheduled requests", async () => {
-      const requests = [
-        {
-          originalRequest: "request 1",
-          cronExpression: "*/1 * * * *",
-        },
-        {
-          originalRequest: "request 2",
-          cronExpression: "*/5 * * * *",
-        },
-      ];
-
-      for (const request of requests) {
-        const id = await agenda.scheduleRequest(request);
-        scheduledIds.push(id);
-      }
-
-      const scheduledRequests = await agenda.getScheduledRequests();
-      expect(scheduledRequests).to.have.lengthOf(2);
-      expect(scheduledRequests[0].originalRequest).to.equal("request 1");
-      expect(scheduledRequests[1].originalRequest).to.equal("request 2");
-    });
-
-    it("should stop all scheduled requests", async () => {
-      const requests = [
-        {
-          originalRequest: "request 1",
-          cronExpression: "*/1 * * * *",
-        },
-        {
-          originalRequest: "request 2",
-          cronExpression: "*/5 * * * *",
-        },
-      ];
-
-      for (const request of requests) {
-        await agenda.scheduleRequest(request);
-      }
-
-      expect(await agenda.getScheduledRequests()).to.have.lengthOf(2);
-
-      await agenda.stopAll();
-      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
-    });
-  });
-
-  describe("Global Management", () => {
-    it("should stop all scheduled requests", async () => {
-      const requests = [
-        {
-          originalRequest: "request 1",
-          cronExpression: "*/1 * * * *",
-        },
-        {
-          originalRequest: "request 2",
-          cronExpression: "*/5 * * * *",
-        },
-      ];
-
-      for (const request of requests) {
-        await agenda.scheduleRequest(request);
-      }
-
-      expect(await agenda.getScheduledRequests()).to.have.lengthOf(2);
-
-      await agenda.stopAll();
-      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
-    });
-  });
-
-  describe("Error Handling", () => {
-    it("should handle execution errors gracefully", async () => {
-      const consoleSpy = sinon.spy(console, "error");
-
-      const request = {
-        originalRequest: "error request",
-        cronExpression: "0 0 * * *",
-      };
-
-      const id = await agenda.scheduleRequest(request);
-
-      // Wait for execution
-      await new Promise((resolve) => setTimeout(resolve, 1100));
-
-      expect(consoleSpy.called).to.be.false;
-
-      agenda.cancelScheduledRequest(id);
-      consoleSpy.restore();
-    });
-  });
-
-  describe("Request Execution", () => {
-    it("should execute non-recurring requests only once", async function () {
-      this.timeout(5000);
-      const onExecutedSpy = sinon.spy();
-
-      const request = {
-        originalRequest: "single execution",
-        cronExpression: `${new Date().getSeconds() + 1} * * * * *`,
-      };
-
-      const id = await agenda.scheduleRequest(request, {
-        onExecuted: onExecutedSpy,
-      });
-
-      try {
-        await new Promise<void>((resolve, reject) => {
-          const timeout = setTimeout(
-            () => reject(new Error("Test timeout")),
-            4000
-          );
-          const checkExecution = () => {
-            if (onExecutedSpy.calledOnce) {
-              clearTimeout(timeout);
-              resolve();
-              return;
-            }
-            setTimeout(checkExecution, 100);
-          };
-          checkExecution();
-        });
-      } finally {
-        agenda.cancelScheduledRequest(id);
-      }
-
-      expect(onExecutedSpy.calledOnce).to.be.true;
-      expect(await agenda.getScheduledRequests()).to.have.lengthOf(0);
-    });
-
-    it("should log execution status", async function () {
-      this.timeout(10000);
-      const consoleLogSpy = sinon.spy(console, "log");
-
-      const request = {
-        originalRequest: "test request",
-        cronExpression: `${new Date().getSeconds() + 1} * * * * *`,
-      };
-
-      const id = await agenda.scheduleRequest(request);
-
-      await new Promise<void>((resolve) => {
-        const checkExecution = () => {
-          if (
-            consoleLogSpy.calledWith(`🔄 Executing scheduled request: ${id}`) &&
-            consoleLogSpy.calledWith(
-              `✅ Scheduled request executed successfully: ${id}`
-            )
-          ) {
-            agenda.cancelScheduledRequest(id);
-            resolve();
-            return;
-          }
-          setTimeout(checkExecution, 100);
-        };
-        checkExecution();
-      });
-
-      expect(consoleLogSpy.calledWith(`🔄 Executing scheduled request: ${id}`))
-        .to.be.true;
-      expect(
-        consoleLogSpy.calledWith(
-          `✅ Scheduled request executed successfully: ${id}`
-        )
-      ).to.be.true;
-
-      consoleLogSpy.restore();
-    });
-  });
-});
-
-let globalAgenda: Agenda;
-before(() => {
-  const cronService = new NodeCronAdapter();
-  const inMemoryAdapter = new InMemoryAdapter();
-  const memory = new Memory(inMemoryAdapter);
-  globalAgenda = new Agenda(cronService, memory);
-});
-
-after(async () => {
-  if (globalAgenda) {
-    globalAgenda.stopAll();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-
-  await globalAgenda.stop();
-  await globalAgenda.cancel({});
-  await new Promise((resolve) => setTimeout(resolve, 100));
-});