@startsimpli/auth 0.4.17 → 0.4.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/auth",
-  "version": "0.4.17",
+  "version": "0.4.18",
   "description": "Shared authentication package for StartSimpli Next.js apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/hooks/__tests__/use-membership-from-api.test.tsx

@@ -0,0 +1,45 @@
+/** @vitest-environment jsdom */
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { useMembershipFromApi } from '../use-membership-from-api';
+
+vi.mock('../../client/use-auth', () => ({
+  useAuth: () => ({
+    user: { id: 'u1', email: 'a@x.com', currentCompanyId: 'c1' },
+    isLoading: false,
+    isAuthenticated: true,
+  }),
+}));
+
+describe('useMembershipFromApi', () => {
+  it('wires myTeams + retrieve + companies.retrieve through to useMembership', async () => {
+    const api = {
+      teams: {
+        myTeams: vi.fn().mockResolvedValue([
+          {
+            id: 'm1',
+            userId: 'u1',
+            teamId: 't1',
+            role: 'owner',
+            joinedAt: '2025-01-01',
+            team: { id: 't1', slug: 'core', name: 'Core', companyId: 'c1' },
+          },
+        ]),
+        retrieve: vi.fn(),
+      },
+      companies: {
+        retrieve: vi.fn().mockResolvedValue({ id: 'c1', slug: 'acme', name: 'Acme' }),
+      },
+    };
+
+    const { result } = renderHook(() => useMembershipFromApi(api));
+
+    await waitFor(() => {
+      expect(result.current.company?.name).toBe('Acme');
+      expect(result.current.currentTeam?.slug).toBe('core');
+      expect(result.current.isOwner).toBe(true);
+    });
+    expect(api.teams.myTeams).toHaveBeenCalledTimes(1);
+    expect(api.companies.retrieve).toHaveBeenCalledWith('c1');
+  });
+});

package/src/hooks/index.ts

@@ -16,6 +16,11 @@ export {
   type MembershipRole,
 } from './use-membership';
 
+export {
+  useMembershipFromApi,
+  type UseMembershipFromApiClient,
+} from './use-membership-from-api';
+
 export {
   useInvitations,
   type UseInvitationsOptions,

package/src/hooks/use-membership-from-api.ts

@@ -0,0 +1,99 @@
+'use client';
+
+/**
+ * useMembershipFromApi — thin adapter around `useMembership` that takes
+ * the @startsimpli/api `api` client and wires `fetchMyTeams`, `fetchTeam`,
+ * and `fetchCompany` automatically.
+ *
+ * Apps previously hand-rolled this adapter inside each /settings/team page;
+ * lifting it here means a one-liner adoption for the next consumer. The api
+ * argument is structurally typed (just the slice we use) so this hook can
+ * still live in @startsimpli/auth without depending on @startsimpli/api. startsim-o7s.
+ */
+
+import { useMemo } from 'react';
+import {
+  useMembership,
+  type MembershipRow,
+  type MembershipTeam,
+  type MembershipCompany,
+  type UseMembershipReturn,
+} from './use-membership';
+
+/** Minimum API surface used by the adapter. */
+export interface UseMembershipFromApiClient {
+  teams: {
+    myTeams: () => Promise<
+      Array<{
+        id: string;
+        userId: string;
+        teamId: string;
+        role: MembershipRow['role'];
+        joinedAt: string;
+        team?: {
+          id: string;
+          slug: string;
+          name: string;
+          companyId: string;
+        };
+      }>
+    >;
+    retrieve: (idOrSlug: string) => Promise<{
+      id: string;
+      slug: string;
+      name: string;
+      companyId: string;
+    }>;
+  };
+  companies: {
+    retrieve: (idOrSlug: string) => Promise<{
+      id: string;
+      slug: string;
+      name: string;
+    }>;
+  };
+}
+
+export function useMembershipFromApi(
+  api: UseMembershipFromApiClient,
+): UseMembershipReturn {
+  const fetchMyTeams = useMemo(
+    () => async (): Promise<MembershipRow[]> => {
+      const rows = await api.teams.myTeams();
+      return rows.map((r) => ({
+        id: r.id,
+        userId: r.userId,
+        teamId: r.teamId,
+        role: r.role,
+        joinedAt: r.joinedAt,
+        team: r.team
+          ? {
+              id: r.team.id,
+              slug: r.team.slug,
+              name: r.team.name,
+              companyId: r.team.companyId,
+            }
+          : undefined,
+      }));
+    },
+    [api],
+  );
+
+  const fetchTeam = useMemo(
+    () => async (idOrSlug: string): Promise<MembershipTeam> => {
+      const t = await api.teams.retrieve(idOrSlug);
+      return { id: t.id, slug: t.slug, name: t.name, companyId: t.companyId };
+    },
+    [api],
+  );
+
+  const fetchCompany = useMemo(
+    () => async (idOrSlug: string): Promise<MembershipCompany> => {
+      const c = await api.companies.retrieve(idOrSlug);
+      return { id: c.id, slug: c.slug, name: c.name };
+    },
+    [api],
+  );
+
+  return useMembership({ fetchMyTeams, fetchTeam, fetchCompany });
+}

package/src/index.ts

@@ -62,6 +62,7 @@ export type {
 // useDomainClaims. Headless; caller passes the @startsimpli/api methods.
 export {
   useMembership,
+  useMembershipFromApi,
   useInvitations,
   useDomainClaims,
 } from './hooks';
@@ -72,6 +73,7 @@ export type {
   MembershipTeam,
   MembershipRow,
   MembershipRole,
+  UseMembershipFromApiClient,
   UseInvitationsOptions,
   UseInvitationsReturn,
   InvitationRow,