@fluxbase/sdk-react 2026.1.22 → 2026.2.1

package/src/context.test.tsx

@@ -0,0 +1,147 @@
+/**
+ * Tests for FluxbaseProvider and useFluxbaseClient
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, renderHook } from '@testing-library/react';
+import React from 'react';
+import { FluxbaseProvider, useFluxbaseClient } from './context';
+import { createMockClient } from './test-utils';
+import type { FluxbaseClient } from '@fluxbase/sdk';
+
+describe('FluxbaseProvider', () => {
+  it('should render children', () => {
+    const client = createMockClient();
+    render(
+      <FluxbaseProvider client={client}>
+        <div data-testid="child">Hello</div>
+      </FluxbaseProvider>
+    );
+
+    expect(screen.getByTestId('child')).toHaveTextContent('Hello');
+  });
+
+  it('should provide client to children', () => {
+    const client = createMockClient();
+    let receivedClient: FluxbaseClient | null = null;
+
+    function TestComponent() {
+      receivedClient = useFluxbaseClient();
+      return null;
+    }
+
+    render(
+      <FluxbaseProvider client={client}>
+        <TestComponent />
+      </FluxbaseProvider>
+    );
+
+    expect(receivedClient).toBe(client);
+  });
+
+  it('should support nested children', () => {
+    const client = createMockClient();
+    render(
+      <FluxbaseProvider client={client}>
+        <div>
+          <span>
+            <p data-testid="nested">Nested content</p>
+          </span>
+        </div>
+      </FluxbaseProvider>
+    );
+
+    expect(screen.getByTestId('nested')).toHaveTextContent('Nested content');
+  });
+});
+
+describe('useFluxbaseClient', () => {
+  it('should return the client from context', () => {
+    const client = createMockClient();
+
+    const { result } = renderHook(() => useFluxbaseClient(), {
+      wrapper: ({ children }) => (
+        <FluxbaseProvider client={client}>{children}</FluxbaseProvider>
+      ),
+    });
+
+    expect(result.current).toBe(client);
+  });
+
+  it('should throw error when used outside provider', () => {
+    // Suppress console.error for this test
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    expect(() => {
+      renderHook(() => useFluxbaseClient());
+    }).toThrow('useFluxbaseClient must be used within a FluxbaseProvider');
+
+    consoleSpy.mockRestore();
+  });
+
+  it('should provide access to auth methods', () => {
+    const client = createMockClient();
+
+    const { result } = renderHook(() => useFluxbaseClient(), {
+      wrapper: ({ children }) => (
+        <FluxbaseProvider client={client}>{children}</FluxbaseProvider>
+      ),
+    });
+
+    expect(result.current.auth).toBeDefined();
+    expect(result.current.auth.getSession).toBeDefined();
+    expect(result.current.auth.signIn).toBeDefined();
+  });
+
+  it('should provide access to storage methods', () => {
+    const client = createMockClient();
+
+    const { result } = renderHook(() => useFluxbaseClient(), {
+      wrapper: ({ children }) => (
+        <FluxbaseProvider client={client}>{children}</FluxbaseProvider>
+      ),
+    });
+
+    expect(result.current.storage).toBeDefined();
+    expect(result.current.storage.from).toBeDefined();
+  });
+
+  it('should provide access to realtime methods', () => {
+    const client = createMockClient();
+
+    const { result } = renderHook(() => useFluxbaseClient(), {
+      wrapper: ({ children }) => (
+        <FluxbaseProvider client={client}>{children}</FluxbaseProvider>
+      ),
+    });
+
+    expect(result.current.realtime).toBeDefined();
+    expect(result.current.realtime.channel).toBeDefined();
+  });
+
+  it('should provide access to graphql methods', () => {
+    const client = createMockClient();
+
+    const { result } = renderHook(() => useFluxbaseClient(), {
+      wrapper: ({ children }) => (
+        <FluxbaseProvider client={client}>{children}</FluxbaseProvider>
+      ),
+    });
+
+    expect(result.current.graphql).toBeDefined();
+    expect(result.current.graphql.execute).toBeDefined();
+  });
+
+  it('should provide access to admin methods', () => {
+    const client = createMockClient();
+
+    const { result } = renderHook(() => useFluxbaseClient(), {
+      wrapper: ({ children }) => (
+        <FluxbaseProvider client={client}>{children}</FluxbaseProvider>
+      ),
+    });
+
+    expect(result.current.admin).toBeDefined();
+    expect(result.current.admin.me).toBeDefined();
+  });
+});

package/src/index.test.ts

@@ -0,0 +1,255 @@
+/**
+ * Tests for module exports
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as exports from './index';
+
+describe('Module Exports', () => {
+  describe('Context exports', () => {
+    it('should export FluxbaseProvider', () => {
+      expect(exports.FluxbaseProvider).toBeDefined();
+    });
+
+    it('should export useFluxbaseClient', () => {
+      expect(exports.useFluxbaseClient).toBeDefined();
+    });
+  });
+
+  describe('Auth hook exports', () => {
+    it('should export useAuth', () => {
+      expect(exports.useAuth).toBeDefined();
+    });
+
+    it('should export useUser', () => {
+      expect(exports.useUser).toBeDefined();
+    });
+
+    it('should export useSession', () => {
+      expect(exports.useSession).toBeDefined();
+    });
+
+    it('should export useSignIn', () => {
+      expect(exports.useSignIn).toBeDefined();
+    });
+
+    it('should export useSignUp', () => {
+      expect(exports.useSignUp).toBeDefined();
+    });
+
+    it('should export useSignOut', () => {
+      expect(exports.useSignOut).toBeDefined();
+    });
+
+    it('should export useUpdateUser', () => {
+      expect(exports.useUpdateUser).toBeDefined();
+    });
+  });
+
+  describe('CAPTCHA hook exports', () => {
+    it('should export useCaptchaConfig', () => {
+      expect(exports.useCaptchaConfig).toBeDefined();
+    });
+
+    it('should export useCaptcha', () => {
+      expect(exports.useCaptcha).toBeDefined();
+    });
+
+    it('should export isCaptchaRequiredForEndpoint', () => {
+      expect(exports.isCaptchaRequiredForEndpoint).toBeDefined();
+    });
+  });
+
+  describe('Auth config exports', () => {
+    it('should export useAuthConfig', () => {
+      expect(exports.useAuthConfig).toBeDefined();
+    });
+  });
+
+  describe('SAML hook exports', () => {
+    it('should export useSAMLProviders', () => {
+      expect(exports.useSAMLProviders).toBeDefined();
+    });
+
+    it('should export useGetSAMLLoginUrl', () => {
+      expect(exports.useGetSAMLLoginUrl).toBeDefined();
+    });
+
+    it('should export useSignInWithSAML', () => {
+      expect(exports.useSignInWithSAML).toBeDefined();
+    });
+
+    it('should export useHandleSAMLCallback', () => {
+      expect(exports.useHandleSAMLCallback).toBeDefined();
+    });
+
+    it('should export useSAMLMetadataUrl', () => {
+      expect(exports.useSAMLMetadataUrl).toBeDefined();
+    });
+  });
+
+  describe('GraphQL hook exports', () => {
+    it('should export useGraphQLQuery', () => {
+      expect(exports.useGraphQLQuery).toBeDefined();
+    });
+
+    it('should export useGraphQLMutation', () => {
+      expect(exports.useGraphQLMutation).toBeDefined();
+    });
+
+    it('should export useGraphQLIntrospection', () => {
+      expect(exports.useGraphQLIntrospection).toBeDefined();
+    });
+
+    it('should export useGraphQL', () => {
+      expect(exports.useGraphQL).toBeDefined();
+    });
+  });
+
+  describe('Database query hook exports', () => {
+    it('should export useFluxbaseQuery', () => {
+      expect(exports.useFluxbaseQuery).toBeDefined();
+    });
+
+    it('should export useTable', () => {
+      expect(exports.useTable).toBeDefined();
+    });
+
+    it('should export useInsert', () => {
+      expect(exports.useInsert).toBeDefined();
+    });
+
+    it('should export useUpdate', () => {
+      expect(exports.useUpdate).toBeDefined();
+    });
+
+    it('should export useUpsert', () => {
+      expect(exports.useUpsert).toBeDefined();
+    });
+
+    it('should export useDelete', () => {
+      expect(exports.useDelete).toBeDefined();
+    });
+  });
+
+  describe('Realtime hook exports', () => {
+    it('should export useRealtime', () => {
+      expect(exports.useRealtime).toBeDefined();
+    });
+
+    it('should export useTableSubscription', () => {
+      expect(exports.useTableSubscription).toBeDefined();
+    });
+
+    it('should export useTableInserts', () => {
+      expect(exports.useTableInserts).toBeDefined();
+    });
+
+    it('should export useTableUpdates', () => {
+      expect(exports.useTableUpdates).toBeDefined();
+    });
+
+    it('should export useTableDeletes', () => {
+      expect(exports.useTableDeletes).toBeDefined();
+    });
+  });
+
+  describe('Storage hook exports', () => {
+    it('should export useStorageList', () => {
+      expect(exports.useStorageList).toBeDefined();
+    });
+
+    it('should export useStorageUpload', () => {
+      expect(exports.useStorageUpload).toBeDefined();
+    });
+
+    it('should export useStorageUploadWithProgress', () => {
+      expect(exports.useStorageUploadWithProgress).toBeDefined();
+    });
+
+    it('should export useStorageDownload', () => {
+      expect(exports.useStorageDownload).toBeDefined();
+    });
+
+    it('should export useStorageDelete', () => {
+      expect(exports.useStorageDelete).toBeDefined();
+    });
+
+    it('should export useStoragePublicUrl', () => {
+      expect(exports.useStoragePublicUrl).toBeDefined();
+    });
+
+    it('should export useStorageTransformUrl', () => {
+      expect(exports.useStorageTransformUrl).toBeDefined();
+    });
+
+    it('should export useStorageSignedUrl', () => {
+      expect(exports.useStorageSignedUrl).toBeDefined();
+    });
+
+    it('should export useStorageSignedUrlWithOptions', () => {
+      expect(exports.useStorageSignedUrlWithOptions).toBeDefined();
+    });
+
+    it('should export useStorageMove', () => {
+      expect(exports.useStorageMove).toBeDefined();
+    });
+
+    it('should export useStorageCopy', () => {
+      expect(exports.useStorageCopy).toBeDefined();
+    });
+
+    it('should export useStorageBuckets', () => {
+      expect(exports.useStorageBuckets).toBeDefined();
+    });
+
+    it('should export useCreateBucket', () => {
+      expect(exports.useCreateBucket).toBeDefined();
+    });
+
+    it('should export useDeleteBucket', () => {
+      expect(exports.useDeleteBucket).toBeDefined();
+    });
+  });
+
+  describe('Admin hook exports', () => {
+    it('should export useAdminAuth', () => {
+      expect(exports.useAdminAuth).toBeDefined();
+    });
+
+    it('should export useUsers', () => {
+      expect(exports.useUsers).toBeDefined();
+    });
+
+    it('should export useClientKeys', () => {
+      expect(exports.useClientKeys).toBeDefined();
+    });
+
+    it('should export useAPIKeys (deprecated alias)', () => {
+      expect(exports.useAPIKeys).toBeDefined();
+      expect(exports.useAPIKeys).toBe(exports.useClientKeys);
+    });
+
+    it('should export useWebhooks', () => {
+      expect(exports.useWebhooks).toBeDefined();
+    });
+
+    it('should export useAppSettings', () => {
+      expect(exports.useAppSettings).toBeDefined();
+    });
+
+    it('should export useSystemSettings', () => {
+      expect(exports.useSystemSettings).toBeDefined();
+    });
+  });
+
+  describe('Total export count', () => {
+    it('should export the expected number of items', () => {
+      // Count the exports (functions and types are counted)
+      const exportKeys = Object.keys(exports);
+
+      // We expect at least 50 exports (hooks, types, etc.)
+      expect(exportKeys.length).toBeGreaterThanOrEqual(50);
+    });
+  });
+});

package/src/test-setup.ts

@@ -0,0 +1,22 @@
+/**
+ * Test setup file for Fluxbase React SDK
+ */
+
+import { vi } from 'vitest';
+import '@testing-library/react';
+import '@testing-library/jest-dom/vitest';
+
+// Mock window.location for tests that need it
+Object.defineProperty(window, 'location', {
+  value: {
+    href: 'http://localhost:3000',
+    origin: 'http://localhost:3000',
+    pathname: '/',
+    search: '',
+    hash: '',
+    assign: vi.fn(),
+    replace: vi.fn(),
+    reload: vi.fn(),
+  },
+  writable: true,
+});

