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

package/src/use-query.ts

@@ -43,17 +43,22 @@ export function useFluxbaseQuery<T = any>(
   options?: UseFluxbaseQueryOptions<T>,
 ) {
   const client = useFluxbaseClient();
+  const tenantId = client.getTenantId();
+
+  const { queryKey: customKey, ...queryOptions } = options || {};
 
   // Require queryKey for stable caching - function.toString() is not reliable
   // as it can vary between renders for inline functions
-  if (!options?.queryKey) {
+  if (!customKey) {
     console.warn(
       "[useFluxbaseQuery] No queryKey provided. This may cause cache misses. " +
         "Please provide a stable queryKey in options.",
     );
   }
 
-  const queryKey = options?.queryKey || ["fluxbase", "query", "unstable"];
+  const queryKey = customKey
+    ? ["fluxbase", tenantId ?? null, ...customKey]
+    : ["fluxbase", tenantId ?? null, "query", "unstable"];
 
   return useQuery({
     queryKey,
@@ -67,7 +72,7 @@ export function useFluxbaseQuery<T = any>(
 
       return (Array.isArray(data) ? data : data ? [data] : []) as T[];
     },
-    ...options,
+    ...queryOptions,
   });
 }
 
@@ -113,8 +118,7 @@ export function useTable<T = any>(
     },
     {
       ...options,
-      // Use table name as base key, or custom key if provided
-      queryKey: options?.queryKey || ["fluxbase", "table", table],
+      queryKey: options?.queryKey || ["table", table],
     },
   );
 }
@@ -138,8 +142,10 @@ export function useInsert<T = any>(table: string) {
       return result;
     },
     onSuccess: () => {
-      // Invalidate all queries for this table
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
+      const tenantId = client.getTenantId();
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", tenantId ?? null, "table", table],
+      });
     },
   });
 }
@@ -167,7 +173,10 @@ export function useUpdate<T = any>(table: string) {
       return result;
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
+      const tenantId = client.getTenantId();
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", tenantId ?? null, "table", table],
+      });
     },
   });
 }
@@ -191,7 +200,10 @@ export function useUpsert<T = any>(table: string) {
       return result;
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
+      const tenantId = client.getTenantId();
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", tenantId ?? null, "table", table],
+      });
     },
   });
 }
@@ -216,7 +228,10 @@ export function useDelete<T = any>(table: string) {
       }
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
+      const tenantId = client.getTenantId();
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", tenantId ?? null, "table", table],
+      });
     },
   });
 }

package/src/use-rpc.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Tests for RPC hooks
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import { useRPCList, useInvokeRPC } from "./use-rpc";
+import { createMockClient, createWrapper } from "./test-utils";
+import type { FluxbaseClient } from "@nimbleflux/fluxbase-sdk";
+
+describe("useRPCList", () => {
+  it("should list RPC procedures", async () => {
+    const mockProcedures = [
+      { id: "1", name: "get-users", namespace: "default", enabled: true, version: 1, source: "filesystem", is_public: true, allowed_tables: [], allowed_schemas: [], max_execution_time_seconds: 30, created_at: "", updated_at: "" },
+    ];
+    const client = createMockClient({
+      rpc: Object.assign(vi.fn(), {
+        list: vi.fn().mockResolvedValue({ data: mockProcedures, error: null }),
+      }) as any,
+    });
+
+    const { result } = renderHook(() => useRPCList(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockProcedures);
+  });
+
+  it("should filter by namespace", async () => {
+    const list = vi
+      .fn()
+      .mockResolvedValue({ data: [], error: null });
+    const client = createMockClient({
+      rpc: Object.assign(vi.fn(), { list }) as any,
+    });
+
+    renderHook(() => useRPCList("custom-ns"), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => {
+      expect(list).toHaveBeenCalledWith("custom-ns");
+    });
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      rpc: Object.assign(vi.fn(), {
+        list: vi
+          .fn()
+          .mockResolvedValue({ data: null, error: new Error("Failed") }),
+      }) as any,
+    });
+
+    const { result } = renderHook(() => useRPCList(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});
+
+describe("useInvokeRPC", () => {
+  it("should invoke an RPC procedure", async () => {
+    const mockResponse = {
+      execution_id: "exec-1",
+      status: "completed" as const,
+      result: { count: 42 },
+    };
+    const client = createMockClient({
+      rpc: Object.assign(vi.fn(), {
+        invoke: vi.fn().mockResolvedValue({ data: mockResponse, error: null }),
+      }) as any,
+    });
+
+    const { result } = renderHook(() => useInvokeRPC(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        name: "get-count",
+        payload: { table: "users" },
+      });
+    });
+
+    expect((client.rpc as any).invoke).toHaveBeenCalledWith(
+      "get-count",
+      { table: "users" },
+      undefined,
+    );
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockResponse);
+  });
+
+  it("should pass options", async () => {
+    const mockResponse = { execution_id: "exec-2", status: "running" as const };
+    const client = createMockClient({
+      rpc: Object.assign(vi.fn(), {
+        invoke: vi.fn().mockResolvedValue({ data: mockResponse, error: null }),
+      }) as any,
+    });
+
+    const { result } = renderHook(() => useInvokeRPC(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        name: "long-task",
+        options: { async: true, namespace: "prod" },
+      });
+    });
+
+    expect((client.rpc as any).invoke).toHaveBeenCalledWith(
+      "long-task",
+      undefined,
+      { async: true, namespace: "prod" },
+    );
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      rpc: Object.assign(vi.fn(), {
+        invoke: vi
+          .fn()
+          .mockResolvedValue({ data: null, error: new Error("Not found") }),
+      }) as any,
+    });
+
+    const { result } = renderHook(() => useInvokeRPC(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({ name: "bad-proc" });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});

