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

package/README.md

@@ -135,18 +135,18 @@ function YourApp() {
 
 ## Documentation
 
-📚 **[Complete React Hooks Guide](../../docs/docs/sdks/react-hooks.md)**
+📚 **[React SDK Reference](../../docs/src/content/docs/api/sdk-react/)**
 
 ### Core Guides
 
-- **[Getting Started](../../docs/docs/sdks/getting-started.md)** - Installation and setup
-- **[React Hooks](../../docs/docs/sdks/react-hooks.md)** - Comprehensive hooks documentation with examples
-- **[Database Operations](../../docs/docs/sdks/database.md)** - Query building and data operations
+- **[SDK Reference](../../docs/src/content/docs/sdk/)** - Core SDK usage and configuration
+- **[Admin Hooks Guide](./README-ADMIN.md)** - Comprehensive admin dashboard documentation
+- **[Vector Search](../../docs/src/content/docs/guides/vector-search.md)** - Semantic search
 
 ### API Reference
 
-- **[React Hooks API](../../docs/static/api/sdk-react/)** - Auto-generated from source code
-- **[Core SDK API](../../docs/static/api/sdk/)** - Core TypeScript SDK reference
+- **[React Hooks API](../../docs/src/content/docs/api/sdk-react/)** - Auto-generated from source code
+- **[Core SDK API](../../docs/src/content/docs/api/sdk/)** - Core TypeScript SDK reference
 
 ## TypeScript Support
 
@@ -169,18 +169,11 @@ function ProductList() {
 
 ## Examples
 
-Check out working examples in the [`/example`](../example/) directory:
-
-- React with Vite
-- Next.js App Router
-- Next.js Pages Router
-- Authentication flows
-- Realtime features
-- File uploads
+See `sdk-react/examples/` for a working example app.
 
 ## Contributing
 
-Contributions are welcome! Please read our [Contributing Guide](../../CONTRIBUTING.md) for details.
+Contributions are welcome! Please see the project repository for contribution guidelines.
 
 ## License
 
@@ -188,8 +181,8 @@ MIT © Fluxbase
 
 ## Links
 
-- [Documentation](../../docs/docs/sdks/react-hooks.md)
-- [API Reference](../../docs/static/api/sdk-react/)
+- [Documentation](../../docs/src/content/docs/sdk/)
+- [API Reference](../../docs/src/content/docs/api/sdk-react/)
 - [Core SDK](../sdk/)
 - [GitHub](https://github.com/nimbleflux/fluxbase)
 - [Issues](https://github.com/nimbleflux/fluxbase/issues)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbleflux/fluxbase-sdk-react",
-  "version": "2026.5.5-rc.2",
+  "version": "2026.6.2",
   "description": "React hooks for Fluxbase SDK",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -39,7 +39,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@nimbleflux/fluxbase-sdk": "^2026.5.5-rc.2",
+    "@nimbleflux/fluxbase-sdk": "^2026.6.2",
     "@tanstack/react-query": "^5.96.2",
     "react": "^18.0.0 || ^19.0.0"
   },

package/src/index.ts

@@ -144,6 +144,49 @@ export { useSubmitJob, useJobStatus } from "./use-jobs";
 // Branching hooks
 export { useBranches } from "./use-branches";
 
+// RPC hooks
+export { useRPCList, useInvokeRPC } from "./use-rpc";
+
+// Vector hooks
+export { useVectorEmbed, useVectorSearch } from "./use-vector";
+
+// Secrets hooks
+export { useSecrets, useCreateSecret, useUpdateSecret, useDeleteSecret } from "./use-secrets";
+
+// Service Keys hooks
+export {
+  useServiceKeys,
+  useCreateServiceKey,
+  useRotateServiceKey,
+  useRevokeServiceKey,
+} from "./use-service-keys";
+
+// AI hooks
+export {
+  useChatbots,
+  useConversations,
+  useConversation,
+  useDeleteConversation,
+  useAIChat,
+  type ChatMessage,
+} from "./use-ai";
+
+// Knowledge Base hooks
+export {
+  useKnowledgeBases,
+  useKnowledgeBase,
+  useCreateKnowledgeBase,
+  useUpdateKnowledgeBase,
+  useDeleteKnowledgeBase,
+  useKBDocuments,
+  useAddDocument,
+  useUploadDocument,
+  useDeleteDocument,
+  useKBSearch,
+  useKBEntities,
+  useKnowledgeGraph,
+} from "./use-knowledge-base";
+
 // Re-export types from SDK
 export type {
   FluxbaseClient,

package/src/test-utils.tsx

@@ -91,6 +91,33 @@ export function createMockClient(
       }),
       ...overrides.realtime,
     },
+    jobs: {
+      submit: vi.fn().mockResolvedValue({ data: { id: "job-1", status: "pending" }, error: null }),
+      get: vi.fn().mockResolvedValue({ data: { id: "job-1", status: "completed" }, error: null }),
+      list: vi.fn().mockResolvedValue({ data: [], error: null }),
+      cancel: vi.fn().mockResolvedValue({ data: null, error: null }),
+      retry: vi.fn().mockResolvedValue({ data: { id: "job-2", status: "pending" }, error: null }),
+      getLogs: vi.fn().mockResolvedValue({ data: [], error: null }),
+      ...overrides.jobs,
+    },
+    functions: {
+      invoke: vi.fn().mockResolvedValue({ data: null, error: null }),
+      list: vi.fn().mockResolvedValue({ data: [], error: null }),
+      get: vi.fn().mockResolvedValue({ data: null, error: null }),
+      ...overrides.functions,
+    },
+    branching: {
+      list: vi.fn().mockResolvedValue({ data: { branches: [], total: 0, limit: 50, offset: 0 }, error: null }),
+      get: vi.fn().mockResolvedValue({ data: null, error: null }),
+      create: vi.fn().mockResolvedValue({ data: { id: "b1", slug: "test-branch", status: "creating" }, error: null }),
+      delete: vi.fn().mockResolvedValue({ error: null }),
+      reset: vi.fn().mockResolvedValue({ data: { id: "b1", slug: "test-branch", status: "creating" }, error: null }),
+      getActivity: vi.fn().mockResolvedValue({ data: [], error: null }),
+      getPoolStats: vi.fn().mockResolvedValue({ data: [], error: null }),
+      exists: vi.fn().mockResolvedValue(false),
+      waitForReady: vi.fn().mockResolvedValue({ data: null, error: null }),
+      ...overrides.branching,
+    },
     graphql: {
       execute: vi.fn().mockResolvedValue({ data: null, errors: null }),
       query: vi.fn().mockResolvedValue({ data: null, errors: null }),
@@ -142,12 +169,159 @@ export function createMockClient(
           test: vi.fn().mockResolvedValue({}),
         },
       },
+      serviceKeys: {
+        list: vi.fn().mockResolvedValue({ data: [], error: null }),
+        get: vi.fn().mockResolvedValue({ data: null, error: null }),
+        create: vi.fn().mockResolvedValue({ data: null, error: null }),
+        update: vi.fn().mockResolvedValue({ data: null, error: null }),
+        delete: vi.fn().mockResolvedValue({ error: null }),
+        disable: vi.fn().mockResolvedValue({ error: null }),
+        enable: vi.fn().mockResolvedValue({ error: null }),
+        revoke: vi.fn().mockResolvedValue({ error: null }),
+        deprecate: vi.fn().mockResolvedValue({ data: null, error: null }),
+        rotate: vi.fn().mockResolvedValue({ data: null, error: null }),
+        getRevocationHistory: vi.fn().mockResolvedValue({ data: null, error: null }),
+      },
+      migrations: {
+        list: vi.fn().mockResolvedValue({ data: [], error: null }),
+        apply: vi
+          .fn()
+          .mockResolvedValue({ data: { message: "Migration applied" }, error: null }),
+        rollback: vi
+          .fn()
+          .mockResolvedValue({ data: { message: "Migration rolled back" }, error: null }),
+        sync: vi.fn().mockResolvedValue({ data: null, error: null }),
+      },
+      impersonation: {
+        impersonateUser: vi
+          .fn()
+          .mockResolvedValue({
+            session: null,
+            target_user: null,
+            access_token: "",
+            refresh_token: "",
+            expires_in: 0,
+          }),
+        impersonateAnon: vi
+          .fn()
+          .mockResolvedValue({
+            session: null,
+            target_user: null,
+            access_token: "",
+            refresh_token: "",
+            expires_in: 0,
+          }),
+        stop: vi
+          .fn()
+          .mockResolvedValue({ success: true, message: "Impersonation stopped" }),
+        getCurrent: vi.fn().mockResolvedValue({ session: null, target_user: null }),
+        listSessions: vi.fn().mockResolvedValue({ sessions: [], total: 0 }),
+      },
+      ddl: {
+        listSchemas: vi.fn().mockResolvedValue({ schemas: [] }),
+        createSchema: vi
+          .fn()
+          .mockResolvedValue({ message: "Schema created", schema: "" }),
+        listTables: vi.fn().mockResolvedValue({ tables: [] }),
+        deleteTable: vi
+          .fn()
+          .mockResolvedValue({ message: "Table deleted" }),
+      },
       ...overrides.admin,
     },
+    rpc: Object.assign(
+      vi.fn().mockResolvedValue({ data: null, error: null }),
+      {
+        list: vi.fn().mockResolvedValue({ data: [], error: null }),
+        invoke: vi.fn().mockResolvedValue({ data: null, error: null }),
+        getStatus: vi.fn().mockResolvedValue({ data: null, error: null }),
+        getLogs: vi.fn().mockResolvedValue({ data: [], error: null }),
+        waitForCompletion: vi.fn().mockResolvedValue({ data: null, error: null }),
+      },
+    ),
+    secrets: {
+      list: vi.fn().mockResolvedValue([]),
+      create: vi.fn().mockResolvedValue({ id: "1", name: "test", scope: "global", version: 1, created_at: "", updated_at: "" }),
+      get: vi.fn().mockResolvedValue({ id: "1", name: "test", scope: "global", version: 1, created_at: "", updated_at: "" }),
+      update: vi.fn().mockResolvedValue({ id: "1", name: "test", scope: "global", version: 2, created_at: "", updated_at: "" }),
+      delete: vi.fn().mockResolvedValue(undefined),
+      getVersions: vi.fn().mockResolvedValue([]),
+      rollback: vi.fn().mockResolvedValue({ id: "1", name: "test", scope: "global", version: 3, created_at: "", updated_at: "" }),
+      stats: vi.fn().mockResolvedValue({ total: 0, expiring_soon: 0, expired: 0 }),
+      getById: vi.fn().mockResolvedValue({ id: "1", name: "test", scope: "global", version: 1, created_at: "", updated_at: "" }),
+      updateById: vi.fn().mockResolvedValue({ id: "1", name: "test", scope: "global", version: 2, created_at: "", updated_at: "" }),
+      deleteById: vi.fn().mockResolvedValue(undefined),
+      getVersionsById: vi.fn().mockResolvedValue([]),
+      rollbackById: vi.fn().mockResolvedValue({ id: "1", name: "test", scope: "global", version: 3, created_at: "", updated_at: "" }),
+      ...overrides.secrets,
+    },
+    vector: {
+      embed: vi.fn().mockResolvedValue({ data: null, error: null }),
+      search: vi.fn().mockResolvedValue({ data: null, error: null }),
+      ...overrides.vector,
+    },
     ...overrides,
   } as unknown as FluxbaseClient;
 }
 
