@nimbleflux/fluxbase-sdk-react 2026.5.5-rc.2 → 2026.6.2

package/src/use-impersonation.ts

@@ -0,0 +1,79 @@
+/**
+ * Impersonation hooks for Fluxbase React SDK
+ * Provides hooks for managing user impersonation sessions
+ */
+
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { useFluxbaseClient } from "./context";
+import type { ListImpersonationSessionsOptions } from "@nimbleflux/fluxbase-sdk";
+
+/**
+ * Hook to list impersonation sessions (audit trail)
+ */
+export function useImpersonationSessions(
+  options?: ListImpersonationSessionsOptions,
+) {
+  const client = useFluxbaseClient();
+
+  return useQuery({
+    queryKey: ["fluxbase", "impersonation", "sessions", options],
+    queryFn: async () => {
+      return await client.admin.impersonation.listSessions(options);
+    },
+  });
+}
+
+/**
+ * Hook to get the current impersonation session
+ */
+export function useCurrentImpersonation() {
+  const client = useFluxbaseClient();
+
+  return useQuery({
+    queryKey: ["fluxbase", "impersonation", "current"],
+    queryFn: async () => {
+      return await client.admin.impersonation.getCurrent();
+    },
+  });
+}
+
+/**
+ * Hook to start impersonating a specific user
+ */
+export function useImpersonateUser() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (request: {
+      target_user_id: string;
+      reason: string;
+    }) => {
+      return await client.admin.impersonation.impersonateUser(request);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "impersonation"],
+      });
+    },
+  });
+}
+
+/**
+ * Hook to stop the current impersonation session
+ */
+export function useStopImpersonation() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async () => {
+      return await client.admin.impersonation.stop();
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "impersonation"],
+      });
+    },
+  });
+}

package/src/use-jobs.test.ts

