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

package/src/use-ddl.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Tests for DDL hooks
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import {
+  useSchemas,
+  useTables,
+  useCreateSchema,
+  useDeleteTable,
+} from "./use-ddl";
+import { createMockClient, createWrapper } from "./test-utils";
+
+describe("useSchemas", () => {
+  it("should list schemas", async () => {
+    const mockSchemas = {
+      schemas: [
+        { name: "public", owner: "postgres" },
+        { name: "analytics", owner: "postgres" },
+      ],
+    };
+    const client = createMockClient({
+      admin: {
+        ddl: {
+          listSchemas: vi.fn().mockResolvedValue(mockSchemas),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useSchemas(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockSchemas);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      admin: {
+        ddl: {
+          listSchemas: vi.fn().mockRejectedValue(new Error("Failed")),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useSchemas(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});
+
+describe("useTables", () => {
+  it("should list all tables when no schema provided", async () => {
+    const mockTables = {
+      tables: [
+        { schema: "public", name: "users" },
+        { schema: "analytics", name: "events" },
+      ],
+    };
+    const listTables = vi.fn().mockResolvedValue(mockTables);
+    const client = createMockClient({
+      admin: { ddl: { listTables } } as any,
+    });
+
+    const { result } = renderHook(() => useTables(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockTables);
+    expect(listTables).toHaveBeenCalledWith(undefined);
+  });
+
+  it("should list tables filtered by schema", async () => {
+    const mockTables = {
+      tables: [{ schema: "public", name: "users" }],
+    };
+    const listTables = vi.fn().mockResolvedValue(mockTables);
+    const client = createMockClient({
+      admin: { ddl: { listTables } } as any,
+    });
+
+    const { result } = renderHook(() => useTables("public"), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(listTables).toHaveBeenCalledWith("public");
+    expect(result.current.data).toEqual(mockTables);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      admin: {
+        ddl: {
+          listTables: vi.fn().mockRejectedValue(new Error("Failed")),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useTables(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});
+
+describe("useCreateSchema", () => {
+  it("should create a schema", async () => {
+    const mockResponse = { message: "Schema created", schema: "analytics" };
+    const createSchema = vi.fn().mockResolvedValue(mockResponse);
+    const client = createMockClient({
+      admin: { ddl: { createSchema } } as any,
+    });
+
+    const { result } = renderHook(() => useCreateSchema(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync("analytics");
+    });
+
+    expect(createSchema).toHaveBeenCalledWith("analytics");
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockResponse);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      admin: {
+        ddl: {
+          createSchema: vi.fn().mockRejectedValue(new Error("Schema exists")),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useCreateSchema(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync("analytics");
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe("useDeleteTable", () => {
+  it("should delete a table", async () => {
+    const mockResponse = { message: "Table deleted" };
+    const deleteTable = vi.fn().mockResolvedValue(mockResponse);
+    const client = createMockClient({
+      admin: { ddl: { deleteTable } } as any,
+    });
+
+    const { result } = renderHook(() => useDeleteTable(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ schema: "public", name: "old_data" });
+    });
+
+    expect(deleteTable).toHaveBeenCalledWith("public", "old_data");
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockResponse);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      admin: {
+        ddl: {
+          deleteTable: vi.fn().mockRejectedValue(new Error("Table not found")),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useDeleteTable(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({ schema: "public", name: "missing" });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});

package/src/use-ddl.ts

@@ -0,0 +1,73 @@
+/**
+ * DDL hooks for Fluxbase React SDK
+ * Provides hooks for managing database schemas and tables
+ */
+
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { useFluxbaseClient } from "./context";
+
+/**
+ * Hook to list all database schemas
+ */
+export function useSchemas() {
+  const client = useFluxbaseClient();
+
+  return useQuery({
+    queryKey: ["fluxbase", "schemas"],
+    queryFn: async () => {
+      return await client.admin.ddl.listSchemas();
+    },
+  });
+}
+
+/**
+ * Hook to list tables, optionally filtered by schema
+ */
+export function useTables(schema?: string) {
+  const client = useFluxbaseClient();
+
+  return useQuery({
+    queryKey: ["fluxbase", "tables", schema],
+    queryFn: async () => {
+      return await client.admin.ddl.listTables(schema);
+    },
+  });
+}
+
+/**
+ * Hook to create a new database schema
+ */
+export function useCreateSchema() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (name: string) => {
+      return await client.admin.ddl.createSchema(name);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "schemas"],
+      });
+    },
+  });
+}
+
+/**
+ * Hook to delete a table from a schema
+ */
+export function useDeleteTable() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async ({ schema, name }: { schema: string; name: string }) => {
+      return await client.admin.ddl.deleteTable(schema, name);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "tables"],
+      });
+    },
+  });
+}

package/src/use-functions.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Tests for Functions hooks
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import { useInvokeFunction, useFunctions } from "./use-functions";
+import { createMockClient, createWrapper } from "./test-utils";
+
+describe("useInvokeFunction", () => {
+  it("should invoke a function", async () => {
+    const invoke = vi.fn().mockResolvedValue({
+      data: { result: "ok" },
+      error: null,
+    });
+    const client = createMockClient({
+      functions: { invoke } as any,
+    });
+
+    const { result } = renderHook(() => useInvokeFunction(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({ name: "hello", payload: { name: "World" } });
+    });
+
+    expect(invoke).toHaveBeenCalledWith("hello", { body: { name: "World" }, method: undefined });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      functions: {
+        invoke: vi.fn().mockResolvedValue({ data: null, error: new Error("Failed") }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useInvokeFunction(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({ name: "bad" });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe("useFunctions", () => {
+  it("should list functions", async () => {
+    const mockFunctions = [
+      { name: "hello", version: "1", namespace: "default" },
+      { name: "world", version: "2", namespace: "default" },
+    ];
+    const client = createMockClient({
+      functions: {
+        list: vi.fn().mockResolvedValue({ data: mockFunctions, error: null }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useFunctions(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockFunctions);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      functions: {
+        list: vi.fn().mockResolvedValue({ data: null, error: new Error("Failed") }),
+      } as any,
+    });
+
+    const { result } = renderHook(() => useFunctions(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});

package/src/use-functions.ts

@@ -1,4 +1,4 @@
-import { useMutation } from "@tanstack/react-query"
+import { useMutation, useQuery } from "@tanstack/react-query"
 import { useFluxbaseClient } from "./context"
 
 export function useInvokeFunction() {
@@ -11,3 +11,15 @@ export function useInvokeFunction() {
     },
   })
 }
+
+export function useFunctions() {
+  const client = useFluxbaseClient()
+  return useQuery({
+    queryKey: ["fluxbase", "functions"],
+    queryFn: async (): Promise<unknown> => {
+      const { data, error } = await client.functions.list()
+      if (error) throw error
+      return data
+    },
+  })
+}

package/src/use-impersonation.test.ts

@@ -0,0 +1,273 @@
+/**
+ * Tests for impersonation hooks
+ */
+
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import {
+  useImpersonationSessions,
+  useCurrentImpersonation,
+  useImpersonateUser,
+  useStopImpersonation,
+} from "./use-impersonation";
+import { createMockClient, createWrapper } from "./test-utils";
+
+describe("useImpersonationSessions", () => {
+  it("should list impersonation sessions", async () => {
+    const mockSessions = {
+      sessions: [
+        {
+          id: "s1",
+          admin_user_id: "admin-1",
+          target_user_id: "user-1",
+          impersonation_type: "user" as const,
+          target_role: "user",
+          reason: "Support",
+          started_at: "",
+          ended_at: null,
+          is_active: true,
+          ip_address: null,
+          user_agent: null,
+        },
+      ],
+      total: 1,
+    };
+    const client = createMockClient({
+      admin: {
+        impersonation: {
+          listSessions: vi.fn().mockResolvedValue(mockSessions),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useImpersonationSessions(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockSessions);
+  });
+
+  it("should pass options to listSessions", async () => {
+    const listSessions = vi.fn().mockResolvedValue({ sessions: [], total: 0 });
+    const client = createMockClient({
+      admin: { impersonation: { listSessions } } as any,
+    });
+
+    renderHook(() => useImpersonationSessions({ is_active: true }), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => {
+      expect(listSessions).toHaveBeenCalledWith({ is_active: true });
+    });
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      admin: {
+        impersonation: {
+          listSessions: vi.fn().mockRejectedValue(new Error("Failed")),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useImpersonationSessions(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});
+
+describe("useCurrentImpersonation", () => {
+  it("should get current impersonation session", async () => {
+    const mockCurrent = {
+      session: {
+        id: "s1",
+        admin_user_id: "admin-1",
+        target_user_id: "user-1",
+        impersonation_type: "user" as const,
+        target_role: "user",
+        reason: "Support",
+        started_at: "",
+        ended_at: null,
+        is_active: true,
+        ip_address: null,
+        user_agent: null,
+      },
+      target_user: { id: "user-1", email: "test@example.com", role: "user" },
+    };
+    const client = createMockClient({
+      admin: {
+        impersonation: {
+          getCurrent: vi.fn().mockResolvedValue(mockCurrent),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useCurrentImpersonation(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data).toEqual(mockCurrent);
+  });
+
+  it("should return null session when not impersonating", async () => {
+    const client = createMockClient({
+      admin: {
+        impersonation: {
+          getCurrent: vi.fn().mockResolvedValue({
+            session: null,
+            target_user: null,
+          }),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useCurrentImpersonation(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.data?.session).toBeNull();
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      admin: {
+        impersonation: {
+          getCurrent: vi.fn().mockRejectedValue(new Error("Failed")),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useCurrentImpersonation(), {
+      wrapper: createWrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeInstanceOf(Error);
+  });
+});
+
+describe("useImpersonateUser", () => {
+  it("should impersonate a user", async () => {
+    const mockResponse = {
+      session: {
+        id: "s1",
+        admin_user_id: "admin-1",
+        target_user_id: "user-1",
+        impersonation_type: "user" as const,
+        target_role: "user",
+        reason: "Support",
+        started_at: "",
+        ended_at: null,
+        is_active: true,
+        ip_address: null,
+        user_agent: null,
+      },
+      target_user: { id: "user-1", email: "test@example.com", role: "user" },
+      access_token: "token-123",
+      refresh_token: "refresh-123",
+      expires_in: 3600,
+    };
+    const impersonateUser = vi.fn().mockResolvedValue(mockResponse);
+    const client = createMockClient({
+      admin: { impersonation: { impersonateUser } } as any,
+    });
+
+    const { result } = renderHook(() => useImpersonateUser(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync({
+        target_user_id: "user-1",
+        reason: "Support ticket #1234",
+      });
+    });
+
+    expect(impersonateUser).toHaveBeenCalledWith({
+      target_user_id: "user-1",
+      reason: "Support ticket #1234",
+    });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockResponse);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      admin: {
+        impersonation: {
+          impersonateUser: vi.fn().mockRejectedValue(new Error("Not allowed")),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useImpersonateUser(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync({
+          target_user_id: "user-1",
+          reason: "test",
+        });
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe("useStopImpersonation", () => {
+  it("should stop impersonation", async () => {
+    const mockResponse = { success: true, message: "Impersonation stopped" };
+    const stop = vi.fn().mockResolvedValue(mockResponse);
+    const client = createMockClient({
+      admin: { impersonation: { stop } } as any,
+    });
+
+    const { result } = renderHook(() => useStopImpersonation(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      await result.current.mutateAsync();
+    });
+
+    expect(stop).toHaveBeenCalled();
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockResponse);
+  });
+
+  it("should handle errors", async () => {
+    const client = createMockClient({
+      admin: {
+        impersonation: {
+          stop: vi.fn().mockRejectedValue(new Error("No active session")),
+        },
+      } as any,
+    });
+
+    const { result } = renderHook(() => useStopImpersonation(), {
+      wrapper: createWrapper(client),
+    });
+
+    await act(async () => {
+      try {
+        await result.current.mutateAsync();
+      } catch {
+        // expected
+      }
+    });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});