@svadmin/core 0.25.2 → 0.25.4

package/src/permissions.test.ts

@@ -1,136 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import type { CanParams, CanResult, Action, AccessControlProvider } from './permissions.svelte';
-
-describe('permissions', () => {
-  test('canAccessAsync respects deny rule', async () => {
-    const provider: AccessControlProvider = {
-      can: async (p) => {
-        const { action } = p as CanParams;
-        if (action === 'delete') return { can: false, reason: 'Denied' };
-        return { can: true };
-      },
-    };
-    expect(await provider.can({ resource: 'posts', action: 'delete' })).toEqual({ can: false, reason: 'Denied' });
-    expect((await provider.can({ resource: 'posts', action: 'list' })) as CanResult).toEqual({ can: true });
-  });
-
-  test('canAccessAsync resolves with allowed status', async () => {
-    const provider: AccessControlProvider = {
-      can: async (params) => {
-        expect((params as CanParams).params?.published).toBe(true);
-        return { can: true };
-      },
-    };
-    const result = await provider.can({ resource: 'posts', action: 'edit', params: { published: true } });
-    expect((result as CanResult).can).toBe(true);
-  });
-
-  test('canAccessAsync resolves with denied status', async () => {
-    const provider: AccessControlProvider = {
-      can: async () => ({ can: false, reason: 'No permission' }),
-    };
-    const result = await provider.can({ resource: 'users', action: 'delete' });
-    expect((result as CanResult).can).toBe(false);
-    expect((result as CanResult).reason).toBe('No permission');
-  });
-
-  test('resource-specific rules', async () => {
-    const provider: AccessControlProvider = {
-      can: async (p) => {
-        const { resource, action } = p as CanParams;
-        if (resource === 'users' && action === 'delete') return { can: false, reason: 'Cannot delete users' };
-        return { can: true };
-      },
-    };
-    expect((await provider.can({ resource: 'users', action: 'delete' }) as CanResult).can).toBe(false);
-    expect((await provider.can({ resource: 'users', action: 'list' }) as CanResult).can).toBe(true);
-    expect((await provider.can({ resource: 'posts', action: 'delete' }) as CanResult).can).toBe(true);
-  });
-
-  test('params.id is passed through', async () => {
-    const provider: AccessControlProvider = {
-      can: async (p) => {
-        const { params } = p as CanParams;
-        if (params?.id === 42) return { can: false, reason: 'Record locked' };
-        return { can: true };
-      },
-    };
-    const result = await provider.can({ resource: 'posts', action: 'edit', params: { id: 42 } });
-    expect((result as CanResult).can).toBe(false);
-    expect((result as CanResult).reason).toBe('Record locked');
-  });
-
-  test('extended action types work', async () => {
-    const provider: AccessControlProvider = {
-      can: async (p) => {
-        const { action } = p as CanParams;
-        if (action === 'show') return { can: false, reason: 'No show' };
-        if (action === 'field') return { can: false, reason: 'No field' };
-        return { can: true };
-      },
-    };
-    expect(((await provider.can({ resource: 'posts', action: 'show' })) as CanResult).can).toBe(false);
-    expect(((await provider.can({ resource: 'posts', action: 'field' })) as CanResult).can).toBe(false);
-    expect(((await provider.can({ resource: 'posts', action: 'list' })) as CanResult).can).toBe(true);
-  });
-
-  test('getAccessControlOptions returns provider options', () => {
-    const provider: AccessControlProvider = {
-      can: async () => ({ can: true }),
-      options: {
-        buttons: { enableAccessControl: true, hideIfUnauthorized: true },
-      },
-    };
-    expect(provider.options?.buttons?.enableAccessControl).toBe(true);
-    expect(provider.options?.buttons?.hideIfUnauthorized).toBe(true);
-  });
-
-  test('getAccessControlOptions returns {} when no options', () => {
-    const provider: AccessControlProvider = {
-      can: async () => ({ can: true }),
-    };
-    expect(provider.options).toBeUndefined();
-  });
-});
-
-describe('CASL adapter', () => {
-  test('createCaslAccessControl works', async () => {
-    const { createCaslAccessControl } = await import('./adapters/casl');
-
-    const ability = {
-      can: (action: string, subject: string) => !(action === 'delete' && subject === 'users'),
-      cannot: (action: string, subject: string) => action === 'delete' && subject === 'users',
-    };
-
-    const provider = createCaslAccessControl(ability);
-
-    const allowed = await provider.can({ resource: 'posts', action: 'edit' }) as CanResult;
-    expect(allowed.can).toBe(true);
-
-    const denied = await provider.can({ resource: 'users', action: 'delete' }) as CanResult;
-    expect(denied.can).toBe(false);
-    expect(denied.reason).toContain('Cannot "delete" on "users"');
-  });
-});
-
-describe('Casbin adapter', () => {
-  test('createCasbinAccessControl works', async () => {
-    const { createCasbinAccessControl } = await import('./adapters/casbin');
-
-    const enforcer = {
-      enforce: async (sub: string, obj: string, act: string) =>
-        !(sub === 'alice' && obj === 'users' && act === 'delete'),
-    };
-
-    const provider = createCasbinAccessControl(enforcer, {
-      getUser: () => 'alice',
-    });
-
-    const allowed = await provider.can({ resource: 'posts', action: 'edit' }) as CanResult;
-    expect(allowed.can).toBe(true);
-
-    const denied = await provider.can({ resource: 'users', action: 'delete' }) as CanResult;
-    expect(denied.can).toBe(false);
-    expect(denied.reason).toContain('alice');
-  });
-});

