@object-ui/react 0.3.1 → 2.0.0

package/src/context/__tests__/ActionContext.test.tsx

@@ -0,0 +1,174 @@
+/**
+ * Tests for ActionContext — ActionProvider, useAction, useHasActionProvider
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook, waitFor, act } from '@testing-library/react';
+import React from 'react';
+import { ActionProvider, useAction, useHasActionProvider } from '../ActionContext';
+
+describe('ActionContext', () => {
+  describe('useAction without ActionProvider', () => {
+    it('falls back to local ActionRunner with default state', () => {
+      const { result } = renderHook(() => useAction());
+
+      expect(result.current.loading).toBe(false);
+      expect(result.current.error).toBeNull();
+      expect(result.current.result).toBeNull();
+      expect(typeof result.current.execute).toBe('function');
+      expect(typeof result.current.executeChain).toBe('function');
+      expect(typeof result.current.updateContext).toBe('function');
+      expect(result.current.runner).toBeDefined();
+    });
+  });
+
+  describe('useHasActionProvider', () => {
+    it('returns false without provider', () => {
+      const { result } = renderHook(() => useHasActionProvider());
+
+      expect(result.current).toBe(false);
+    });
+
+    it('returns true with provider', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) =>
+        React.createElement(ActionProvider, { context: {} }, children);
+
+      const { result } = renderHook(() => useHasActionProvider(), { wrapper });
+
+      expect(result.current).toBe(true);
+    });
+  });
+
+  describe('ActionProvider basic', () => {
+    it('children can access execute function', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) =>
+        React.createElement(ActionProvider, { context: {} }, children);
+
+      const { result } = renderHook(() => useAction(), { wrapper });
+
+      expect(typeof result.current.execute).toBe('function');
+      expect(typeof result.current.executeChain).toBe('function');
+      expect(typeof result.current.updateContext).toBe('function');
+      expect(result.current.loading).toBe(false);
+      expect(result.current.error).toBeNull();
+      expect(result.current.result).toBeNull();
+    });
+  });
+
+  describe('ActionProvider execute', () => {
+    it('executes a toast action and returns result', async () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) =>
+        React.createElement(ActionProvider, { context: {} }, children);
+
+      const { result } = renderHook(() => useAction(), { wrapper });
+
+      let actionResult: any;
+      await act(async () => {
+        actionResult = await result.current.execute({
+          type: 'script',
+          execute: 'true',
+          toast: { showOnSuccess: true },
+          successMessage: 'Done!',
+        });
+      });
+
+      expect(actionResult.success).toBe(true);
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect(result.current.result).toEqual(actionResult);
+      expect(result.current.error).toBeNull();
+    });
+  });
+
+  describe('ActionProvider execute error', () => {
+    it('executes an action that fails and sets error state', async () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) =>
+        React.createElement(ActionProvider, { context: {} }, children);
+
+      const { result } = renderHook(() => useAction(), { wrapper });
+
+      let actionResult: any;
+      await act(async () => {
+        actionResult = await result.current.execute({
+          onClick: vi.fn().mockRejectedValue(new Error('boom')),
+        });
+      });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect(actionResult.success).toBe(false);
+      expect(result.current.error).toBeTruthy();
+      expect(result.current.result?.success).toBe(false);
+    });
+  });
+
+  describe('ActionProvider executeChain', () => {
+    it('executes a chain of actions', async () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) =>
+        React.createElement(ActionProvider, { context: {} }, children);
+
+      const { result } = renderHook(() => useAction(), { wrapper });
+
+      let chainResult: any;
+      await act(async () => {
+        chainResult = await result.current.executeChain([
+          { type: 'script', execute: 'true' },
+          { type: 'script', execute: 'true' },
+        ]);
+      });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      expect(chainResult.success).toBe(true);
+      expect(result.current.result).toEqual(chainResult);
+      expect(result.current.error).toBeNull();
+    });
+  });
+
+  describe('ActionProvider updateContext', () => {
+    it('updateContext is callable', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) =>
+        React.createElement(ActionProvider, { context: {} }, children);
+
+      const { result } = renderHook(() => useAction(), { wrapper });
+
+      expect(() => {
+        result.current.updateContext({ record: { id: 1 } });
+      }).not.toThrow();
+    });
+  });
+
+  describe('ActionProvider with handlers', () => {
+    it('invokes onToast handler when a toast action is executed', async () => {
+      const onToast = vi.fn();
+      const onNavigate = vi.fn();
+
+      const wrapper = ({ children }: { children: React.ReactNode }) =>
+        React.createElement(
+          ActionProvider,
+          { context: {}, onToast, onNavigate },
+          children,
+        );
+
+      const { result } = renderHook(() => useAction(), { wrapper });
+
+      await act(async () => {
+        await result.current.execute({
+          type: 'script',
+          execute: 'true',
+          toast: { showOnSuccess: true },
+          successMessage: 'Saved!',
+        });
+      });
+
+      expect(onToast).toHaveBeenCalledWith('Saved!', expect.objectContaining({ type: 'success' }));
+    });
+  });
+});

package/src/context/index.ts

@@ -7,3 +7,5 @@
  */
 
 export * from './SchemaRendererContext';
