@nimbleflux/fluxbase-sdk-react 2026.5.5-rc.1 → 2026.6.1

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

@@ -0,0 +1,237 @@
+/**
+ * Tests for Service Keys hooks
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import {
+  useServiceKeys,
+  useCreateServiceKey,
+  useRotateServiceKey,
+  useRevokeServiceKey,
+} from "./use-service-keys";
+import { createMockClient, createWrapper } from "./test-utils";
+
+describe("useServiceKeys", () => {
+  it("should list service keys", async () => {
+    const mockKeys = [
+      {
+        id: "1",
+        name: "Production Key",
+        key_type: "service" as const,
+        scopes: ["*"],
+        enabled: true,
+        key_prefix: "fb_prod_abcdef",
+        created_at: "",
+      },
+    ];
+    const client = createMockClient();
+    (
+      client.admin.serviceKeys.list as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({ data: mockKeys, error: null });
+
+    const { result } = renderHook(() => useServiceKeys(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockKeys);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient();
+    (
+      client.admin.serviceKeys.list as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({ data: null, error: new Error("Unauthorized") });
+
+    const { result } = renderHook(() => useServiceKeys(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});
+
+describe("useCreateServiceKey", () => {
+  it("should create a service key and invalidate queries", async () => {
+    const mockKey = {
+      id: "2",
+      name: "New Key",
+      key_type: "service" as const,
+      scopes: ["*"],
+      enabled: true,
+      key_prefix: "fb_new_123456",
+      key: "fb_new_123456789",
+      created_at: "",
+    };
+    const client = createMockClient();
+    (
+      client.admin.serviceKeys.create as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({ data: mockKey, error: null });
+
+    const { result } = renderHook(() => useCreateServiceKey(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        name: "New Key",
+        key_type: "service",
+        scopes: ["*"],
+      });
+    });
+
+    expect(client.admin.serviceKeys.create).toHaveBeenCalledWith({
+      name: "New Key",
+      key_type: "service",
+      scopes: ["*"],
+    });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockKey);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient();
+    (
+      client.admin.serviceKeys.create as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({ data: null, error: new Error("Limit reached") });
+
+    const { result } = renderHook(() => useCreateServiceKey(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({
+          name: "Excess",
+          key_type: "service",
+        });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe("useRotateServiceKey", () => {
+  it("should rotate a service key and invalidate queries", async () => {
+    const mockKey = {
+      id: "3",
+      name: "Rotated Key",
+      key_type: "service" as const,
+      scopes: ["*"],
+      enabled: true,
+      key_prefix: "fb_rot_newpass",
+      key: "fb_rot_newpassword",
+      created_at: "",
+      deprecated_at: "",
+      grace_period_ends_at: "",
+    };
+    const client = createMockClient();
+    (
+      client.admin.serviceKeys.rotate as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({ data: mockKey, error: null });
+
+    const { result } = renderHook(() => useRotateServiceKey(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync("old-key-id");
+    });
+
+    expect(client.admin.serviceKeys.rotate).toHaveBeenCalledWith("old-key-id");
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockKey);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient();
+    (
+      client.admin.serviceKeys.rotate as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({ data: null, error: new Error("Key not found") });
+
+    const { result } = renderHook(() => useRotateServiceKey(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync("missing-id");
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe("useRevokeServiceKey", () => {
+  it("should revoke a service key and invalidate queries", async () => {
+    const client = createMockClient();
+    (
+      client.admin.serviceKeys.revoke as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({ error: null });
+
+    const { result } = renderHook(() => useRevokeServiceKey(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ id: "compromised-id" });
+    });
+
+    expect(client.admin.serviceKeys.revoke).toHaveBeenCalledWith(
+      "compromised-id",
+      undefined,
+    );
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+
+  it("should pass revocation reason", async () => {
+    const client = createMockClient();
+    (
+      client.admin.serviceKeys.revoke as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({ error: null });
+
+    const { result } = renderHook(() => useRevokeServiceKey(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        id: "key-id",
+        request: { reason: "Key was compromised" },
+      });
+    });
+
+    expect(client.admin.serviceKeys.revoke).toHaveBeenCalledWith("key-id", {
+      reason: "Key was compromised",
+    });
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient();
+    (
+      client.admin.serviceKeys.revoke as ReturnType<typeof vi.fn>
+    ).mockResolvedValue({ error: new Error("Already revoked") });
+
+    const { result } = renderHook(() => useRevokeServiceKey(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({ id: "bad-id" });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});

package/src/use-service-keys.ts

@@ -0,0 +1,91 @@
+/**
+ * Service keys hooks for Fluxbase React SDK
+ * Provides hooks for managing tenant service keys (anon and service)
+ */
+
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { useFluxbaseClient } from "./context";
+import type {
+  CreateServiceKeyRequest,
+  RevokeServiceKeyRequest,
+} from "@nimbleflux/fluxbase-sdk";
+
+/**
+ * Hook to list all service keys
+ */
+export function useServiceKeys() {
+  const client = useFluxbaseClient();
+
+  return useQuery({
+    queryKey: ["fluxbase", "service-keys"],
+    queryFn: async () => {
+      const { data, error } = await client.admin.serviceKeys.list();
+      if (error) throw error;
+      return data;
+    },
+  });
+}
+
+/**
+ * Hook to create a new service key
+ *
+ * The full key value is only returned once — store it securely!
+ */
+export function useCreateServiceKey() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (request: CreateServiceKeyRequest) => {
+      const { data, error } = await client.admin.serviceKeys.create(request);
+      if (error) throw error;
+      return data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "service-keys"] });
+    },
+  });
+}
+
+/**
+ * Hook to rotate a service key (creates a replacement and deprecates the old one)
+ */
+export function useRotateServiceKey() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (id: string) => {
+      const { data, error } = await client.admin.serviceKeys.rotate(id);
+      if (error) throw error;
+      return data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "service-keys"] });
+    },
+  });
+}
+
+/**
+ * Hook to revoke a service key permanently (emergency)
+ */
+export function useRevokeServiceKey() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (params: {
+      id: string;
+      request?: RevokeServiceKeyRequest;
+    }) => {
+      const { error } = await client.admin.serviceKeys.revoke(
+        params.id,
+        params.request,
+      );
+      if (error) throw error;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "service-keys"] });
+    },
+  });
+}

