flowfn 0.0.1

package/tests/stream.test.ts

@@ -0,0 +1,233 @@
+/**
+ * Tests for Stream System
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { createFlow } from "../src/core/flow-fn.js";
+import { FlowFn } from "../src/core/flow-fn.js";
+
+describe("Stream System", () => {
+  let flow: FlowFn;
+
+  beforeEach(() => {
+    flow = createFlow({ adapter: "memory" });
+  });
+
+  describe("Publishing and Subscribing", () => {
+    it("should publish and receive messages", async () => {
+      const stream = flow.stream("test-stream");
+      const received: any[] = [];
+
+      await stream.subscribe(async (msg) => {
+        received.push(msg.data);
+        await msg.ack();
+      });
+
+      await stream.publish({ value: "hello" });
+      await stream.publish({ value: "world" });
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(received.length).toBe(2);
+      expect(received[0].value).toBe("hello");
+      expect(received[1].value).toBe("world");
+    });
+
+    it("should publish batch messages", async () => {
+      const stream = flow.stream("batch-stream");
+      const received: any[] = [];
+
+      await stream.subscribe(async (msg) => {
+        received.push(msg.data);
+        await msg.ack();
+      });
+
+      await stream.publishBatch([
+        { data: { id: 1 } },
+        { data: { id: 2 } },
+        { data: { id: 3 } },
+      ]);
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(received.length).toBe(3);
+    });
+  });
+
+  describe("Stream Trimming", () => {
+    it("should trim by max length", async () => {
+      const stream = flow.stream("trim-stream");
+
+      // Publish more messages than max
+      for (let i = 0; i < 10; i++) {
+        await stream.publish({ index: i });
+      }
+
+      const trimmed = await stream.trim({ maxLength: 5 });
+
+      expect(trimmed).toBe(5); // Should have removed 5 messages
+    });
+
+    it("should trim by max age", async () => {
+      const stream = flow.stream("age-stream");
+
+      await stream.publish({ old: true });
+
+      // Wait a bit
+      await new Promise((r) => setTimeout(r, 100));
+
+      const trimmed = await stream.trim({ maxAgeSeconds: 0.05 }); // 50ms
+
+      expect(trimmed).toBeGreaterThan(0);
+    });
+
+    it("should auto-trim on maxLength option", async () => {
+      const stream = flow.stream("auto-trim", { maxLength: 3 });
+
+      await stream.publish({ id: 1 });
+      await stream.publish({ id: 2 });
+      await stream.publish({ id: 3 });
+      await stream.publish({ id: 4 }); // Should trigger trim
+
+      const count = stream.getMessageCount();
+      expect(count).toBeLessThanOrEqual(3);
+    });
+  });
+
+  describe("Message Retrieval", () => {
+    it("should get messages by range", async () => {
+      const stream = flow.stream("retrieval-stream");
+
+      const ids = [];
+      ids.push(await stream.publish({ index: 1 }));
+      ids.push(await stream.publish({ index: 2 }));
+      ids.push(await stream.publish({ index: 3 }));
+
+      const messages = await stream.getMessages(ids[0], ids[2]);
+
+      expect(messages.length).toBeGreaterThan(0);
+    });
+
+    it("should limit message count", async () => {
+      const stream = flow.stream("limit-stream");
+
+      await stream.publish({ id: 1 });
+      await stream.publish({ id: 2 });
+      await stream.publish({ id: 3 });
+
+      const firstId = (await stream.getMessages("0", "z", 1))[0]?.id || "0";
+      const messages = await stream.getMessages(firstId, "z", 2);
+
+      expect(messages.length).toBeLessThanOrEqual(2);
+    });
+  });
+
+  describe("Consumer Groups", () => {
+    it("should create consumer with group", async () => {
+      const stream = flow.stream("consumer-stream");
+      const received: any[] = [];
+
+      const consumer = stream.createConsumer("consumer-1", {
+        groupId: "processors",
+        fromBeginning: false,
+      });
+
+      await consumer.subscribe(async (msg) => {
+        received.push(msg.data);
+        await msg.ack();
+      });
+
+      await stream.publish({ value: "test" });
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(received.length).toBeGreaterThan(0);
+    });
+
+    it("should replay from beginning", async () => {
+      const stream = flow.stream("replay-stream");
+
+      // Publish before subscribing
+      await stream.publish({ id: 1 });
+      await stream.publish({ id: 2 });
+
+      const received: any[] = [];
+      const consumer = stream.createConsumer("replayer", {
+        groupId: "group1",
+        fromBeginning: true,
+      });
+
+      await consumer.subscribe(async (msg) => {
+        received.push(msg.data);
+        await msg.ack();
+      });
+
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(received.length).toBe(2);
+      expect(received[0].id).toBe(1);
+      expect(received[1].id).toBe(2);
+    });
+
+    it("should pause and resume consumer", async () => {
+      const stream = flow.stream("pause-stream");
+      const received: any[] = [];
+
+      const consumer = stream.createConsumer("pausable", {
+        groupId: "group1",
+      });
+
+      await consumer.subscribe(async (msg) => {
+        received.push(msg.data);
+        await msg.ack();
+      });
+
+      await stream.publish({ id: 1 });
+      await new Promise((r) => setTimeout(r, 50));
+
+      await consumer.pause();
+      await stream.publish({ id: 2 }); // Should not be received
+
+      await consumer.resume();
+      await stream.publish({ id: 3 });
+      await new Promise((r) => setTimeout(r, 50));
+
+      // Should have received 1 and 3, but not 2
+      expect(received.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("Stream Replay", () => {
+    it("should replay messages from timestamp", async () => {
+      const stream = flow.stream("replay-ts-stream");
+
+      const startTime = Date.now();
+
+      await stream.publish({ id: 1 });
+      await new Promise((r) => setTimeout(r, 50));
+      await stream.publish({ id: 2 });
+
+      const received: any[] = [];
+      const count = await stream.replay(startTime, async (msg) => {
+        received.push(msg.data);
+      });
+
+      expect(count).toBe(2);
+      expect(received.length).toBe(2);
+    });
+  });
+
+  describe("Stream Info", () => {
+    it("should get stream info", async () => {
+      const stream = flow.stream("info-stream");
+
+      await stream.publish({ test: true });
+      await stream.publish({ test: true });
+
+      const info = await stream.getInfo();
+
+      expect(info.name).toBe("info-stream");
+      expect(info.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+});

package/tests/workflow.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Tests for Workflow System
+ */
+
+import { describe, it, expect, beforeEach } from "vitest";
+import { createFlow } from "../src/core/flow-fn.js";
+import { FlowFn } from "../src/core/flow-fn.js";
+
+describe("Workflow System", () => {
+  let flow: FlowFn;
+
+  beforeEach(() => {
+    flow = createFlow({ adapter: "memory" });
+  });
+
+  describe("Workflow Execution", () => {
+    it("should execute sequential steps", async () => {
+      const steps: string[] = [];
+
+      const workflow = flow
+        .workflow("sequential")
+        .step("step1", async (ctx) => {
+          steps.push("step1");
+          ctx.set("result1", "done");
+        })
+        .step("step2", async (ctx) => {
+          steps.push("step2");
+          expect(ctx.get("result1")).toBe("done");
+        })
+        .step("step3", async (ctx) => {
+          steps.push("step3");
+        })
+        .build();
+
+      await workflow.execute({ input: "test" });
+      await new Promise((r) => setTimeout(r, 100));
+
+      expect(steps).toEqual(["step1", "step2", "step3"]);
+    });
+
+    it("should execute parallel steps", async () => {
+      const results: number[] = [];
+
+      const workflow = flow
+        .workflow("parallel")
+        .parallel([
+          async (ctx) => {
+            results.push(1);
+          },
+          async (ctx) => {
+            results.push(2);
+          },
+          async (ctx) => {
+            results.push(3);
+          },
+        ])
+        .build();
+
+      await workflow.execute({});
+      await new Promise((r) => setTimeout(r, 100));
+
+      expect(results.length).toBe(3);
+      expect(results).toContain(1);
+      expect(results).toContain(2);
+      expect(results).toContain(3);
+    });
+  });
+
+  describe("Workflow State Management", () => {
+    it("should persist state across steps", async () => {
+      const workflow = flow
+        .workflow("state-test")
+        .step("set-values", async (ctx) => {
+          ctx.set("key1", "value1");
+          ctx.set("key2", 42);
+        })
+        .step("read-values", async (ctx) => {
+          expect(ctx.get("key1")).toBe("value1");
+          expect(ctx.get("key2")).toBe(42);
+        })
+        .build();
+
+      await workflow.execute({});
+      await new Promise((r) => setTimeout(r, 100));
+    });
+
+    it("should track execution status", async () => {
+      const workflow = flow
+        .workflow("status-test")
+        .step("work", async (ctx) => {
+          await new Promise((r) => setTimeout(r, 50));
+        })
+        .build();
+
+      const execution = await workflow.execute({ test: true });
+
+      expect(execution.status).toBe("running");
+      expect(execution.input).toEqual({ test: true });
+
+      await new Promise((r) => setTimeout(r, 150));
+
+      const result = await workflow.getExecution(execution.id);
+      expect(result.status).toBe("completed");
+    });
+  });
+
+  describe("Workflow Error Handling", () => {
+    it("should handle step failures", async () => {
+      const workflow = flow
+        .workflow("error-test")
+        .step("failing-step", async (ctx) => {
+          throw new Error("Step failed");
+        })
+        .build();
+
+      const execution = await workflow.execute({});
+      await new Promise((r) => setTimeout(r, 100));
+
+      const result = await workflow.getExecution(execution.id);
+      expect(result.status).toBe("failed");
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe("Workflow Listing and Filtering", () => {
+    it("should list executions", async () => {
+      const workflow = flow
+        .workflow("list-test")
+        .step("step1", async () => {})
+        .build();
+
+      await workflow.execute({ id: 1 });
+      await workflow.execute({ id: 2 });
+      await new Promise((r) => setTimeout(r, 100));
+
+      const executions = await workflow.listExecutions();
+      expect(executions.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("should filter executions by status", async () => {
+      const workflow = flow
+        .workflow("filter-test")
+        .step("work", async () => {
+          await new Promise((r) => setTimeout(r, 50));
+        })
+        .build();
+
+      await workflow.execute({ id: 1 });
+      await workflow.execute({ id: 2 });
+
+      await new Promise((r) => setTimeout(r, 20)); // Some running
+
+      const running = await workflow.listExecutions({ status: "running" });
+      expect(running.length).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe("Workflow Cancel and Retry", () => {
+    it("should cancel running execution", async () => {
+      const workflow = flow
+        .workflow("cancel-test")
+        .step("long-step", async () => {
+          await new Promise((r) => setTimeout(r, 500));
+        })
+        .build();
+
+      const execution = await workflow.execute({});
+
+      await new Promise((r) => setTimeout(r, 50));
+      await workflow.cancelExecution(execution.id);
+
+      const result = await workflow.getExecution(execution.id);
+      expect(result.status).toBe("cancelled");
+    });
+
+    it("should retry failed execution", async () => {
+      let attempts = 0;
+
+      const workflow = flow
+        .workflow("retry-test")
+        .step("flaky-step", async () => {
+          attempts++;
+          if (attempts === 1) {
+            throw new Error("First attempt fails");
+          }
+        })
+        .build();
+
+      const execution = await workflow.execute({});
+      await new Promise((r) => setTimeout(r, 100));
+
+      // First execution should fail
+      let result = await workflow.getExecution(execution.id);
+      expect(result.status).toBe("failed");
+
+      // Retry should create new execution
+      const retried = await workflow.retryExecution(execution.id);
+      await new Promise((r) => setTimeout(r, 100));
+
+      result = await workflow.getExecution(retried.id);
+      expect(result.status).toBe("completed");
+      expect(attempts).toBe(2);
+    });
+  });
+
+  describe("Workflow History", () => {
+    it("should track execution history", async () => {
+      const workflow = flow
+        .workflow("history-test")
+        .step("step1", async () => {})
+        .step("step2", async () => {})
+        .build();
+
+      const execution = await workflow.execute({});
+      await new Promise((r) => setTimeout(r, 100));
+
+      const history = await workflow.getExecutionHistory(execution.id);
+
+      expect(history.length).toBeGreaterThan(0);
+
+      const types = history.map((e) => e.type);
+      expect(types).toContain("execution.started");
+      expect(types).toContain("step.started");
+      expect(types).toContain("step.completed");
+    });
+  });
+
+  describe("Workflow Metrics", () => {
+    it("should collect workflow metrics", async () => {
+      const workflow = flow
+        .workflow("metrics-test")
+        .step("work", async () => {
+          await new Promise((r) => setTimeout(r, 10));
+        })
+        .build();
+
+      await workflow.execute({ id: 1 });
+      await workflow.execute({ id: 2 });
+      await new Promise((r) => setTimeout(r, 100));
+
+      const metrics = await workflow.getMetrics();
+
+      expect(metrics.totalExecutions).toBe(2);
+      expect(metrics.successRate).toBeGreaterThan(0);
+      expect(metrics.avgDuration).toBeGreaterThan(0);
+    });
+  });
+
+  describe("Conditional Branching", () => {
+    it("should execute conditional branches", async () => {
+      let branchTaken = "";
+
+      const thenBranch = flow
+        .workflow("then-branch")
+        .step("then-step", async () => {
+          branchTaken = "then";
+        });
+
+      const elseBranch = flow
+        .workflow("else-branch")
+        .step("else-step", async () => {
+          branchTaken = "else";
+        });
+
+      const workflow = flow
+        .workflow("branch-test")
+        .branch({
+          condition: (ctx) => ctx.input.value > 10,
+          then: thenBranch as any,
+          else: elseBranch as any,
+        })
+        .build();
+
+      await workflow.execute({ value: 15 });
+      await new Promise((r) => setTimeout(r, 100));
+
+      expect(branchTaken).toBe("then");
+
+      branchTaken = "";
+      await workflow.execute({ value: 5 });
+      await new Promise((r) => setTimeout(r, 100));
+
+      expect(branchTaken).toBe("else");
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2020", "DOM"],
+    "declaration": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+});

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/*.test.ts', 'src/index.ts', 'src/queue/types.ts', 'src/stream/types.ts', 'src/workflow/types.ts'],
+    },
+  },
+});