@structured-id/ui-core 0.1.5

package/src/profile/composables/useAccountApi.ts

@@ -0,0 +1,203 @@
+/**
+ * Profile account API composable.
+ *
+ * Wraps AccountServiceClient proto calls with Bearer auth.
+ * Covers: consents, activity, linked accounts, app launcher, passwordless.
+ */
+import {
+  getTransport,
+  AccountServiceClient,
+  type ConsentInfo,
+  type ClaimConsent,
+  type GetConsentDetailResponse,
+  type ActivityEvent,
+  type ListActivityEventsResponse,
+  type LinkedAccount,
+  type ListLinkedAccountsResponse,
+  type LinkAccountResponse,
+  type ReauthenticateLinkResponse,
+  type AvailableApp,
+  type LaunchAppResponse,
+  type PasswordlessStatus,
+  type DisablePasswordlessResponse,
+  ConsentStatus,
+  ClaimType,
+  ClaimConsentStatus,
+  ActivityEventStatus,
+  LinkedAccountTrustCategory,
+  LinkedAccountStatus,
+  Timestamp,
+} from "../../index";
+import { authMeta } from "../auth";
+
+function client(): AccountServiceClient {
+  return new AccountServiceClient(getTransport());
+}
+
+// ── Consents ──
+
+export type { ConsentInfo, ClaimConsent, GetConsentDetailResponse };
+
+export async function listConsents(): Promise<ConsentInfo[]> {
+  const { response } = await client().listConsents({}, { meta: authMeta() });
+  return response.consents;
+}
+
+export async function getConsentDetail(
+  siteId: string,
+): Promise<GetConsentDetailResponse> {
+  const { response } = await client().getConsentDetail(
+    { siteId },
+    { meta: authMeta() },
+  );
+  return response;
+}
+
+export async function updateClaimConsent(
+  siteId: string,
+  claimName: string,
+  grant: boolean,
+): Promise<void> {
+  await client().updateClaimConsent(
+    { siteId, claimName, grant },
+    { meta: authMeta() },
+  );
+}
+
+export async function disconnectSite(siteId: string): Promise<void> {
+  await client().disconnectSite({ siteId }, { meta: authMeta() });
+}
+
+// ── Activity ──
+
+export type { ActivityEvent, ListActivityEventsResponse };
+
+export interface ActivityFilters {
+  eventTypes?: string[];
+  applicationId?: string;
+  statusFilter?: ActivityEventStatus;
+  dateFrom?: Date;
+  dateTo?: Date;
+  search?: string;
+  pageSize?: number;
+  pageToken?: string;
+}
+
+export async function listActivityEvents(
+  filters: ActivityFilters = {},
+): Promise<ListActivityEventsResponse> {
+  const { response } = await client().listActivityEvents(
+    {
+      eventTypes: filters.eventTypes ?? [],
+      applicationId: filters.applicationId,
+      statusFilter: filters.statusFilter,
+      dateFrom: filters.dateFrom
+        ? Timestamp.fromDate(filters.dateFrom)
+        : undefined,
+      dateTo: filters.dateTo ? Timestamp.fromDate(filters.dateTo) : undefined,
+      search: filters.search,
+      pageSize: filters.pageSize ?? 20,
+      pageToken: filters.pageToken ?? "",
+    },
+    { meta: authMeta() },
+  );
+  return response;
+}
+
+export async function getActivityEventDetail(
+  eventId: string,
+): Promise<ActivityEvent> {
+  const { response } = await client().getActivityEventDetail(
+    { eventId },
+    { meta: authMeta() },
+  );
+  return response;
+}
+
+export async function reportSuspiciousEvent(
+  eventId: string,
+  description?: string,
+): Promise<void> {
+  await client().reportSuspiciousEvent(
+    { eventId, description },
+    { meta: authMeta() },
+  );
+}
+
+// ── Linked Accounts ──
+
+export type { LinkedAccount, ListLinkedAccountsResponse };
+
+export async function listLinkedAccounts(): Promise<ListLinkedAccountsResponse> {
+  const { response } = await client().listLinkedAccounts({}, { meta: authMeta() });
+  return response;
+}
+
+export async function linkAccount(
+  providerId: string,
+  redirectUri: string,
+): Promise<LinkAccountResponse> {
+  const { response } = await client().linkAccount(
+    { providerId, redirectUri },
+    { meta: authMeta() },
+  );
+  return response;
+}
+
+export async function unlinkAccount(linkedAccountId: string): Promise<void> {
+  await client().unlinkAccount({ linkedAccountId }, { meta: authMeta() });
+}
+
+export async function reauthenticateLink(
+  linkedAccountId: string,
+  redirectUri: string,
+): Promise<ReauthenticateLinkResponse> {
+  const { response } = await client().reauthenticateLink(
+    { linkedAccountId, redirectUri },
+    { meta: authMeta() },
+  );
+  return response;
+}
+
+// ── App Launcher ──
+
+export type { AvailableApp, PasswordlessStatus, DisablePasswordlessResponse };
+
+export async function listAvailableApps(): Promise<AvailableApp[]> {
+  const { response } = await client().listAvailableApps({}, { meta: authMeta() });
+  return response.apps;
+}
+
+export async function launchApp(appId: string): Promise<LaunchAppResponse> {
+  const { response } = await client().launchApp({ appId }, { meta: authMeta() });
+  return response;
+}
+
+// ── Passwordless ──
+
+export async function getPasswordlessStatus(): Promise<PasswordlessStatus> {
+  const { response } = await client().getPasswordlessStatus(
+    {},
+    { meta: authMeta() },
+  );
+  return response;
+}
+
+export async function enablePasswordless(): Promise<void> {
+  await client().enablePasswordless({}, { meta: authMeta() });
+}
+
+export async function disablePasswordless(): Promise<DisablePasswordlessResponse> {
+  const { response } = await client().disablePasswordless({}, { meta: authMeta() });
+  return response;
+}
+
+// Re-export enums
+export {
+  ConsentStatus,
+  ClaimType,
+  ClaimConsentStatus,
+  ActivityEventStatus,
+  LinkedAccountTrustCategory,
+  LinkedAccountStatus,
+};