@@ -0,0 +1,224 @@
+/**
+ * Tests for Jobs hooks
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import {
+  useSubmitJob,
+  useJobStatus,
+  useJobs,
+  useCancelJob,
+  useRetryJob,
+} from "./use-jobs";
+import { createMockClient, createWrapper } from "./test-utils";
+
+describe("useSubmitJob", () => {
+  it("should submit a job", async () => {
+    const submit = vi.fn().mockResolvedValue({
+      data: { id: "job-1", status: "pending" },
+      error: null,
+    });
+    const client = createMockClient({
+      jobs: { submit } as any,
+    });
+
+    const { result } = renderHook(() => useSubmitJob(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ name: "send-email", payload: { to: "a@b.com" } });
+    });
+
+    expect(submit).toHaveBeenCalledWith("send-email", { to: "a@b.com" });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      jobs: {
+        submit: vi.fn().mockResolvedValue({ data: null, error: new Error("Failed") }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useSubmitJob(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({ name: "bad-job" });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe("useJobStatus", () => {
+  it("should get job status by ID", async () => {
+    const mockJob = { id: "job-1", status: "completed" };
+    const client = createMockClient({
+      jobs: {
+        get: vi.fn().mockResolvedValue({ data: mockJob, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useJobStatus("job-1"), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockJob);
+  });
+
+  it("should not fetch when jobId is null", () => {
+    const client = createMockClient();
+    const { result } = renderHook(() => useJobStatus(null), {
+      wrapper: createWrapper(client),
+    });
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.data).toBeUndefined();
+  });
+});
+
+describe("useJobs", () => {
+  it("should list jobs", async () => {
+    const mockJobs = [
+      { id: "job-1", status: "completed" },
+      { id: "job-2", status: "running" },
+    ];
+    const client = createMockClient({
+      jobs: {
+        list: vi.fn().mockResolvedValue({ data: mockJobs, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useJobs(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockJobs);
+  });
+
+  it("should pass options to list", async () => {
+    const list = vi.fn().mockResolvedValue({ data: [], error: null });
+    const client = createMockClient({
+      jobs: { list } as any,
+    });
+
+    renderHook(() => useJobs({ status: "running", limit: 10 }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => {
+      expect(list).toHaveBeenCalledWith({ status: "running", limit: 10 });
+    });
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      jobs: {
+        list: vi.fn().mockResolvedValue({ data: null, error: new Error("Failed") }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useJobs(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});
+
+describe("useCancelJob", () => {
+  it("should cancel a job and invalidate queries", async () => {
+    const cancel = vi.fn().mockResolvedValue({ data: null, error: null });
+    const client = createMockClient({
+      jobs: { cancel } as any,
+    });
+
+    const { result } = renderHook(() => useCancelJob(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync("job-1");
+    });
+
+    expect(cancel).toHaveBeenCalledWith("job-1");
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      jobs: {
+        cancel: vi.fn().mockResolvedValue({ data: null, error: new Error("Not found") }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useCancelJob(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync("job-1");
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe("useRetryJob", () => {
+  it("should retry a job and invalidate queries", async () => {
+    const retry = vi.fn().mockResolvedValue({
+      data: { id: "job-2", status: "pending" },
+      error: null,
+    });
+    const client = createMockClient({
+      jobs: { retry } as any,
+    });
+
+    const { result } = renderHook(() => useRetryJob(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync("job-1");
+    });
+
+    expect(retry).toHaveBeenCalledWith("job-1");
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      jobs: {
+        retry: vi.fn().mockResolvedValue({ data: null, error: new Error("Failed") }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useRetryJob(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync("job-1");
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});

package/src/use-jobs.ts

@@ -31,3 +31,51 @@ export function useJobStatus(jobId: string | null) {
     },
   })
 }
+
+export interface UseJobsOptions {
+  namespace?: string;
+  limit?: number;
+  offset?: number;
+  status?: string;
+}
+
+export function useJobs(options?: UseJobsOptions) {
+  const client = useFluxbaseClient()
+  return useQuery({
+    queryKey: ["fluxbase", "jobs", options],
+    queryFn: async (): Promise<unknown> => {
+      const { data, error } = await client.jobs.list(options)
+      if (error) throw error
+      return data
+    },
+  })
+}
+
+export function useCancelJob() {
+  const client = useFluxbaseClient()
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: async (jobId: string): Promise<void> => {
+      const { error } = await client.jobs.cancel(jobId)
+      if (error) throw error
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "jobs"] })
+    },
+  })
+}
+
+export function useRetryJob() {
+  const client = useFluxbaseClient()
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: async (jobId: string): Promise<unknown> => {
+      const { data, error } = await client.jobs.retry(jobId)
+      if (error) throw error
+      return data
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "jobs"] })
+    },
+  })
+}

package/src/use-knowledge-base.test.ts

@@ -0,0 +1,310 @@
+/**
+ * Tests for Knowledge Base hooks
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import {
+  useKnowledgeBases,
+  useKnowledgeBase,
+  useKBDocuments,
+  useCreateKnowledgeBase,
+  useDeleteKnowledgeBase,
+  useAddDocument,
+  useUploadDocument,
+  useDeleteDocument,
+  useKBSearch,
+  useKBEntities,
+  useKnowledgeGraph,
+} from "./use-knowledge-base";
+import {
+  createMockAIClient,
+  createWrapper,
+} from "./test-utils";
+
+describe("useKnowledgeBases", () => {
+  it("should list knowledge bases", async () => {
+    const mockKbs = [
+      { id: "kb1", name: "Test KB", namespace: "default", description: "", enabled: true, document_count: 0, total_chunks: 0, embedding_model: "text-embedding-3-small", created_at: "", updated_at: "" },
+    ];
+    const client = createMockAIClient({
+      knowledgeBase: {
+        list: vi.fn().mockResolvedValue({ data: mockKbs, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useKnowledgeBases(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockKbs);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockAIClient({
+      knowledgeBase: {
+        list: vi.fn().mockResolvedValue({ data: null, error: new Error("Failed") }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useKnowledgeBases(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});
+
+describe("useKnowledgeBase", () => {
+  it("should get a single knowledge base", async () => {
+    const mockKb = {
+      id: "kb1", name: "Test KB", namespace: "default", description: "Test",
+      enabled: true, document_count: 5, total_chunks: 50,
+      embedding_model: "text-embedding-3-small", embedding_dimensions: 1536,
+      chunk_size: 1000, chunk_overlap: 200, chunk_strategy: "recursive",
+      source: "", created_at: "", updated_at: "",
+    };
+    const client = createMockAIClient({
+      knowledgeBase: {
+        get: vi.fn().mockResolvedValue({ data: mockKb, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useKnowledgeBase("kb1"), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockKb);
+  });
+
+  it("should not fetch when kbId is null", () => {
+    const client = createMockAIClient();
+    const { result } = renderHook(() => useKnowledgeBase(null), {
+      wrapper: createWrapper(client),
+    });
+    expect(result.current.data).toBeUndefined();
+  });
+});
+
+describe("useCreateKnowledgeBase", () => {
+  it("should create a knowledge base", async () => {
+    const createFn = vi.fn().mockResolvedValue({
+      data: { id: "kb1", name: "New" },
+      error: null,
+    });
+    const client = createMockAIClient({
+      knowledgeBase: { create: createFn } as any,
+    });
+
+    const { result } = renderHook(() => useCreateKnowledgeBase(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ name: "New" });
+    });
+
+    expect(createFn).toHaveBeenCalledWith({ name: "New" });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+});
+
+describe("useDeleteKnowledgeBase", () => {
+  it("should delete a knowledge base", async () => {
+    const deleteFn = vi.fn().mockResolvedValue({ data: true, error: null });
+    const client = createMockAIClient({
+      knowledgeBase: { delete: deleteFn } as any,
+    });
+
+    const { result } = renderHook(() => useDeleteKnowledgeBase(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync("kb1");
+    });
+
+    expect(deleteFn).toHaveBeenCalledWith("kb1");
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+});
+
+describe("useKBDocuments", () => {
+  it("should list documents in a knowledge base", async () => {
+    const mockDocs = [
+      { id: "doc1", knowledge_base_id: "kb1", title: "Doc 1", mime_type: "text/plain", content_hash: "abc", chunk_count: 5, status: "indexed", created_at: "", updated_at: "" },
+    ];
+    const client = createMockAIClient({
+      knowledgeBase: {
+        listDocuments: vi.fn().mockResolvedValue({ data: mockDocs, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useKBDocuments("kb1"), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockDocs);
+  });
+
+  it("should not fetch when kbId is null", () => {
+    const client = createMockAIClient();
+    const { result } = renderHook(() => useKBDocuments(null), {
+      wrapper: createWrapper(client),
+    });
+    expect(result.current.isLoading).toBe(false);
+  });
+});
+
+describe("useAddDocument", () => {
+  it("should add a document", async () => {
+    const addFn = vi.fn().mockResolvedValue({
+      data: { document_id: "doc1", status: "processing", message: "Added" },
+      error: null,
+    });
+    const client = createMockAIClient({
+      knowledgeBase: { addDocument: addFn } as any,
+    });
+
+    const { result } = renderHook(() => useAddDocument(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        kbId: "kb1",
+        request: { title: "Test", content: "Hello world" },
+      });
+    });
+
+    expect(addFn).toHaveBeenCalledWith("kb1", { title: "Test", content: "Hello world" });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+});
+
+describe("useUploadDocument", () => {
+  it("should upload a file document", async () => {
+    const uploadFn = vi.fn().mockResolvedValue({
+      data: { document_id: "doc1", status: "processing", message: "Uploaded", filename: "test.pdf", extracted_length: 1000, mime_type: "application/pdf" },
+      error: null,
+    });
+    const client = createMockAIClient({
+      knowledgeBase: { uploadDocument: uploadFn } as any,
+    });
+
+    const { result } = renderHook(() => useUploadDocument(), {
+      wrapper: createWrapper(client),
+    });
+
+    const file = new Blob(["content"], { type: "application/pdf" });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        kbId: "kb1",
+        file,
+        filename: "test.pdf",
+      });
+    });
+
+    expect(uploadFn).toHaveBeenCalledWith("kb1", file, "test.pdf", undefined);
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+});
+
+describe("useDeleteDocument", () => {
+  it("should delete a document", async () => {
+    const deleteFn = vi.fn().mockResolvedValue({ data: true, error: null });
+    const client = createMockAIClient({
+      knowledgeBase: { deleteDocument: deleteFn } as any,
+    });
+
+    const { result } = renderHook(() => useDeleteDocument(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ kbId: "kb1", docId: "doc1" });
+    });
+
+    expect(deleteFn).toHaveBeenCalledWith("kb1", "doc1");
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+});
+
+describe("useKBSearch", () => {
+  it("should search a knowledge base", async () => {
+    const mockResults = {
+      results: [{ chunk_id: "c1", document_id: "d1", document_title: "Doc 1", content: "test", similarity: 0.95 }],
+      count: 1,
+      query: "test",
+    };
+    const searchFn = vi.fn().mockResolvedValue({ data: mockResults, error: null });
+    const client = createMockAIClient({
+      knowledgeBase: { search: searchFn } as any,
+    });
+
+    const { result } = renderHook(
+      () => useKBSearch("kb1", { query: "test" }),
+      { wrapper: createWrapper(client) },
+    );
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockResults);
+    expect(searchFn).toHaveBeenCalledWith("kb1", { query: "test" });
+  });
+
+  it("should not search when request is null", () => {
+    const client = createMockAIClient();
+    const { result } = renderHook(() => useKBSearch("kb1", null), {
+      wrapper: createWrapper(client),
+    });
+    expect(result.current.data).toBeUndefined();
+  });
+});
+
+describe("useKBEntities", () => {
+  it("should list entities", async () => {
+    const mockEntities = [
+      { id: "e1", knowledge_base_id: "kb1", entity_type: "person", name: "John", canonical_name: "John", aliases: [], metadata: {}, created_at: "", updated_at: "" },
+    ];
+    const client = createMockAIClient({
+      knowledgeBase: {
+        listEntities: vi.fn().mockResolvedValue({ data: mockEntities, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useKBEntities("kb1"), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockEntities);
+  });
+});
+
+describe("useKnowledgeGraph", () => {
+  it("should get the knowledge graph", async () => {
+    const mockGraph = {
+      entities: [],
+      relationships: [],
+      entity_count: 0,
+      relationship_count: 0,
+    };
+    const client = createMockAIClient({
+      knowledgeBase: {
+        getKnowledgeGraph: vi.fn().mockResolvedValue({ data: mockGraph, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useKnowledgeGraph("kb1"), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockGraph);
+  });
+});