@svadmin/core 0.25.1 → 0.25.3

package/src/inferencer.test.ts

@@ -1,189 +0,0 @@
-// Unit tests for Inferencer
-import { describe, test, expect } from 'bun:test';
-import { inferFieldType, inferResource } from './inferencer';
-
-describe('inferFieldType', () => {
-  test('detects boolean', () => {
-    expect(inferFieldType('active', true)).toBe('boolean');
-  });
-
-  test('detects number', () => {
-    expect(inferFieldType('age', 25)).toBe('number');
-  });
-
-  test('detects email', () => {
-    expect(inferFieldType('email', 'user@example.com')).toBe('email');
-  });
-
-  test('detects email from key name', () => {
-    expect(inferFieldType('user_email', 'test')).toBe('email');
-  });
-
-  test('detects URL', () => {
-    expect(inferFieldType('website', 'https://example.com')).toBe('url');
-  });
-
-  test('detects image URL', () => {
-    expect(inferFieldType('avatar', 'https://example.com/photo.jpg')).toBe('image');
-  });
-
-  test('detects image from key name', () => {
-    expect(inferFieldType('avatar', '/uploads/user.png')).toBe('image');
-  });
-
-  test('detects date ISO string', () => {
-    expect(inferFieldType('created', '2024-01-15T10:30:00Z')).toBe('date');
-  });
-
-  test('detects date from key name', () => {
-    expect(inferFieldType('created_at', 'some value')).toBe('date');
-  });
-
-  test('detects phone', () => {
-    expect(inferFieldType('phone', '+1 (555) 123-4567')).toBe('phone');
-  });
-
-  test('detects color hex', () => {
-    expect(inferFieldType('color', '#ff5533')).toBe('color');
-  });
-
-  test('detects textarea for long strings', () => {
-    expect(inferFieldType('content', 'a'.repeat(250))).toBe('textarea');
-  });
-
-  test('detects textarea from key name', () => {
-    expect(inferFieldType('description', 'short')).toBe('textarea');
-  });
-
-  test('detects tags array', () => {
-    expect(inferFieldType('tags', ['svelte', 'admin'])).toBe('tags');
-  });
-
-  test('detects images array', () => {
-    expect(inferFieldType('photos', ['https://x.com/a.png', 'https://x.com/b.jpg'])).toBe('images');
-  });
-
-  test('detects json object', () => {
-    expect(inferFieldType('meta', { foo: 'bar' })).toBe('json');
-  });
-
-  test('null defaults to text', () => {
-    expect(inferFieldType('unknown', null)).toBe('text');
-  });
-
-  test('plain string defaults to text', () => {
-    expect(inferFieldType('title', 'Hello World')).toBe('text');
-  });
-});
-
-describe('inferResource', () => {
-  const sampleData = [
-    {
-      id: 1,
-      title: 'First Post',
-      content: 'A very long description that is more than two hundred characters. '.repeat(4),
-      author_id: 5,
-      status: 'published',
-      views: 100,
-      is_featured: true,
-      created_at: '2024-01-15T10:00:00Z',
-      email: 'author@blog.com',
-      tags: ['svelte', 'admin'],
-    },
-    {
-      id: 2,
-      title: 'Second Post',
-      content: 'Another long body text that exceeds the 200 char limit easily. '.repeat(5),
-      author_id: 3,
-      status: 'draft',
-      views: 42,
-      is_featured: false,
-      created_at: '2024-02-20T14:30:00Z',
-      email: 'editor@blog.com',
-      tags: ['react'],
-    },
-  ];
-
-  test('returns correct resource name and label', () => {
-    const result = inferResource('posts', sampleData);
-    expect(result.resource.name).toBe('posts');
-    expect(result.resource.label).toBe('Posts');
-  });
-
-  test('infers correct number of fields', () => {
-    const result = inferResource('posts', sampleData);
-    expect(result.fields.length).toBe(10); // id, title, content, author_id, status, views, is_featured, created_at, email, tags
-  });
-
-  test('detects id as primary key', () => {
-    const result = inferResource('posts', sampleData);
-    const idField = result.fields.find(f => f.key === 'id');
-    expect(idField).toBeDefined();
-    expect(idField!.showInForm).toBe(false);
-  });
-
-  test('detects number type for views', () => {
-    const result = inferResource('posts', sampleData);
-    const viewsField = result.fields.find(f => f.key === 'views');
-    expect(viewsField!.type).toBe('number');
-  });
-
-  test('detects boolean type for is_featured', () => {
-    const result = inferResource('posts', sampleData);
-    const field = result.fields.find(f => f.key === 'is_featured');
-    expect(field!.type).toBe('boolean');
-  });
-
-  test('detects date for created_at', () => {
-    const result = inferResource('posts', sampleData);
-    const field = result.fields.find(f => f.key === 'created_at');
-    expect(field!.type).toBe('date');
-  });
-
-  test('detects relation for author_id', () => {
-    const result = inferResource('posts', sampleData);
-    const field = result.fields.find(f => f.key === 'author_id');
-    expect(field!.type).toBe('relation');
-    expect(field!.resource).toBe('authors');
-  });
-
-  test('detects email type', () => {
-    const result = inferResource('posts', sampleData);
-    const field = result.fields.find(f => f.key === 'email');
-    expect(field!.type).toBe('email');
-  });
-
-  test('detects tags array', () => {
-    const result = inferResource('posts', sampleData);
-    const field = result.fields.find(f => f.key === 'tags');
-    expect(field!.type).toBe('tags');
-  });
-
-  test('detects textarea for content', () => {
-    const result = inferResource('posts', sampleData);
-    const field = result.fields.find(f => f.key === 'content');
-    expect(field!.type).toBe('textarea');
-    expect(field!.showInList).toBe(false);
-  });
-
-  test('generates valid TypeScript code', () => {
-    const result = inferResource('posts', sampleData);
-    expect(result.code).toContain("name: 'posts'");
-    expect(result.code).toContain("import type { ResourceDefinition }");
-    expect(result.code).toContain("export const postsResource");
-  });
-
-  test('handles empty data gracefully', () => {
-    const result = inferResource('empty', []);
-    expect(result.fields.length).toBe(0);
-    expect(result.code).toContain('No data available');
-  });
-
-  test('custom primaryKey', () => {
-    const data = [{ _id: 'abc', name: 'Test' }];
-    const result = inferResource('items', data, { primaryKey: '_id' });
-    expect(result.resource.primaryKey).toBe('_id');
-    const pkField = result.fields.find(f => f.key === '_id');
-    expect(pkField!.showInForm).toBe(false);
-  });
-});

