@griffin-app/griffin-executor 0.1.0

package/src/events/adapters/in-memory.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { InMemoryAdapter } from "./in-memory.js";
+import type { ExecutionEvent } from "../types.js";
+
+describe("InMemoryAdapter", () => {
+  let adapter: InMemoryAdapter;
+
+  beforeEach(() => {
+    adapter = new InMemoryAdapter();
+  });
+
+  const createMockEvent = (
+    type: ExecutionEvent["type"],
+    executionId: string,
+    seq: number,
+  ): ExecutionEvent =>
+    ({
+      type,
+      event_id: `event-${seq}`,
+      seq,
+      timestamp: Date.now(),
+      monitor_id: "monitor-1",
+      execution_id: executionId,
+      organization_id: "org-1",
+      monitor_name: "Test Monitor",
+      monitor_version: "1.0.0",
+      node_count: 1,
+      edge_count: 1,
+    }) as ExecutionEvent;
+
+  describe("publish", () => {
+    it("should store events", async () => {
+      const events = [
+        createMockEvent("MONITOR_START", "exec-1", 0),
+        createMockEvent("MONITOR_END", "exec-1", 1),
+      ];
+
+      await adapter.publish(events);
+
+      const stored = adapter.getEvents();
+      expect(stored).toHaveLength(2);
+      expect(stored[0].type).toBe("MONITOR_START");
+      expect(stored[1].type).toBe("MONITOR_END");
+    });
+
+    it("should track publish count", async () => {
+      await adapter.publish([createMockEvent("MONITOR_START", "exec-1", 0)]);
+      await adapter.publish([createMockEvent("MONITOR_END", "exec-1", 1)]);
+
+      expect(adapter.getPublishCount()).toBe(2);
+    });
+
+    it("should append events across multiple publishes", async () => {
+      await adapter.publish([createMockEvent("MONITOR_START", "exec-1", 0)]);
+      await adapter.publish([createMockEvent("MONITOR_END", "exec-1", 1)]);
+
+      const events = adapter.getEvents();
+      expect(events).toHaveLength(2);
+    });
+  });
+
+  describe("getEventsByType", () => {
+    it("should filter events by type", async () => {
+      const events = [
+        createMockEvent("MONITOR_START", "exec-1", 0),
+        createMockEvent("MONITOR_END", "exec-1", 1),
+        createMockEvent("MONITOR_START", "exec-2", 2),
+      ];
+
+      await adapter.publish(events);
+
+      const planStartEvents = adapter.getEventsByType("MONITOR_START");
+      expect(planStartEvents).toHaveLength(2);
+      expect(planStartEvents.every((e) => e.type === "MONITOR_START")).toBe(
+        true,
+      );
+    });
+  });
+
+  describe("getEventsForExecution", () => {
+    it("should filter events by executionId", async () => {
+      const events = [
+        createMockEvent("MONITOR_START", "exec-1", 0),
+        createMockEvent("MONITOR_END", "exec-1", 1),
+        createMockEvent("MONITOR_START", "exec-2", 2),
+      ];
+
+      await adapter.publish(events);
+
+      const exec1Events = adapter.getEventsForExecution("exec-1");
+      expect(exec1Events).toHaveLength(2);
+      expect(exec1Events.every((e) => e.execution_id === "exec-1")).toBe(true);
+    });
+  });
+
+  describe("clear", () => {
+    it("should clear all events and reset counters", async () => {
+      await adapter.publish([createMockEvent("MONITOR_START", "exec-1", 0)]);
+
+      adapter.clear();
+
+      expect(adapter.getEvents()).toHaveLength(0);
+      expect(adapter.getPublishCount()).toBe(0);
+    });
+  });
+
+  describe.skip("latency simulation", () => {
+    it("should simulate latency", async () => {
+      const adapterWithLatency = new InMemoryAdapter({ latencyMs: 50 });
+      const start = Date.now();
+
+      await adapterWithLatency.publish([
+        createMockEvent("MONITOR_START", "exec-1", 0),
+      ]);
+
+      const duration = Date.now() - start;
+      expect(duration).toBeGreaterThanOrEqual(50);
+    });
+  });
+
+  describe("failure simulation", () => {
+    it("should simulate failures", async () => {
+      const adapterWithFailures = new InMemoryAdapter({
+        failureProbability: 1.0, // Always fail
+      });
+
+      await expect(
+        adapterWithFailures.publish([
+          createMockEvent("MONITOR_START", "exec-1", 0),
+        ]),
+      ).rejects.toThrow("Simulated publish failure");
+    });
+
+    it("should succeed when failure probability is 0", async () => {
+      const adapterNoFailures = new InMemoryAdapter({
+        failureProbability: 0.0,
+      });
+
+      await expect(
+        adapterNoFailures.publish([
+          createMockEvent("MONITOR_START", "exec-1", 0),
+        ]),
+      ).resolves.not.toThrow();
+    });
+  });
+});

