@wopr-network/platform-ui-core 1.0.0

package/src/lib/__tests__/org-billing-api.test.ts

@@ -0,0 +1,242 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const {
+  mockOrgBillingBalanceQuery,
+  mockOrgMemberUsageQuery,
+  mockOrgBillingInfoQuery,
+  mockOrgTopupCheckoutMutate,
+} = vi.hoisted(() => ({
+  mockOrgBillingBalanceQuery: vi.fn(),
+  mockOrgMemberUsageQuery: vi.fn(),
+  mockOrgBillingInfoQuery: vi.fn(),
+  mockOrgTopupCheckoutMutate: vi.fn(),
+}));
+
+vi.mock("@/lib/trpc", () => ({
+  trpcVanilla: {
+    org: {
+      orgBillingBalance: { query: mockOrgBillingBalanceQuery },
+      orgMemberUsage: { query: mockOrgMemberUsageQuery },
+      orgBillingInfo: { query: mockOrgBillingInfoQuery },
+      orgTopupCheckout: { mutate: mockOrgTopupCheckoutMutate },
+    },
+  },
+  trpc: {},
+}));
+
+import {
+  createOrgTopupCheckout,
+  getOrgBillingInfo,
+  getOrgCreditBalance,
+  getOrgMemberUsage,
+} from "@/lib/org-billing-api";
+
+describe("getOrgCreditBalance", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("converts cents to dollars and returns balance", async () => {
+    mockOrgBillingBalanceQuery.mockResolvedValue({
+      balanceCents: 5000,
+      dailyBurnCents: 200,
+      runwayDays: 25,
+    });
+
+    const result = await getOrgCreditBalance("org-1");
+    expect(result).toEqual({
+      balance: 50,
+      dailyBurn: 2,
+      runway: 25,
+    });
+    expect(mockOrgBillingBalanceQuery).toHaveBeenCalledWith({ orgId: "org-1" });
+  });
+
+  it("defaults to zero balance when response fields are null", async () => {
+    mockOrgBillingBalanceQuery.mockResolvedValue({
+      balanceCents: null,
+      dailyBurnCents: null,
+      runwayDays: null,
+    });
+
+    const result = await getOrgCreditBalance("org-1");
+    expect(result).toEqual({
+      balance: 0,
+      dailyBurn: 0,
+      runway: null,
+    });
+  });
+
+  it("defaults to zero balance when response fields are undefined", async () => {
+    mockOrgBillingBalanceQuery.mockResolvedValue({});
+
+    const result = await getOrgCreditBalance("org-1");
+    expect(result).toEqual({
+      balance: 0,
+      dailyBurn: 0,
+      runway: null,
+    });
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockOrgBillingBalanceQuery.mockRejectedValue(new Error("Forbidden"));
+    await expect(getOrgCreditBalance("org-1")).rejects.toThrow("Forbidden");
+  });
+});
+
+describe("getOrgMemberUsage", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("transforms member usage with cents-to-dollars conversion", async () => {
+    mockOrgMemberUsageQuery.mockResolvedValue({
+      orgId: "org-1",
+      periodStart: "2026-03-01",
+      members: [
+        {
+          memberId: "m-1",
+          name: "Alice",
+          email: "alice@test.com",
+          creditsConsumedCents: 1500,
+          lastActiveAt: "2026-03-02T10:00:00Z",
+        },
+        {
+          memberId: "m-2",
+          name: "Bob",
+          email: "bob@test.com",
+          creditsConsumedCents: 300,
+          lastActiveAt: null,
+        },
+      ],
+    });
+
+    const result = await getOrgMemberUsage("org-1");
+    expect(result).toEqual({
+      orgId: "org-1",
+      periodStart: "2026-03-01",
+      members: [
+        {
+          memberId: "m-1",
+          name: "Alice",
+          email: "alice@test.com",
+          creditsConsumed: 15,
+          lastActiveAt: "2026-03-02T10:00:00Z",
+        },
+        {
+          memberId: "m-2",
+          name: "Bob",
+          email: "bob@test.com",
+          creditsConsumed: 3,
+          lastActiveAt: null,
+        },
+      ],
+    });
+    expect(mockOrgMemberUsageQuery).toHaveBeenCalledWith({ orgId: "org-1" });
+  });
+
+  it("defaults member fields when properties are missing", async () => {
+    mockOrgMemberUsageQuery.mockResolvedValue({
+      orgId: "org-1",
+      periodStart: "2026-03-01",
+      members: [{}],
+    });
+
+    const result = await getOrgMemberUsage("org-1");
+    expect(result.members[0]).toEqual({
+      memberId: "",
+      name: "",
+      email: "",
+      creditsConsumed: 0,
+      lastActiveAt: null,
+    });
+  });
+
+  it("handles null members array", async () => {
+    mockOrgMemberUsageQuery.mockResolvedValue({
+      orgId: "org-1",
+      periodStart: "2026-03-01",
+      members: null,
+    });
+
+    const result = await getOrgMemberUsage("org-1");
+    expect(result.members).toEqual([]);
+  });
+
+  it("falls back orgId and periodStart when missing from response", async () => {
+    mockOrgMemberUsageQuery.mockResolvedValue({
+      members: [],
+    });
+
+    const result = await getOrgMemberUsage("org-1");
+    expect(result.orgId).toBe("org-1");
+    expect(result.periodStart).toBe("");
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockOrgMemberUsageQuery.mockRejectedValue(new Error("Server error"));
+    await expect(getOrgMemberUsage("org-1")).rejects.toThrow("Server error");
+  });
+});
+
+describe("getOrgBillingInfo", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("returns payment methods and invoices", async () => {
+    const paymentMethods = [{ id: "pm-1", brand: "visa", last4: "4242" }];
+    const invoices = [{ id: "inv-1", amount: 5000, status: "paid" }];
+    mockOrgBillingInfoQuery.mockResolvedValue({ paymentMethods, invoices });
+
+    const result = await getOrgBillingInfo("org-1");
+    expect(result).toEqual({ paymentMethods, invoices });
+    expect(mockOrgBillingInfoQuery).toHaveBeenCalledWith({ orgId: "org-1" });
+  });
+
+  it("defaults to empty arrays when fields are null", async () => {
+    mockOrgBillingInfoQuery.mockResolvedValue({
+      paymentMethods: null,
+      invoices: null,
+    });
+
+    const result = await getOrgBillingInfo("org-1");
+    expect(result).toEqual({ paymentMethods: [], invoices: [] });
+  });
+
+  it("defaults to empty arrays when fields are undefined", async () => {
+    mockOrgBillingInfoQuery.mockResolvedValue({});
+
+    const result = await getOrgBillingInfo("org-1");
+    expect(result).toEqual({ paymentMethods: [], invoices: [] });
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockOrgBillingInfoQuery.mockRejectedValue(new Error("Not found"));
+    await expect(getOrgBillingInfo("org-1")).rejects.toThrow("Not found");
+  });
+});
+
+describe("createOrgTopupCheckout", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("passes all parameters to tRPC mutate", async () => {
+    const checkoutUrl = "https://checkout.stripe.com/session-123";
+    mockOrgTopupCheckoutMutate.mockResolvedValue(checkoutUrl);
+
+    const result = await createOrgTopupCheckout(
+      "org-1",
+      "price-abc",
+      "https://app.example.com/billing?success=true",
+      "https://app.example.com/billing?canceled=true",
+    );
+    expect(result).toBe(checkoutUrl);
+    expect(mockOrgTopupCheckoutMutate).toHaveBeenCalledWith({
+      orgId: "org-1",
+      priceId: "price-abc",
+      successUrl: "https://app.example.com/billing?success=true",
+      cancelUrl: "https://app.example.com/billing?canceled=true",
+    });
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockOrgTopupCheckoutMutate.mockRejectedValue(new Error("Invalid price"));
+    await expect(
+      createOrgTopupCheckout("org-1", "bad-price", "http://s", "http://c"),
+    ).rejects.toThrow("Invalid price");
+  });
+});