package/src/live.test.ts

@@ -1,134 +0,0 @@
-/**
- * LiveProvider unit tests
- * Tests the subscription management logic without requiring actual WebSocket/SSE connections.
- */
-import { describe, test, expect, mock } from 'bun:test';
-import type { LiveProvider, LiveEvent } from './live.svelte';
-
-// Helper: create a minimal in-memory LiveProvider for testing subscription logic
-function createMockLiveProvider(): LiveProvider & { emit: (event: LiveEvent) => void } {
-  type Callback = (event: LiveEvent) => void;
-  const subscribers = new Map<string, Set<Callback>>();
-
-  return {
-    subscribe({ resource, callback }) {
-      if (!subscribers.has(resource)) {
-        subscribers.set(resource, new Set());
-      }
-      subscribers.get(resource)!.add(callback);
-
-      return () => {
-        const callbacks = subscribers.get(resource);
-        if (callbacks) {
-          callbacks.delete(callback);
-          if (callbacks.size === 0) subscribers.delete(resource);
-        }
-      };
-    },
-
-    emit(event: LiveEvent) {
-      const callbacks = subscribers.get(event.resource);
-      if (callbacks) {
-        for (const cb of callbacks) cb(event);
-      }
-      // Wildcard
-      const wildcardCallbacks = subscribers.get('*');
-      if (wildcardCallbacks) {
-        for (const cb of wildcardCallbacks) cb(event);
-      }
-    },
-  };
-}
-
-describe('LiveProvider subscription', () => {
-  test('subscribe receives events for correct resource', () => {
-    const provider = createMockLiveProvider();
-    const received: LiveEvent[] = [];
-
-    provider.subscribe({
-      resource: 'posts',
-      callback: (event) => received.push(event),
-    });
-
-    provider.emit({ type: 'INSERT', resource: 'posts', payload: { id: 1 } });
-    provider.emit({ type: 'UPDATE', resource: 'comments', payload: { id: 2 } });
-
-    expect(received.length).toBe(1);
-    expect(received[0].type).toBe('INSERT');
-    expect(received[0].resource).toBe('posts');
-  });
-
-  test('wildcard subscriber receives all events', () => {
-    const provider = createMockLiveProvider();
-    const received: LiveEvent[] = [];
-
-    provider.subscribe({
-      resource: '*',
-      callback: (event) => received.push(event),
-    });
-
-    provider.emit({ type: 'INSERT', resource: 'posts', payload: {} });
-    provider.emit({ type: 'DELETE', resource: 'users', payload: {} });
-
-    expect(received.length).toBe(2);
-    expect(received[0].resource).toBe('posts');
-    expect(received[1].resource).toBe('users');
-  });
-
-  test('unsubscribe stops receiving events', () => {
-    const provider = createMockLiveProvider();
-    const received: LiveEvent[] = [];
-
-    const unsub = provider.subscribe({
-      resource: 'posts',
-      callback: (event) => received.push(event),
-    });
-
-    provider.emit({ type: 'INSERT', resource: 'posts', payload: {} });
-    expect(received.length).toBe(1);
-
-    unsub();
-
-    provider.emit({ type: 'UPDATE', resource: 'posts', payload: {} });
-    expect(received.length).toBe(1); // No new events after unsub
-  });
-
-  test('multiple subscribers for same resource', () => {
-    const provider = createMockLiveProvider();
-    const received1: LiveEvent[] = [];
-    const received2: LiveEvent[] = [];
-
-    provider.subscribe({ resource: 'posts', callback: (e) => received1.push(e) });
-    provider.subscribe({ resource: 'posts', callback: (e) => received2.push(e) });
-
-    provider.emit({ type: 'INSERT', resource: 'posts', payload: { id: 1 } });
-
-    expect(received1.length).toBe(1);
-    expect(received2.length).toBe(1);
-  });
-
-  test('LiveEvent types are correct', () => {
-    const insertEvent: LiveEvent = { type: 'INSERT', resource: 'posts', payload: { title: 'New' } };
-    const updateEvent: LiveEvent = { type: 'UPDATE', resource: 'posts', payload: { title: 'Updated' } };
-    const deleteEvent: LiveEvent = { type: 'DELETE', resource: 'posts', payload: { id: 1 } };
-
-    expect(insertEvent.type).toBe('INSERT');
-    expect(updateEvent.type).toBe('UPDATE');
-    expect(deleteEvent.type).toBe('DELETE');
-  });
-
-  test('unsubscribing one does not affect others', () => {
-    const provider = createMockLiveProvider();
-    const received1: LiveEvent[] = [];
-    const received2: LiveEvent[] = [];
-
-    const unsub1 = provider.subscribe({ resource: 'posts', callback: (e) => received1.push(e) });
-    provider.subscribe({ resource: 'posts', callback: (e) => received2.push(e) });
-
-    unsub1();
-    provider.emit({ type: 'INSERT', resource: 'posts', payload: {} });
-
-    expect(received1.length).toBe(0);
-    expect(received2.length).toBe(1);
-  });
-});

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