+export * from './ActionContext';
+export * from './ThemeContext';

package/src/hooks/__tests__/useActionRunner.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Tests for useActionRunner hook
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { useActionRunner } from '../useActionRunner';
+
+describe('useActionRunner', () => {
+  it('returns initial state with loading=false, error=null, result=null', () => {
+    const { result } = renderHook(() => useActionRunner());
+
+    expect(result.current.loading).toBe(false);
+    expect(result.current.error).toBeNull();
+    expect(result.current.result).toBeNull();
+  });
+
+  it('exposes runner, execute, and updateContext', () => {
+    const { result } = renderHook(() => useActionRunner());
+
+    expect(result.current.runner).toBeDefined();
+    expect(typeof result.current.execute).toBe('function');
+    expect(typeof result.current.updateContext).toBe('function');
+  });
+
+  it('handles options with context key format', () => {
+    const { result } = renderHook(() =>
+      useActionRunner({ context: { data: { name: 'test' } } }),
+    );
+
+    expect(result.current.runner).toBeDefined();
+    expect(result.current.loading).toBe(false);
+  });
+
+  it('handles plain context object format (backwards compat)', () => {
+    const { result } = renderHook(() =>
+      useActionRunner({ data: { name: 'test' } }),
+    );
+
+    expect(result.current.runner).toBeDefined();
+    expect(result.current.loading).toBe(false);
+  });
+
+  it('sets loading=true during execution and loading=false after', async () => {
+    let resolveAction: () => void;
+    const pendingAction = new Promise<void>((resolve) => {
+      resolveAction = resolve;
+    });
+
+    const { result } = renderHook(() => useActionRunner());
+
+    let executePromise: Promise<unknown>;
+    act(() => {
+      executePromise = result.current.execute({
+        onClick: () => pendingAction,
+      });
+    });
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(true);
+    });
+
+    await act(async () => {
+      resolveAction!();
+      await executePromise;
+    });
+
+    expect(result.current.loading).toBe(false);
+  });
+
+  it('sets result on successful action execution', async () => {
+    const onNavigate = vi.fn();
+    const { result } = renderHook(() =>
+      useActionRunner({ context: {}, onNavigate }),
+    );
+
+    await act(async () => {
+      await result.current.execute({
+        type: 'navigation',
+        navigate: { to: '/dashboard' },
+      });
+    });
+
+    expect(result.current.result).toEqual({ success: true });
+    expect(result.current.error).toBeNull();
+    expect(result.current.loading).toBe(false);
+    expect(onNavigate).toHaveBeenCalledWith(
+      '/dashboard',
+      expect.objectContaining({ external: false }),
+    );
+  });
+
+  it('sets error on failed action execution (catch path)', async () => {
+    const { result } = renderHook(() => useActionRunner());
+
+    await act(async () => {
+      await result.current.execute({
+        onClick: () => {
+          throw new Error('Something went wrong');
+        },
+      });
+    });
+
+    expect(result.current.error).toBe('Something went wrong');
+    expect(result.current.result).toEqual({
+      success: false,
+      error: 'Something went wrong',
+    });
+    expect(result.current.loading).toBe(false);
+  });
+
+  it('updateContext calls runner.updateContext', () => {
+    const { result } = renderHook(() => useActionRunner());
+
+    const spy = vi.spyOn(result.current.runner, 'updateContext');
+
+    act(() => {
+      result.current.updateContext({ data: { id: 42 } });
+    });
+
+    expect(spy).toHaveBeenCalledWith({ data: { id: 42 } });
+  });
+
+  it('accepts handler options (onToast, onNavigate, etc.)', async () => {
+    const onToast = vi.fn();
+    const onNavigate = vi.fn();
+
+    const { result } = renderHook(() =>
+      useActionRunner({
+        context: {},
+        onToast,
+        onNavigate,
+      }),
+    );
+
+    await act(async () => {
+      await result.current.execute({
+        type: 'navigation',
+        navigate: { to: '/settings' },
+        successMessage: 'Navigated!',
+      });
+    });
+
+    expect(onNavigate).toHaveBeenCalledWith(
+      '/settings',
+      expect.objectContaining({ external: false }),
+    );
+    expect(onToast).toHaveBeenCalledWith(
+      'Navigated!',
+      expect.objectContaining({ type: 'success' }),
+    );
+  });
+});

