@fluxbase/sdk-react 2026.1.22-rc.9 → 2026.2.1

package/src/use-admin-auth.test.ts

@@ -0,0 +1,175 @@
+/**
+ * Tests for admin authentication hook
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { useAdminAuth } from './use-admin-auth';
+import { createMockClient, createWrapper } from './test-utils';
+
+describe('useAdminAuth', () => {
+  it('should check auth status on mount when autoCheck is true', async () => {
+    const mockUser = { id: '1', email: 'admin@example.com', role: 'admin' };
+    const meMock = vi.fn().mockResolvedValue({ data: { user: mockUser }, error: null });
+
+    const client = createMockClient({
+      admin: { me: meMock },
+    } as any);
+
+    const { result } = renderHook(
+      () => useAdminAuth({ autoCheck: true }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.user).toEqual(mockUser);
+    expect(result.current.isAuthenticated).toBe(true);
+    expect(meMock).toHaveBeenCalled();
+  });
+
+  it('should not check auth status when autoCheck is false', async () => {
+    const meMock = vi.fn();
+
+    const client = createMockClient({
+      admin: { me: meMock },
+    } as any);
+
+    const { result } = renderHook(
+      () => useAdminAuth({ autoCheck: false }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(meMock).not.toHaveBeenCalled();
+    expect(result.current.isAuthenticated).toBe(false);
+  });
+
+  it('should handle auth check error', async () => {
+    const error = new Error('Not authenticated');
+    const meMock = vi.fn().mockResolvedValue({ data: null, error });
+
+    const client = createMockClient({
+      admin: { me: meMock },
+    } as any);
+
+    const { result } = renderHook(
+      () => useAdminAuth({ autoCheck: true }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.user).toBeNull();
+    expect(result.current.isAuthenticated).toBe(false);
+    expect(result.current.error).toBe(error);
+  });
+
+  it('should login successfully', async () => {
+    const mockUser = { id: '1', email: 'admin@example.com', role: 'admin' };
+    const loginMock = vi.fn().mockResolvedValue({
+      data: { user: mockUser, token: 'token' },
+      error: null,
+    });
+
+    const client = createMockClient({
+      admin: { login: loginMock, me: vi.fn().mockResolvedValue({ data: null, error: null }) },
+    } as any);
+
+    const { result } = renderHook(
+      () => useAdminAuth({ autoCheck: false }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await act(async () => {
+      await result.current.login('admin@example.com', 'password');
+    });
+
+    expect(loginMock).toHaveBeenCalledWith({ email: 'admin@example.com', password: 'password' });
+    expect(result.current.user).toEqual(mockUser);
+    expect(result.current.isAuthenticated).toBe(true);
+  });
+
+  it('should handle login error', async () => {
+    const error = new Error('Invalid credentials');
+    const loginMock = vi.fn().mockResolvedValue({ data: null, error });
+
+    const client = createMockClient({
+      admin: { login: loginMock, me: vi.fn().mockResolvedValue({ data: null, error: null }) },
+    } as any);
+
+    const { result } = renderHook(
+      () => useAdminAuth({ autoCheck: false }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await expect(act(async () => {
+      await result.current.login('admin@example.com', 'wrong-password');
+    })).rejects.toThrow();
+
+    // User should remain null after failed login
+    expect(result.current.user).toBeNull();
+    expect(result.current.isAuthenticated).toBe(false);
+  });
+
+  it('should logout', async () => {
+    const mockUser = { id: '1', email: 'admin@example.com', role: 'admin' };
+    const meMock = vi.fn().mockResolvedValue({ data: { user: mockUser }, error: null });
+
+    const client = createMockClient({
+      admin: { me: meMock },
+    } as any);
+
+    const { result } = renderHook(
+      () => useAdminAuth({ autoCheck: true }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await waitFor(() => expect(result.current.isAuthenticated).toBe(true));
+
+    await act(async () => {
+      await result.current.logout();
+    });
+
+    expect(result.current.user).toBeNull();
+    expect(result.current.isAuthenticated).toBe(false);
+  });
+
+  it('should refresh user info', async () => {
+    const mockUser = { id: '1', email: 'admin@example.com', role: 'admin' };
+    const meMock = vi.fn().mockResolvedValue({ data: { user: mockUser }, error: null });
+
+    const client = createMockClient({
+      admin: { me: meMock },
+    } as any);
+
+    const { result } = renderHook(
+      () => useAdminAuth({ autoCheck: false }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await act(async () => {
+      await result.current.refresh();
+    });
+
+    expect(meMock).toHaveBeenCalledTimes(1);
+    expect(result.current.user).toEqual(mockUser);
+  });
+
+  it('should show loading state during operations', async () => {
+    const meMock = vi.fn().mockImplementation(() => new Promise((resolve) => {
+      setTimeout(() => resolve({ data: { user: {} }, error: null }), 100);
+    }));
+
+    const client = createMockClient({
+      admin: { me: meMock },
+    } as any);
+
+    const { result } = renderHook(
+      () => useAdminAuth({ autoCheck: true }),
+      { wrapper: createWrapper(client) }
+    );
+
+    expect(result.current.isLoading).toBe(true);
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+  });
+});

package/src/use-admin-auth.ts

@@ -137,14 +137,22 @@ export function useAdminAuth(
 
   /**
    * Logout admin
+   *
+   * WARNING: Currently only clears local state. The server-side session/token
+   * remains valid until it expires. This should call a logout endpoint to
+   * invalidate the session on the server for proper security.
    */
   const logout = useCallback(async (): Promise<void> => {
     try {
       setIsLoading(true);
       setError(null);
-      // Clear user state
+
+      // TODO: Call server-side logout endpoint when available
+      // This is a security concern - the token remains valid on the server
+      // await client.admin.logout();
+
+      // Clear local user state
       setUser(null);
-      // Note: Add logout endpoint call here when available
     } catch (err) {
       setError(err as Error);
       throw err;

package/src/use-admin-hooks.test.ts

@@ -0,0 +1,457 @@
+/**
+ * Tests for admin hooks (settings, webhooks)
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import {
+  useAppSettings,
+  useSystemSettings,
+  useWebhooks,
+} from "./use-admin-hooks";
+import { createMockClient, createWrapper } from "./test-utils";
+
+describe("useAppSettings", () => {
+  it("should fetch settings on mount when autoFetch is true", async () => {
+    const mockSettings = { features: { darkMode: true } };
+    const getMock = vi.fn().mockResolvedValue(mockSettings);
+
+    const client = createMockClient({
+      admin: {
+        settings: {
+          app: { get: getMock, update: vi.fn() },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(() => useAppSettings({ autoFetch: true }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.settings).toEqual(mockSettings);
+    expect(getMock).toHaveBeenCalled();
+  });
+
+  it("should not fetch settings on mount when autoFetch is false", async () => {
+    const getMock = vi.fn();
+
+    const client = createMockClient({
+      admin: {
+        settings: {
+          app: { get: getMock, update: vi.fn() },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(() => useAppSettings({ autoFetch: false }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(getMock).not.toHaveBeenCalled();
+  });
+
+  it("should update settings", async () => {
+    const mockSettings = { features: { darkMode: true } };
+    const getMock = vi.fn().mockResolvedValue(mockSettings);
+    const updateMock = vi.fn().mockResolvedValue({});
+
+    const client = createMockClient({
+      admin: {
+        settings: {
+          app: { get: getMock, update: updateMock },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(() => useAppSettings({ autoFetch: true }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.updateSettings({
+        features: { enable_realtime: false },
+      });
+    });
+
+    expect(updateMock).toHaveBeenCalledWith({
+      features: { enable_realtime: false },
+    });
+    // Should refetch after update
+    expect(getMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("should handle errors", async () => {
+    const error = new Error("Failed to fetch");
+    const getMock = vi.fn().mockRejectedValue(error);
+
+    const client = createMockClient({
+      admin: {
+        settings: {
+          app: { get: getMock, update: vi.fn() },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(() => useAppSettings({ autoFetch: true }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBe(error);
+  });
+
+  it("should refetch on demand", async () => {
+    const mockSettings = { features: {} };
+    const getMock = vi.fn().mockResolvedValue(mockSettings);
+
+    const client = createMockClient({
+      admin: {
+        settings: {
+          app: { get: getMock, update: vi.fn() },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(() => useAppSettings({ autoFetch: false }), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.refetch();
+    });
+
+    expect(getMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("useSystemSettings", () => {
+  it("should fetch settings on mount when autoFetch is true", async () => {
+    const mockSettings = [{ key: "theme", value: "dark" }];
+    const listMock = vi.fn().mockResolvedValue({ settings: mockSettings });
+
+    const client = createMockClient({
+      admin: {
+        settings: {
+          system: { list: listMock, update: vi.fn(), delete: vi.fn() },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useSystemSettings({ autoFetch: true }),
+      { wrapper: createWrapper(client) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.settings).toEqual(mockSettings);
+  });
+
+  it("should get setting by key", async () => {
+    const mockSettings = [
+      { key: "theme", value: "dark" },
+      { key: "language", value: "en" },
+    ];
+    const listMock = vi.fn().mockResolvedValue({ settings: mockSettings });
+
+    const client = createMockClient({
+      admin: {
+        settings: {
+          system: { list: listMock, update: vi.fn(), delete: vi.fn() },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useSystemSettings({ autoFetch: true }),
+      { wrapper: createWrapper(client) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    const setting = result.current.getSetting("theme");
+    expect(setting).toEqual({ key: "theme", value: "dark" });
+
+    const notFound = result.current.getSetting("nonexistent");
+    expect(notFound).toBeUndefined();
+  });
+
+  it("should update setting", async () => {
+    const mockSettings = [{ key: "theme", value: "dark" }];
+    const listMock = vi.fn().mockResolvedValue({ settings: mockSettings });
+    const updateMock = vi.fn().mockResolvedValue({});
+
+    const client = createMockClient({
+      admin: {
+        settings: {
+          system: { list: listMock, update: updateMock, delete: vi.fn() },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useSystemSettings({ autoFetch: true }),
+      { wrapper: createWrapper(client) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.updateSetting("theme", {
+        value: { theme: "light" },
+      });
+    });
+
+    expect(updateMock).toHaveBeenCalledWith("theme", {
+      value: { theme: "light" },
+    });
+    // Should refetch after update
+    expect(listMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("should delete setting", async () => {
+    const mockSettings = [{ key: "theme", value: "dark" }];
+    const listMock = vi.fn().mockResolvedValue({ settings: mockSettings });
+    const deleteMock = vi.fn().mockResolvedValue({});
+
+    const client = createMockClient({
+      admin: {
+        settings: {
+          system: { list: listMock, update: vi.fn(), delete: deleteMock },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useSystemSettings({ autoFetch: true }),
+      { wrapper: createWrapper(client) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.deleteSetting("theme");
+    });
+
+    expect(deleteMock).toHaveBeenCalledWith("theme");
+    // Should refetch after delete
+    expect(listMock).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("useWebhooks", () => {
+  it("should fetch webhooks on mount when autoFetch is true", async () => {
+    const mockWebhooks = [{ id: "1", url: "https://example.com/webhook" }];
+    const listMock = vi.fn().mockResolvedValue({ webhooks: mockWebhooks });
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          webhooks: {
+            list: listMock,
+            create: vi.fn(),
+            update: vi.fn(),
+            delete: vi.fn(),
+            test: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(() => useWebhooks({ autoFetch: true }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.webhooks).toEqual(mockWebhooks);
+  });
+
+  it("should create webhook", async () => {
+    const mockWebhooks: any[] = [];
+    const listMock = vi.fn().mockResolvedValue({ webhooks: mockWebhooks });
+    const createMock = vi
+      .fn()
+      .mockResolvedValue({ id: "1", url: "https://example.com/webhook" });
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          webhooks: {
+            list: listMock,
+            create: createMock,
+            update: vi.fn(),
+            delete: vi.fn(),
+            test: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(() => useWebhooks({ autoFetch: true }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.createWebhook({
+        url: "https://example.com/webhook",
+        events: ["user.created"],
+      });
+    });
+
+    expect(createMock).toHaveBeenCalledWith({
+      url: "https://example.com/webhook",
+      events: ["user.created"],
+    });
+    // Should refetch after create
+    expect(listMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("should update webhook", async () => {
+    const mockWebhooks = [{ id: "1", url: "https://example.com/webhook" }];
+    const listMock = vi.fn().mockResolvedValue({ webhooks: mockWebhooks });
+    const updateMock = vi
+      .fn()
+      .mockResolvedValue({ id: "1", url: "https://new.com/webhook" });
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          webhooks: {
+            list: listMock,
+            create: vi.fn(),
+            update: updateMock,
+            delete: vi.fn(),
+            test: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(() => useWebhooks({ autoFetch: true }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.updateWebhook("1", {
+        url: "https://new.com/webhook",
+      });
+    });
+
+    expect(updateMock).toHaveBeenCalledWith("1", {
+      url: "https://new.com/webhook",
+    });
+    // Should refetch after update
+    expect(listMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("should delete webhook", async () => {
+    const mockWebhooks = [{ id: "1", url: "https://example.com/webhook" }];
+    const listMock = vi.fn().mockResolvedValue({ webhooks: mockWebhooks });
+    const deleteMock = vi.fn().mockResolvedValue({});
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          webhooks: {
+            list: listMock,
+            create: vi.fn(),
+            update: vi.fn(),
+            delete: deleteMock,
+            test: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(() => useWebhooks({ autoFetch: true }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.deleteWebhook("1");
+    });
+
+    expect(deleteMock).toHaveBeenCalledWith("1");
+    // Should refetch after delete
+    expect(listMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("should test webhook", async () => {
+    const mockWebhooks = [{ id: "1", url: "https://example.com/webhook" }];
+    const listMock = vi.fn().mockResolvedValue({ webhooks: mockWebhooks });
+    const testMock = vi.fn().mockResolvedValue({});
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          webhooks: {
+            list: listMock,
+            create: vi.fn(),
+            update: vi.fn(),
+            delete: vi.fn(),
+            test: testMock,
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(() => useWebhooks({ autoFetch: true }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.testWebhook("1");
+    });
+
+    expect(testMock).toHaveBeenCalledWith("1");
+  });
+
+  it("should set up refetch interval", async () => {
+    vi.useFakeTimers();
+    const mockWebhooks: any[] = [];
+    const listMock = vi.fn().mockResolvedValue({ webhooks: mockWebhooks });
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          webhooks: {
+            list: listMock,
+            create: vi.fn(),
+            update: vi.fn(),
+            delete: vi.fn(),
+            test: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { unmount } = renderHook(
+      () => useWebhooks({ autoFetch: true, refetchInterval: 5000 }),
+      { wrapper: createWrapper(client) },
+    );
+
+    // Initial fetch
+    expect(listMock).toHaveBeenCalledTimes(1);
+
+    // Advance timer
+    await act(async () => {
+      vi.advanceTimersByTime(5000);
+    });
+
+    expect(listMock).toHaveBeenCalledTimes(2);
+
+    unmount();
+    vi.useRealTimers();
+  });
+});