+/**
+ * Create a mock client with AI/Knowledge Base support
+ */
+export function createMockAIClient(
+  overrides: Partial<FluxbaseClient> = {},
+): FluxbaseClient {
+  const base = createMockClient(overrides);
+  return {
+    ...base,
+    ai: {
+      listChatbots: vi.fn().mockResolvedValue({ data: [], error: null }),
+      getChatbot: vi.fn().mockResolvedValue({ data: null, error: null }),
+      lookupChatbot: vi.fn().mockResolvedValue({ data: null, error: null }),
+      createChat: vi.fn().mockReturnValue({
+        connect: vi.fn().mockResolvedValue(undefined),
+        disconnect: vi.fn(),
+        isConnected: vi.fn().mockReturnValue(true),
+        startChat: vi.fn().mockResolvedValue("conv-1"),
+        sendMessage: vi.fn().mockResolvedValue(undefined),
+        cancel: vi.fn(),
+        getAccumulatedContent: vi.fn().mockReturnValue(""),
+      }),
+      listConversations: vi
+        .fn()
+        .mockResolvedValue({ data: { conversations: [], total: 0, has_more: false }, error: null }),
+      getConversation: vi.fn().mockResolvedValue({ data: null, error: null }),
+      deleteConversation: vi.fn().mockResolvedValue({ error: null }),
+      updateConversation: vi.fn().mockResolvedValue({ data: null, error: null }),
+      ...overrides.ai,
+    },
+    knowledgeBase: {
+      list: vi.fn().mockResolvedValue({ data: [], error: null }),
+      get: vi.fn().mockResolvedValue({ data: null, error: null }),
+      create: vi.fn().mockResolvedValue({ data: null, error: null }),
+      update: vi.fn().mockResolvedValue({ data: null, error: null }),
+      delete: vi.fn().mockResolvedValue({ data: true, error: null }),
+      listDocuments: vi.fn().mockResolvedValue({ data: [], error: null }),
+      getDocument: vi.fn().mockResolvedValue({ data: null, error: null }),
+      addDocument: vi.fn().mockResolvedValue({ data: null, error: null }),
+      uploadDocument: vi.fn().mockResolvedValue({ data: null, error: null }),
+      updateDocument: vi.fn().mockResolvedValue({ data: null, error: null }),
+      deleteDocument: vi.fn().mockResolvedValue({ data: true, error: null }),
+      deleteDocumentsByFilter: vi.fn().mockResolvedValue({ data: null, error: null }),
+      search: vi.fn().mockResolvedValue({ data: null, error: null }),
+      listEntities: vi.fn().mockResolvedValue({ data: [], error: null }),
+      searchEntities: vi.fn().mockResolvedValue({ data: [], error: null }),
+      getEntityRelationships: vi.fn().mockResolvedValue({ data: [], error: null }),
+      getKnowledgeGraph: vi.fn().mockResolvedValue({ data: null, error: null }),
+      ...overrides.knowledgeBase,
+    },
+    vector: {
+      embed: vi.fn().mockResolvedValue({ data: null, error: null }),
+      search: vi.fn().mockResolvedValue({ data: null, error: null }),
+      ...overrides.vector,
+    },
+  } as unknown as FluxbaseClient;
+}
+
 /**
  * Create a fresh QueryClient for testing
  */

