@multiplier-labs/stepflow 0.3.1 → 0.3.4

package/src/events/socketio.test.ts

@@ -1,10 +1,6 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import {
-  SocketIOEventTransport,
-  SocketIOServer,
-  SocketIOSocket,
-} from "./socketio";
-import type { WorkflowEvent } from "./types";
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SocketIOEventTransport, SocketIOServer, SocketIOSocket } from './socketio';
+import type { WorkflowEvent } from './types';
 
 // Mock Socket.IO server
 function createMockServer(): SocketIOServer & {
@@ -52,19 +48,17 @@ function createMockSocket(): SocketIOSocket & {
   };
 }
 
-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("SocketIOEventTransport", () => {
+describe('SocketIOEventTransport', () => {
   let io: ReturnType<typeof createMockServer>;
   let transport: SocketIOEventTransport;
 
@@ -73,130 +67,124 @@ describe("SocketIOEventTransport", () => {
     transport = new SocketIOEventTransport({ io });
   });
 
-  describe("emit", () => {
-    it("should emit event to run-specific room", () => {
-      const event = createTestEvent({ runId: "run-456" });
+  describe('emit', () => {
+    it('should emit event to run-specific room', () => {
+      const event = createTestEvent({ runId: 'run-456' });
       transport.emit(event);
 
-      const roomEmit = io._rooms.get("run:run-456");
+      const roomEmit = io._rooms.get('run:run-456');
       expect(roomEmit).toBeDefined();
-      expect(roomEmit!.emit).toHaveBeenCalledWith("workflow:event", {
+      expect(roomEmit!.emit).toHaveBeenCalledWith('workflow:event', {
         ...event,
-        timestamp: "2024-01-01T12:00:00.000Z",
+        timestamp: '2024-01-01T12:00:00.000Z',
       });
     });
 
-    it("should emit event to global room by default", () => {
+    it('should emit event to global room by default', () => {
       const event = createTestEvent();
       transport.emit(event);
 
-      const globalRoomEmit = io._rooms.get("workflow:all");
+      const globalRoomEmit = io._rooms.get('workflow:all');
       expect(globalRoomEmit).toBeDefined();
       expect(globalRoomEmit!.emit).toHaveBeenCalled();
     });
 
-    it("should not emit to global room when broadcastGlobal is false", () => {
+    it('should not emit to global room when broadcastGlobal is false', () => {
       transport = new SocketIOEventTransport({ io, broadcastGlobal: false });
       const event = createTestEvent();
       transport.emit(event);
 
       // Should only have run-specific room, not global
       expect(io._rooms.size).toBe(1);
-      expect(io._rooms.has("run:run-123")).toBe(true);
-      expect(io._rooms.has("workflow:all")).toBe(false);
+      expect(io._rooms.has('run:run-123')).toBe(true);
+      expect(io._rooms.has('workflow:all')).toBe(false);
     });
 
-    it("should use custom event name", () => {
-      transport = new SocketIOEventTransport({ io, eventName: "custom:event" });
+    it('should use custom event name', () => {
+      transport = new SocketIOEventTransport({ io, eventName: 'custom:event' });
       const event = createTestEvent();
       transport.emit(event);
 
-      const roomEmit = io._rooms.get("run:run-123");
-      expect(roomEmit!.emit).toHaveBeenCalledWith(
-        "custom:event",
-        expect.any(Object),
-      );
+      const roomEmit = io._rooms.get('run:run-123');
+      expect(roomEmit!.emit).toHaveBeenCalledWith('custom:event', expect.any(Object));
     });
 
-    it("should use custom room prefix", () => {
-      transport = new SocketIOEventTransport({ io, roomPrefix: "workflow:" });
-      const event = createTestEvent({ runId: "xyz" });
+    it('should use custom room prefix', () => {
+      transport = new SocketIOEventTransport({ io, roomPrefix: 'workflow:' });
+      const event = createTestEvent({ runId: 'xyz' });
       transport.emit(event);
 
-      expect(io._rooms.has("workflow:xyz")).toBe(true);
+      expect(io._rooms.has('workflow:xyz')).toBe(true);
     });
 
-    it("should serialize timestamp to ISO string", () => {
+    it('should serialize timestamp to ISO string', () => {
       const event = createTestEvent({
-        timestamp: new Date("2024-06-15T10:30:00Z"),
+        timestamp: new Date('2024-06-15T10:30:00Z'),
       });
       transport.emit(event);
 
-      const roomEmit = io._rooms.get("run:run-123");
-      const emittedEvent = roomEmit!.emit.mock.calls[0][1] as Record<
-        string,
-        unknown
-      >;
-      expect(emittedEvent.timestamp).toBe("2024-06-15T10:30:00.000Z");
+      const roomEmit = io._rooms.get('run:run-123');
+      const emittedEvent = roomEmit!.emit.mock.calls[0][1] as Record<string, unknown>;
+      expect(emittedEvent.timestamp).toBe('2024-06-15T10:30:00.000Z');
     });
   });
 
-  describe("subscribe", () => {
-    it("should call callback when event matches runId", () => {
+  describe('subscribe', () => {
+    it('should call callback when event matches runId', () => {
       const callback = vi.fn();
-      transport.subscribe("run-123", callback);
+      transport.subscribe('run-123', callback);
 
-      const event = createTestEvent({ runId: "run-123" });
+      const event = createTestEvent({ runId: 'run-123' });
       transport.emit(event);
 
       expect(callback).toHaveBeenCalledWith(event);
     });
 
-    it("should not call callback for different runId", () => {
+    it('should not call callback for different runId', () => {
       const callback = vi.fn();
-      transport.subscribe("run-123", callback);
+      transport.subscribe('run-123', callback);
 
-      const event = createTestEvent({ runId: "run-456" });
+      const event = createTestEvent({ runId: 'run-456' });
       transport.emit(event);
 
       expect(callback).not.toHaveBeenCalled();
     });
 
-    it("should allow multiple subscribers for same runId", () => {
+    it('should allow multiple subscribers for same runId', () => {
       const callback1 = vi.fn();
       const callback2 = vi.fn();
-      transport.subscribe("run-123", callback1);
-      transport.subscribe("run-123", callback2);
+      transport.subscribe('run-123', callback1);
+      transport.subscribe('run-123', callback2);
 
-      const event = createTestEvent({ runId: "run-123" });
+      const event = createTestEvent({ runId: 'run-123' });
       transport.emit(event);
 
       expect(callback1).toHaveBeenCalledWith(event);
       expect(callback2).toHaveBeenCalledWith(event);
     });
 
-    it("should unsubscribe when calling returned function", () => {
+    it('should unsubscribe when calling returned function', () => {
       const callback = vi.fn();
-      const unsubscribe = transport.subscribe("run-123", callback);
+      const unsubscribe = transport.subscribe('run-123', callback);
 
       unsubscribe();
 
-      const event = createTestEvent({ runId: "run-123" });
+      const event = createTestEvent({ runId: 'run-123' });
       transport.emit(event);
 
       expect(callback).not.toHaveBeenCalled();
     });
 
-    it("should handle callback errors gracefully", () => {
+    it('should handle callback errors gracefully', () => {
       const errorCallback = vi.fn().mockImplementation(() => {
-        throw new Error("Callback error");
+        throw new Error('Callback error');
       });
       const normalCallback = vi.fn();
 
-      transport.subscribe("run-123", errorCallback);
-      transport.subscribe("run-123", normalCallback);
+      transport.subscribe('run-123', errorCallback);
+      transport.subscribe('run-123', normalCallback);
 
-      const event = createTestEvent({ runId: "run-123" });
+      const event = createTestEvent({ runId: 'run-123' });
       transport.emit(event);
 
       // Both callbacks should have been called despite error
@@ -205,13 +193,13 @@ describe("SocketIOEventTransport", () => {
     });
   });
 
-  describe("subscribeAll", () => {
-    it("should call callback for all events", () => {
+  describe('subscribeAll', () => {
+    it('should call callback for all events', () => {
       const callback = vi.fn();
       transport.subscribeAll(callback);
 
-      const event1 = createTestEvent({ runId: "run-1" });
-      const event2 = createTestEvent({ runId: "run-2" });
+      const event1 = createTestEvent({ runId: 'run-1' });
+      const event2 = createTestEvent({ runId: 'run-2' });
       transport.emit(event1);
       transport.emit(event2);
 
@@ -220,7 +208,7 @@ describe("SocketIOEventTransport", () => {
       expect(callback).toHaveBeenCalledWith(event2);
     });
 
-    it("should unsubscribe when calling returned function", () => {
+    it('should unsubscribe when calling returned function', () => {
       const callback = vi.fn();
       const unsubscribe = transport.subscribeAll(callback);
 
@@ -233,80 +221,74 @@ describe("SocketIOEventTransport", () => {
     });
   });
 
-  describe("setupClientHandlers", () => {
+  describe('setupClientHandlers', () => {
     const allowAll = vi.fn().mockResolvedValue(true);
 
-    it("should register subscription handlers on socket", () => {
+    it('should register subscription handlers on socket', () => {
       const socket = createMockSocket();
       transport.setupClientHandlers(socket, allowAll);
 
-      expect(socket._handlers.has("workflow:subscribe")).toBe(true);
-      expect(socket._handlers.has("workflow:unsubscribe")).toBe(true);
-      expect(socket._handlers.has("workflow:subscribe:all")).toBe(true);
-      expect(socket._handlers.has("workflow:unsubscribe:all")).toBe(true);
+      expect(socket._handlers.has('workflow:subscribe')).toBe(true);
+      expect(socket._handlers.has('workflow:unsubscribe')).toBe(true);
+      expect(socket._handlers.has('workflow:subscribe:all')).toBe(true);
+      expect(socket._handlers.has('workflow:unsubscribe:all')).toBe(true);
     });
 
-    it("should join run-specific room on subscribe when authorized", async () => {
+    it('should join run-specific room on subscribe when authorized', async () => {
       const socket = createMockSocket();
       transport.setupClientHandlers(socket, allowAll);
 
-      const subscribeHandler = socket._handlers.get("workflow:subscribe")!;
-      await subscribeHandler("run-123");
+      const subscribeHandler = socket._handlers.get('workflow:subscribe')!;
+      await subscribeHandler('run-123');
 
-      expect(socket._joinedRooms.has("run:run-123")).toBe(true);
+      expect(socket._joinedRooms.has('run:run-123')).toBe(true);
     });
 
-    it("should leave run-specific room on unsubscribe", async () => {
+    it('should leave run-specific room on unsubscribe', async () => {
       const socket = createMockSocket();
       transport.setupClientHandlers(socket, allowAll);
 
       // First subscribe
-      const subscribeHandler = socket._handlers.get("workflow:subscribe")!;
-      await subscribeHandler("run-123");
+      const subscribeHandler = socket._handlers.get('workflow:subscribe')!;
+      await subscribeHandler('run-123');
 
       // Then unsubscribe
-      const unsubscribeHandler = socket._handlers.get("workflow:unsubscribe")!;
-      unsubscribeHandler("run-123");
+      const unsubscribeHandler = socket._handlers.get('workflow:unsubscribe')!;
+      unsubscribeHandler('run-123');
 
-      expect(socket._joinedRooms.has("run:run-123")).toBe(false);
+      expect(socket._joinedRooms.has('run:run-123')).toBe(false);
     });
 
-    it("should join global room on subscribe:all when authorized", async () => {
+    it('should join global room on subscribe:all when authorized', async () => {
       const socket = createMockSocket();
       transport.setupClientHandlers(socket, allowAll);
 
-      const subscribeAllHandler = socket._handlers.get(
-        "workflow:subscribe:all",
-      )!;
+      const subscribeAllHandler = socket._handlers.get('workflow:subscribe:all')!;
       await subscribeAllHandler();
 
-      expect(socket._joinedRooms.has("workflow:all")).toBe(true);
+      expect(socket._joinedRooms.has('workflow:all')).toBe(true);
     });
 
-    it("should leave global room on unsubscribe:all", async () => {
+    it('should leave global room on unsubscribe:all', async () => {
       const socket = createMockSocket();
       transport.setupClientHandlers(socket, allowAll);
 
       // First subscribe
-      const subscribeAllHandler = socket._handlers.get(
-        "workflow:subscribe:all",
-      )!;
+      const subscribeAllHandler = socket._handlers.get('workflow:subscribe:all')!;
       await subscribeAllHandler();
 
       // Then unsubscribe
-      const unsubscribeAllHandler = socket._handlers.get(
-        "workflow:unsubscribe:all",
-      )!;
+      const unsubscribeAllHandler = socket._handlers.get('workflow:unsubscribe:all')!;
       unsubscribeAllHandler();
 
-      expect(socket._joinedRooms.has("workflow:all")).toBe(false);
+      expect(socket._joinedRooms.has('workflow:all')).toBe(false);
     });
 
-    it("should ignore non-string runId on subscribe", async () => {
+    it('should ignore non-string runId on subscribe', async () => {
       const socket = createMockSocket();
       transport.setupClientHandlers(socket, allowAll);
 
-      const subscribeHandler = socket._handlers.get("workflow:subscribe")!;
+      const subscribeHandler = socket._handlers.get('workflow:subscribe')!;
       await subscribeHandler(123); // Not a string
       await subscribeHandler(null);
       await subscribeHandler(undefined);
@@ -314,111 +296,79 @@ describe("SocketIOEventTransport", () => {
       expect(socket._joinedRooms.size).toBe(0);
     });
 
-    it("should deny run subscription when authorize returns false", async () => {
-      const logger = {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-      };
+    it('should deny run subscription when authorize returns false', async () => {
+      const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
       transport = new SocketIOEventTransport({ io, logger });
 
       const socket = createMockSocket();
       const authorize = vi.fn().mockResolvedValue(false);
       transport.setupClientHandlers(socket, authorize);
 
-      const subscribeHandler = socket._handlers.get("workflow:subscribe")!;
-      await subscribeHandler("run-secret");
+      const subscribeHandler = socket._handlers.get('workflow:subscribe')!;
+      await subscribeHandler('run-secret');
 
-      expect(authorize).toHaveBeenCalledWith("run-secret", socket);
-      expect(socket._joinedRooms.has("run:run-secret")).toBe(false);
-      expect(logger.warn).toHaveBeenCalledWith(
-        expect.stringContaining("run-secret"),
-      );
+      expect(authorize).toHaveBeenCalledWith('run-secret', socket);
+      expect(socket._joinedRooms.has('run:run-secret')).toBe(false);
+      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('run-secret'));
     });
 
-    it("should deny run subscription when authorize throws", async () => {
-      const logger = {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-      };
+    it('should deny run subscription when authorize throws', async () => {
+      const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
       transport = new SocketIOEventTransport({ io, logger });
 
       const socket = createMockSocket();
-      const authorize = vi.fn().mockRejectedValue(new Error("auth error"));
+      const authorize = vi.fn().mockRejectedValue(new Error('auth error'));
       transport.setupClientHandlers(socket, authorize);
 
-      const subscribeHandler = socket._handlers.get("workflow:subscribe")!;
-      await subscribeHandler("run-123");
+      const subscribeHandler = socket._handlers.get('workflow:subscribe')!;
+      await subscribeHandler('run-123');
 
-      expect(socket._joinedRooms.has("run:run-123")).toBe(false);
-      expect(logger.error).toHaveBeenCalledWith(
-        "Authorization check failed:",
-        expect.any(Error),
-      );
+      expect(socket._joinedRooms.has('run:run-123')).toBe(false);
+      expect(logger.error).toHaveBeenCalledWith('Authorization check failed:', expect.any(Error));
     });
 
-    it("should deny global subscription when authorize returns false", async () => {
-      const logger = {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-      };
+    it('should deny global subscription when authorize returns false', async () => {
+      const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
       transport = new SocketIOEventTransport({ io, logger });
 
       const socket = createMockSocket();
       const authorize = vi.fn().mockResolvedValue(false);
       transport.setupClientHandlers(socket, authorize);
 
-      const subscribeAllHandler = socket._handlers.get(
-        "workflow:subscribe:all",
-      )!;
+      const subscribeAllHandler = socket._handlers.get('workflow:subscribe:all')!;
       await subscribeAllHandler();
 
-      expect(authorize).toHaveBeenCalledWith("*", socket);
-      expect(socket._joinedRooms.has("workflow:all")).toBe(false);
-      expect(logger.warn).toHaveBeenCalledWith("Global subscription denied");
+      expect(authorize).toHaveBeenCalledWith('*', socket);
+      expect(socket._joinedRooms.has('workflow:all')).toBe(false);
+      expect(logger.warn).toHaveBeenCalledWith('Global subscription denied');
     });
 
-    it("should deny global subscription when authorize throws", async () => {
-      const logger = {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-      };
+    it('should deny global subscription when authorize throws', async () => {
+      const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
       transport = new SocketIOEventTransport({ io, logger });
 
       const socket = createMockSocket();
-      const authorize = vi.fn().mockRejectedValue(new Error("auth down"));
+      const authorize = vi.fn().mockRejectedValue(new Error('auth down'));
       transport.setupClientHandlers(socket, authorize);
 
-      const subscribeAllHandler = socket._handlers.get(
-        "workflow:subscribe:all",
-      )!;
+      const subscribeAllHandler = socket._handlers.get('workflow:subscribe:all')!;
       await subscribeAllHandler();
 
-      expect(socket._joinedRooms.has("workflow:all")).toBe(false);
-      expect(logger.error).toHaveBeenCalledWith(
-        "Authorization check failed:",
-        expect.any(Error),
-      );
+      expect(socket._joinedRooms.has('workflow:all')).toBe(false);
+      expect(logger.error).toHaveBeenCalledWith('Authorization check failed:', expect.any(Error));
     });
   });
 
-  describe("close", () => {
-    it("should clear all subscribers", () => {
+  describe('close', () => {
+    it('should clear all subscribers', () => {
       const runCallback = vi.fn();
       const globalCallback = vi.fn();
-      transport.subscribe("run-123", runCallback);
+      transport.subscribe('run-123', runCallback);
       transport.subscribeAll(globalCallback);
 
       transport.close();
 
-      const event = createTestEvent({ runId: "run-123" });
+      const event = createTestEvent({ runId: 'run-123' });
       transport.emit(event);
 
       expect(runCallback).not.toHaveBeenCalled();

package/src/events/socketio.ts

@@ -5,13 +5,8 @@
  * Clients can subscribe to specific run IDs or receive all events.
  */
 
-import type {
-  EventTransport,
-  EventCallback,
-  Unsubscribe,
-  WorkflowEvent,
-} from "./types";
-import type { Logger } from "../core/types";
+import type { EventTransport, EventCallback, Unsubscribe, WorkflowEvent } from './types';
+import type { Logger } from '../core/types';
 
 /**
  * Minimal Socket.IO Server interface.
@@ -39,7 +34,7 @@ export interface SocketIOSocket {
  */
 export type SocketIOAuthorizeFn = (
   runId: string,
-  socket: SocketIOSocket,
+  socket: SocketIOSocket
 ) => boolean | Promise<boolean>;
 
 /**
@@ -100,17 +95,15 @@ export class SocketIOEventTransport implements EventTransport {
 
   constructor(config: SocketIOEventTransportConfig) {
     this.io = config.io;
-    this.eventName = config.eventName ?? "workflow:event";
-    this.roomPrefix = config.roomPrefix ?? "run:";
+    this.eventName = config.eventName ?? 'workflow:event';
+    this.roomPrefix = config.roomPrefix ?? 'run:';
     this.broadcastGlobal = config.broadcastGlobal ?? true;
-    this.globalRoom = config.globalRoom ?? "workflow:all";
+    this.globalRoom = config.globalRoom ?? 'workflow:all';
     this.logger = config.logger ?? {
       debug() {},
       info() {},
       warn() {},
-      error(message: string, ...args: unknown[]) {
-        console.error(message, ...args);
-      },
+      error(message: string, ...args: unknown[]) { console.error(message, ...args); },
     };
   }
 
@@ -140,7 +133,7 @@ export class SocketIOEventTransport implements EventTransport {
         try {
           callback(event);
         } catch (error) {
-          this.logger.error("Event callback error:", error);
+          this.logger.error('Event callback error:', error);
         }
       }
     }
@@ -149,7 +142,7 @@ export class SocketIOEventTransport implements EventTransport {
       try {
         callback(event);
       } catch (error) {
-        this.logger.error("Event callback error:", error);
+        this.logger.error('Event callback error:', error);
       }
     }
   }
@@ -207,12 +200,12 @@ export class SocketIOEventTransport implements EventTransport {
    */
   setupClientHandlers(
     socket: SocketIOSocket,
-    authorize: SocketIOAuthorizeFn,
+    authorize: SocketIOAuthorizeFn
   ): void {
     // Subscribe to a specific run
-    socket.on("workflow:subscribe", async (...args: unknown[]) => {
+    socket.on('workflow:subscribe', async (...args: unknown[]) => {
       const runId = args[0];
-      if (typeof runId !== "string") return;
+      if (typeof runId !== 'string') return;
 
       try {
         const allowed = await authorize(runId, socket);
@@ -221,7 +214,7 @@ export class SocketIOEventTransport implements EventTransport {
           return;
         }
       } catch (error) {
-        this.logger.error("Authorization check failed:", error);
+        this.logger.error('Authorization check failed:', error);
         return;
       }
 
@@ -229,23 +222,23 @@ export class SocketIOEventTransport implements EventTransport {
     });
 
     // Unsubscribe from a specific run
-    socket.on("workflow:unsubscribe", (...args: unknown[]) => {
+    socket.on('workflow:unsubscribe', (...args: unknown[]) => {
       const runId = args[0];
-      if (typeof runId === "string") {
+      if (typeof runId === 'string') {
         socket.leave(`${this.roomPrefix}${runId}`);
       }
     });
 
     // Subscribe to all events (requires authorization to pass with '*' as runId)
-    socket.on("workflow:subscribe:all", async () => {
+    socket.on('workflow:subscribe:all', async () => {
       try {
-        const allowed = await authorize("*", socket);
+        const allowed = await authorize('*', socket);
         if (!allowed) {
-          this.logger.warn("Global subscription denied");
+          this.logger.warn('Global subscription denied');
           return;
         }
       } catch (error) {
-        this.logger.error("Authorization check failed:", error);
+        this.logger.error('Authorization check failed:', error);
         return;
       }
 
@@ -253,7 +246,7 @@ export class SocketIOEventTransport implements EventTransport {
     });
 
     // Unsubscribe from all events
-    socket.on("workflow:unsubscribe:all", () => {
+    socket.on('workflow:unsubscribe:all', () => {
       socket.leave(this.globalRoom);
     });
   }