@@ -1,114 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { useCreate, useUpdate, invalidateByScopes } from './mutation-hooks.svelte';
-import { flushSync } from 'svelte';
-import { QueryClient } from '@tanstack/svelte-query';
-
-vi.mock('./context.svelte', () => ({
-  useDataProvider: () => ({
-    getOne: vi.fn(),
-    getList: vi.fn(),
-    create: vi.fn().mockResolvedValue({ data: { id: 1 } }),
-    update: vi.fn().mockResolvedValue({ data: { id: 1 } })
-  }),
-  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(),
-    createMutation: (opts: any) => ({
-      mutate: vi.fn((vars, callbacks) => {
-        if (opts.mutationFn) opts.mutationFn(vars);
-        if (callbacks?.onSuccess) callbacks.onSuccess({ data: {} });
-      }),
-      isPending: false
-    })
-  };
-});
-
-describe('useCreate & useUpdate - Headless Svelte 5 Compatibility', () => {
-
-  it('safely binds useCreate and allows mutations over proxies', () => {
-    let createMutation: ReturnType<typeof useCreate>;
-    
-    const cleanup = $effect.root(() => {
-        createMutation = useCreate();
-    });
-
-    flushSync();
-    
-    expect(createMutation!.mutation.mutate).toBeDefined();
-    expect(createMutation!.mutation.isPending).toBe(false);
-
-    cleanup();
-  });
-
-  it('safely binds useUpdate and evaluates data updates', () => {
-    let updateMutation: ReturnType<typeof useUpdate>;
-    
-    const cleanup = $effect.root(() => {
-        updateMutation = useUpdate();
-    });
-
-    flushSync();
-    
-    expect(updateMutation!.mutation.mutate).toBeDefined();
-    expect(updateMutation!.mutation.isPending).toBe(false);
-
-    cleanup();
-  });
-});
-describe('mutation-hooks', () => {
-
-  describe('invalidateByScopes - Multi-Provider Cache Isolation', () => {
-    it('filters perfectly by dataProviderName when passed', () => {
-      const queryClient = new QueryClient();
-      queryClient.invalidateQueries = vi.fn(async () => {});
-
-      const resource = 'posts';
-      const providerName = 'secondaryProvider';
-      
-      // Act
-      invalidateByScopes(queryClient, resource, ['list'], ['list'], undefined, providerName);
-      
-      expect(queryClient.invalidateQueries).toHaveBeenCalled();
-      
-      // Assert predicate captures DataProvider scopes
-      const calls = (queryClient.invalidateQueries as ReturnType<typeof vi.fn>).mock.calls;
-      
-      // Using arbitrary mock objects simulating Query keys
-      const predicateFn = calls[0][0].predicate;
-      
-      const shouldPass = predicateFn({ queryKey: ['secondaryProvider', 'posts', 'list'] });
-      const shouldFail = predicateFn({ queryKey: ['default', 'posts', 'list'] });
-      const shouldFailResource = predicateFn({ queryKey: ['secondaryProvider', 'users', 'list'] });
-
-      expect(shouldPass).toBe(true);
-      expect(shouldFail).toBe(false);
-      expect(shouldFailResource).toBe(false);
-    });
-    
-    it('falls back to all providers when NO provider is specified', () => {
-      const queryClient = new QueryClient();
-      queryClient.invalidateQueries = vi.fn(async () => {});
-
-      // Act without providerName
-      invalidateByScopes(queryClient, 'posts', ['list'], ['list']);
-      
-      const predicateFn = (queryClient.invalidateQueries as ReturnType<typeof vi.fn>).mock.calls[0][0].predicate;
-      
-      const pass1 = predicateFn({ queryKey: ['default', 'posts', 'list'] });
-      const pass2 = predicateFn({ queryKey: ['custom', 'posts', 'list'] });
-      expect(pass1).toBe(true);
-      expect(pass2).toBe(true);
-    });
-  });
-
-});

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();
-  });
-});