package/src/test-utils.tsx

@@ -0,0 +1,215 @@
+/**
+ * Test utilities for Fluxbase React SDK
+ */
+
+import React, { ReactElement } from "react";
+import { render, RenderOptions } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { FluxbaseProvider } from "./context";
+import type { FluxbaseClient } from "@fluxbase/sdk";
+import { vi } from "vitest";
+
+/**
+ * Create a mock FluxbaseClient for testing
+ */
+export function createMockClient(
+  overrides: Partial<FluxbaseClient> = {},
+): FluxbaseClient {
+  return {
+    auth: {
+      getSession: vi.fn().mockResolvedValue({ data: null, error: null }),
+      getCurrentUser: vi.fn().mockResolvedValue({ data: null, error: null }),
+      signIn: vi.fn().mockResolvedValue({ user: null, session: null }),
+      signUp: vi.fn().mockResolvedValue({ data: null, error: null }),
+      signOut: vi.fn().mockResolvedValue(undefined),
+      updateUser: vi
+        .fn()
+        .mockResolvedValue({ id: "1", email: "test@example.com" }),
+      getAuthConfig: vi.fn().mockResolvedValue({ data: {}, error: null }),
+      getCaptchaConfig: vi.fn().mockResolvedValue({ data: {}, error: null }),
+      getSAMLProviders: vi
+        .fn()
+        .mockResolvedValue({ data: { providers: [] }, error: null }),
+      getSAMLLoginUrl: vi
+        .fn()
+        .mockResolvedValue({ data: { url: "" }, error: null }),
+      signInWithSAML: vi.fn().mockResolvedValue({ data: null, error: null }),
+      handleSAMLCallback: vi
+        .fn()
+        .mockResolvedValue({ data: null, error: null }),
+      getSAMLMetadataUrl: vi
+        .fn()
+        .mockReturnValue("http://localhost/saml/metadata"),
+      ...overrides.auth,
+    },
+    from: vi.fn().mockReturnValue({
+      select: vi.fn().mockReturnThis(),
+      insert: vi.fn().mockResolvedValue({ data: null, error: null }),
+      update: vi.fn().mockResolvedValue({ data: null, error: null }),
+      upsert: vi.fn().mockResolvedValue({ data: null, error: null }),
+      delete: vi.fn().mockResolvedValue({ data: null, error: null }),
+      execute: vi.fn().mockResolvedValue({ data: [], error: null }),
+      eq: vi.fn().mockReturnThis(),
+    }),
+    storage: {
+      from: vi.fn().mockReturnValue({
+        list: vi.fn().mockResolvedValue({ data: [], error: null }),
+        upload: vi
+          .fn()
+          .mockResolvedValue({ data: { path: "test.txt" }, error: null }),
+        download: vi.fn().mockResolvedValue({ data: new Blob(), error: null }),
+        remove: vi.fn().mockResolvedValue({ data: null, error: null }),
+        getPublicUrl: vi
+          .fn()
+          .mockReturnValue({ data: { publicUrl: "http://localhost/file" } }),
+        getTransformUrl: vi
+          .fn()
+          .mockReturnValue("http://localhost/transform/file"),
+        createSignedUrl: vi
+          .fn()
+          .mockResolvedValue({
+            data: { signedUrl: "http://localhost/signed" },
+            error: null,
+          }),
+        move: vi
+          .fn()
+          .mockResolvedValue({ data: { path: "new.txt" }, error: null }),
+        copy: vi
+          .fn()
+          .mockResolvedValue({ data: { path: "copy.txt" }, error: null }),
+      }),
+      listBuckets: vi.fn().mockResolvedValue({ data: [], error: null }),
+      createBucket: vi.fn().mockResolvedValue({ error: null }),
+      deleteBucket: vi.fn().mockResolvedValue({ error: null }),
+      ...overrides.storage,
+    },
+    realtime: {
+      channel: vi.fn().mockReturnValue({
+        on: vi.fn().mockReturnThis(),
+        subscribe: vi.fn().mockReturnThis(),
+        unsubscribe: vi.fn(),
+      }),
+      ...overrides.realtime,
+    },
+    graphql: {
+      execute: vi.fn().mockResolvedValue({ data: null, errors: null }),
+      query: vi.fn().mockResolvedValue({ data: null, errors: null }),
+      mutation: vi.fn().mockResolvedValue({ data: null, errors: null }),
+      introspect: vi
+        .fn()
+        .mockResolvedValue({ data: { __schema: {} }, errors: null }),
+      ...overrides.graphql,
+    },
+    admin: {
+      me: vi.fn().mockResolvedValue({ data: null, error: null }),
+      login: vi.fn().mockResolvedValue({ data: null, error: null }),
+      listUsers: vi
+        .fn()
+        .mockResolvedValue({ data: { users: [], total: 0 }, error: null }),
+      inviteUser: vi.fn().mockResolvedValue({ data: null, error: null }),
+      updateUserRole: vi.fn().mockResolvedValue({ data: null, error: null }),
+      deleteUser: vi.fn().mockResolvedValue({ data: null, error: null }),
+      resetUserPassword: vi
+        .fn()
+        .mockResolvedValue({
+          data: { message: "Password reset" },
+          error: null,
+        }),
+      settings: {
+        app: {
+          get: vi.fn().mockResolvedValue({}),
+          update: vi.fn().mockResolvedValue({}),
+        },
+        system: {
+          list: vi.fn().mockResolvedValue({ settings: [] }),
+          update: vi.fn().mockResolvedValue({}),
+          delete: vi.fn().mockResolvedValue({}),
+        },
+      },
+      management: {
+        clientKeys: {
+          list: vi.fn().mockResolvedValue({ client_keys: [] }),
+          create: vi.fn().mockResolvedValue({ key: "new-key", client_key: {} }),
+          update: vi.fn().mockResolvedValue({}),
+          revoke: vi.fn().mockResolvedValue({}),
+          delete: vi.fn().mockResolvedValue({}),
+        },
+        webhooks: {
+          list: vi.fn().mockResolvedValue({ webhooks: [] }),
+          create: vi.fn().mockResolvedValue({}),
+          update: vi.fn().mockResolvedValue({}),
+          delete: vi.fn().mockResolvedValue({}),
+          test: vi.fn().mockResolvedValue({}),
+        },
+      },
+      ...overrides.admin,
+    },
+    ...overrides,
+  } as unknown as FluxbaseClient;
+}
+
+/**
+ * Create a fresh QueryClient for testing
+ */
+export function createTestQueryClient(): QueryClient {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+        gcTime: 0,
+      },
+      mutations: {
+        retry: false,
+      },
+    },
+  });
+}
+
+interface WrapperProps {
+  children: React.ReactNode;
+}
+
+/**
+ * Create a wrapper component with all providers
+ */
+export function createWrapper(
+  client: FluxbaseClient,
+  queryClient?: QueryClient,
+) {
+  const qc = queryClient || createTestQueryClient();
+
+  return function Wrapper({ children }: WrapperProps) {
+    return (
+      <QueryClientProvider client={qc}>
+        <FluxbaseProvider client={client}>{children}</FluxbaseProvider>
+      </QueryClientProvider>
+    );
+  };
+}
+
+/**
+ * Custom render function that includes all providers
+ */
+export function renderWithProviders(
+  ui: ReactElement,
+  options?: Omit<RenderOptions, "wrapper"> & {
+    client?: FluxbaseClient;
+    queryClient?: QueryClient;
+  },
+) {
+  const {
+    client = createMockClient(),
+    queryClient,
+    ...renderOptions
+  } = options || {};
+  const wrapper = createWrapper(client, queryClient);
+
+  return {
+    ...render(ui, { wrapper, ...renderOptions }),
+    client,
+    queryClient: queryClient || createTestQueryClient(),
+  };
+}
+
+// Re-export testing library utilities
+export * from "@testing-library/react";