polymorph-sdk 0.2.2 → 0.2.4

package/src/__tests__/usePolymorphSession.test.ts

@@ -0,0 +1,422 @@
+import { act, cleanup, renderHook, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ResolvedWidgetConfig } from "../types";
+import { usePolymorphSession } from "../usePolymorphSession";
+
+const MOCK_CONFIG: ResolvedWidgetConfig = {
+  id: "cfg-1",
+  title: "Test Widget",
+  subtitle: "Sub",
+  primaryColor: "#000",
+  position: "bottom-right",
+  darkMode: false,
+  enableVoice: true,
+  greeting: "Hello!",
+  collectEmail: "hidden",
+  collectPhone: "hidden",
+};
+
+function mockResolveResponse(cfg = MOCK_CONFIG) {
+  return {
+    id: cfg.id,
+    title: cfg.title,
+    subtitle: cfg.subtitle,
+    primary_color: cfg.primaryColor,
+    position: cfg.position,
+    dark_mode: cfg.darkMode,
+    enable_voice: cfg.enableVoice,
+    greeting: cfg.greeting,
+    collect_email: cfg.collectEmail,
+    collect_phone: cfg.collectPhone,
+  };
+}
+
+function roomResponse(overrides = {}) {
+  return {
+    ok: true,
+    json: () =>
+      Promise.resolve({
+        token: "tok-123",
+        livekit_url: "wss://lk.example.com",
+        ...overrides,
+      }),
+  };
+}
+
+let fetchMock: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  fetchMock = vi.fn();
+  vi.stubGlobal("fetch", fetchMock);
+  fetchMock.mockImplementation((url: string) => {
+    if (url.includes("/widget-configs/resolve")) {
+      return Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve(mockResolveResponse()),
+      });
+    }
+    // Default: reject unknown URLs
+    return Promise.resolve({
+      ok: false,
+      status: 404,
+      text: () => Promise.resolve("Not found"),
+    });
+  });
+  sessionStorage.clear();
+  localStorage.clear();
+});
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+describe("usePolymorphSession", () => {
+  // ── Config fetch on mount ──
+
+  it("starts with idle status, empty messages, null roomConnection", () => {
+    const { result } = renderHook(() =>
+      usePolymorphSession({ apiBaseUrl: "http://test", apiKey: "key" }),
+    );
+    expect(result.current.status).toBe("idle");
+    expect(result.current.messages).toEqual([]);
+    expect(result.current.roomConnection).toBeNull();
+  });
+
+  it("fetches /widget-configs/resolve on mount and sets resolvedConfig", async () => {
+    const { result } = renderHook(() =>
+      usePolymorphSession({ apiBaseUrl: "http://test", apiKey: "key" }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.resolvedConfig).not.toBeNull();
+    });
+
+    expect(result.current.resolvedConfig?.id).toBe("cfg-1");
+    expect(result.current.resolvedConfig?.title).toBe("Test Widget");
+    expect(fetchMock).toHaveBeenCalledWith(
+      "http://test/widget-configs/resolve",
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: "Bearer key",
+        }),
+      }),
+    );
+  });
+
+  it("adds greeting message from resolved config", async () => {
+    const { result } = renderHook(() =>
+      usePolymorphSession({ apiBaseUrl: "http://test", apiKey: "key" }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.messages).toHaveLength(1);
+    });
+
+    expect(result.current.messages[0].role).toBe("agent");
+    expect(result.current.messages[0].text).toBe("Hello!");
+    expect(result.current.messages[0].id).toBe("greeting");
+  });
+
+  it("appends ?config_id=X when configId prop is set", async () => {
+    const { result } = renderHook(() =>
+      usePolymorphSession({
+        apiBaseUrl: "http://test",
+        apiKey: "key",
+        configId: "my-config",
+      }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.resolvedConfig).not.toBeNull();
+    });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      "http://test/widget-configs/resolve?config_id=my-config",
+      expect.anything(),
+    );
+  });
+
+  // ── Connect flow ──
+
+  it("connect() sets roomConnection on success", async () => {
+    fetchMock.mockImplementation((url: string) => {
+      if (url.includes("/widget-configs/resolve")) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(mockResolveResponse()),
+        });
+      }
+      if (url.includes("/voice-rooms/start")) {
+        return Promise.resolve(roomResponse());
+      }
+      return Promise.resolve({
+        ok: false,
+        status: 404,
+        text: () => Promise.resolve(""),
+      });
+    });
+
+    const { result } = renderHook(() =>
+      usePolymorphSession({ apiBaseUrl: "http://test", apiKey: "key" }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.resolvedConfig).not.toBeNull();
+    });
+
+    act(() => {
+      void result.current.connect();
+    });
+
+    await waitFor(() => {
+      expect(result.current.roomConnection).not.toBeNull();
+    });
+
+    expect(result.current.roomConnection).toEqual({
+      token: "tok-123",
+      livekitUrl: "wss://lk.example.com",
+    });
+  });
+
+  it("connect() is a no-op when already connecting", async () => {
+    let resolvePost!: (v: unknown) => void;
+    fetchMock.mockImplementation((url: string) => {
+      if (url.includes("/widget-configs/resolve")) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(mockResolveResponse()),
+        });
+      }
+      if (url.includes("/voice-rooms/start")) {
+        return new Promise((r) => {
+          resolvePost = r;
+        });
+      }
+      return Promise.resolve({
+        ok: false,
+        status: 404,
+        text: () => Promise.resolve(""),
+      });
+    });
+
+    const { result } = renderHook(() =>
+      usePolymorphSession({ apiBaseUrl: "http://test", apiKey: "key" }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.resolvedConfig).not.toBeNull();
+    });
+
+    const _callCountBefore = fetchMock.mock.calls.length;
+
+    act(() => {
+      void result.current.connect();
+    });
+
+    await waitFor(() => {
+      expect(result.current.status).toBe("connecting");
+    });
+
+    // Second connect should be no-op
+    act(() => {
+      void result.current.connect();
+    });
+
+    // Only one additional fetch call (the POST) should have been made
+    const postCalls = fetchMock.mock.calls.filter((c: string[]) =>
+      c[0].includes("/voice-rooms/start"),
+    );
+    expect(postCalls).toHaveLength(1);
+
+    // Cleanup
+    resolvePost(roomResponse());
+  });
+
+  it("failed /voice-rooms/start sets status to error", async () => {
+    fetchMock.mockImplementation((url: string) => {
+      if (url.includes("/widget-configs/resolve")) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(mockResolveResponse()),
+        });
+      }
+      if (url.includes("/voice-rooms/start")) {
+        return Promise.resolve({
+          ok: false,
+          status: 500,
+          text: () => Promise.resolve("Internal Server Error"),
+        });
+      }
+      return Promise.resolve({
+        ok: false,
+        status: 404,
+        text: () => Promise.resolve(""),
+      });
+    });
+
+    const { result } = renderHook(() =>
+      usePolymorphSession({ apiBaseUrl: "http://test", apiKey: "key" }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.resolvedConfig).not.toBeNull();
+    });
+
+    act(() => {
+      void result.current.connect();
+    });
+
+    await waitFor(() => {
+      expect(result.current.status).toBe("error");
+    });
+
+    expect(result.current.error).toBe("Internal Server Error");
+  });
+
+  // ── Messages ──
+
+  it("sendMessage adds a user message", async () => {
+    fetchMock.mockImplementation((url: string) => {
+      if (url.includes("/widget-configs/resolve")) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(mockResolveResponse()),
+        });
+      }
+      if (url.includes("/voice-rooms/start")) {
+        return Promise.resolve(roomResponse());
+      }
+      return Promise.resolve({
+        ok: false,
+        status: 404,
+        text: () => Promise.resolve(""),
+      });
+    });
+
+    const { result } = renderHook(() =>
+      usePolymorphSession({ apiBaseUrl: "http://test", apiKey: "key" }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.messages).toHaveLength(1);
+    });
+
+    act(() => {
+      result.current.sendMessage("Hi there");
+    });
+
+    expect(result.current.messages).toHaveLength(2);
+    expect(result.current.messages[1].role).toBe("user");
+    expect(result.current.messages[1].text).toBe("Hi there");
+    expect(result.current.messages[1].source).toBe("chat");
+    expect(result.current.messages[1].id).toBeTruthy();
+    expect(result.current.messages[1].timestamp).toBeGreaterThan(0);
+  });
+
+  it("messages array grows with multiple sends", async () => {
+    fetchMock.mockImplementation((url: string) => {
+      if (url.includes("/widget-configs/resolve")) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(mockResolveResponse()),
+        });
+      }
+      if (url.includes("/voice-rooms/start")) {
+        return Promise.resolve(roomResponse());
+      }
+      return Promise.resolve({
+        ok: false,
+        status: 404,
+        text: () => Promise.resolve(""),
+      });
+    });
+
+    const { result } = renderHook(() =>
+      usePolymorphSession({ apiBaseUrl: "http://test", apiKey: "key" }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.messages).toHaveLength(1);
+    });
+
+    act(() => {
+      result.current.sendMessage("msg 1");
+    });
+    act(() => {
+      result.current.sendMessage("msg 2");
+    });
+
+    expect(result.current.messages).toHaveLength(3);
+    expect(result.current.messages[1].text).toBe("msg 1");
+    expect(result.current.messages[2].text).toBe("msg 2");
+  });
+
+  // ── Disconnect ──
+
+  it("disconnect resets status to idle and clears roomConnection", async () => {
+    fetchMock.mockImplementation((url: string) => {
+      if (url.includes("/widget-configs/resolve")) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(mockResolveResponse()),
+        });
+      }
+      if (url.includes("/voice-rooms/start")) {
+        return Promise.resolve(roomResponse());
+      }
+      return Promise.resolve({
+        ok: false,
+        status: 404,
+        text: () => Promise.resolve(""),
+      });
+    });
+
+    const { result } = renderHook(() =>
+      usePolymorphSession({ apiBaseUrl: "http://test", apiKey: "key" }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.resolvedConfig).not.toBeNull();
+    });
+
+    act(() => {
+      void result.current.connect();
+    });
+
+    await waitFor(() => {
+      expect(result.current.roomConnection).not.toBeNull();
+    });
+
+    act(() => {
+      result.current.disconnect();
+    });
+
+    expect(result.current.status).toBe("idle");
+    expect(result.current.roomConnection).toBeNull();
+  });
+
+  // ── addMessage ──
+
+  it("addMessage appends messages with correct role and source", async () => {
+    const { result } = renderHook(() =>
+      usePolymorphSession({ apiBaseUrl: "http://test", apiKey: "key" }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.messages).toHaveLength(1);
+    });
+
+    act(() => {
+      result.current.addMessage("agent", "Agent reply", "voice", "Agent");
+    });
+
+    expect(result.current.messages).toHaveLength(2);
+    expect(result.current.messages[1]).toMatchObject({
+      role: "agent",
+      text: "Agent reply",
+      source: "voice",
+      senderName: "Agent",
+    });
+  });
+});

package/src/index.ts

@@ -1,8 +1,11 @@
 export { PolymorphWidget } from "./PolymorphWidget";
 export type {
   ChatMessage,
+  FieldRequirement,
+  IdentityCollection,
+  ResolvedWidgetConfig,
   SessionStatus,
-  WidgetBranding,
   WidgetConfig,
+  WidgetUser,
 } from "./types";
 export { usePolymorphSession } from "./usePolymorphSession";