package/src/hooks/__tests__/useDiscovery.test.tsx

@@ -0,0 +1,149 @@
+/**
+ * Tests for useDiscovery hook
+ */
+
+import React from 'react';
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { useDiscovery } from '../useDiscovery';
+import { SchemaRendererContext } from '../../context/SchemaRendererContext';
+
+function createWrapper(dataSource: any) {
+  return ({ children }: { children: React.ReactNode }) =>
+    React.createElement(
+      SchemaRendererContext.Provider,
+      { value: { dataSource } },
+      children,
+    );
+}
+
+describe('useDiscovery', () => {
+  it('returns isLoading false and null discovery when no context is provided', async () => {
+    const { result } = renderHook(() => useDiscovery());
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.discovery).toBeNull();
+    expect(result.current.error).toBeNull();
+  });
+
+  it('returns isLoading false and null discovery when dataSource has no getDiscovery method', async () => {
+    const dataSource = { someOtherMethod: vi.fn() };
+
+    const { result } = renderHook(() => useDiscovery(), {
+      wrapper: createWrapper(dataSource),
+    });
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.discovery).toBeNull();
+    expect(result.current.error).toBeNull();
+  });
+
+  it('successfully fetches discovery data from dataSource.getDiscovery()', async () => {
+    const discoveryData = {
+      name: 'test-server',
+      version: '1.0.0',
+      services: {
+        auth: { enabled: true, status: 'available' as const },
+        data: { enabled: true, status: 'available' as const },
+      },
+    };
+
+    const dataSource = {
+      getDiscovery: vi.fn().mockResolvedValue(discoveryData),
+    };
+
+    const { result } = renderHook(() => useDiscovery(), {
+      wrapper: createWrapper(dataSource),
+    });
+
+    expect(result.current.isLoading).toBe(true);
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.discovery).toEqual(discoveryData);
+    expect(result.current.error).toBeNull();
+    expect(dataSource.getDiscovery).toHaveBeenCalled();
+  });
+
+  it('handles errors from getDiscovery gracefully', async () => {
+    const dataSource = {
+      getDiscovery: vi.fn().mockRejectedValue(new Error('Network error')),
+    };
+
+    const { result } = renderHook(() => useDiscovery(), {
+      wrapper: createWrapper(dataSource),
+    });
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.discovery).toBeNull();
+    expect(result.current.error?.message).toBe('Network error');
+  });
+
+  it('isAuthEnabled defaults to true when no discovery', async () => {
+    const { result } = renderHook(() => useDiscovery());
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.isAuthEnabled).toBe(true);
+  });
+
+  it('isAuthEnabled reflects the auth service enabled state', async () => {
+    const discoveryData = {
+      services: {
+        auth: { enabled: false },
+      },
+    };
+
+    const dataSource = {
+      getDiscovery: vi.fn().mockResolvedValue(discoveryData),
+    };
+
+    const { result } = renderHook(() => useDiscovery(), {
+      wrapper: createWrapper(dataSource),
+    });
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.isAuthEnabled).toBe(false);
+  });
+
+  it('cleans up on unmount (cancelled flag)', async () => {
+    let resolveDiscovery: (value: any) => void;
+    const discoveryPromise = new Promise((resolve) => {
+      resolveDiscovery = resolve;
+    });
+
+    const dataSource = {
+      getDiscovery: vi.fn().mockReturnValue(discoveryPromise),
+    };
+
+    const { result, unmount } = renderHook(() => useDiscovery(), {
+      wrapper: createWrapper(dataSource),
+    });
+
+    expect(result.current.isLoading).toBe(true);
+
+    unmount();
+
+    // Resolve after unmount — state should not update
+    resolveDiscovery!({ name: 'late-response' });
+
+    // Discovery should remain null since the component was unmounted
+    expect(result.current.discovery).toBeNull();
+  });
+});