package/src/use-tenant.ts

@@ -4,7 +4,8 @@
  * @module use-tenant
  */
 
-import { useState, useEffect, useCallback } from "react";
+import { useState, useCallback } from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { useFluxbaseClient } from "./context";
 import type {
   Tenant,
@@ -98,58 +99,55 @@ export interface UseTenantsReturn {
 export function useTenants(options: UseTenantsOptions = {}): UseTenantsReturn {
   const { autoFetch = true } = options;
   const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
 
-  const [tenants, setTenants] = useState<TenantWithRole[]>([]);
-  const [isLoading, setIsLoading] = useState(autoFetch);
-  const [error, setError] = useState<Error | null>(null);
   const [currentTenantId, setCurrentTenantId] = useState<string | undefined>(
     client.getTenantId(),
   );
 
-  const fetchTenants = useCallback(async () => {
-    try {
-      setIsLoading(true);
-      setError(null);
-      const { data, error: fetchError } = await client.tenant.listMine();
-      if (fetchError) {
-        setError(fetchError);
-      } else {
-        setTenants(data || []);
-      }
-    } catch (err) {
-      setError(err as Error);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client]);
+  const query = useQuery({
+    queryKey: ["fluxbase", "tenants", "mine"],
+    queryFn: async () => {
+      const { data, error } = await client.tenant.listMine();
+      if (error) throw error;
+      return data || ([] as TenantWithRole[]);
+    },
+    enabled: autoFetch,
+  });
 
   const createTenant = useCallback(
     async (opts: CreateTenantOptions): Promise<Tenant> => {
       const { data, error: createError } = await client.tenant.create(opts);
       if (createError) throw createError;
-      await fetchTenants();
+      await queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "tenants"],
+      });
       return data!;
     },
-    [client, fetchTenants],
+    [client, queryClient],
   );
 
   const updateTenant = useCallback(
     async (id: string, opts: UpdateTenantOptions): Promise<Tenant> => {
       const { data, error: updateError } = await client.tenant.update(id, opts);
       if (updateError) throw updateError;
-      await fetchTenants();
+      await queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "tenants"],
+      });
       return data!;
     },