package/src/lib/__tests__/pricing-data.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { capabilityMeta, pricingData } from "@/lib/pricing-data";
+
+describe("pricing-data", () => {
+  describe("pricingData", () => {
+    it("matches snapshot", () => {
+      expect(pricingData).toMatchSnapshot();
+    });
+
+    it("has expected bot price", () => {
+      expect(pricingData.bot_price).toEqual({ amount: 5, period: "month" });
+    });
+
+    it("has expected signup credit", () => {
+      expect(pricingData.signup_credit).toBe(5);
+    });
+
+    it("has expected number of capability categories", () => {
+      expect(pricingData.capabilities).toHaveLength(4);
+    });
+  });
+
+  describe("capabilityMeta", () => {
+    it("matches snapshot", () => {
+      expect(capabilityMeta).toMatchSnapshot();
+    });
+
+    it("maps all expected backend keys", () => {
+      expect(Object.keys(capabilityMeta).sort()).toEqual(["image_gen", "llm", "sms", "stt", "tts"]);
+    });
+  });
+});

package/src/lib/__tests__/settings-api.test.ts

@@ -0,0 +1,272 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const {
+  mockNotificationPreferencesQuery,
+  mockUpdateNotificationPreferencesMutate,
+  mockStoreKeyMutate,
+  mockTestKeyMutate,
+  mockListCapabilitySettingsQuery,
+  mockUpdateCapabilitySettingsMutate,
+  mockListCapabilityMetaQuery,
+} = vi.hoisted(() => ({
+  mockNotificationPreferencesQuery: vi.fn(),
+  mockUpdateNotificationPreferencesMutate: vi.fn(),
+  mockStoreKeyMutate: vi.fn(),
+  mockTestKeyMutate: vi.fn(),
+  mockListCapabilitySettingsQuery: vi.fn(),
+  mockUpdateCapabilitySettingsMutate: vi.fn(),
+  mockListCapabilityMetaQuery: vi.fn(),
+}));
+
+vi.mock("@/lib/trpc", () => ({
+  trpcVanilla: {
+    settings: {
+      notificationPreferences: { query: mockNotificationPreferencesQuery },
+      updateNotificationPreferences: { mutate: mockUpdateNotificationPreferencesMutate },
+    },
+    capabilities: {
+      storeKey: { mutate: mockStoreKeyMutate },
+      testKey: { mutate: mockTestKeyMutate },
+      listCapabilitySettings: { query: mockListCapabilitySettingsQuery },
+      updateCapabilitySettings: { mutate: mockUpdateCapabilitySettingsMutate },
+      listCapabilityMeta: { query: mockListCapabilityMetaQuery },
+    },
+  },
+  trpc: {},
+}));
+
+vi.mock("@/lib/fetch-utils", () => ({
+  handleUnauthorized: vi.fn(() => {
+    throw new Error("Unauthorized");
+  }),
+  UnauthorizedError: class extends Error {},
+}));
+
+vi.mock("@/lib/api-config", () => ({
+  API_BASE_URL: "http://test-api:3001/api",
+  PLATFORM_BASE_URL: "http://test-api:3001",
+}));
+
+vi.mock("@/lib/tenant-context", () => ({
+  getActiveTenantId: vi.fn(() => "tenant-123"),
+}));
+
+import {
+  fetchCapabilityMeta,
+  getNotificationPreferences,
+  listCapabilities,
+  saveProviderKey,
+  testProviderKey,
+  updateCapability,
+  updateNotificationPreferences,
+} from "@/lib/settings-api";
+
+describe("getNotificationPreferences", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("returns preferences from tRPC query", async () => {
+    const prefs = {
+      billing_low_balance: true,
+      billing_receipts: false,
+      billing_auto_topup: true,
+      agent_channel_disconnect: false,
+      agent_status_changes: true,
+      account_role_changes: false,
+      account_team_invites: true,
+    };
+    mockNotificationPreferencesQuery.mockResolvedValue(prefs);
+
+    const result = await getNotificationPreferences();
+    expect(result).toEqual(prefs);
+    expect(mockNotificationPreferencesQuery).toHaveBeenCalledWith(undefined);
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockNotificationPreferencesQuery.mockRejectedValue(new Error("Network error"));
+    await expect(getNotificationPreferences()).rejects.toThrow("Network error");
+  });
+});
+
+describe("updateNotificationPreferences", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("sends partial prefs and returns updated result", async () => {
+    const updated = {
+      billing_low_balance: false,
+      billing_receipts: true,
+      billing_auto_topup: false,
+      agent_channel_disconnect: false,
+      agent_status_changes: false,
+      account_role_changes: false,
+      account_team_invites: false,
+    };
+    mockUpdateNotificationPreferencesMutate.mockResolvedValue(updated);
+
+    const result = await updateNotificationPreferences({ billing_low_balance: false });
+    expect(result).toEqual(updated);
+    expect(mockUpdateNotificationPreferencesMutate).toHaveBeenCalledWith({
+      billing_low_balance: false,
+    });
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockUpdateNotificationPreferencesMutate.mockRejectedValue(new Error("Forbidden"));
+    await expect(updateNotificationPreferences({ billing_receipts: true })).rejects.toThrow(
+      "Forbidden",
+    );
+  });
+});
+
+describe("saveProviderKey", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("calls storeKey with provider and apiKey", async () => {
+    const response = { ok: true as const, id: "key-1", provider: "openai" };
+    mockStoreKeyMutate.mockResolvedValue(response);
+
+    const result = await saveProviderKey("openai", "sk-test-123");
+    expect(result).toEqual(response);
+    expect(mockStoreKeyMutate).toHaveBeenCalledWith({
+      provider: "openai",
+      apiKey: "sk-test-123",
+    });
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockStoreKeyMutate.mockRejectedValue(new Error("Invalid key"));
+    await expect(saveProviderKey("openai", "bad")).rejects.toThrow("Invalid key");
+  });
+});
+
+describe("testProviderKey", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("calls testKey with provider and key", async () => {
+    mockTestKeyMutate.mockResolvedValue({ valid: true });
+
+    const result = await testProviderKey("anthropic", "sk-ant-123");
+    expect(result).toEqual({ valid: true });
+    expect(mockTestKeyMutate).toHaveBeenCalledWith({
+      provider: "anthropic",
+      key: "sk-ant-123",
+    });
+  });
+
+  it("defaults key to empty string when not provided", async () => {
+    mockTestKeyMutate.mockResolvedValue({ valid: false, error: "No key" });
+
+    const result = await testProviderKey("openai");
+    expect(result).toEqual({ valid: false, error: "No key" });
+    expect(mockTestKeyMutate).toHaveBeenCalledWith({
+      provider: "openai",
+      key: "",
+    });
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockTestKeyMutate.mockRejectedValue(new Error("Timeout"));
+    await expect(testProviderKey("openai", "k")).rejects.toThrow("Timeout");
+  });
+});
+
+describe("listCapabilities", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("returns capability settings array", async () => {
+    const caps = [
+      {
+        capability: "transcription",
+        mode: "hosted",
+        maskedKey: null,
+        keyStatus: null,
+        provider: "deepgram",
+      },
+    ];
+    mockListCapabilitySettingsQuery.mockResolvedValue(caps);
+
+    const result = await listCapabilities();
+    expect(result).toEqual(caps);
+    expect(mockListCapabilitySettingsQuery).toHaveBeenCalledWith(undefined);
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockListCapabilitySettingsQuery.mockRejectedValue(new Error("Server error"));
+    await expect(listCapabilities()).rejects.toThrow("Server error");
+  });
+});
+
+describe("updateCapability", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("sends capability, mode, and optional key", async () => {
+    const updated = {
+      capability: "transcription",
+      mode: "byok",
+      maskedKey: "sk-***123",
+      keyStatus: "valid",
+      provider: "deepgram",
+    };
+    mockUpdateCapabilitySettingsMutate.mockResolvedValue(updated);
+
+    const result = await updateCapability("transcription", {
+      mode: "byok",
+      key: "sk-full-key",
+    });
+    expect(result).toEqual(updated);
+    expect(mockUpdateCapabilitySettingsMutate).toHaveBeenCalledWith({
+      capability: "transcription",
+      mode: "byok",
+      key: "sk-full-key",
+    });
+  });
+
+  it("sends without key when not provided", async () => {
+    const updated = {
+      capability: "text-gen",
+      mode: "hosted",
+      maskedKey: null,
+      keyStatus: null,
+      provider: "anthropic",
+    };
+    mockUpdateCapabilitySettingsMutate.mockResolvedValue(updated);
+
+    await updateCapability("text-gen", { mode: "hosted" });
+    expect(mockUpdateCapabilitySettingsMutate).toHaveBeenCalledWith({
+      capability: "text-gen",
+      mode: "hosted",
+      key: undefined,
+    });
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockUpdateCapabilitySettingsMutate.mockRejectedValue(new Error("Bad request"));
+    await expect(updateCapability("text-gen", { mode: "hosted" })).rejects.toThrow("Bad request");
+  });
+});
+
+describe("fetchCapabilityMeta", () => {
+  afterEach(() => vi.clearAllMocks());
+
+  it("returns capability meta entries", async () => {
+    const meta = [
+      {
+        capability: "transcription",
+        label: "Transcription",
+        description: "Speech to text",
+        pricing: "$0.01/min",
+        hostedProvider: "deepgram",
+        icon: "mic",
+        sortOrder: 1,
+      },
+    ];
+    mockListCapabilityMetaQuery.mockResolvedValue(meta);
+
+    const result = await fetchCapabilityMeta();
+    expect(result).toEqual(meta);
+  });
+
+  it("propagates tRPC errors", async () => {
+    mockListCapabilityMetaQuery.mockRejectedValue(new Error("Not found"));
+    await expect(fetchCapabilityMeta()).rejects.toThrow("Not found");
+  });
+});