package/src/query-hooks.test.svelte.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { useList, useOne } from './query-hooks.svelte';
-import { flushSync } from 'svelte';
-import { QueryClient } from '@tanstack/svelte-query';
-
-vi.mock('./context.svelte', () => ({
-  useDataProvider: () => ({
-    getOne: vi.fn(),
-    getList: vi.fn()
-  }),
-  useResource: () => ({ name: 'posts' }),
-  getResource: (name: string) => ({ name, primaryKey: 'id' }),
-  useRouterContext: () => ({ navigate: vi.fn() }),
-  useTranslate: () => (key: string) => key,
-  useNotification: () => ({ open: vi.fn(), close: vi.fn() }),
-  getLiveProvider: () => undefined
-}));
-
-vi.mock('@tanstack/svelte-query', async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual as any,
-    useQueryClient: () => new QueryClient(),
-    createQuery: () => ({
-      data: { data: [{ id: 1, title: 'One' }], title: 'One' }, // Unified mock to please both array and direct object assertions
-      isPending: false,
-      isFetching: false,
-      error: null
-    })
-  };
-});
-
-describe('useList & useOne - Headless Svelte 5 Compatibility', () => {
-
-  it('safely binds useList query state without headless Svelte destruction', () => {
-    let listQuery: ReturnType<typeof useList>;
-    
-    const cleanup = $effect.root(() => {
-        listQuery = useList({ resource: 'posts' });
-    });
-
-    flushSync();
-    
-    expect(listQuery!.data).toBeDefined();
-    expect(listQuery!.data!.data[0].title).toBe('One');
-    expect(listQuery!.isPending).toBe(false);
-
-    cleanup();
-  });
-
-  it('safely binds useOne query state without headless component mounting', () => {
-    let oneQuery: ReturnType<typeof useOne>;
-    
-    const cleanup = $effect.root(() => {
-        oneQuery = useOne({ resource: 'posts', id: 1 });
-    });
-
-    flushSync();
-    
-    expect(oneQuery!.data).toBeDefined();
-    expect((oneQuery!.data!.data as any).title).toBe('One');
-
-    cleanup();
-  });
-});

package/src/reactive-hooks.test.svelte.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { useThemedLayoutContext } from './hooks.svelte';
-
-describe('Svelte 5 Reactive Runes Compatibility', () => {
-
-  it('verifies that sidebarCollapsed is correctly synchronized out of component lifecycle', () => {
-    let observedValue = false;
-    let layout: ReturnType<typeof useThemedLayoutContext>;
-    
-    const cleanup = $effect.root(() => {
-        layout = useThemedLayoutContext();
-        
-        $effect(() => {
-           observedValue = layout.sidebarCollapsed;
-        });
-    });
-
-    expect(observedValue).toBe(false);
-
-    layout!.toggleSidebar();
-
-    expect(layout!.sidebarCollapsed).toBe(true);
-
-    cleanup();
-  });
-});

package/src/resource-types.test.ts