package/src/events/adapters/in-memory.ts

@@ -0,0 +1,93 @@
+/**
+ * In-memory event bus adapter for testing and local development.
+ *
+ * Stores events in memory and provides access for inspection.
+ * Useful for testing the DurableEventEmitter batching behavior without
+ * requiring actual infrastructure.
+ */
+
+import type { DurableEventBusAdapter } from "../emitter.js";
+import type { ExecutionEvent } from "../types.js";
+
+/**
+ * In-memory adapter that stores events for inspection.
+ *
+ * Primarily useful for testing and development.
+ * Can simulate failures and latency.
+ */
+export class InMemoryAdapter implements DurableEventBusAdapter {
+  private readonly events: ExecutionEvent[] = [];
+  private publishCount = 0;
+
+  constructor(
+    private options: {
+      /** Simulate latency in milliseconds */
+      latencyMs?: number;
+      /** Probability of failure (0-1) for testing error handling */
+      failureProbability?: number;
+    } = {},
+  ) {}
+
+  async publish(events: ExecutionEvent[]): Promise<void> {
+    // Simulate latency
+    if (this.options.latencyMs) {
+      await this.sleep(this.options.latencyMs);
+    }
+
+    // Simulate failures
+    if (
+      this.options.failureProbability &&
+      Math.random() < this.options.failureProbability
+    ) {
+      throw new Error("Simulated publish failure");
+    }
+
+    this.events.push(...events);
+    this.publishCount++;
+  }
+
+  /**
+   * Get all published events.
+   */
+  getEvents(): ExecutionEvent[] {
+    return [...this.events];
+  }
+
+  /**
+   * Get events by type.
+   */
+  getEventsByType<T extends ExecutionEvent["type"]>(
+    type: T,
+  ): Array<Extract<ExecutionEvent, { type: T }>> {
+    return this.events.filter((e) => e.type === type) as Array<
+      Extract<ExecutionEvent, { type: T }>
+    >;
+  }
+
+  /**
+   * Get events for a specific execution.
+   */
+  getEventsForExecution(executionId: string): ExecutionEvent[] {
+    return this.events.filter((e) => e.execution_id === executionId);
+  }
+
+  /**
+   * Get the number of times publish() was called.
+   * Useful for verifying batching behavior.
+   */
+  getPublishCount(): number {
+    return this.publishCount;
+  }
+
+  /**
+   * Clear all stored events.
+   */
+  clear(): void {
+    this.events.length = 0;
+    this.publishCount = 0;
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/events/adapters/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Event bus adapters for durable event publishing.
+ *
+ * These adapters implement the DurableEventBusAdapter interface
+ * and can be used with the DurableEventEmitter for batched event publishing.
+ */
+
+export * from "./kinesis.js";
+export * from "./in-memory.js";

package/src/events/adapters/kinesis.test.ts

@@ -0,0 +1,323 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { KinesisAdapter } from "./kinesis.js";
+import type { ExecutionEvent } from "../types.js";
+import type { KinesisClient } from "@aws-sdk/client-kinesis";
+
+describe("KinesisAdapter", () => {
+  const createMockEvent = (
+    type: ExecutionEvent["type"],
+    executionId: string,
+    organizationId: string,
+    seq: number,
+  ): ExecutionEvent =>
+    ({
+      type,
+      event_id: `event-${seq}`,
+      seq,
+      timestamp: Date.now(),
+      monitor_id: "monitor-1",
+      execution_id: executionId,
+      organization_id: organizationId,
+      monitor_name: "Test Monitor",
+      monitor_version: "1.0.0",
+      node_count: 1,
+      edge_count: 1,
+    }) as ExecutionEvent;
+
+  describe("publish", () => {
+    it("should publish events successfully", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        FailedRecordCount: 0,
+        Records: [{ SequenceNumber: "seq-1", ShardId: "shard-1" }],
+      });
+
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+      });
+
+      const events = [createMockEvent("MONITOR_START", "exec-1", "org-1", 0)];
+
+      await adapter.publish(events);
+
+      expect(mockSend).toHaveBeenCalledOnce();
+      const command = mockSend.mock.calls[0][0];
+      expect(command.input.StreamName).toBe("test-stream");
+      expect(command.input.Records).toHaveLength(1);
+    });
+
+    it("should handle empty event array", async () => {
+      const mockSend = vi.fn();
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+      });
+
+      await adapter.publish([]);
+
+      expect(mockSend).not.toHaveBeenCalled();
+    });
+
+    it("should batch events into chunks of 500", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        FailedRecordCount: 0,
+        Records: [],
+      });
+
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+      });
+
+      // Create 1250 events (should result in 3 batches: 500, 500, 250)
+      const events = Array.from({ length: 1250 }, (_, i) =>
+        createMockEvent("MONITOR_START", "exec-1", "org-1", i),
+      );
+
+      await adapter.publish(events);
+
+      expect(mockSend).toHaveBeenCalledTimes(3);
+      expect(mockSend.mock.calls[0][0].input.Records).toHaveLength(500);
+      expect(mockSend.mock.calls[1][0].input.Records).toHaveLength(500);
+      expect(mockSend.mock.calls[2][0].input.Records).toHaveLength(250);
+    });
+  });
+
+  describe("partition key strategies", () => {
+    it("should use executionId as partition key by default", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        FailedRecordCount: 0,
+        Records: [],
+      });
+
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+      });
+
+      const events = [
+        createMockEvent("MONITOR_START", "exec-123", "org-456", 0),
+      ];
+
+      await adapter.publish(events);
+
+      const records = mockSend.mock.calls[0][0].input.Records;
+      expect(records[0].PartitionKey).toBe("exec-123");
+    });
+
+    it("should use organizationId as partition key when configured", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        FailedRecordCount: 0,
+        Records: [],
+      });
+
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+        partitionKeyStrategy: "organizationId",
+      });
+
+      const events = [
+        createMockEvent("MONITOR_START", "exec-123", "org-456", 0),
+      ];
+
+      await adapter.publish(events);
+
+      const records = mockSend.mock.calls[0][0].input.Records;
+      expect(records[0].PartitionKey).toBe("org-456");
+    });
+
+    it("should use composite partition key when configured", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        FailedRecordCount: 0,
+        Records: [],
+      });
+
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+        partitionKeyStrategy: "composite",
+      });
+
+      const events = [
+        createMockEvent("MONITOR_START", "exec-123", "org-456", 0),
+      ];
+
+      await adapter.publish(events);
+
+      const records = mockSend.mock.calls[0][0].input.Records;
+      expect(records[0].PartitionKey).toBe("org-456:exec-123");
+    });
+  });
+
+  describe("retry logic", () => {
+    it("should retry failed records with exponential backoff", async () => {
+      let callCount = 0;
+      const mockSend = vi.fn().mockImplementation(() => {
+        callCount++;
+        if (callCount === 1) {
+          // First call: one record fails
+          return Promise.resolve({
+            FailedRecordCount: 1,
+            Records: [{ ErrorCode: "ProvisionedThroughputExceededException" }],
+          });
+        }
+        // Second call: success
+        return Promise.resolve({
+          FailedRecordCount: 0,
+          Records: [{ SequenceNumber: "seq-1", ShardId: "shard-1" }],
+        });
+      });
+
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+        maxRetries: 3,
+        retryDelayMs: 10, // Short delay for testing
+      });
+
+      const events = [createMockEvent("MONITOR_START", "exec-1", "org-1", 0)];
+
+      await adapter.publish(events);
+
+      expect(mockSend).toHaveBeenCalledTimes(2); // Initial + 1 retry
+    });
+
+    it("should stop retrying after max attempts", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        FailedRecordCount: 1,
+        Records: [{ ErrorCode: "ProvisionedThroughputExceededException" }],
+      });
+
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+        maxRetries: 2,
+        retryDelayMs: 10,
+      });
+
+      const events = [createMockEvent("MONITOR_START", "exec-1", "org-1", 0)];
+
+      // Should not throw, but log errors
+      await adapter.publish(events);
+
+      expect(mockSend).toHaveBeenCalledTimes(3); // Initial + 2 retries
+    });
+
+    it("should retry on client errors", async () => {
+      let callCount = 0;
+      const mockSend = vi.fn().mockImplementation(() => {
+        callCount++;
+        if (callCount === 1) {
+          return Promise.reject(new Error("Network error"));
+        }
+        return Promise.resolve({
+          FailedRecordCount: 0,
+          Records: [{ SequenceNumber: "seq-1", ShardId: "shard-1" }],
+        });
+      });
+
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+        maxRetries: 3,
+        retryDelayMs: 10,
+      });
+
+      const events = [createMockEvent("MONITOR_START", "exec-1", "org-1", 0)];
+
+      await adapter.publish(events);
+
+      expect(mockSend).toHaveBeenCalledTimes(2); // Initial + 1 retry
+    });
+
+    it("should throw after max retries on client errors", async () => {
+      const mockSend = vi.fn().mockRejectedValue(new Error("Network error"));
+
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+        maxRetries: 2,
+        retryDelayMs: 10,
+      });
+
+      const events = [createMockEvent("MONITOR_START", "exec-1", "org-1", 0)];
+
+      await expect(adapter.publish(events)).rejects.toThrow("Network error");
+      expect(mockSend).toHaveBeenCalledTimes(3); // Initial + 2 retries
+    });
+  });
+
+  describe("event serialization", () => {
+    it("should serialize events as JSON", async () => {
+      const mockSend = vi.fn().mockResolvedValue({
+        FailedRecordCount: 0,
+        Records: [],
+      });
+
+      const mockClient = {
+        send: mockSend,
+      } as unknown as KinesisClient;
+
+      const adapter = new KinesisAdapter({
+        client: mockClient,
+        streamName: "test-stream",
+      });
+
+      const event = createMockEvent("MONITOR_START", "exec-1", "org-1", 0);
+      await adapter.publish([event]);
+
+      const records = mockSend.mock.calls[0][0].input.Records;
+      const data = records[0].Data;
+
+      // Decode the Uint8Array back to JSON
+      const decoder = new TextDecoder();
+      const json = decoder.decode(data);
+      const parsed = JSON.parse(json);
+
+      expect(parsed.type).toBe("MONITOR_START");
+      expect(parsed.execution_id).toBe("exec-1");
+      expect(parsed.organization_id).toBe("org-1");
+    });
+  });
+});