package/src/profile/composables/useAuthApi.opaque.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  opaqueLoginStart,
+  opaqueLoginFinish,
+  opaqueRegistrationStart,
+  opaqueRegistrationFinish,
+} from "./useAuthApi";
+
+// Mock the gRPC transport + AuthServiceClient
+const mockOpaqueLoginStart = vi.fn();
+const mockOpaqueLoginFinish = vi.fn();
+const mockOpaqueRegistrationStart = vi.fn();
+const mockOpaqueRegistrationFinish = vi.fn();
+
+vi.mock("../../index", () => ({
+  getTransport: vi.fn(),
+  AuthServiceClient: vi.fn().mockImplementation(() => ({
+    opaqueLoginStart: mockOpaqueLoginStart,
+    opaqueLoginFinish: mockOpaqueLoginFinish,
+    opaqueRegistrationStart: mockOpaqueRegistrationStart,
+    opaqueRegistrationFinish: mockOpaqueRegistrationFinish,
+  })),
+}));
+
+// authMeta needs to be mocked since it uses useAuth() which needs Vue context
+vi.mock("../auth", () => ({
+  authMeta: () => ({}),
+}));
+
+describe("OPAQUE gRPC wrappers", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("opaqueLoginStart", () => {
+    it("sends principal and credentialRequest, returns response", async () => {
+      const expected = {
+        credentialResponse: new Uint8Array([1, 2, 3]),
+        serverLoginState: "state-123",
+      };
+      mockOpaqueLoginStart.mockResolvedValue({ response: expected });
+
+      const result = await opaqueLoginStart(
+        "alice@test.com",
+        new Uint8Array([10, 20]),
+      );
+
+      expect(mockOpaqueLoginStart).toHaveBeenCalledWith({
+        principal: "alice@test.com",
+        credentialRequest: new Uint8Array([10, 20]),
+      });
+      expect(result).toBe(expected);
+    });
+
+    it("propagates gRPC errors", async () => {
+      mockOpaqueLoginStart.mockRejectedValue(new Error("UNAVAILABLE"));
+      await expect(opaqueLoginStart("x", new Uint8Array())).rejects.toThrow(
+        "UNAVAILABLE",
+      );
+    });
+  });
+
+  describe("opaqueLoginFinish", () => {
+    it("sends principal, finalization, and serverLoginState", async () => {
+      const expected = {
+        sessionId: "sess-1",
+        accessToken: "jwt",
+        expiresIn: BigInt(3600),
+      };
+      mockOpaqueLoginFinish.mockResolvedValue({ response: expected });
+
+      const result = await opaqueLoginFinish(
+        "alice@test.com",
+        new Uint8Array([7, 8, 9]),
+        "state-123",
+      );
+
+      expect(mockOpaqueLoginFinish).toHaveBeenCalledWith({
+        principal: "alice@test.com",
+        credentialFinalization: new Uint8Array([7, 8, 9]),
+        serverLoginState: "state-123",
+      });
+      expect(result).toBe(expected);
+    });
+  });
+
+  describe("opaqueRegistrationStart", () => {
+    it("sends principal and registrationRequest", async () => {
+      const expected = {
+        registrationResponse: new Uint8Array([4, 5, 6]),
+        serverSetup: "setup-abc",
+      };
+      mockOpaqueRegistrationStart.mockResolvedValue({ response: expected });
+
+      const result = await opaqueRegistrationStart(
+        "bob@test.com",
+        new Uint8Array([11, 12]),
+      );
+
+      expect(mockOpaqueRegistrationStart).toHaveBeenCalledWith({
+        principal: "bob@test.com",
+        registrationRequest: new Uint8Array([11, 12]),
+      });
+      expect(result).toBe(expected);
+    });
+  });
+
+  describe("opaqueRegistrationFinish", () => {
+    it("sends principal, record, and serverSetup", async () => {
+      const expected = {
+        profileId: "profile-uuid",
+        credentialId: "cred-uuid",
+        serverPepper: new Uint8Array(),
+      };
+      mockOpaqueRegistrationFinish.mockResolvedValue({ response: expected });
+
+      const result = await opaqueRegistrationFinish(
+        "bob@test.com",
+        new Uint8Array([20, 21]),
+        "setup-abc",
+      );
+
+      expect(mockOpaqueRegistrationFinish).toHaveBeenCalledWith({
+        principal: "bob@test.com",
+        registrationRecord: new Uint8Array([20, 21]),
+        serverSetup: "setup-abc",
+      });
+      expect(result).toBe(expected);
+    });
+
+    it("propagates gRPC errors", async () => {
+      mockOpaqueRegistrationFinish.mockRejectedValue(
+        new Error("ALREADY_EXISTS"),
+      );
+      await expect(
+        opaqueRegistrationFinish("x", new Uint8Array(), "s"),
+      ).rejects.toThrow("ALREADY_EXISTS");
+    });
+  });
+});