@@ -1,79 +0,0 @@
-// Resource Type Registry — type-level tests
-import { describe, test, expect } from 'bun:test';
-import type { ResourceTypeMap, KnownResources, InferData } from './types';
-
-describe('Resource Type Registry', () => {
-  test('ResourceTypeMap is an empty interface by default', () => {
-    // When no declaration merging is used, keyof ResourceTypeMap = never
-    type Keys = keyof ResourceTypeMap;
-    // This compiles — verifying the interface exists and is empty
-    const _check: Keys extends never ? true : false = true;
-    expect(_check).toBe(true);
-  });
-
-  test('KnownResources falls back to string when ResourceTypeMap is empty', () => {
-    // When ResourceTypeMap is empty, KnownResources should be string
-    const resource: KnownResources = 'anything';
-    expect(typeof resource).toBe('string');
-  });
-
-  test('InferData falls back to Record<string, unknown> for unknown resources', () => {
-    // For any resource not in ResourceTypeMap, InferData should return Record<string, unknown>
-    type Result = InferData<'nonexistent'>;
-    const data: Result = { arbitrary: 'value', number: 42 };
-    expect(data.arbitrary).toBe('value');
-  });
-
-  test('type utilities are structurally sound', () => {
-    // Simulate what happens with declaration merging by testing the conditional types
-    // When R extends keyof ResourceTypeMap (which is never when empty),
-    // InferData should return Record<string, unknown>
-    type TestInfer = InferData<'users'>;
-    const obj: TestInfer = { id: '1', name: 'test' };
-    expect(obj).toBeDefined();
-  });
-
-  test('KnownResources accepts any string when ResourceTypeMap is empty', () => {
-    // This verifies backward compatibility — all strings are valid resource names
-    const resources: KnownResources[] = ['users', 'posts', 'categories', 'anything'];
-    expect(resources).toHaveLength(4);
-  });
-});
-
-// ─── Declaration Merging Example (compile-time only) ──────────
-// The following block verifies that declaration merging works correctly.
-// It's wrapped in a function so it doesn't affect runtime.
-
-function _typeTests() {
-  // Simulate declaration merging
-  interface TestResourceMap {
-    users: { id: string; name: string; email: string };
-    posts: { id: string; title: string; content: string };
-  }
-
-  // Test conditional type behavior with a populated map
-  type TestKnown<M> = keyof M extends never ? string : Extract<keyof M, string>;
-  type TestInfer<R extends string, M> = R extends keyof M ? M[R] : Record<string, unknown>;
-
-  // When map is populated, resources are constrained
-  type Resources = TestKnown<TestResourceMap>;
-  const _r1: Resources = 'users';
-  const _r2: Resources = 'posts';
-  // @ts-expect-error — 'invalid' is not in TestResourceMap
-  const _r3: Resources = 'invalid';
-
-  // InferData resolves correctly
-  type UserData = TestInfer<'users', TestResourceMap>;
-  const _user: UserData = { id: '1', name: 'Alice', email: 'a@b.com' };
-
-  type PostData = TestInfer<'posts', TestResourceMap>;
-  const _post: PostData = { id: '1', title: 'Hello', content: 'World' };
-
-  // Unknown resource falls back
-  type UnknownData = TestInfer<'unknown', TestResourceMap>;
-  const _unknown: UnknownData = { any: 'thing' };
-
-  void _r1; void _r2; void _r3; void _user; void _post; void _unknown;
-}
-
-void _typeTests;

package/src/router-provider.test.ts

@@ -1,82 +0,0 @@
-// Unit tests for RouterProvider implementations
-// Router provider tests need a DOM environment or a mock.
-import { describe, test, expect, beforeEach } from 'bun:test';
-import { createHashRouterProvider, createHistoryRouterProvider } from './router-provider';
-
-describe('createHashRouterProvider (unit — no DOM)', () => {
-
-  test('returns provider with go, back, parse methods', () => {
-    const provider = createHashRouterProvider();
-    expect(typeof provider.go).toBe('function');
-    expect(typeof provider.back).toBe('function');
-    expect(typeof provider.parse).toBe('function');
-  });
-});
-
-describe('createHistoryRouterProvider (unit — no DOM)', () => {
-  test('returns provider with go, back, parse methods', () => {
-    const provider = createHistoryRouterProvider();
-    expect(typeof provider.go).toBe('function');
-    expect(typeof provider.back).toBe('function');
-    expect(typeof provider.parse).toBe('function');
-  });
-
-  test('accepts basePath argument', () => {
-    const provider = createHistoryRouterProvider('/admin');
-    expect(typeof provider.parse).toBe('function');
-  });
-});
-
-// DOM-dependent tests — mocked window if not exists
-describe('createHashRouterProvider (with mock DOM)', () => {
-  beforeEach(() => {
-    if (typeof globalThis.window === 'undefined') {
-      let _hash = '';
-      (globalThis as any).window = {
-        location: {
-          get hash() { return _hash ? (_hash.startsWith('#') ? _hash : '#' + _hash) : ''; },
-          set hash(val) { _hash = val; }
-        }
-      };
-    }
-  });
-
-  test('parse returns empty segments for root', () => {
-    window.location.hash = '';
-    const provider = createHashRouterProvider();
-    const parsed = provider.parse();
-    expect(parsed.pathname).toBe('/');
-  });
-
-  test('parse extracts resource from hash', () => {
-    window.location.hash = '#/posts';
-    const provider = createHashRouterProvider();
-    const parsed = provider.parse();
-    expect(parsed.pathname).toBe('/posts');
-    expect(parsed.resource).toBe('posts');
-  });
-
-  test('parse extracts resource, action, and id', () => {
-    window.location.hash = '#/posts/edit/42';
-    const provider = createHashRouterProvider();
-    const parsed = provider.parse();
-    expect(parsed.resource).toBe('posts');
-    expect(parsed.action).toBe('edit');
-    expect(parsed.id).toBe('42');
-  });
-
-  test('parse extracts query params from hash', () => {
-    window.location.hash = '#/posts?page=2&sort=name';
-    const provider = createHashRouterProvider();
-    const parsed = provider.parse();
-    expect(parsed.params.page).toBe('2');
-    expect(parsed.params.sort).toBe('name');
-  });
-
-  test('go sets window.location.hash', () => {
-    const provider = createHashRouterProvider();
-    provider.go({ to: '/users' });
-    expect(window.location.hash).toBe('#/users');
-  });
-});
-

