@stigmer/react 3.1.17 → 3.2.1

package/src/channel/__tests__/useConnectSlackChannel.test.tsx

@@ -0,0 +1,276 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { StigmerError } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { OAUTH_CALLBACK_MESSAGE_TYPE } from "../../internal/oauthPopup";
+import { useConnectSlackChannel } from "../useConnectSlackChannel";
+
+/**
+ * Fake popup satisfying what the hook touches: `location.href` (consent
+ * navigation), `closed`, and `close()`.
+ */
+function fakePopup() {
+  const popup = {
+    closed: false,
+    close() {
+      popup.closed = true;
+    },
+    location: { href: "about:blank" },
+  };
+  return popup as unknown as Window & { closed: boolean; location: { href: string } };
+}
+
+function createMockStigmer(overrides: {
+  initiateInstall?: (input: unknown) => Promise<unknown>;
+  completeInstall?: (input: unknown) => Promise<unknown>;
+} = {}) {
+  return {
+    agentChannel: {
+      initiateInstall:
+        overrides.initiateInstall ??
+        vi.fn().mockResolvedValue({
+          authorizationUrl: "https://slack.com/oauth/v2/authorize?x=1",
+          state: "state-1",
+        }),
+      completeInstall:
+        overrides.completeInstall ??
+        vi.fn().mockResolvedValue({ metadata: { id: "ach_1" } }),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        {children}
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+function deliverCallback(state: string, code = "auth-code-123") {
+  window.dispatchEvent(
+    new MessageEvent("message", {
+      data: { type: OAUTH_CALLBACK_MESSAGE_TYPE, code, state },
+      origin: window.location.origin,
+    }),
+  );
+}
+
+describe("useConnectSlackChannel", () => {
+  let popup: ReturnType<typeof fakePopup>;
+
+  beforeEach(() => {
+    popup = fakePopup();
+    vi.spyOn(window, "open").mockReturnValue(popup as unknown as Window);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("walks the full phase machine on the happy path", async () => {
+    const installed = { metadata: { id: "ach_1" }, status: { installState: 2 } };
+    const initiateInstall = vi.fn().mockResolvedValue({
+      authorizationUrl: "https://slack.com/oauth/v2/authorize?x=1",
+      state: "state-1",
+    });
+    const completeInstall = vi.fn().mockResolvedValue(installed);
+    const client = createMockStigmer({ initiateInstall, completeInstall });
+
+    const { result } = renderHook(() => useConnectSlackChannel(), {
+      wrapper: wrapper(client),
+    });
+    expect(result.current.phase).toBe("idle");
+
+    let connectPromise: Promise<unknown> = Promise.resolve();
+    act(() => {
+      connectPromise = result.current.connect("ach_1");
+    });
+
+    // The popup must navigate to the consent URL once initiate resolves.
+    await waitFor(() =>
+      expect(result.current.phase).toBe("awaiting-callback"),
+    );
+    expect(popup.location.href).toBe("https://slack.com/oauth/v2/authorize?x=1");
+    expect(initiateInstall).toHaveBeenCalledWith(
+      expect.objectContaining({ resourceId: "ach_1" }),
+    );
+
+    act(() => deliverCallback("state-1"));
+
+    await act(async () => {
+      await expect(connectPromise).resolves.toBe(installed);
+    });
+
+    expect(completeInstall).toHaveBeenCalledWith(
+      expect.objectContaining({
+        resourceId: "ach_1",
+        state: "state-1",
+        code: "auth-code-123",
+      }),
+    );
+    expect(result.current.phase).toBe("done");
+    expect(result.current.isInProgress).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("fails fast with a helpful error when the popup is blocked", async () => {
+    vi.spyOn(window, "open").mockReturnValue(null);
+    const client = createMockStigmer();
+
+    const { result } = renderHook(() => useConnectSlackChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    await act(async () => {
+      await expect(result.current.connect("ach_1")).rejects.toThrow(
+        /allow popups/i,
+      );
+    });
+
+    expect(result.current.phase).toBe("idle");
+    expect(result.current.error?.message).toMatch(/blocked/i);
+  });
+
+  it("surfaces the server refusal when the deployment cannot run installs", async () => {
+    // Unconfigured cloud deployment or OSS edition: initiateInstall
+    // answers FAILED_PRECONDITION with server-authored copy. The hook
+    // must relay that copy verbatim and close the popup.
+    const initiateInstall = vi
+      .fn()
+      .mockRejectedValue(
+        new StigmerError(
+          "failed-precondition",
+          "channel installs require Stigmer Cloud",
+          9,
+        ),
+      );
+    const client = createMockStigmer({ initiateInstall });
+
+    const { result } = renderHook(() => useConnectSlackChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    await act(async () => {
+      await expect(result.current.connect("ach_1")).rejects.toThrow(
+        "channel installs require Stigmer Cloud",
+      );
+    });
+
+    expect(result.current.error?.message).toBe(
+      "channel installs require Stigmer Cloud",
+    );
+    expect(result.current.phase).toBe("idle");
+    expect(popup.closed).toBe(true);
+  });
+
+  it("surfaces completeInstall refusals (duplicate workspace, Enterprise Grid)", async () => {
+    const completeInstall = vi
+      .fn()
+      .mockRejectedValue(
+        new StigmerError(
+          "failed-precondition",
+          "This Slack workspace is already connected to a Stigmer agent. " +
+            "A workspace can host one agent — disconnect the existing channel first.",
+          9,
+        ),
+      );
+    const client = createMockStigmer({ completeInstall });
+
+    const { result } = renderHook(() => useConnectSlackChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    let connectPromise: Promise<unknown> = Promise.resolve();
+    act(() => {
+      connectPromise = result.current.connect("ach_1");
+    });
+    connectPromise.catch(() => {});
+
+    await waitFor(() =>
+      expect(result.current.phase).toBe("awaiting-callback"),
+    );
+    act(() => deliverCallback("state-1"));
+
+    await waitFor(() => expect(result.current.error).toBeTruthy());
+    expect(result.current.error?.message).toMatch(/already connected/i);
+    expect(result.current.phase).toBe("idle");
+  });
+
+  it("rejects on state mismatch from the callback", async () => {
+    const client = createMockStigmer();
+
+    const { result } = renderHook(() => useConnectSlackChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    let connectPromise: Promise<unknown> = Promise.resolve();
+    act(() => {
+      connectPromise = result.current.connect("ach_1");
+    });
+    connectPromise.catch(() => {});
+
+    await waitFor(() =>
+      expect(result.current.phase).toBe("awaiting-callback"),
+    );
+    act(() => deliverCallback("state-FORGED"));
+
+    await waitFor(() => expect(result.current.error).toBeTruthy());
+    expect(result.current.error?.message).toMatch(/state mismatch/i);
+  });
+
+  it("clearError cancels an in-flight flow without recording an error", async () => {
+    const client = createMockStigmer();
+
+    const { result } = renderHook(() => useConnectSlackChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    let connectPromise: Promise<unknown> = Promise.resolve();
+    act(() => {
+      connectPromise = result.current.connect("ach_1");
+    });
+    connectPromise.catch(() => {});
+
+    await waitFor(() =>
+      expect(result.current.phase).toBe("awaiting-callback"),
+    );
+
+    act(() => result.current.clearError());
+
+    // Cancellation is a user decision, not a failure: no error state,
+    // popup closed, back to idle.
+    await waitFor(() => expect(result.current.phase).toBe("idle"));
+    expect(result.current.error).toBeNull();
+    expect(popup.closed).toBe(true);
+    await expect(connectPromise).rejects.toThrow(/cancelled/i);
+  });
+
+  it("reports isInProgress across all active phases", async () => {
+    const client = createMockStigmer();
+    const { result } = renderHook(() => useConnectSlackChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isInProgress).toBe(false);
+
+    let connectPromise: Promise<unknown> = Promise.resolve();
+    act(() => {
+      connectPromise = result.current.connect("ach_1");
+    });
+
+    await waitFor(() =>
+      expect(result.current.phase).toBe("awaiting-callback"),
+    );
+    expect(result.current.isInProgress).toBe(true);
+
+    act(() => deliverCallback("state-1"));
+    await act(async () => {
+      await connectPromise;
+    });
+    expect(result.current.isInProgress).toBe(false);
+  });
+});

package/src/channel/__tests__/useDeleteAgentChannel.test.tsx

@@ -0,0 +1,97 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { StigmerContext } from "../../context";
+import { useDeleteAgentChannel } from "../useDeleteAgentChannel";
+
+function createMockStigmer(overrides: {
+  delete?: (id: string) => Promise<unknown>;
+} = {}) {
+  return {
+    agentChannel: {
+      delete: overrides.delete ?? vi.fn().mockResolvedValue({}),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        {children}
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+describe("useDeleteAgentChannel", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("deletes by id and returns the deleted resource", async () => {
+    const deleted = { metadata: { id: "ach_1" } };
+    const del = vi.fn().mockResolvedValue(deleted);
+    const client = createMockStigmer({ delete: del });
+
+    const { result } = renderHook(() => useDeleteAgentChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    let returned: unknown;
+    await act(async () => {
+      returned = await result.current.deleteChannel("ach_1");
+    });
+
+    expect(del).toHaveBeenCalledWith("ach_1");
+    expect(returned).toBe(deleted);
+    expect(result.current.error).toBeNull();
+    expect(result.current.isDeleting).toBe(false);
+  });
+
+  it("tracks isDeleting during the flight", async () => {
+    let resolveDelete: (value: unknown) => void = () => {};
+    const del = vi.fn().mockImplementation(
+      () => new Promise((resolve) => { resolveDelete = resolve; }),
+    );
+    const client = createMockStigmer({ delete: del });
+
+    const { result } = renderHook(() => useDeleteAgentChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    let deletePromise: Promise<unknown> = Promise.resolve();
+    act(() => {
+      deletePromise = result.current.deleteChannel("ach_1");
+    });
+
+    await waitFor(() => expect(result.current.isDeleting).toBe(true));
+
+    await act(async () => {
+      resolveDelete({});
+      await deletePromise;
+    });
+    expect(result.current.isDeleting).toBe(false);
+  });
+
+  it("captures and rethrows delete failures", async () => {
+    const del = vi.fn().mockRejectedValue(new Error("permission denied"));
+    const client = createMockStigmer({ delete: del });
+
+    const { result } = renderHook(() => useDeleteAgentChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    await act(async () => {
+      await expect(result.current.deleteChannel("ach_1")).rejects.toThrow(
+        "permission denied",
+      );
+    });
+
+    expect(result.current.error?.message).toBe("permission denied");
+    expect(result.current.isDeleting).toBe(false);
+
+    act(() => result.current.clearError());
+    expect(result.current.error).toBeNull();
+  });
+});

package/src/channel/__tests__/useInstallChannel.test.tsx

@@ -0,0 +1,177 @@
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { Code, ConnectError } from "@connectrpc/connect";
+import { StigmerError, getErrorReason } from "@stigmer/sdk";
+import { ErrorInfoSchema } from "@stigmer/protos/google/rpc/error_details_pb";
+import { StigmerContext } from "../../context";
+import { useInstallChannel } from "../useInstallChannel";
+
+function createMockStigmer(overrides: {
+  initiateInstall?: (input: unknown) => Promise<unknown>;
+} = {}) {
+  return {
+    agentChannel: {
+      initiateInstall:
+        overrides.initiateInstall ??
+        vi.fn().mockResolvedValue({ completed: true }),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        {children}
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+describe("useInstallChannel", () => {
+  it("runs the whole install in one call when the server answers completed", async () => {
+    const initiateInstall = vi.fn().mockResolvedValue({ completed: true });
+    const client = createMockStigmer({ initiateInstall });
+
+    const { result } = renderHook(() => useInstallChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.install("ach_1");
+    });
+
+    expect(initiateInstall).toHaveBeenCalledWith(
+      expect.objectContaining({ resourceId: "ach_1" }),
+    );
+    expect(result.current.phase).toBe("done");
+    expect(result.current.error).toBeNull();
+    expect(result.current.isInProgress).toBe(false);
+  });
+
+  it("tracks the installing phase during the flight", async () => {
+    let resolveInstall: (value: unknown) => void = () => {};
+    const initiateInstall = vi.fn().mockImplementation(
+      () => new Promise((resolve) => { resolveInstall = resolve; }),
+    );
+    const client = createMockStigmer({ initiateInstall });
+
+    const { result } = renderHook(() => useInstallChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    let installPromise: Promise<void> = Promise.resolve();
+    act(() => {
+      installPromise = result.current.install("ach_1");
+    });
+
+    await waitFor(() => expect(result.current.isInProgress).toBe(true));
+    expect(result.current.phase).toBe("installing");
+
+    await act(async () => {
+      resolveInstall({ completed: true });
+      await installPromise;
+    });
+    expect(result.current.phase).toBe("done");
+  });
+
+  it("refuses a completed=false answer — a redirect provider was routed to the direct hook", async () => {
+    // DD-WA-1b: the server's flag is the authoritative install style. A
+    // false answer here means a client wiring error, surfaced loudly
+    // rather than silently treated as success.
+    const initiateInstall = vi.fn().mockResolvedValue({
+      completed: false,
+      authorizationUrl: "https://slack.com/oauth",
+      state: "s",
+    });
+    const client = createMockStigmer({ initiateInstall });
+
+    const { result } = renderHook(() => useInstallChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    await act(async () => {
+      await expect(result.current.install("ach_1")).rejects.toThrow(
+        /interactive install/i,
+      );
+    });
+
+    expect(result.current.error?.message).toMatch(/interactive install/i);
+    expect(result.current.phase).toBe("idle");
+  });
+
+  it("surfaces server refusals with their copy and resets to idle", async () => {
+    const initiateInstall = vi.fn().mockRejectedValue(
+      new StigmerError(
+        "failed-precondition",
+        "WhatsApp rejected the channel app's access token.",
+        9,
+      ),
+    );
+    const client = createMockStigmer({ initiateInstall });
+
+    const { result } = renderHook(() => useInstallChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    await act(async () => {
+      await expect(result.current.install("ach_1")).rejects.toThrow(
+        /access token/i,
+      );
+    });
+
+    expect(result.current.error?.message).toMatch(/access token/i);
+    expect(result.current.phase).toBe("idle");
+
+    act(() => result.current.clearError());
+    expect(result.current.error).toBeNull();
+  });
+
+  it("preserves the ErrorInfo reason chain for guided refusals", async () => {
+    // The wire shape of the duplicate-number refusal: FAILED_PRECONDITION
+    // with a google.rpc.ErrorInfo detail, wrapped by the SDK into a
+    // StigmerError with the ConnectError chained as cause.
+    const connectError = new ConnectError(
+      "This WhatsApp number is already connected.",
+      Code.FailedPrecondition,
+      undefined,
+      [
+        {
+          desc: ErrorInfoSchema,
+          value: {
+            domain: "stigmer.ai",
+            reason: "WHATSAPP_NUMBER_ALREADY_CONNECTED",
+            metadata: {
+              display_phone_number: "+1 555 025 3483",
+              channel_app_id: "chapp_1",
+            },
+          },
+        },
+      ],
+    );
+    const initiateInstall = vi.fn().mockRejectedValue(
+      new StigmerError(
+        "failed-precondition",
+        connectError.rawMessage,
+        Code.FailedPrecondition,
+        { cause: connectError },
+      ),
+    );
+    const client = createMockStigmer({ initiateInstall });
+
+    const { result } = renderHook(() => useInstallChannel(), {
+      wrapper: wrapper(client),
+    });
+
+    await act(async () => {
+      await expect(result.current.install("ach_1")).rejects.toThrow();
+    });
+
+    // The hook must not re-wrap the error in a way that severs the cause
+    // chain — the dialog's guided refusal reads the reason through it.
+    const reason = getErrorReason(result.current.error);
+    expect(reason?.reason).toBe("WHATSAPP_NUMBER_ALREADY_CONNECTED");
+    expect(reason?.metadata.display_phone_number).toBe("+1 555 025 3483");
+  });
+});