@nimbleflux/fluxbase-sdk-react 2026.5.5-rc.2 → 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-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));
+  });
+});

package/src/use-vector.ts

@@ -0,0 +1,55 @@
+/**
+ * Vector hooks for Fluxbase React SDK
+ * Provides hooks for vector embedding and similarity search
+ */
+
+import { useMutation } from "@tanstack/react-query";
+import { useFluxbaseClient } from "./context";
+import type { EmbedRequest, VectorSearchOptions } from "@nimbleflux/fluxbase-sdk";
+
+/**
+ * Hook to generate embeddings for text
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useVectorEmbed()
+ * const { data } = await mutateAsync({ text: 'Hello world' })
+ * ```
+ */
+export function useVectorEmbed() {
+  const client = useFluxbaseClient();
+
+  return useMutation({
+    mutationFn: async (request: EmbedRequest) => {
+      const { data, error } = await client.vector.embed(request);
+      if (error) throw error;
+      return data;
+    },
+  });
+}
+
+/**
+ * Hook for vector similarity search with automatic text embedding
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useVectorSearch()
+ * const { data } = await mutateAsync({
+ *   table: 'documents',
+ *   column: 'embedding',
+ *   query: 'How to use TypeScript?',
+ *   match_count: 10,
+ * })
+ * ```
+ */
+export function useVectorSearch() {
+  const client = useFluxbaseClient();
+
+  return useMutation({
+    mutationFn: async (options: VectorSearchOptions) => {
+      const { data, error } = await client.vector.search(options);
+      if (error) throw error;
+      return data;
+    },
+  });
+}