package/src/routing-hooks.test.svelte.ts

@@ -1,55 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { useGo, useBack } from './routing-hooks.svelte';
-import { useParsed } from './useParsed.svelte';
-import { flushSync } from 'svelte';
-
-vi.mock('./context.svelte', () => ({
-  useRouterContext: () => ({ 
-    navigate: vi.fn(), 
-    url: '/posts/1/edit',
-    parsedParams: { resource: 'posts', action: 'edit', id: '1' },
-    go: vi.fn(),
-    back: vi.fn()
-  }),
-  getRouterProvider: () => undefined
-}));
-
-vi.mock('./useParsed.svelte', () => ({
-  useParsed: () => ({ resource: 'posts', action: 'edit', id: '1' })
-}));
-
-describe('routing-hooks - Headless Svelte 5 Compatibility', () => {
-
-  it('safely extracts parses from url and binds to runes Context', () => {
-    let parsedParams!: ReturnType<typeof useParsed>;
-
-    const cleanup = $effect.root(() => {
-        parsedParams = useParsed();
-    });
-
-    flushSync();
-    
-    expect(parsedParams!.action).toBe('edit');
-    expect(parsedParams.resource).toBe('posts');
-    expect(parsedParams.id).toBe('1');
-
-    cleanup();
-  });
-
-  it('useGo and useBack return functional closures out of Context', () => {
-    let go!: ReturnType<typeof useGo>;
-    let back!: ReturnType<typeof useBack>;
-    
-    const cleanup = $effect.root(() => {
-        go = useGo();
-        back = useBack();
-    });
-
-    flushSync();
-    
-    expect(typeof go).toBe('function');
-    expect(typeof back).toBe('function');
-
-    cleanup();
-  });
-});

package/src/table-hooks.test.svelte.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { useTable } from './table-hooks.svelte';
-import { flushSync } from 'svelte';
-import { QueryClient } from '@tanstack/svelte-query';
-
-vi.mock('./context.svelte', () => ({
-  useDataProvider: () => ({
-    getList: vi.fn().mockResolvedValue({ data: [], total: 0 })
-  }),
-  useResource: () => ({ name: 'posts' }),
-  getResource: (name: string) => ({ name, primaryKey: 'id' }),
-  useRouterContext: () => ({ navigate: vi.fn(), url: '/', parsedParams: { current: 1, pageSize: 10 } }),
-  useTranslate: () => (key: string) => key,
-  getSyncWithLocation: () => false,
-  useNotification: () => ({ open: vi.fn(), close: vi.fn() }),
-  getLiveProvider: () => undefined
-}));
-
-vi.mock('@tanstack/svelte-query', async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual as any,
-    useQueryClient: () => new QueryClient(),
-    createQuery: () => ({
-      data: { data: [{ id: 1, title: 'Row' }], total: 1 },
-      isPending: false,
-      isFetching: false,
-      error: null
-    })
-  };
-});
-
-describe('useTable - Headless Svelte 5 Compatibility', () => {
-
-  it('binds useTable logic internally and updates pagination flawlessly via $state', () => {
-    let table: ReturnType<typeof useTable>;
-
-    const cleanup = $effect.root(() => {
-        table = useTable({ resource: 'posts' });
-    });
-
-    flushSync();
-    
-    expect(table!.query).toBeDefined();
-    expect(table!.query?.data?.data[0].title).toBe('Row');
-    expect(table!.current).toBe(1);
-
-    // Trigger mutable state 
-    table!.setPage(2);
-    
-    flushSync();
-
-    expect(table!.current).toBe(2);
-
-    cleanup();
-  });
-});