package/src/lib/admin-affiliate-api.ts

@@ -0,0 +1,51 @@
+import { trpcVanilla } from "./trpc";
+
+// ---- Types ----
+
+export interface SuppressionEvent {
+  id: string;
+  referrerTenantId: string;
+  referredTenantId: string;
+  verdict: string;
+  signals: string[];
+  signalDetails: Record<string, string>;
+  phase: string;
+  createdAt: string;
+}
+
+export interface VelocityReferrer {
+  referrerTenantId: string;
+  payoutCount30d: number;
+  payoutTotal30dCents: number;
+}
+
+export interface FingerprintCluster {
+  stripeFingerprint: string;
+  tenantIds: string[];
+}
+
+// ---- API calls ----
+
+export async function getAffiliateSuppressions(
+  limit = 50,
+  offset = 0,
+): Promise<{ events: SuppressionEvent[]; total: number }> {
+  return trpcVanilla.admin.affiliateSuppressions.query({ limit, offset });
+}
+
+export async function getAffiliateVelocity(
+  capReferrals = 20,
+  capCredits = 20000,
+): Promise<VelocityReferrer[]> {
+  return trpcVanilla.admin.affiliateVelocity.query({ capReferrals, capCredits });
+}
+
+export async function getAffiliateFingerprintClusters(): Promise<FingerprintCluster[]> {
+  return trpcVanilla.admin.affiliateFingerprintClusters.query(undefined);
+}
+
+export async function blockAffiliateFingerprint(
+  fingerprint: string,
+): Promise<{ success: boolean }> {
+  return trpcVanilla.admin.affiliateBlockFingerprint.mutate({ fingerprint });
+}