package/src/use-rpc.ts

@@ -0,0 +1,58 @@
+/**
+ * RPC hooks for Fluxbase React SDK
+ * Provides hooks for listing and invoking RPC procedures
+ */
+
+import { useQuery, useMutation } from "@tanstack/react-query";
+import { useFluxbaseClient } from "./context";
+
+interface RPCInvokeOptions {
+  namespace?: string;
+  async?: boolean;
+  timeout?: number;
+}
+
+/**
+ * Hook to list available RPC procedures
+ */
+export function useRPCList(namespace?: string) {
+  const client = useFluxbaseClient();
+
+  return useQuery({
+    queryKey: ["fluxbase", "rpc", namespace],
+    queryFn: async () => {
+      const { data, error } = await client.rpc.list(namespace);
+      if (error) throw error;
+      return data;
+    },
+  });
+}
+
+/**
+ * Hook to invoke an RPC procedure
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync, data } = useInvokeRPC()
+ * await mutateAsync({ name: 'get-user-orders', payload: { user_id: '123' } })
+ * ```
+ */
+export function useInvokeRPC() {
+  const client = useFluxbaseClient();
+
+  return useMutation({
+    mutationFn: async (params: {
+      name: string;
+      payload?: Record<string, unknown>;
+      options?: RPCInvokeOptions;
+    }) => {
+      const { data, error } = await client.rpc.invoke(
+        params.name,
+        params.payload,
+        params.options,
+      );
+      if (error) throw error;
+      return data;
+    },
+  });
+}

package/src/use-secrets.test.ts