-    [client, fetchTenants],
+    [client, queryClient],
   );
 
   const deleteTenant = useCallback(
     async (id: string): Promise<void> => {
       const { error: deleteError } = await client.tenant.delete(id);
       if (deleteError) throw deleteError;
-      await fetchTenants();
+      await queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "tenants"],
+      });
     },
-    [client, fetchTenants],
+    [client, queryClient],
   );
 
   const setCurrentTenant = useCallback(
@@ -160,17 +158,13 @@ export function useTenants(options: UseTenantsOptions = {}): UseTenantsReturn {
     [client],
   );
 
-  useEffect(() => {
-    if (autoFetch) {
-      fetchTenants();
-    }
-  }, [autoFetch, fetchTenants]);
-
   return {
-    tenants,
-    isLoading,
-    error,
-    refetch: fetchTenants,
+    tenants: query.data ?? [],
+    isLoading: autoFetch ? query.isLoading : false,
+    error: query.error,
+    refetch: async () => {
+      await query.refetch();
+    },
     createTenant,
     updateTenant,
     deleteTenant,
@@ -249,31 +243,17 @@ export interface UseTenantReturn {
 export function useTenant(options: UseTenantOptions): UseTenantReturn {
   const { tenantId, autoFetch = true } = options;
   const client = useFluxbaseClient();
-
-  const [tenant, setTenant] = useState<Tenant | null>(null);
-  const [isLoading, setIsLoading] = useState(autoFetch);
-  const [error, setError] = useState<Error | null>(null);
-
-  const fetchTenant = useCallback(async () => {
-    if (!tenantId) return;
-
-    try {
-      setIsLoading(true);
-      setError(null);
-      const { data, error: fetchError } = await client.tenant.get(tenantId);
-      if (fetchError) {
-        setError(fetchError);
-        setTenant(null);
-      } else {
-        setTenant(data);
-      }
-    } catch (err) {
-      setError(err as Error);
-      setTenant(null);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [client, tenantId]);
+  const queryClient = useQueryClient();
+
+  const query = useQuery({
+    queryKey: ["fluxbase", "tenant", tenantId],
+    queryFn: async () => {
+      const { data, error } = await client.tenant.get(tenantId);
+      if (error) throw error;
+      return data;
+    },
+    enabled: autoFetch && !!tenantId,
+  });
 
   const update = useCallback(
     async (opts: UpdateTenantOptions): Promise<Tenant> => {
@@ -282,29 +262,29 @@ export function useTenant(options: UseTenantOptions): UseTenantReturn {
         opts,
       );
       if (updateError) throw updateError;
-      setTenant(data);
+      await queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "tenant", tenantId],
+      });
       return data!;
     },
-    [client, tenantId],
+    [client, tenantId, queryClient],
   );
 
   const remove = useCallback(async (): Promise<void> => {
     const { error: deleteError } = await client.tenant.delete(tenantId);
     if (deleteError) throw deleteError;
-    setTenant(null);
-  }, [client, tenantId]);
-
-  useEffect(() => {
-    if (autoFetch && tenantId) {
-      fetchTenant();
-    }
-  }, [autoFetch, fetchTenant, tenantId]);
+    await queryClient.invalidateQueries({
+      queryKey: ["fluxbase", "tenant", tenantId],
+    });
+  }, [client, tenantId, queryClient]);
 
   return {
-    tenant,
-    isLoading,
-    error,
-    refetch: fetchTenant,
+    tenant: query.data ?? null,
+    isLoading: autoFetch ? query.isLoading : false,
+    error: query.error,
+    refetch: async () => {
+      await query.refetch();
+    },
     update,
     remove,
   };

package/src/use-vector.test.ts

@@ -0,0 +1,176 @@
+/**
+ * Tests for Vector hooks
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import { useVectorEmbed, useVectorSearch } from "./use-vector";
+import { createMockClient, createWrapper } from "./test-utils";
+
+describe("useVectorEmbed", () => {
+  it("should embed text", async () => {
+    const mockResponse = {
+      embeddings: [[0.1, 0.2, 0.3]],
+      model: "text-embedding-3-small",
+      dimensions: 3,
+    };
+    const client = createMockClient();
+    (client.vector.embed as ReturnType<typeof vi.fn>).mockResolvedValue({
+      data: mockResponse,
+      error: null,
+    });
+
+    const { result } = renderHook(() => useVectorEmbed(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ text: "Hello world" });
+    });
+
+    expect(client.vector.embed).toHaveBeenCalledWith({ text: "Hello world" });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockResponse);
+  });
+
+  it("should embed multiple texts", async () => {
+    const mockResponse = {
+      embeddings: [[0.1], [0.2]],
+      model: "text-embedding-3-small",
+      dimensions: 1,
+    };
+    const client = createMockClient();
+    (client.vector.embed as ReturnType<typeof vi.fn>).mockResolvedValue({
+      data: mockResponse,
+      error: null,
+    });
+
+    const { result } = renderHook(() => useVectorEmbed(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        texts: ["Hello", "World"],
+        model: "text-embedding-3-large",
+      });
+    });
+
+    expect(client.vector.embed).toHaveBeenCalledWith({
+      texts: ["Hello", "World"],
+      model: "text-embedding-3-large",
+    });
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient();
+    (client.vector.embed as ReturnType<typeof vi.fn>).mockResolvedValue({
+      data: null,
+      error: new Error("Embedding failed"),
+    });
+
+    const { result } = renderHook(() => useVectorEmbed(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({ text: "test" });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe("useVectorSearch", () => {
+  it("should search with text query", async () => {
+    const mockResult = {
+      data: [{ id: "1", content: "Match 1" }],
+      distances: [0.1],
+      model: "text-embedding-3-small",
+    };
+    const client = createMockClient();
+    (client.vector.search as ReturnType<typeof vi.fn>).mockResolvedValue({
+      data: mockResult,
+      error: null,
+    });
+
+    const { result } = renderHook(() => useVectorSearch(), {
+      wrapper: createWrapper(client),
+    });
+
+    const searchOpts = {
+      table: "documents",
+      column: "embedding",
+      query: "How to use TypeScript?",
+      match_count: 10,
+    };
+
+    await act(async () => {
+      await result.current.mutateAsync(searchOpts);
+    });
+
+    expect(client.vector.search).toHaveBeenCalledWith(searchOpts);
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockResult);
+  });
+
+  it("should search with pre-computed vector", async () => {
+    const mockResult = {
+      data: [{ id: "2", content: "Vector match" }],
+      distances: [0.05],
+    };
+    const client = createMockClient();
+    (client.vector.search as ReturnType<typeof vi.fn>).mockResolvedValue({
+      data: mockResult,
+      error: null,
+    });
+
+    const { result } = renderHook(() => useVectorSearch(), {
+      wrapper: createWrapper(client),
+    });
+
+    const searchOpts = {
+      table: "documents",
+      column: "embedding",
+      vector: [0.1, 0.2, 0.3],
+      metric: "cosine" as const,
+      match_count: 5,
+    };
+
+    await act(async () => {
+      await result.current.mutateAsync(searchOpts);
+    });
+
+    expect(client.vector.search).toHaveBeenCalledWith(searchOpts);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient();
+    (client.vector.search as ReturnType<typeof vi.fn>).mockResolvedValue({
+      data: null,
+      error: new Error("Search failed"),
+    });
+
+    const { result } = renderHook(() => useVectorSearch(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({
+          table: "documents",
+          column: "embedding",
+          query: "test",
+        });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});