package/src/use-ai.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Tests for AI hooks
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import {
+  useChatbots,
+  useConversations,
+  useConversation,
+  useDeleteConversation,
+} from "./use-ai";
+import {
+  createMockAIClient,
+  createWrapper,
+} from "./test-utils";
+import type { FluxbaseClient } from "@nimbleflux/fluxbase-sdk";
+
+describe("useChatbots", () => {
+  it("should list chatbots", async () => {
+    const mockChatbots = [
+      { id: "1", name: "Bot1", namespace: "default", enabled: true, version: "1", source: "filesystem" },
+    ];
+    const client = createMockAIClient({
+      ai: {
+        listChatbots: vi.fn().mockResolvedValue({ data: mockChatbots, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useChatbots(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockChatbots);
+  });
+
+  it("should filter by namespace", async () => {
+    const listChatbots = vi
+      .fn()
+      .mockResolvedValue({ data: [], error: null });
+    const client = createMockAIClient({
+      ai: { listChatbots } as any,
+    });
+
+    renderHook(() => useChatbots("my-ns"), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => {
+      expect(listChatbots).toHaveBeenCalledWith("my-ns");
+    });
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockAIClient({
+      ai: {
+        listChatbots: vi
+          .fn()
+          .mockResolvedValue({ data: null, error: new Error("Failed") }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useChatbots(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});
+
+describe("useConversations", () => {
+  it("should list conversations", async () => {
+    const mockData = {
+      conversations: [
+        { id: "c1", chatbot: "bot1", namespace: "default", title: "Test", created_at: "", updated_at: "" },
+      ],
+      total: 1,
+      has_more: false,
+    };
+    const client = createMockAIClient({
+      ai: {
+        listConversations: vi
+          .fn()
+          .mockResolvedValue({ data: mockData, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useConversations(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockData);
+  });
+
+  it("should pass options to listConversations", async () => {
+    const listConversations = vi
+      .fn()
+      .mockResolvedValue({ data: { conversations: [], total: 0, has_more: false }, error: null });
+    const client = createMockAIClient({
+      ai: { listConversations } as any,
+    });
+
+    renderHook(
+      () => useConversations({ chatbot: "my-bot", limit: 10 }),
+      { wrapper: createWrapper(client) },
+    );
+
+    await waitFor(() => {
+      expect(listConversations).toHaveBeenCalledWith({
+        chatbot: "my-bot",
+        limit: 10,
+      });
+    });
+  });
+});
+
+describe("useConversation", () => {
+  it("should get a conversation by ID", async () => {
+    const mockConv = { id: "c1", chatbot: "bot1", namespace: "default", created_at: "", updated_at: "", messages: [] };
+    const client = createMockAIClient({
+      ai: {
+        getConversation: vi
+          .fn()
+          .mockResolvedValue({ data: mockConv, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useConversation("c1"), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockConv);
+  });
+
+  it("should not fetch when conversationId is null", () => {
+    const client = createMockAIClient();
+    const { result } = renderHook(() => useConversation(null), {
+      wrapper: createWrapper(client),
+    });
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.data).toBeUndefined();
+  });
+});
+
+describe("useDeleteConversation", () => {
+  it("should delete a conversation and invalidate queries", async () => {
+    const deleteConversation = vi
+      .fn()
+      .mockResolvedValue({ error: null });
+    const client = createMockAIClient({
+      ai: { deleteConversation } as any,
+    });
+
+    const { result } = renderHook(() => useDeleteConversation(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync("conv-1");
+    });
+
+    expect(deleteConversation).toHaveBeenCalledWith("conv-1");
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockAIClient({
+      ai: {
+        deleteConversation: vi
+          .fn()
+          .mockResolvedValue({ error: new Error("Not found") }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useDeleteConversation(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync("conv-1");
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});