flowfn 0.0.1

package/tests/dlq.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Tests for Dead Letter Queue (DLQ)
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { MemoryDLQManager, DLQJob } from "../src/queue/dlq.js";
+import { Job } from "../src/queue/types.js";
+
+describe("DLQ Manager", () => {
+  let dlq: MemoryDLQManager;
+
+  beforeEach(() => {
+    dlq = new MemoryDLQManager({
+      maxRetries: 3,
+      queueName: "test-dlq",
+    });
+  });
+
+  it("should move job to DLQ", async () => {
+    const job: Partial<Job> = {
+      id: "job-1",
+      name: "test-job",
+      data: { foo: "bar" },
+      state: "failed",
+      failedReason: "Test failure",
+      attemptsMade: 3,
+    } as Job;
+
+    const dlqJob = await dlq.moveToDLQ(job as Job, "Max retries exceeded");
+
+    expect(dlqJob.id).toBe("job-1");
+    expect(dlqJob.originalQueue).toBe("test-job");
+    expect(dlqJob.dlqReason).toBe("Max retries exceeded");
+    expect(dlqJob.dlqTimestamp).toBeGreaterThan(0);
+  });
+
+  it("should get all DLQ jobs", async () => {
+    const job1: Partial<Job> = {
+      id: "job-1",
+      name: "queue-1",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    const job2: Partial<Job> = {
+      id: "job-2",
+      name: "queue-2",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    await dlq.moveToDLQ(job1 as Job, "reason1");
+    await dlq.moveToDLQ(job2 as Job, "reason2");
+
+    const all = await dlq.getAll();
+    expect(all).toHaveLength(2);
+  });
+
+  it("should get jobs by queue", async () => {
+    const job1: Partial<Job> = {
+      id: "job-1",
+      name: "queue-1",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    const job2: Partial<Job> = {
+      id: "job-2",
+      name: "queue-2",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    await dlq.moveToDLQ(job1 as Job, "reason");
+    await dlq.moveToDLQ(job2 as Job, "reason");
+
+    const queue1Jobs = await dlq.getByQueue("queue-1");
+    expect(queue1Jobs).toHaveLength(1);
+    expect(queue1Jobs[0].id).toBe("job-1");
+  });
+
+  it("should retry DLQ job", async () => {
+    const job: Partial<Job> = {
+      id: "job-1",
+      name: "test-queue",
+      data: { value: 123 },
+      state: "failed",
+      attemptsMade: 3,
+    } as Job;
+
+    await dlq.moveToDLQ(job as Job, "Test failure");
+
+    const retriedJob = await dlq.retry("job-1");
+
+    expect(retriedJob.state).toBe("waiting");
+    expect(retriedJob.attemptsMade).toBe(0);
+    expect(retriedJob.failedReason).toBeUndefined();
+
+    // Should be removed from DLQ
+    const remaining = await dlq.getAll();
+    expect(remaining).toHaveLength(0);
+  });
+
+  it("should retry all jobs from a queue", async () => {
+    const job1: Partial<Job> = {
+      id: "job-1",
+      name: "queue-1",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    const job2: Partial<Job> = {
+      id: "job-2",
+      name: "queue-1",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    await dlq.moveToDLQ(job1 as Job, "reason");
+    await dlq.moveToDLQ(job2 as Job, "reason");
+
+    const count = await dlq.retryAll("queue-1");
+    expect(count).toBe(2);
+
+    const remaining = await dlq.getAll();
+    expect(remaining).toHaveLength(0);
+  });
+
+  it("should clean expired jobs", async () => {
+    const job: Partial<Job> = {
+      id: "job-1",
+      name: "test-queue",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    await dlq.moveToDLQ(job as Job, "reason");
+
+    // Clean jobs older than 0ms (should clean all)
+    const count = await dlq.clean(0);
+    expect(count).toBe(1);
+
+    const remaining = await dlq.getAll();
+    expect(remaining).toHaveLength(0);
+  });
+
+  it("should get stats", async () => {
+    const job1: Partial<Job> = {
+      id: "job-1",
+      name: "queue-1",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    const job2: Partial<Job> = {
+      id: "job-2",
+      name: "queue-2",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    const job3: Partial<Job> = {
+      id: "job-3",
+      name: "queue-1",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    await dlq.moveToDLQ(job1 as Job, "reason");
+    await dlq.moveToDLQ(job2 as Job, "reason");
+    await dlq.moveToDLQ(job3 as Job, "reason");
+
+    const stats = await dlq.getStats();
+    expect(stats.total).toBe(3);
+    expect(stats.byQueue["queue-1"]).toBe(2);
+    expect(stats.byQueue["queue-2"]).toBe(1);
+  });
+
+  it("should call onDLQ callback", async () => {
+    let callbackCalled = false;
+    let callbackJob: Job | null = null;
+    let callbackReason = "";
+
+    const dlqWithCallback = new MemoryDLQManager({
+      onDLQ: (job, reason) => {
+        callbackCalled = true;
+        callbackJob = job;
+        callbackReason = reason;
+      },
+    });
+
+    const job: Partial<Job> = {
+      id: "job-1",
+      name: "test-queue",
+      data: {},
+      state: "failed",
+    } as Job;
+
+    await dlqWithCallback.moveToDLQ(job as Job, "Test reason");
+
+    expect(callbackCalled).toBe(true);
+    expect(callbackJob?.id).toBe("job-1");
+    expect(callbackReason).toBe("Test reason");
+  });
+});

package/tests/health.test.ts

@@ -0,0 +1,228 @@
+/**
+ * Tests for Health Monitoring
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  HealthCheckerImpl,
+  MemoryEventTracker,
+} from "../src/monitoring/health.js";
+
+describe("Health Checker", () => {
+  let healthChecker: HealthCheckerImpl;
+
+  beforeEach(() => {
+    healthChecker = new HealthCheckerImpl();
+  });
+
+  it("should perform default health checks", async () => {
+    const health = await healthChecker.check();
+
+    expect(health.healthy).toBe(true);
+    expect(health.timestamp).toBeGreaterThan(0);
+    expect(health.checks.length).toBeGreaterThan(0);
+
+    // Should have uptime and memory checks
+    const checkNames = health.checks.map((c) => c.name);
+    expect(checkNames).toContain("uptime");
+    expect(checkNames).toContain("memory");
+  });
+
+  it("should add custom health check", async () => {
+    healthChecker.addCheck("custom", async () => ({
+      name: "custom",
+      status: "pass",
+      message: "Custom check passed",
+    }));
+
+    const health = await healthChecker.check();
+    const customCheck = health.checks.find((c) => c.name === "custom");
+
+    expect(customCheck).toBeDefined();
+    expect(customCheck?.status).toBe("pass");
+    expect(customCheck?.message).toBe("Custom check passed");
+  });
+
+  it("should handle failing health checks", async () => {
+    healthChecker.addCheck("failing", async () => ({
+      name: "failing",
+      status: "fail",
+      message: "This check failed",
+    }));
+
+    const health = await healthChecker.check();
+
+    expect(health.healthy).toBe(false);
+    const failingCheck = health.checks.find((c) => c.name === "failing");
+    expect(failingCheck?.status).toBe("fail");
+  });
+
+  it("should remove health check", async () => {
+    healthChecker.addCheck("temp", async () => ({
+      name: "temp",
+      status: "pass",
+    }));
+
+    let health = await healthChecker.check();
+    expect(health.checks.some((c) => c.name === "temp")).toBe(true);
+
+    healthChecker.removeCheck("temp");
+
+    health = await healthChecker.check();
+    expect(health.checks.some((c) => c.name === "temp")).toBe(false);
+  });
+
+  it("should track response time", async () => {
+    healthChecker.addCheck("slow", async () => {
+      await new Promise((r) => setTimeout(r, 10));
+      return {
+        name: "slow",
+        status: "pass",
+      };
+    });
+
+    const health = await healthChecker.check();
+    const slowCheck = health.checks.find((c) => c.name === "slow");
+
+    expect(slowCheck?.responseTime).toBeGreaterThan(0);
+  });
+
+  it("should handle check errors", async () => {
+    healthChecker.addCheck("error", async () => {
+      throw new Error("Check error");
+    });
+
+    const health = await healthChecker.check();
+
+    expect(health.healthy).toBe(false);
+    const errorCheck = health.checks.find((c) => c.name === "error");
+    expect(errorCheck?.status).toBe("fail");
+    expect(errorCheck?.message).toBe("Check error");
+  });
+});
+
+describe("Event Tracker", () => {
+  let tracker: MemoryEventTracker;
+
+  beforeEach(() => {
+    tracker = new MemoryEventTracker();
+  });
+
+  it("should track events", () => {
+    tracker.track({
+      type: "test.event",
+      category: "system",
+      severity: "info",
+      message: "Test event",
+    });
+
+    const events = tracker.getEvents();
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe("test.event");
+    expect(events[0].id).toBeDefined();
+    expect(events[0].timestamp).toBeGreaterThan(0);
+  });
+
+  it("should filter by category", () => {
+    tracker.track({
+      type: "queue.event",
+      category: "queue",
+      severity: "info",
+      message: "Queue event",
+    });
+
+    tracker.track({
+      type: "stream.event",
+      category: "stream",
+      severity: "info",
+      message: "Stream event",
+    });
+
+    const queueEvents = tracker.getEvents({ category: "queue" });
+    expect(queueEvents).toHaveLength(1);
+    expect(queueEvents[0].category).toBe("queue");
+  });
+
+  it("should filter by severity", () => {
+    tracker.track({
+      type: "info.event",
+      category: "system",
+      severity: "info",
+      message: "Info",
+    });
+
+    tracker.track({
+      type: "error.event",
+      category: "system",
+      severity: "error",
+      message: "Error",
+    });
+
+    const errors = tracker.getEvents({ severity: "error" });
+    expect(errors).toHaveLength(1);
+    expect(errors[0].severity).toBe("error");
+  });
+
+  it("should filter by timestamp", () => {
+    const now = Date.now();
+
+    tracker.track({
+      type: "event1",
+      category: "system",
+      severity: "info",
+      message: "Event 1",
+    });
+
+    const events = tracker.getEvents({ since: now });
+    expect(events.length).toBeGreaterThan(0);
+    expect(events[0].timestamp).toBeGreaterThanOrEqual(now);
+  });
+
+  it("should limit results", () => {
+    for (let i = 0; i < 10; i++) {
+      tracker.track({
+        type: `event${i}`,
+        category: "system",
+        severity: "info",
+        message: `Event ${i}`,
+      });
+    }
+
+    const limited = tracker.getEvents({ limit: 5 });
+    expect(limited).toHaveLength(5);
+  });
+
+  it("should cleanup old events", () => {
+    tracker.track({
+      type: "old.event",
+      category: "system",
+      severity: "info",
+      message: "Old event",
+    });
+
+    const cleaned = tracker.cleanup(0); // Clean all
+    expect(cleaned).toBeGreaterThan(0);
+
+    const remaining = tracker.getEvents();
+    expect(remaining).toHaveLength(0);
+  });
+
+  it("should track metadata", () => {
+    tracker.track({
+      type: "meta.event",
+      category: "system",
+      severity: "info",
+      message: "Event with metadata",
+      metadata: {
+        key: "value",
+        count: 42,
+      },
+    });
+
+    const events = tracker.getEvents();
+    expect(events[0].metadata).toEqual({
+      key: "value",
+      count: 42,
+    });
+  });
+});

package/tests/integration.test.ts

@@ -0,0 +1,253 @@
+/**
+ * Integration tests for FlowFn
+ * Tests the complete stack: queues, streams, workflows together
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { createFlow } from "../src/core/flow-fn.js";
+import { FlowFn } from "../src/core/flow-fn.js";
+
+describe("FlowFn Integration Tests", () => {
+  let flow: FlowFn;
+
+  beforeEach(() => {
+    flow = createFlow({ adapter: "memory" });
+  });
+
+  afterEach(async () => {
+    await flow.close();
+  });
+
+  describe("Queue + Stream Integration", () => {
+    it("should process queue jobs and publish to stream", async () => {
+      const queue = flow.queue("processing");
+      const stream = flow.stream("events");
+      const results: any[] = [];
+
+      // Subscribe to stream
+      await stream.subscribe(async (msg) => {
+        results.push(msg.data);
+        await msg.ack();
+      });
+
+      // Process queue and publish to stream
+      queue.process(async (job) => {
+        await stream.publish({ processed: job.data });
+        return { success: true };
+      });
+
+      // Add jobs
+      await queue.add("task", { value: 1 });
+      await queue.add("task", { value: 2 });
+
+      // Wait for processing
+      await new Promise((r) => setTimeout(r, 100));
+
+      expect(results.length).toBeGreaterThan(0);
+    }, 10000);
+  });
+
+  describe("Workflow + Queue Integration", () => {
+    it("should trigger workflow from queue job", async () => {
+      const queue = flow.queue("triggers");
+      let workflowExecuted = false;
+
+      const workflow = flow
+        .workflow("process-order")
+        .step("validate", async (ctx) => {
+          ctx.set("validated", true);
+        })
+        .step("execute", async (ctx) => {
+          workflowExecuted = true;
+          ctx.set("executed", true);
+        })
+        .build();
+
+      queue.process(async (job) => {
+        await workflow.execute(job.data);
+        return { done: true };
+      });
+
+      await queue.add("order", { orderId: "123" });
+
+      // Wait for processing
+      await new Promise((r) => setTimeout(r, 200));
+
+      expect(workflowExecuted).toBe(true);
+    }, 10000);
+  });
+
+  describe("Health Check Integration", () => {
+    it("should report healthy system", async () => {
+      const health = await flow.healthCheck();
+
+      expect(health.healthy).toBe(true);
+      expect(health.timestamp).toBeGreaterThan(0);
+      expect(health.checks.length).toBeGreaterThan(0);
+
+      // Should have default checks
+      const checkNames = health.checks.map((c) => c.name);
+      expect(checkNames).toContain("uptime");
+      expect(checkNames).toContain("memory");
+    });
+
+    it("should track health check events", async () => {
+      await flow.healthCheck();
+
+      const tracker = flow.getEventTracker();
+      const events = tracker.getEvents({ type: "health.check" });
+
+      expect(events.length).toBeGreaterThan(0);
+      expect(events[0].category).toBe("system");
+    });
+  });
+
+  describe("Metrics Integration", () => {
+    it("should collect queue metrics", async () => {
+      const queue = flow.queue("metrics-test");
+
+      // Record some metrics
+      flow.metrics.record("queue.throughput", 10, { queue: "metrics-test" });
+      flow.metrics.record("queue.throughput", 20, { queue: "metrics-test" });
+
+      const metrics = await flow.metrics.getQueueMetrics("metrics-test");
+
+      expect(metrics).toBeDefined();
+      expect(metrics.waiting).toBeDefined();
+    });
+  });
+
+  describe("Complete E2E Flow", () => {
+    it("should handle queue → workflow → stream flow", async () => {
+      const queue = flow.queue("orders");
+      const stream = flow.stream("order-events");
+      const results: string[] = [];
+
+      // Subscribe to events
+      await stream.subscribe(async (msg) => {
+        results.push(msg.data.status);
+        await msg.ack();
+      });
+
+      // Workflow for order processing
+      const workflow = flow
+        .workflow("order-processing")
+        .step("validate", async (ctx) => {
+          await stream.publish({ status: "validating", order: ctx.input });
+          ctx.set("valid", true);
+        })
+        .step("process", async (ctx) => {
+          await stream.publish({ status: "processing", order: ctx.input });
+          ctx.set("processed", true);
+        })
+        .step("complete", async (ctx) => {
+          await stream.publish({ status: "completed", order: ctx.input });
+        })
+        .build();
+
+      // Queue processor triggers workflow
+      queue.process(async (job) => {
+        await workflow.execute(job.data);
+        return { success: true };
+      });
+
+      // Add order
+      await queue.add("new-order", { id: "order-123", amount: 100 });
+
+      // Wait for complete flow
+      await new Promise((r) => setTimeout(r, 300));
+
+      // Should have all events
+      expect(results).toContain("validating");
+      expect(results).toContain("processing");
+      expect(results).toContain("completed");
+    }, 10000);
+  });
+
+  describe("Error Handling Integration", () => {
+    it("should handle workflow failures gracefully", async () => {
+      const workflow = flow
+        .workflow("failing-workflow")
+        .step("step1", async (ctx) => {
+          ctx.set("step1", true);
+        })
+        .step("step2", async (ctx) => {
+          throw new Error("Intentional failure");
+        })
+        .step("step3", async (ctx) => {
+          ctx.set("step3", true); // Should not execute
+        })
+        .build();
+
+      const execution = await workflow.execute({ test: true });
+
+      // Wait for execution
+      await new Promise((r) => setTimeout(r, 100));
+
+      const result = await workflow.getExecution(execution.id);
+      expect(result.status).toBe("failed");
+      expect(result.error).toBeDefined();
+    }, 10000);
+  });
+
+  describe("Concurrent Operations", () => {
+    it("should handle multiple queues concurrently", async () => {
+      const queue1 = flow.queue("concurrent-1");
+      const queue2 = flow.queue("concurrent-2");
+
+      let count1 = 0;
+      let count2 = 0;
+
+      queue1.process(async () => {
+        count1++;
+      });
+      queue2.process(async () => {
+        count2++;
+      });
+
+      // Add jobs to both queues
+      await Promise.all([
+        queue1.add("job", { id: 1 }),
+        queue1.add("job", { id: 2 }),
+        queue2.add("job", { id: 3 }),
+        queue2.add("job", { id: 4 }),
+      ]);
+
+      await new Promise((r) => setTimeout(r, 200));
+
+      expect(count1).toBe(2);
+      expect(count2).toBe(2);
+    }, 10000);
+
+    it("should handle multiple streams concurrently", async () => {
+      const stream1 = flow.stream("stream-1");
+      const stream2 = flow.stream("stream-2");
+
+      const results1: any[] = [];
+      const results2: any[] = [];
+
+      await stream1.subscribe(async (msg) => {
+        results1.push(msg.data);
+        await msg.ack();
+      });
+
+      await stream2.subscribe(async (msg) => {
+        results2.push(msg.data);
+        await msg.ack();
+      });
+
+      // Publish to both streams
+      await Promise.all([
+        stream1.publish({ stream: 1, value: "a" }),
+        stream2.publish({ stream: 2, value: "b" }),
+        stream1.publish({ stream: 1, value: "c" }),
+        stream2.publish({ stream: 2, value: "d" }),
+      ]);
+
+      await new Promise((r) => setTimeout(r, 100));
+
+      expect(results1.length).toBe(2);
+      expect(results2.length).toBe(2);
+    }, 10000);
+  });
+});