package/src/hooks/__tests__/useDynamicApp.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Tests for useDynamicApp hook
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { useDynamicApp } from '../useDynamicApp';
+
+describe('useDynamicApp', () => {
+  const staticConfig = {
+    name: 'crm',
+    label: 'CRM App',
+    objects: ['contact', 'account'],
+  };
+
+  it('returns static config when no adapter is provided', () => {
+    const { result } = renderHook(() =>
+      useDynamicApp({ appId: 'crm', staticConfig }),
+    );
+
+    expect(result.current.config).toEqual(staticConfig);
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.isServerConfig).toBe(false);
+  });
+
+  it('returns null config when neither adapter nor static config provided', () => {
+    const { result } = renderHook(() =>
+      useDynamicApp({ appId: 'crm' }),
+    );
+
+    expect(result.current.config).toBeNull();
+    expect(result.current.isLoading).toBe(false);
+  });
+
+  it('loads config from server adapter', async () => {
+    const serverConfig = { name: 'crm', label: 'CRM (Server)', objects: ['contact'] };
+    const adapter = {
+      getApp: vi.fn().mockResolvedValue(serverConfig),
+    };
+
+    const { result } = renderHook(() =>
+      useDynamicApp({ appId: 'crm', staticConfig, adapter }),
+    );
+
+    // Initially loading
+    expect(result.current.isLoading).toBe(true);
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.config).toEqual(serverConfig);
+    expect(result.current.isServerConfig).toBe(true);
+    expect(adapter.getApp).toHaveBeenCalledWith('crm');
+  });
+
+  it('falls back to static config when server returns null', async () => {
+    const adapter = {
+      getApp: vi.fn().mockResolvedValue(null),
+    };
+
+    const { result } = renderHook(() =>
+      useDynamicApp({ appId: 'crm', staticConfig, adapter }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.config).toEqual(staticConfig);
+    expect(result.current.isServerConfig).toBe(false);
+  });
+
+  it('falls back to static config on server error', async () => {
+    const adapter = {
+      getApp: vi.fn().mockRejectedValue(new Error('Network error')),
+    };
+
+    const { result } = renderHook(() =>
+      useDynamicApp({ appId: 'crm', staticConfig, adapter }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.config).toEqual(staticConfig);
+    expect(result.current.isServerConfig).toBe(false);
+    expect(result.current.error?.message).toBe('Network error');
+  });
+
+  it('skips loading when enabled is false', () => {
+    const adapter = {
+      getApp: vi.fn(),
+    };
+
+    const { result } = renderHook(() =>
+      useDynamicApp({ appId: 'crm', staticConfig, adapter, enabled: false }),
+    );
+
+    expect(result.current.config).toEqual(staticConfig);
+    expect(result.current.isLoading).toBe(false);
+    expect(adapter.getApp).not.toHaveBeenCalled();
+  });
+
+  it('refresh invalidates cache and re-fetches', async () => {
+    let callCount = 0;
+    const adapter = {
+      getApp: vi.fn().mockImplementation(async () => {
+        callCount++;
+        return { name: 'crm', version: callCount };
+      }),
+      invalidateCache: vi.fn(),
+    };
+
+    const { result } = renderHook(() =>
+      useDynamicApp({ appId: 'crm', adapter }),
+    );
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect((result.current.config as any).version).toBe(1);
+
+    await act(async () => {
+      await result.current.refresh();
+    });
+
+    expect(adapter.invalidateCache).toHaveBeenCalledWith('app:crm');
+    expect((result.current.config as any).version).toBe(2);
+  });
+
+  it('reloads when appId changes', async () => {
+    const adapter = {
+      getApp: vi.fn().mockImplementation(async (appId: string) => {
+        return { name: appId };
+      }),
+    };
+
+    const { result, rerender } = renderHook(
+      ({ appId }: { appId: string }) =>
+        useDynamicApp({ appId, adapter }),
+      { initialProps: { appId: 'crm' } },
+    );
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect((result.current.config as any).name).toBe('crm');
+
+    rerender({ appId: 'erp' });
+
+    await waitFor(() => {
+      expect((result.current.config as any).name).toBe('erp');
+    });
+
+    expect(adapter.getApp).toHaveBeenCalledWith('erp');
+  });
+});