@multiplier-labs/stepflow 0.3.1 → 0.3.4

package/src/events/memory.test.ts

@@ -1,96 +1,94 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { MemoryEventTransport } from "./memory";
-import type { WorkflowEvent, WorkflowEventType } from "./types";
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { MemoryEventTransport } from './memory';
+import type { WorkflowEvent, WorkflowEventType } from './types';
 
-function createTestEvent(
-  overrides: Partial<WorkflowEvent> = {},
-): WorkflowEvent {
+function createTestEvent(overrides: Partial<WorkflowEvent> = {}): WorkflowEvent {
   return {
-    eventType: "run.started",
-    runId: "run-123",
-    kind: "test.workflow",
-    timestamp: new Date("2024-01-01T12:00:00Z"),
+    eventType: 'run.started',
+    runId: 'run-123',
+    kind: 'test.workflow',
+    timestamp: new Date('2024-01-01T12:00:00Z'),
     ...overrides,
   };
 }
 
-describe("MemoryEventTransport", () => {
+describe('MemoryEventTransport', () => {
   let transport: MemoryEventTransport;
 
   beforeEach(() => {
     transport = new MemoryEventTransport();
   });
 
-  describe("subscribeToType", () => {
-    it("should call callback when event of matching type is emitted", () => {
+  describe('subscribeToType', () => {
+    it('should call callback when event of matching type is emitted', () => {
       const callback = vi.fn();
-      transport.subscribeToType("run.completed", callback);
+      transport.subscribeToType('run.completed', callback);
 
-      const event = createTestEvent({ eventType: "run.completed" });
+      const event = createTestEvent({ eventType: 'run.completed' });
       transport.emit(event);
 
       expect(callback).toHaveBeenCalledWith(event);
     });
 
-    it("should not call callback for events of a different type", () => {
+    it('should not call callback for events of a different type', () => {
       const callback = vi.fn();
-      transport.subscribeToType("run.completed", callback);
+      transport.subscribeToType('run.completed', callback);
 
-      transport.emit(createTestEvent({ eventType: "run.started" }));
+      transport.emit(createTestEvent({ eventType: 'run.started' }));
 
       expect(callback).not.toHaveBeenCalled();
     });
 
-    it("should unsubscribe when calling the returned function", () => {
+    it('should unsubscribe when calling the returned function', () => {
       const callback = vi.fn();
-      const unsubscribe = transport.subscribeToType("run.completed", callback);
+      const unsubscribe = transport.subscribeToType('run.completed', callback);
 
       // Emit once before unsubscribe
-      transport.emit(createTestEvent({ eventType: "run.completed" }));
+      transport.emit(createTestEvent({ eventType: 'run.completed' }));
       expect(callback).toHaveBeenCalledTimes(1);
 
       unsubscribe();
 
       // Emit again after unsubscribe
-      transport.emit(createTestEvent({ eventType: "run.completed" }));
+      transport.emit(createTestEvent({ eventType: 'run.completed' }));
       expect(callback).toHaveBeenCalledTimes(1);
     });
 
-    it("should support multiple type subscriptions independently", () => {
+    it('should support multiple type subscriptions independently', () => {
       const completedCb = vi.fn();
       const failedCb = vi.fn();
-      transport.subscribeToType("run.completed", completedCb);
-      transport.subscribeToType("run.failed", failedCb);
+      transport.subscribeToType('run.completed', completedCb);
+      transport.subscribeToType('run.failed', failedCb);
 
-      transport.emit(createTestEvent({ eventType: "run.completed" }));
+      transport.emit(createTestEvent({ eventType: 'run.completed' }));
 
       expect(completedCb).toHaveBeenCalledTimes(1);
       expect(failedCb).not.toHaveBeenCalled();
     });
   });
 
-  describe("getListenerCount", () => {
-    it("should return 0 when no listeners are registered", () => {
+  describe('getListenerCount', () => {
+    it('should return 0 when no listeners are registered', () => {
       expect(transport.getListenerCount()).toBe(0);
     });
 
-    it("should return global listener count when called without channel", () => {
+    it('should return global listener count when called without channel', () => {
       transport.subscribeAll(vi.fn());
       transport.subscribeAll(vi.fn());
 
       expect(transport.getListenerCount()).toBe(2);
     });
 
-    it("should return channel-specific listener count when called with channel", () => {
-      transport.subscribe("run-1", vi.fn());
-      transport.subscribe("run-1", vi.fn());
-      transport.subscribe("run-2", vi.fn());
+    it('should return channel-specific listener count when called with channel', () => {
+      transport.subscribe('run-1', vi.fn());
+      transport.subscribe('run-1', vi.fn());
+      transport.subscribe('run-2', vi.fn());
 
-      expect(transport.getListenerCount("run:run-1")).toBe(2);
-      expect(transport.getListenerCount("run:run-2")).toBe(1);
+      expect(transport.getListenerCount('run:run-1')).toBe(2);
+      expect(transport.getListenerCount('run:run-2')).toBe(1);
     });
 
-    it("should update count after subscribe and unsubscribe", () => {
+    it('should update count after subscribe and unsubscribe', () => {
       const unsub = transport.subscribeAll(vi.fn());
       expect(transport.getListenerCount()).toBe(1);
 
@@ -98,12 +96,12 @@ describe("MemoryEventTransport", () => {
       expect(transport.getListenerCount()).toBe(0);
     });
 
-    it("should return count for type-based channels", () => {
-      transport.subscribeToType("step.completed", vi.fn());
-      transport.subscribeToType("step.completed", vi.fn());
+    it('should return count for type-based channels', () => {
+      transport.subscribeToType('step.completed', vi.fn());
+      transport.subscribeToType('step.completed', vi.fn());
 
-      expect(transport.getListenerCount("type:step.completed")).toBe(2);
-      expect(transport.getListenerCount("type:step.failed")).toBe(0);
+      expect(transport.getListenerCount('type:step.completed')).toBe(2);
+      expect(transport.getListenerCount('type:step.failed')).toBe(0);
     });
   });
 });

package/src/events/memory.ts

@@ -6,14 +6,14 @@
  * all state in-process with no persistence or multi-process safety guarantees.
  */
 
-import { EventEmitter } from "events";
+import { EventEmitter } from 'events';
 import type {
   EventTransport,
   WorkflowEvent,
   WorkflowEventType,
   EventCallback,
   Unsubscribe,
-} from "./types";
+} from './types';
 
 /**
  * In-memory event transport implementation using EventEmitter.
@@ -32,7 +32,7 @@ export class MemoryEventTransport implements EventTransport {
    */
   emit(event: WorkflowEvent): void {
     // Emit to global subscribers
-    this.emitter.emit("event", event);
+    this.emitter.emit('event', event);
 
     // Emit to run-specific subscribers
     this.emitter.emit(`run:${event.runId}`, event);
@@ -56,19 +56,16 @@ export class MemoryEventTransport implements EventTransport {
    * Subscribe to all events.
    */
   subscribeAll(callback: EventCallback): Unsubscribe {
-    this.emitter.on("event", callback);
+    this.emitter.on('event', callback);
     return () => {
-      this.emitter.off("event", callback);
+      this.emitter.off('event', callback);
     };
   }
 
   /**
    * Subscribe to events of a specific type.
    */
-  subscribeToType(
-    eventType: WorkflowEventType,
-    callback: EventCallback,
-  ): Unsubscribe {
+  subscribeToType(eventType: WorkflowEventType, callback: EventCallback): Unsubscribe {
     const channel = `type:${eventType}`;
     this.emitter.on(channel, callback);
     return () => {
@@ -90,6 +87,6 @@ export class MemoryEventTransport implements EventTransport {
     if (channel) {
       return this.emitter.listenerCount(channel);
     }
-    return this.emitter.listenerCount("event");
+    return this.emitter.listenerCount('event');
   }
 }