@svadmin/core 0.25.2 → 0.25.4

package/src/inferencer-openapi.test.ts

@@ -1,192 +0,0 @@
-/**
- * Tests for OpenAPI → ResourceDefinition inference
- */
-import { describe, test, expect } from 'bun:test';
-import { inferFromOpenAPI } from './inferencer-openapi';
-
-const sampleOpenAPI = {
-  openapi: '3.0.0',
-  info: { title: 'Blog API', version: '1.0.0' },
-  paths: {
-    '/api/posts': {
-      get: { operationId: 'getPosts' },
-      post: { operationId: 'createPost' },
-    },
-    '/api/posts/{id}': {
-      get: { operationId: 'getPost' },
-      put: { operationId: 'updatePost' },
-      delete: { operationId: 'deletePost' },
-    },
-    '/api/users': {
-      get: { operationId: 'getUsers' },
-    },
-  },
-  components: {
-    schemas: {
-      Post: {
-        type: 'object',
-        required: ['title', 'content'],
-        properties: {
-          id: { type: 'integer' },
-          title: { type: 'string' },
-          content: { type: 'string', description: 'Post body content' },
-          status: { type: 'string', enum: ['draft', 'published', 'archived'] },
-          author_id: { type: 'integer' },
-          email: { type: 'string', format: 'email' },
-          created_at: { type: 'string', format: 'date-time' },
-          tags: { type: 'array', items: { type: 'string' } },
-          is_featured: { type: 'boolean' },
-          views: { type: 'integer' },
-          website: { type: 'string', format: 'uri' },
-          meta: { type: 'object' },
-        },
-      },
-      User: {
-        type: 'object',
-        properties: {
-          id: { type: 'integer' },
-          name: { type: 'string' },
-          avatar: { type: 'string', format: 'uri' },
-        },
-      },
-    },
-  },
-};
-
-describe('inferFromOpenAPI', () => {
-  test('parses both schemas', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    expect(resources.length).toBe(2);
-  });
-
-  test('resource name is pluralized and lowercase', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts');
-    expect(post).toBeDefined();
-    expect(post!.label).toBe('Post');
-  });
-
-  test('detects required fields', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const titleField = post.fields.find(f => f.key === 'title')!;
-    const viewsField = post.fields.find(f => f.key === 'views')!;
-    expect(titleField.required).toBe(true);
-    expect(viewsField.required).toBeFalsy();
-  });
-
-  test('maps integer to number type', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const viewsField = post.fields.find(f => f.key === 'views')!;
-    expect(viewsField.type).toBe('number');
-  });
-
-  test('maps boolean type', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const field = post.fields.find(f => f.key === 'is_featured')!;
-    expect(field.type).toBe('boolean');
-  });
-
-  test('maps date-time format to date', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const field = post.fields.find(f => f.key === 'created_at')!;
-    expect(field.type).toBe('date');
-  });
-
-  test('maps email format', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const field = post.fields.find(f => f.key === 'email')!;
-    expect(field.type).toBe('email');
-  });
-
-  test('maps uri format to url', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const field = post.fields.find(f => f.key === 'website')!;
-    expect(field.type).toBe('url');
-  });
-
-  test('maps enum to select with options', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const field = post.fields.find(f => f.key === 'status')!;
-    expect(field.type).toBe('select');
-    expect(field.options!.length).toBe(3);
-    expect(field.options![0].value).toBe('draft');
-  });
-
-  test('maps array of strings to tags', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const field = post.fields.find(f => f.key === 'tags')!;
-    expect(field.type).toBe('tags');
-  });
-
-  test('maps object to json', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const field = post.fields.find(f => f.key === 'meta')!;
-    expect(field.type).toBe('json');
-  });
-
-  test('detects relation from _id suffix', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const field = post.fields.find(f => f.key === 'author_id')!;
-    expect(field.type).toBe('relation');
-    expect(field.resource).toBe('authors');
-  });
-
-  test('detects CRUD capabilities from paths', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    expect(post.canCreate).toBe(true);
-    expect(post.canEdit).toBe(true);
-    expect(post.canDelete).toBe(true);
-    expect(post.canShow).toBe(true);
-  });
-
-  test('read-only resource has limited capabilities', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const user = resources.find(r => r.name === 'users')!;
-    expect(user.canShow).toBe(true);
-    expect(user.canCreate).toBe(false);
-    expect(user.canDelete).toBe(false);
-  });
-
-  test('include filter works', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI, { include: ['Post'] });
-    expect(resources.length).toBe(1);
-    expect(resources[0].name).toBe('posts');
-  });
-
-  test('exclude filter works', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI, { exclude: ['User'] });
-    expect(resources.length).toBe(1);
-    expect(resources[0].name).toBe('posts');
-  });
-
-  test('content field is detected as textarea from key name hint', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const field = post.fields.find(f => f.key === 'content')!;
-    expect(field.type).toBe('textarea');
-    expect(field.showInList).toBe(false);
-  });
-
-  test('id field excluded from form', () => {
-    const resources = inferFromOpenAPI(sampleOpenAPI);
-    const post = resources.find(r => r.name === 'posts')!;
-    const idField = post.fields.find(f => f.key === 'id')!;
-    expect(idField.showInForm).toBe(false);
-  });
-
-  test('empty spec returns empty array', () => {
-    const resources = inferFromOpenAPI({});
-    expect(resources.length).toBe(0);
-  });
-});

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