package/src/task-hooks.test.svelte.ts

@@ -1,129 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { flushSync } from 'svelte';
-import { QueryClient } from '@tanstack/svelte-query';
-import { useSubmitTask, useTask, useTaskList, useTaskSubscription } from './task-hooks.svelte';
-
-const mockTaskProvider = {
-  submit: vi.fn(async () => ({
-    id: 'task-1',
-    wait: async () => ({ id: 'task-1', status: 'done' }),
-  })),
-  get: vi.fn(async (taskId: string) => ({ id: taskId, status: 'running' })),
-  list: vi.fn(async () => ({ data: [{ id: 'task-1', status: 'queued' }], total: 1 })),
-  listDlq: vi.fn(async () => ({ data: [{ id: 'task-2', status: 'failed' }], total: 1 })),
-  subscribe: vi.fn((_taskId: string, callback: (task: { id: string; status: string }) => void) => {
-    callback({ id: 'task-1', status: 'running' });
-    return () => {};
-  }),
-};
-
-vi.mock('./context.svelte', () => ({
-  getTaskProvider: () => mockTaskProvider,
-  getAuthProvider: () => null,
-}));
-
-vi.mock('./notification.svelte', () => ({
-  notify: vi.fn(),
-}));
-
-vi.mock('@tanstack/svelte-query', async (importOriginal) => {
-  const actual = await importOriginal();
-  return {
-    ...actual as any,
-    useQueryClient: () => new QueryClient(),
-    createMutation: (factory: any) => {
-      const config = factory();
-      return {
-        mutateAsync: async (vars: unknown) => config.mutationFn(vars),
-        mutate: vi.fn(),
-        isPending: false,
-      };
-    },
-    createQuery: (factory: any) => {
-      const config = factory();
-      return {
-        data: config.queryKey[0] === 'taskList'
-          ? { data: [{ id: 'task-1', status: 'queued' }], total: 1 }
-          : { id: 'task-1', status: 'running' },
-        isLoading: false,
-        isSuccess: true,
-        isError: false,
-        error: null,
-        dataUpdatedAt: Date.now(),
-        errorUpdatedAt: 0,
-      };
-    },
-  };
-});
-
-describe('task-hooks', () => {
-  it('useSubmitTask exposes a working mutation', async () => {
-    let submitTask: ReturnType<typeof useSubmitTask>;
-
-    const cleanup = $effect.root(() => {
-      submitTask = useSubmitTask();
-    });
-
-    flushSync();
-
-    const handle = await submitTask!.mutation.mutateAsync({
-      taskName: 'image.generate',
-      options: { body: { prompt: 'poster' } },
-    });
-
-    expect(handle.id).toBe('task-1');
-    expect(mockTaskProvider.submit).toHaveBeenCalledWith('image.generate', {
-      body: { prompt: 'poster' },
-    });
-
-    cleanup();
-  });
-
-  it('useTask returns query state for a single task', () => {
-    let taskQuery: ReturnType<typeof useTask>;
-
-    const cleanup = $effect.root(() => {
-      taskQuery = useTask({ taskId: 'task-1' });
-    });
-
-    flushSync();
-
-    expect(taskQuery!.data).toBeDefined();
-    expect((taskQuery!.data as any).status).toBe('running');
-
-    cleanup();
-  });
-
-  it('useTaskList returns task collection data', () => {
-    let taskListQuery: ReturnType<typeof useTaskList>;
-
-    const cleanup = $effect.root(() => {
-      taskListQuery = useTaskList();
-    });
-
-    flushSync();
-
-    expect(taskListQuery!.data).toBeDefined();
-    expect((taskListQuery!.data as any).data[0].id).toBe('task-1');
-
-    cleanup();
-  });
-
-  it('useTaskSubscription subscribes to task updates', () => {
-    const onTask = vi.fn();
-
-    const cleanup = $effect.root(() => {
-      useTaskSubscription({
-        taskId: 'task-1',
-        onTask,
-      });
-    });
-
-    flushSync();
-
-    expect(mockTaskProvider.subscribe).toHaveBeenCalledWith('task-1', expect.any(Function));
-    expect(onTask).toHaveBeenCalledWith({ id: 'task-1', status: 'running' });
-
-    cleanup();
-  });
-});