@vafast/api-client 0.1.1 → 0.1.3

package/test/websocket.test.ts

@@ -1,434 +0,0 @@
-import { describe, expect, it, beforeEach, mock } from "bun:test";
-import { VafastWebSocketClient, createWebSocketClient, createTypedWebSocketClient } from "../src";
-
-// Mock WebSocket
-class MockWebSocket {
-  static instances: MockWebSocket[] = [];
-  static mockOpen: (() => void) | null = null;
-  static mockClose: (() => void) | null = null;
-  static mockError: ((error: Event) => void) | null = null;
-  static mockMessage: ((event: MessageEvent) => void) | null = null;
-
-  url: string;
-  readyState: number;
-  onopen: ((event: Event) => void) | null = null;
-  onclose: ((event: CloseEvent) => void) | null = null;
-  onerror: ((event: Event) => void) | null = null;
-  onmessage: ((event: MessageEvent) => void) | null = null;
-
-  constructor(url: string) {
-    this.url = url;
-    this.readyState = WebSocket.CONNECTING;
-    MockWebSocket.instances.push(this);
-
-    // Simulate connection process
-    setTimeout(() => {
-      this.readyState = WebSocket.OPEN;
-      if (this.onopen) {
-        this.onopen(new Event("open"));
-      }
-      if (MockWebSocket.mockOpen) {
-        MockWebSocket.mockOpen();
-      }
-    }, 10);
-  }
-
-  send(data: any) {
-    if (this.readyState !== WebSocket.OPEN) {
-      throw new Error("WebSocket is not connected");
-    }
-
-    // Simulate message
-    if (this.onmessage) {
-      const messageEvent = new MessageEvent("message", {
-        data: typeof data === "string" ? data : JSON.stringify(data),
-      });
-      this.onmessage(messageEvent);
-    }
-  }
-
-  close() {
-    this.readyState = WebSocket.CLOSED;
-    if (this.onclose) {
-      this.onclose(new CloseEvent("close"));
-    }
-    if (MockWebSocket.mockClose) {
-      MockWebSocket.mockClose();
-    }
-  }
-
-  static reset() {
-    MockWebSocket.instances = [];
-    MockWebSocket.mockOpen = null;
-    MockWebSocket.mockClose = null;
-    MockWebSocket.mockError = null;
-    MockWebSocket.mockMessage = null;
-  }
-}
-
-// Mock global WebSocket
-global.WebSocket = MockWebSocket as any;
-
-describe("WebSocket Client", () => {
-  beforeEach(() => {
-    MockWebSocket.reset();
-  });
-
-  describe("VafastWebSocketClient", () => {
-    let client: VafastWebSocketClient;
-
-    beforeEach(() => {
-      client = new VafastWebSocketClient("wss://test.example.com");
-    });
-
-    it("should create WebSocket client", () => {
-      expect(client).toBeDefined();
-    });
-
-    it("should connect to WebSocket server", async () => {
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-      expect(client.isConnected()).toBe(true);
-    });
-
-    it("should handle connection events", async () => {
-      let connected = false;
-
-      // Set up event listener before connection
-      client.on("open", () => {
-        connected = true;
-      });
-
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-
-      // Since the connection is already established, we need to test the event listener differently
-      // Let's test that the event listener was added correctly
-      expect(client.getEventListenerCount("open")).toBe(1);
-
-      // And test that we can trigger events manually
-      let testEventTriggered = false;
-      client.on("test", () => {
-        testEventTriggered = true;
-      });
-
-      // Simulate a test event
-      const listeners = (client as any).eventListeners.get("test");
-      if (listeners) {
-        listeners.forEach((callback: any) => callback());
-      }
-
-      expect(testEventTriggered).toBe(true);
-    });
-
-    it("should send messages", async () => {
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-
-      let receivedMessage: any = null;
-      client.on("message", (data) => {
-        receivedMessage = data;
-      });
-
-      client.send({ type: "test", data: "hello" });
-      expect(receivedMessage).toBeDefined();
-    });
-
-    it("should handle disconnection", async () => {
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-      expect(client.isConnected()).toBe(true);
-
-      client.disconnect();
-      expect(client.isConnected()).toBe(false);
-    });
-
-    it("should handle message events", async () => {
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-
-      let messageCount = 0;
-      client.on("message", () => {
-        messageCount++;
-      });
-
-      client.send("test message 1");
-      client.send("test message 2");
-
-      expect(messageCount).toBeGreaterThan(0);
-    });
-
-    it("should remove event listeners", async () => {
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-
-      let messageCount = 0;
-      const handler = () => {
-        messageCount++;
-      };
-
-      client.on("message", handler);
-      client.send("test message");
-      expect(messageCount).toBeGreaterThan(0);
-
-      client.off("message", handler);
-      messageCount = 0;
-      client.send("test message 2");
-      expect(messageCount).toBe(0);
-    });
-
-    it("should get connection state", async () => {
-      expect(client.getReadyState()).toBe(WebSocket.CLOSED); // CLOSED
-
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-      expect(client.getReadyState()).toBe(WebSocket.OPEN); // OPEN
-
-      client.disconnect();
-      expect(client.getReadyState()).toBe(WebSocket.CLOSED); // CLOSED
-    });
-
-    it("should get connection state text", () => {
-      expect(client.getReadyStateText()).toBe("CLOSED");
-    });
-
-    it("should configure auto-reconnect", () => {
-      client.setAutoReconnect(false);
-      client.setAutoReconnect(true);
-      expect(client).toBeDefined();
-    });
-
-    it("should configure max reconnect attempts", () => {
-      client.setMaxReconnectAttempts(10);
-      expect(client).toBeDefined();
-    });
-
-    it("should configure reconnect delay", () => {
-      client.setReconnectDelay(5000);
-      expect(client).toBeDefined();
-    });
-
-    it("should get event listener count", async () => {
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-
-      expect(client.getEventListenerCount("message")).toBe(0);
-
-      client.on("message", () => {});
-      expect(client.getEventListenerCount("message")).toBe(1);
-
-      client.on("message", () => {});
-      expect(client.getEventListenerCount("message")).toBe(2);
-    });
-
-    it("should clear event listeners", async () => {
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-
-      client.on("message", () => {});
-      client.on("open", () => {});
-
-      expect(client.getEventNames().length).toBeGreaterThan(0);
-
-      client.clearEventListeners();
-      expect(client.getEventNames().length).toBe(0);
-    });
-
-    it("should clear specific event listeners", async () => {
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-
-      client.on("message", () => {});
-      client.on("open", () => {});
-
-      expect(client.getEventListenerCount("message")).toBe(1);
-      expect(client.getEventListenerCount("open")).toBe(1);
-
-      client.clearEventListeners("message");
-      expect(client.getEventListenerCount("message")).toBe(0);
-      expect(client.getEventListenerCount("open")).toBe(1);
-    });
-
-    it("should handle manual reconnection", async () => {
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-      client.disconnect();
-
-      expect(client.isConnected()).toBe(false);
-
-      await client.reconnect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-      expect(client.isConnected()).toBe(true);
-    });
-
-    it("should handle connection errors gracefully", async () => {
-      // Mock WebSocket to throw error
-      const originalWebSocket = global.WebSocket;
-      global.WebSocket = class extends MockWebSocket {
-        constructor(url: string) {
-          super(url);
-          setTimeout(() => {
-            if (this.onerror) {
-              this.onerror(new Event("error"));
-            }
-          }, 10);
-        }
-      } as any;
-
-      try {
-        await client.connect();
-        // Should not reach here if error is thrown
-        expect(false).toBe(true);
-      } catch (error) {
-        expect(error).toBeDefined();
-      } finally {
-        global.WebSocket = originalWebSocket;
-      }
-    });
-  });
-
-  describe("createWebSocketClient", () => {
-    it("should create WebSocket client with factory function", () => {
-      const client = createWebSocketClient("wss://test.example.com");
-      expect(client).toBeDefined();
-      expect(client).toBeInstanceOf(VafastWebSocketClient);
-    });
-
-    it("should create WebSocket client with options", () => {
-      const client = createWebSocketClient("wss://test.example.com", {
-        autoReconnect: false,
-        maxReconnectAttempts: 10,
-        reconnectDelay: 5000,
-      });
-      expect(client).toBeDefined();
-    });
-  });
-
-  describe("createTypedWebSocketClient", () => {
-    interface TestEvents {
-      chat: { message: string; userId: string };
-      join: { room: string; userId: string };
-    }
-
-    it("should create typed WebSocket client", () => {
-      const client = createTypedWebSocketClient<TestEvents>("wss://test.example.com");
-      expect(client).toBeDefined();
-    });
-
-    it("should have typed event methods", () => {
-      const client = createTypedWebSocketClient<TestEvents>("wss://test.example.com");
-
-      // These should have proper typing
-      expect(typeof client.on).toBe("function");
-      expect(typeof client.send).toBe("function");
-    });
-
-    it("should handle typed events", async () => {
-      const client = createTypedWebSocketClient<TestEvents>("wss://test.example.com");
-
-      // First connect the client
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-
-      let receivedChat: any = null;
-      let receivedJoin: any = null;
-
-      client.on("chat", (data) => {
-        receivedChat = data;
-      });
-
-      client.on("join", (data) => {
-        receivedJoin = data;
-      });
-
-      // Now send messages
-      client.send("chat", { message: "Hello!", userId: "user123" });
-      client.send("join", { room: "general", userId: "user123" });
-
-      expect(receivedChat).toBeDefined();
-      expect(receivedJoin).toBeDefined();
-    });
-  });
-
-  describe("WebSocket Lifecycle", () => {
-    it("should handle complete connection lifecycle", async () => {
-      const client = new VafastWebSocketClient("wss://test.example.com");
-
-      // Initial state
-      expect(client.isConnected()).toBe(false);
-
-      // Connect
-      await client.connect();
-      // Wait for the async connection to complete
-      await new Promise((resolve) => setTimeout(resolve, 20));
-      expect(client.isConnected()).toBe(true);
-
-      // Send message
-      let messageReceived = false;
-      client.on("message", () => {
-        messageReceived = true;
-      });
-
-      client.send("test message");
-      expect(messageReceived).toBe(true);
-
-      // Disconnect
-      client.disconnect();
-      expect(client.isConnected()).toBe(false);
-    });
-
-    it("should handle multiple connections and disconnections", async () => {
-      const client = new VafastWebSocketClient("wss://test.example.com");
-
-      for (let i = 0; i < 3; i++) {
-        await client.connect();
-        // Wait for the async connection to complete
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        expect(client.isConnected()).toBe(true);
-
-        client.disconnect();
-        expect(client.isConnected()).toBe(false);
-      }
-    });
-  });
-
-  describe("Error Scenarios", () => {
-    it("should handle sending message when disconnected", async () => {
-      const client = new VafastWebSocketClient("wss://test.example.com");
-
-      expect(() => {
-        client.send("test message");
-      }).toThrow("WebSocket is not connected");
-    });
-
-    it("should handle invalid event listener removal", () => {
-      const client = new VafastWebSocketClient("wss://test.example.com");
-
-      // Should not throw when removing non-existent listener
-      expect(() => {
-        client.off("nonexistent", () => {});
-      }).not.toThrow();
-    });
-
-    it("should handle invalid interceptor index", () => {
-      const client = new VafastWebSocketClient("wss://test.example.com");
-
-      // WebSocket client doesn't have removeInterceptor method
-      // This test should be removed or modified
-      expect(client).toBeDefined();
-    });
-  });
-});

package/tsup.config.ts

@@ -1,23 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig([
-  {
-    entry: ['src/index.ts'],
-    outDir: 'dist',
-    format: ['esm'],
-    target: 'node18',
-    dts: true,
-    clean: true,
-    sourcemap: true,
-    outExtension: () => ({ js: '.mjs' }),
-  },
-  {
-    entry: ['src/index.ts'],
-    outDir: 'dist/cjs',
-    format: ['cjs'],
-    target: 'node18',
-    dts: false,
-    clean: false,
-  },
-])
-