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

package/src/use-client-keys.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Tests for client keys management hook
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { useClientKeys, useAPIKeys } from './use-client-keys';
+import { createMockClient, createWrapper } from './test-utils';
+
+describe('useClientKeys', () => {
+  it('should fetch client keys on mount when autoFetch is true', async () => {
+    const mockKeys = [
+      { id: '1', name: 'Key 1', description: 'First key' },
+      { id: '2', name: 'Key 2', description: 'Second key' },
+    ];
+    const listMock = vi.fn().mockResolvedValue({ client_keys: mockKeys });
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          clientKeys: {
+            list: listMock,
+            create: vi.fn(),
+            update: vi.fn(),
+            revoke: vi.fn(),
+            delete: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useClientKeys({ autoFetch: true }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.keys).toEqual(mockKeys);
+  });
+
+  it('should not fetch keys when autoFetch is false', async () => {
+    const listMock = vi.fn();
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          clientKeys: {
+            list: listMock,
+            create: vi.fn(),
+            update: vi.fn(),
+            revoke: vi.fn(),
+            delete: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useClientKeys({ autoFetch: false }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(listMock).not.toHaveBeenCalled();
+  });
+
+  it('should create client key', async () => {
+    const mockKeys: any[] = [];
+    const listMock = vi.fn().mockResolvedValue({ client_keys: mockKeys });
+    const createMock = vi.fn().mockResolvedValue({
+      key: 'new-secret-key',
+      client_key: { id: '1', name: 'New Key' },
+    });
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          clientKeys: {
+            list: listMock,
+            create: createMock,
+            update: vi.fn(),
+            revoke: vi.fn(),
+            delete: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useClientKeys({ autoFetch: true }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    let response;
+    await act(async () => {
+      response = await result.current.createKey({
+        name: 'New Key',
+        description: 'A new key',
+        scopes: ['read', 'write'],
+        rate_limit_per_minute: 60,
+      });
+    });
+
+    expect(createMock).toHaveBeenCalledWith({
+      name: 'New Key',
+      description: 'A new key',
+      scopes: ['read', 'write'],
+      rate_limit_per_minute: 60,
+    });
+    expect(response).toEqual({
+      key: 'new-secret-key',
+      keyData: { id: '1', name: 'New Key' },
+    });
+    // Should refetch after create
+    expect(listMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('should update client key', async () => {
+    const mockKeys = [{ id: '1', name: 'Key 1' }];
+    const listMock = vi.fn().mockResolvedValue({ client_keys: mockKeys });
+    const updateMock = vi.fn().mockResolvedValue({});
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          clientKeys: {
+            list: listMock,
+            create: vi.fn(),
+            update: updateMock,
+            revoke: vi.fn(),
+            delete: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useClientKeys({ autoFetch: true }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.updateKey('1', { name: 'Updated Key' });
+    });
+
+    expect(updateMock).toHaveBeenCalledWith('1', { name: 'Updated Key' });
+    // Should refetch after update
+    expect(listMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('should revoke client key', async () => {
+    const mockKeys = [{ id: '1', name: 'Key 1' }];
+    const listMock = vi.fn().mockResolvedValue({ client_keys: mockKeys });
+    const revokeMock = vi.fn().mockResolvedValue({});
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          clientKeys: {
+            list: listMock,
+            create: vi.fn(),
+            update: vi.fn(),
+            revoke: revokeMock,
+            delete: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useClientKeys({ autoFetch: true }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.revokeKey('1');
+    });
+
+    expect(revokeMock).toHaveBeenCalledWith('1');
+    // Should refetch after revoke
+    expect(listMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('should delete client key', async () => {
+    const mockKeys = [{ id: '1', name: 'Key 1' }];
+    const listMock = vi.fn().mockResolvedValue({ client_keys: mockKeys });
+    const deleteMock = vi.fn().mockResolvedValue({});
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          clientKeys: {
+            list: listMock,
+            create: vi.fn(),
+            update: vi.fn(),
+            revoke: vi.fn(),
+            delete: deleteMock,
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useClientKeys({ autoFetch: true }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    await act(async () => {
+      await result.current.deleteKey('1');
+    });
+
+    expect(deleteMock).toHaveBeenCalledWith('1');
+    // Should refetch after delete
+    expect(listMock).toHaveBeenCalledTimes(2);
+  });
+
+  it('should handle fetch error', async () => {
+    const error = new Error('Failed to fetch');
+    const listMock = vi.fn().mockRejectedValue(error);
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          clientKeys: {
+            list: listMock,
+            create: vi.fn(),
+            update: vi.fn(),
+            revoke: vi.fn(),
+            delete: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useClientKeys({ 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 listMock = vi.fn().mockResolvedValue({ client_keys: [] });
+
+    const client = createMockClient({
+      admin: {
+        management: {
+          clientKeys: {
+            list: listMock,
+            create: vi.fn(),
+            update: vi.fn(),
+            revoke: vi.fn(),
+            delete: vi.fn(),
+          },
+        },
+      },
+    } as any);
+
+    const { result } = renderHook(
+      () => useClientKeys({ autoFetch: false }),
+      { wrapper: createWrapper(client) }
+    );
+
+    await act(async () => {
+      await result.current.refetch();
+    });
+
+    expect(listMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('useAPIKeys (deprecated alias)', () => {
+  it('should be the same as useClientKeys', () => {
+    expect(useAPIKeys).toBe(useClientKeys);
+  });
+});

package/src/use-client-keys.ts

@@ -0,0 +1,185 @@
+import { useState, useEffect, useCallback } from 'react'
+import { useFluxbaseClient } from './context'
+import type { ClientKey, CreateClientKeyRequest } from '@fluxbase/sdk'
+
+export interface UseClientKeysOptions {
+  /**
+   * Whether to automatically fetch client keys on mount
+   * @default true
+   */
+  autoFetch?: boolean
+}
+
+export interface UseClientKeysReturn {
+  /**
+   * Array of client keys
+   */
+  keys: ClientKey[]
+
+  /**
+   * Whether keys are being fetched
+   */
+  isLoading: boolean
+
+  /**
+   * Any error that occurred
+   */
+  error: Error | null
+
+  /**
+   * Refetch client keys
+   */
+  refetch: () => Promise<void>
+
+  /**
+   * Create a new client key
+   */
+  createKey: (request: CreateClientKeyRequest) => Promise<{ key: string; keyData: ClientKey }>
+
+  /**
+   * Update a client key
+   */
+  updateKey: (keyId: string, update: { name?: string; description?: string }) => Promise<void>
+
+  /**
+   * Revoke a client key
+   */
+  revokeKey: (keyId: string) => Promise<void>
+
+  /**
+   * Delete a client key
+   */
+  deleteKey: (keyId: string) => Promise<void>
+}
+
+/**
+ * Hook for managing client keys
+ *
+ * Provides client key list and management functions.
+ *
+ * @example
+ * ```tsx
+ * function ClientKeyManager() {
+ *   const { keys, isLoading, createKey, revokeKey } = useClientKeys()
+ *
+ *   const handleCreate = async () => {
+ *     const { key, keyData } = await createKey({
+ *       name: 'Backend Service',
+ *       description: 'Client key for backend',
+ *       expires_at: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString()
+ *     })
+ *     alert(`Key created: ${key}`)
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleCreate}>Create Key</button>
+ *       {keys.map(k => (
+ *         <div key={k.id}>
+ *           {k.name}
+ *           <button onClick={() => revokeKey(k.id)}>Revoke</button>
+ *         </div>
+ *       ))}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+export function useClientKeys(options: UseClientKeysOptions = {}): UseClientKeysReturn {
+  const { autoFetch = true } = options
+  const client = useFluxbaseClient()
+
+  const [keys, setKeys] = useState<ClientKey[]>([])
+  const [isLoading, setIsLoading] = useState(autoFetch)
+  const [error, setError] = useState<Error | null>(null)
+
+  /**
+   * Fetch client keys from API
+   */
+  const fetchKeys = useCallback(async () => {
+    try {
+      setIsLoading(true)
+      setError(null)
+      const response = await client.admin.management.clientKeys.list()
+      setKeys(response.client_keys)
+    } catch (err) {
+      setError(err as Error)
+    } finally {
+      setIsLoading(false)
+    }
+  }, [client])
+
+  /**
+   * Create a new client key
+   */
+  const createKey = useCallback(
+    async (request: CreateClientKeyRequest): Promise<{ key: string; keyData: ClientKey }> => {
+      const response = await client.admin.management.clientKeys.create(request)
+      await fetchKeys() // Refresh list
+      return { key: response.key, keyData: response.client_key }
+    },
+    [client, fetchKeys]
+  )
+
+  /**
+   * Update a client key
+   */
+  const updateKey = useCallback(
+    async (keyId: string, update: { name?: string; description?: string }): Promise<void> => {
+      await client.admin.management.clientKeys.update(keyId, update)
+      await fetchKeys() // Refresh list
+    },
+    [client, fetchKeys]
+  )
+
+  /**
+   * Revoke a client key
+   */
+  const revokeKey = useCallback(
+    async (keyId: string): Promise<void> => {
+      await client.admin.management.clientKeys.revoke(keyId)
+      await fetchKeys() // Refresh list
+    },
+    [client, fetchKeys]
+  )
+
+  /**
+   * Delete a client key
+   */
+  const deleteKey = useCallback(
+    async (keyId: string): Promise<void> => {
+      await client.admin.management.clientKeys.delete(keyId)
+      await fetchKeys() // Refresh list
+    },
+    [client, fetchKeys]
+  )
+
+  // Auto-fetch on mount
+  useEffect(() => {
+    if (autoFetch) {
+      fetchKeys()
+    }
+  }, [autoFetch, fetchKeys])
+
+  return {
+    keys,
+    isLoading,
+    error,
+    refetch: fetchKeys,
+    createKey,
+    updateKey,
+    revokeKey,
+    deleteKey
+  }
+}
+
+/**
+ * @deprecated Use useClientKeys instead
+ */
+export const useAPIKeys = useClientKeys
+
+/** @deprecated Use UseClientKeysOptions instead */
+export type UseAPIKeysOptions = UseClientKeysOptions
+
+/** @deprecated Use UseClientKeysReturn instead */
+export type UseAPIKeysReturn = UseClientKeysReturn