@@ -0,0 +1,253 @@
+/**
+ * Tests for Secrets hooks
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import {
+  useSecrets,
+  useCreateSecret,
+  useUpdateSecret,
+  useDeleteSecret,
+} from "./use-secrets";
+import { createMockClient, createWrapper } from "./test-utils";
+
+describe("useSecrets", () => {
+  it("should list secrets", async () => {
+    const mockSecrets = [
+      { id: "1", name: "API_KEY", scope: "global", version: 1, is_expired: false, created_at: "", updated_at: "" },
+    ];
+    const client = createMockClient();
+    (client.secrets.list as ReturnType<typeof vi.fn>).mockResolvedValue(mockSecrets);
+
+    const { result } = renderHook(() => useSecrets(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockSecrets);
+  });
+
+  it("should pass options to list", async () => {
+    const client = createMockClient();
+    (client.secrets.list as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+    renderHook(() => useSecrets({ scope: "namespace", namespace: "prod" }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => {
+      expect(client.secrets.list).toHaveBeenCalledWith({
+        scope: "namespace",
+        namespace: "prod",
+      });
+    });
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient();
+    (client.secrets.list as ReturnType<typeof vi.fn>).mockRejectedValue(
+      new Error("Unauthorized"),
+    );
+
+    const { result } = renderHook(() => useSecrets(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});
+
+describe("useCreateSecret", () => {
+  it("should create a secret and invalidate queries", async () => {
+    const mockSecret = {
+      id: "2",
+      name: "NEW_KEY",
+      scope: "global" as const,
+      version: 1,
+      created_at: "",
+      updated_at: "",
+    };
+    const client = createMockClient();
+    (client.secrets.create as ReturnType<typeof vi.fn>).mockResolvedValue(mockSecret);
+
+    const { result } = renderHook(() => useCreateSecret(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        name: "NEW_KEY",
+        value: "secret-value",
+      });
+    });
+
+    expect(client.secrets.create).toHaveBeenCalledWith({
+      name: "NEW_KEY",
+      value: "secret-value",
+    });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockSecret);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient();
+    (client.secrets.create as ReturnType<typeof vi.fn>).mockRejectedValue(
+      new Error("Secret exists"),
+    );
+
+    const { result } = renderHook(() => useCreateSecret(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({ name: "DUP", value: "val" });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe("useUpdateSecret", () => {
+  it("should update a secret and invalidate queries", async () => {
+    const mockSecret = {
+      id: "1",
+      name: "API_KEY",
+      scope: "global" as const,
+      version: 2,
+      created_at: "",
+      updated_at: "",
+    };
+    const client = createMockClient();
+    (client.secrets.update as ReturnType<typeof vi.fn>).mockResolvedValue(mockSecret);
+
+    const { result } = renderHook(() => useUpdateSecret(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        name: "API_KEY",
+        request: { value: "new-value" },
+      });
+    });
+
+    expect(client.secrets.update).toHaveBeenCalledWith(
+      "API_KEY",
+      { value: "new-value" },
+      { namespace: undefined },
+    );
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockSecret);
+  });
+
+  it("should pass namespace option", async () => {
+    const client = createMockClient();
+    (client.secrets.update as ReturnType<typeof vi.fn>).mockResolvedValue({});
+
+    const { result } = renderHook(() => useUpdateSecret(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        name: "DB_URL",
+        request: { value: "postgres://new" },
+        namespace: "production",
+      });
+    });
+
+    expect(client.secrets.update).toHaveBeenCalledWith(
+      "DB_URL",
+      { value: "postgres://new" },
+      { namespace: "production" },
+    );
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient();
+    (client.secrets.update as ReturnType<typeof vi.fn>).mockRejectedValue(
+      new Error("Not found"),
+    );
+
+    const { result } = renderHook(() => useUpdateSecret(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({
+          name: "MISSING",
+          request: { value: "val" },
+        });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe("useDeleteSecret", () => {
+  it("should delete a secret and invalidate queries", async () => {
+    const client = createMockClient();
+    (client.secrets.delete as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+
+    const { result } = renderHook(() => useDeleteSecret(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ name: "OLD_KEY" });
+    });
+
+    expect(client.secrets.delete).toHaveBeenCalledWith("OLD_KEY", {
+      namespace: undefined,
+    });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+
+  it("should pass namespace option", async () => {
+    const client = createMockClient();
+    (client.secrets.delete as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+
+    const { result } = renderHook(() => useDeleteSecret(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ name: "DB_URL", namespace: "staging" });
+    });
+
+    expect(client.secrets.delete).toHaveBeenCalledWith("DB_URL", {
+      namespace: "staging",
+    });
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient();
+    (client.secrets.delete as ReturnType<typeof vi.fn>).mockRejectedValue(
+      new Error("Not found"),
+    );
+
+    const { result } = renderHook(() => useDeleteSecret(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({ name: "MISSING" });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});

package/src/use-secrets.ts

@@ -0,0 +1,85 @@
+/**
+ * Secrets hooks for Fluxbase React SDK
+ * Provides hooks for managing edge function and job secrets
+ */
+
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { useFluxbaseClient } from "./context";
+import type {
+  ListSecretsOptions,
+  CreateSecretRequest,
+  UpdateSecretRequest,
+} from "@nimbleflux/fluxbase-sdk";
+
+/**
+ * Hook to list all secrets (metadata only, never includes values)
+ */
+export function useSecrets(options?: ListSecretsOptions) {
+  const client = useFluxbaseClient();
+
+  return useQuery({
+    queryKey: ["fluxbase", "secrets", options],
+    queryFn: async () => {
+      return await client.secrets.list(options);
+    },
+  });
+}
+
+/**
+ * Hook to create a new secret
+ */
+export function useCreateSecret() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (request: CreateSecretRequest) => {
+      return await client.secrets.create(request);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "secrets"] });
+    },
+  });
+}
+
+/**
+ * Hook to update a secret by name
+ */
+export function useUpdateSecret() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (params: {
+      name: string;
+      request: UpdateSecretRequest;
+      namespace?: string;
+    }) => {
+      return await client.secrets.update(params.name, params.request, {
+        namespace: params.namespace,
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "secrets"] });
+    },
+  });
+}
+
+/**
+ * Hook to delete a secret by name
+ */
+export function useDeleteSecret() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (params: { name: string; namespace?: string }) => {
+      await client.secrets.delete(params.name, {
+        namespace: params.namespace,
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "secrets"] });
+    },
+  });
+}