@nimbleflux/fluxbase-sdk-react 2026.3.6-rc.1

package/src/use-auth.test.ts

@@ -0,0 +1,313 @@
+/**
+ * Tests for authentication hooks
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, waitFor, act } from '@testing-library/react';
+import {
+  useUser,
+  useSession,
+  useSignIn,
+  useSignUp,
+  useSignOut,
+  useUpdateUser,
+  useAuth,
+} from './use-auth';
+import { createMockClient, createWrapper, createTestQueryClient } from './test-utils';
+
+describe('useUser', () => {
+  it('should return null when no session', async () => {
+    const client = createMockClient({
+      auth: {
+        getSession: vi.fn().mockResolvedValue({ data: { session: null }, error: null }),
+      },
+    } as any);
+
+    const { result } = renderHook(() => useUser(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toBeNull();
+  });
+
+  it('should return user when session exists', async () => {
+    const mockUser = { id: '1', email: 'test@example.com' };
+    const client = createMockClient({
+      auth: {
+        getSession: vi.fn().mockResolvedValue({ data: { session: { access_token: 'token' } }, error: null }),
+        getCurrentUser: vi.fn().mockResolvedValue({ data: { user: mockUser }, error: null }),
+      },
+    } as any);
+
+    const { result } = renderHook(() => useUser(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockUser);
+  });
+
+  it('should return null when getCurrentUser fails', async () => {
+    const client = createMockClient({
+      auth: {
+        getSession: vi.fn().mockResolvedValue({ data: { session: { access_token: 'token' } }, error: null }),
+        getCurrentUser: vi.fn().mockRejectedValue(new Error('Not authenticated')),
+      },
+    } as any);
+
+    const { result } = renderHook(() => useUser(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toBeNull();
+  });
+});
+
+describe('useSession', () => {
+  it('should return null when no session', async () => {
+    const client = createMockClient({
+      auth: {
+        getSession: vi.fn().mockResolvedValue({ data: { session: null }, error: null }),
+      },
+    } as any);
+
+    const { result } = renderHook(() => useSession(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toBeNull();
+  });
+
+  it('should return session when exists', async () => {
+    const mockSession = { access_token: 'token', refresh_token: 'refresh' };
+    const client = createMockClient({
+      auth: {
+        getSession: vi.fn().mockResolvedValue({ data: { session: mockSession }, error: null }),
+      },
+    } as any);
+
+    const { result } = renderHook(() => useSession(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockSession);
+  });
+});
+
+describe('useSignIn', () => {
+  it('should call signIn and update cache on success', async () => {
+    const mockSession = { user: { id: '1', email: 'test@example.com' }, access_token: 'token' };
+    const signInMock = vi.fn().mockResolvedValue(mockSession);
+    const client = createMockClient({
+      auth: {
+        signIn: signInMock,
+      },
+    } as any);
+
+    const queryClient = createTestQueryClient();
+    const { result } = renderHook(() => useSignIn(), {
+      wrapper: createWrapper(client, queryClient),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ email: 'test@example.com', password: 'password' });
+    });
+
+    expect(signInMock).toHaveBeenCalledWith({ email: 'test@example.com', password: 'password' });
+    expect(queryClient.getQueryData(['fluxbase', 'auth', 'session'])).toEqual(mockSession);
+  });
+
+  it('should handle 2FA required response (no user)', async () => {
+    const mockResponse = { mfa_required: true };
+    const signInMock = vi.fn().mockResolvedValue(mockResponse);
+    const client = createMockClient({
+      auth: {
+        signIn: signInMock,
+      },
+    } as any);
+
+    const queryClient = createTestQueryClient();
+    const { result } = renderHook(() => useSignIn(), {
+      wrapper: createWrapper(client, queryClient),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ email: 'test@example.com', password: 'password' });
+    });
+
+    // User should not be set when 2FA is required
+    expect(queryClient.getQueryData(['fluxbase', 'auth', 'user'])).toBeUndefined();
+  });
+});
+
+describe('useSignUp', () => {
+  it('should call signUp and return response on success', async () => {
+    const mockResponse = {
+      data: {
+        user: { id: '1', email: 'test@example.com' },
+        session: { access_token: 'token' },
+      },
+    };
+    const signUpMock = vi.fn().mockResolvedValue(mockResponse);
+    const client = createMockClient({
+      auth: {
+        signUp: signUpMock,
+      },
+    } as any);
+
+    const { result } = renderHook(() => useSignUp(), {
+      wrapper: createWrapper(client),
+    });
+
+    let response;
+    await act(async () => {
+      response = await result.current.mutateAsync({ email: 'test@example.com', password: 'password' });
+    });
+
+    expect(signUpMock).toHaveBeenCalledWith({ email: 'test@example.com', password: 'password' });
+    expect(response).toEqual(mockResponse);
+  });
+
+  it('should handle signup without immediate session', async () => {
+    const mockResponse = { data: null };
+    const signUpMock = vi.fn().mockResolvedValue(mockResponse);
+    const client = createMockClient({
+      auth: {
+        signUp: signUpMock,
+      },
+    } as any);
+
+    const queryClient = createTestQueryClient();
+    const { result } = renderHook(() => useSignUp(), {
+      wrapper: createWrapper(client, queryClient),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ email: 'test@example.com', password: 'password' });
+    });
+
+    // Cache should not be updated when data is null
+    expect(queryClient.getQueryData(['fluxbase', 'auth', 'session'])).toBeUndefined();
+  });
+});
+
+describe('useSignOut', () => {
+  it('should call signOut successfully', async () => {
+    const signOutMock = vi.fn().mockResolvedValue(undefined);
+    const client = createMockClient({
+      auth: {
+        signOut: signOutMock,
+      },
+    } as any);
+
+    const { result } = renderHook(() => useSignOut(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync();
+    });
+
+    expect(signOutMock).toHaveBeenCalled();
+  });
+});
+
+describe('useUpdateUser', () => {
+  it('should call updateUser and update cache', async () => {
+    const updatedUser = { id: '1', email: 'new@example.com' };
+    const updateUserMock = vi.fn().mockResolvedValue(updatedUser);
+    const client = createMockClient({
+      auth: {
+        updateUser: updateUserMock,
+      },
+    } as any);
+
+    const queryClient = createTestQueryClient();
+    const { result } = renderHook(() => useUpdateUser(), {
+      wrapper: createWrapper(client, queryClient),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ email: 'new@example.com' });
+    });
+
+    expect(updateUserMock).toHaveBeenCalledWith({ email: 'new@example.com' });
+    expect(queryClient.getQueryData(['fluxbase', 'auth', 'user'])).toEqual(updatedUser);
+  });
+});
+
+describe('useAuth', () => {
+  it('should return combined auth state', async () => {
+    const mockUser = { id: '1', email: 'test@example.com' };
+    const mockSession = { access_token: 'token' };
+    const client = createMockClient({
+      auth: {
+        getSession: vi.fn().mockResolvedValue({ data: { session: mockSession }, error: null }),
+        getCurrentUser: vi.fn().mockResolvedValue({ data: { user: mockUser }, error: null }),
+      },
+    } as any);
+
+    const { result } = renderHook(() => useAuth(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.user).toEqual(mockUser);
+    expect(result.current.session).toEqual(mockSession);
+    expect(result.current.isAuthenticated).toBe(true);
+    expect(result.current.signIn).toBeDefined();
+    expect(result.current.signUp).toBeDefined();
+    expect(result.current.signOut).toBeDefined();
+    expect(result.current.updateUser).toBeDefined();
+  });
+
+  it('should show loading state initially', () => {
+    const client = createMockClient({
+      auth: {
+        getSession: vi.fn().mockImplementation(() => new Promise(() => {})), // Never resolves
+      },
+    } as any);
+
+    const { result } = renderHook(() => useAuth(), {
+      wrapper: createWrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(true);
+  });
+
+  it('should show unauthenticated state when no session', async () => {
+    const client = createMockClient({
+      auth: {
+        getSession: vi.fn().mockResolvedValue({ data: { session: null }, error: null }),
+      },
+    } as any);
+
+    const { result } = renderHook(() => useAuth(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.user).toBeNull();
+    expect(result.current.session).toBeNull();
+    expect(result.current.isAuthenticated).toBe(false);
+  });
+
+  it('should have pending states for mutations', () => {
+    const client = createMockClient();
+
+    const { result } = renderHook(() => useAuth(), {
+      wrapper: createWrapper(client),
+    });
+
+    expect(result.current.isSigningIn).toBe(false);
+    expect(result.current.isSigningUp).toBe(false);
+    expect(result.current.isSigningOut).toBe(false);
+    expect(result.current.isUpdating).toBe(false);
+  });
+});

package/src/use-auth.ts

@@ -0,0 +1,164 @@
+/**
+ * Authentication hooks for Fluxbase SDK
+ */
+
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useFluxbaseClient } from "./context";
+import type {
+  SignInCredentials,
+  SignUpCredentials,
+  User,
+  AuthSession,
+} from "@fluxbase/sdk";
+
+/**
+ * Hook to get the current user
+ */
+export function useUser() {
+  const client = useFluxbaseClient();
+
+  return useQuery({
+    queryKey: ["fluxbase", "auth", "user"],
+    queryFn: async () => {
+      const { data } = await client.auth.getSession();
+      if (!data?.session) {
+        return null;
+      }
+
+      try {
+        const result = await client.auth.getCurrentUser();
+        return result.data?.user ?? null;
+      } catch {
+        return null;
+      }
+    },
+    staleTime: 1000 * 60 * 5, // 5 minutes
+  });
+}
+
+/**
+ * Hook to get the current session
+ */
+export function useSession() {
+  const client = useFluxbaseClient();
+
+  return useQuery<AuthSession | null>({
+    queryKey: ["fluxbase", "auth", "session"],
+    queryFn: async () => {
+      const { data } = await client.auth.getSession();
+      return data?.session ?? null;
+    },
+    staleTime: 1000 * 60 * 5, // 5 minutes
+  });
+}
+
+/**
+ * Hook for signing in
+ */
+export function useSignIn() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (credentials: SignInCredentials) => {
+      return await client.auth.signIn(credentials);
+    },
+    onSuccess: (session) => {
+      queryClient.setQueryData(["fluxbase", "auth", "session"], session);
+      // Only set user if this is a complete auth session (not 2FA required)
+      // Check for truthy user value, not just property existence
+      if (session && "user" in session && session.user) {
+        queryClient.setQueryData(["fluxbase", "auth", "user"], session.user);
+      }
+    },
+  });
+}
+
+/**
+ * Hook for signing up
+ */
+export function useSignUp() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (credentials: SignUpCredentials) => {
+      return await client.auth.signUp(credentials);
+    },
+    onSuccess: (response) => {
+      if (response.data) {
+        queryClient.setQueryData(
+          ["fluxbase", "auth", "session"],
+          response.data.session,
+        );
+        queryClient.setQueryData(
+          ["fluxbase", "auth", "user"],
+          response.data.user,
+        );
+      }
+    },
+  });
+}
+
+/**
+ * Hook for signing out
+ */
+export function useSignOut() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async () => {
+      await client.auth.signOut();
+    },
+    onSuccess: () => {
+      queryClient.setQueryData(["fluxbase", "auth", "session"], null);
+      queryClient.setQueryData(["fluxbase", "auth", "user"], null);
+      queryClient.invalidateQueries({ queryKey: ["fluxbase"] });
+    },
+  });
+}
+
+/**
+ * Hook for updating the current user
+ */
+export function useUpdateUser() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (data: Partial<Pick<User, "email" | "metadata">>) => {
+      return await client.auth.updateUser(data);
+    },
+    onSuccess: (user) => {
+      queryClient.setQueryData(["fluxbase", "auth", "user"], user);
+    },
+  });
+}
+
+/**
+ * Combined auth hook with all auth state and methods
+ */
+export function useAuth() {
+  const { data: user, isLoading: isLoadingUser } = useUser();
+  const { data: session, isLoading: isLoadingSession } = useSession();
+  const signIn = useSignIn();
+  const signUp = useSignUp();
+  const signOut = useSignOut();
+  const updateUser = useUpdateUser();
+
+  return {
+    user,
+    session,
+    isLoading: isLoadingUser || isLoadingSession,
+    isAuthenticated: !!session,
+    signIn: signIn.mutateAsync,
+    signUp: signUp.mutateAsync,
+    signOut: signOut.mutateAsync,
+    updateUser: updateUser.mutateAsync,
+    isSigningIn: signIn.isPending,
+    isSigningUp: signUp.isPending,
+    isSigningOut: signOut.isPending,
+    isUpdating: updateUser.isPending,
+  };
+}