@svadmin/core 0.25.1 → 0.25.3

package/src/helpers.test.ts

@@ -1,177 +0,0 @@
-// Unit tests for helpers-pure.ts — pure functions, no Svelte runtime
-import { describe, test, expect } from 'bun:test';
-import {
-  getDefaultFilter, getDefaultSortOrder,
-  unionFilters, unionSorters,
-  parseCSV,
-} from './helpers-pure';
-import type { Filter, Sort } from './types';
-
-// ─── getDefaultFilter ─────────────────────────────────────────
-
-describe('getDefaultFilter', () => {
-  const filters: Filter[] = [
-    { field: 'status', operator: 'eq', value: 'published' },
-    { field: 'price', operator: 'gte', value: 100 },
-    { field: 'title', operator: 'contains', value: 'hello' },
-  ];
-
-  test('returns value for matching field+operator', () => {
-    expect(getDefaultFilter('status', filters)).toBe('published');
-    expect(getDefaultFilter('price', filters, 'gte')).toBe(100);
-  });
-
-  test('returns undefined for non-matching field', () => {
-    expect(getDefaultFilter('nonexistent', filters)).toBeUndefined();
-  });
-
-  test('returns undefined for wrong operator', () => {
-    expect(getDefaultFilter('status', filters, 'contains')).toBeUndefined();
-  });
-
-  test('returns undefined for empty/undefined filters', () => {
-    expect(getDefaultFilter('status', [])).toBeUndefined();
-    expect(getDefaultFilter('status', undefined)).toBeUndefined();
-  });
-});
-
-// ─── getDefaultSortOrder ──────────────────────────────────────
-
-describe('getDefaultSortOrder', () => {
-  const sorters: Sort[] = [
-    { field: 'name', order: 'asc' },
-    { field: 'createdAt', order: 'desc' },
-  ];
-
-  test('returns order for matching field', () => {
-    expect(getDefaultSortOrder('name', sorters)).toBe('asc');
-    expect(getDefaultSortOrder('createdAt', sorters)).toBe('desc');
-  });
-
-  test('returns undefined for non-matching field', () => {
-    expect(getDefaultSortOrder('unknown', sorters)).toBeUndefined();
-  });
-
-  test('returns undefined for empty/undefined sorters', () => {
-    expect(getDefaultSortOrder('name', undefined)).toBeUndefined();
-    expect(getDefaultSortOrder('name', [])).toBeUndefined();
-  });
-});
-
-// ─── unionFilters ─────────────────────────────────────────────
-
-describe('unionFilters', () => {
-  test('merges new filters over previous', () => {
-    const prev: Filter[] = [
-      { field: 'status', operator: 'eq', value: 'draft' },
-    ];
-    const next: Filter[] = [
-      { field: 'status', operator: 'eq', value: 'published' },
-    ];
-    const result = unionFilters([], next, prev);
-    expect(result).toHaveLength(1);
-    expect(result[0].value).toBe('published');
-  });
-
-  test('permanent filters override everything', () => {
-    const permanent: Filter[] = [
-      { field: 'org', operator: 'eq', value: 'acme' },
-    ];
-    const next: Filter[] = [
-      { field: 'org', operator: 'eq', value: 'other' },
-    ];
-    const result = unionFilters(permanent, next, []);
-    expect(result).toHaveLength(1);
-    expect(result[0].value).toBe('acme');
-  });
-
-  test('removes filters with undefined value', () => {
-    const prev: Filter[] = [
-      { field: 'status', operator: 'eq', value: 'draft' },
-    ];
-    const next: Filter[] = [
-      { field: 'status', operator: 'eq', value: undefined },
-    ];
-    const result = unionFilters([], next, prev);
-    expect(result).toHaveLength(0);
-  });
-
-  test('adds new filters not in previous', () => {
-    const prev: Filter[] = [
-      { field: 'status', operator: 'eq', value: 'draft' },
-    ];
-    const next: Filter[] = [
-      { field: 'category', operator: 'eq', value: 'tech' },
-    ];
-    const result = unionFilters([], next, prev);
-    expect(result).toHaveLength(2);
-  });
-
-  test('handles empty arrays', () => {
-    expect(unionFilters([], [], [])).toEqual([]);
-  });
-});
-
-// ─── unionSorters ─────────────────────────────────────────────
-
-describe('unionSorters', () => {
-  test('new sorters take priority', () => {
-    const permanent: Sort[] = [{ field: 'id', order: 'asc' }];
-    const newSorters: Sort[] = [{ field: 'name', order: 'desc' }];
-    const result = unionSorters(permanent, newSorters);
-    expect(result).toHaveLength(2);
-    expect(result[0].field).toBe('name');
-  });
-
-  test('permanent sorters override new sorters on same field', () => {
-    const permanent: Sort[] = [{ field: 'name', order: 'asc' }];
-    const newSorters: Sort[] = [{ field: 'name', order: 'desc' }];
-    const result = unionSorters(permanent, newSorters);
-    expect(result).toHaveLength(1);
-    expect(result[0].order).toBe('asc');
-  });
-
-  test('empty arrays', () => {
-    expect(unionSorters([], [])).toEqual([]);
-  });
-});
-
-// ─── parseCSV ─────────────────────────────────────────────────
-
-describe('parseCSV', () => {
-  test('parses simple CSV', () => {
-    const rows = parseCSV('name,age\nAlice,30\nBob,25');
-    expect(rows).toHaveLength(3);
-    expect(rows[0]).toEqual(['name', 'age']);
-    expect(rows[1]).toEqual(['Alice', '30']);
-    expect(rows[2]).toEqual(['Bob', '25']);
-  });
-
-  test('handles quoted fields', () => {
-    const rows = parseCSV('name,bio\nAlice,"Hello, World"');
-    expect(rows).toHaveLength(2);
-    expect(rows[1][1]).toBe('Hello, World');
-  });
-
-  test('handles escaped quotes', () => {
-    const rows = parseCSV('val\n"He said ""hello"""');
-    expect(rows).toHaveLength(2);
-    expect(rows[1][0]).toBe('He said "hello"');
-  });
-
-  test('handles CRLF line endings', () => {
-    const rows = parseCSV('a,b\r\n1,2\r\n3,4');
-    expect(rows).toHaveLength(3);
-  });
-
-  test('skips empty rows', () => {
-    const rows = parseCSV('a\n\nb\n');
-    expect(rows).toHaveLength(2);
-    expect(rows[0]).toEqual(['a']);
-    expect(rows[1]).toEqual(['b']);
-  });
-
-  test('handles empty input', () => {
-    expect(parseCSV('')).toEqual([]);
-  });
-});

package/src/http-error.test.ts

@@ -1,85 +0,0 @@
-// HttpError + CrudOperator + LogicalFilter tests
-import { describe, test, expect } from 'bun:test';
-import { HttpError } from './types';
-import type { CrudOperator, Filter, LogicalFilter } from './types';
-
-describe('HttpError', () => {
-  test('creates with message and statusCode', () => {
-    const err = new HttpError('Not Found', 404);
-    expect(err.message).toBe('Not Found');
-    expect(err.statusCode).toBe(404);
-    expect(err.name).toBe('HttpError');
-    expect(err.errors).toBeUndefined();
-  });
-
-  test('creates with validation errors', () => {
-    const err = new HttpError('Validation Failed', 422, {
-      email: ['Email is required', 'Email must be valid'],
-      name: 'Name is required',
-    });
-    expect(err.statusCode).toBe(422);
-    expect(err.errors!.email).toEqual(['Email is required', 'Email must be valid']);
-    expect(err.errors!.name).toBe('Name is required');
-  });
-
-  test('is instanceof Error', () => {
-    const err = new HttpError('Server Error', 500);
-    expect(err instanceof Error).toBe(true);
-    expect(err instanceof HttpError).toBe(true);
-  });
-});
-
-describe('CrudOperator types', () => {
-  test('all operators are valid', () => {
-    const operators: CrudOperator[] = [
-      'eq', 'ne', 'lt', 'gt', 'lte', 'gte',
-      'contains', 'ncontains',
-      'startswith', 'endswith',
-      'in', 'nin',
-      'null', 'nnull',
-      'between', 'nbetween',
-    ];
-    expect(operators).toHaveLength(16);
-  });
-
-  test('Filter uses CrudOperator', () => {
-    const filter: Filter = { field: 'name', operator: 'startswith', value: 'A' };
-    expect(filter.operator).toBe('startswith');
-  });
-
-  test('negation operators', () => {
-    const filters: Filter[] = [
-      { field: 'status', operator: 'ncontains', value: 'draft' },
-      { field: 'deleted_at', operator: 'nnull', value: null },
-      { field: 'category', operator: 'nin', value: [1, 2] },
-      { field: 'price', operator: 'nbetween', value: [100, 200] },
-    ];
-    expect(filters).toHaveLength(4);
-  });
-});
-
-describe('LogicalFilter', () => {
-  test('or combination', () => {
-    const logical: LogicalFilter = {
-      operator: 'or',
-      value: [
-        { field: 'status', operator: 'eq', value: 'published' },
-        { field: 'status', operator: 'eq', value: 'draft' },
-      ],
-    };
-    expect(logical.operator).toBe('or');
-    expect(logical.value).toHaveLength(2);
-  });
-
-  test('and combination', () => {
-    const logical: LogicalFilter = {
-      operator: 'and',
-      value: [
-        { field: 'price', operator: 'gte', value: 10 },
-        { field: 'price', operator: 'lte', value: 100 },
-      ],
-    };
-    expect(logical.operator).toBe('and');
-    expect(logical.value).toHaveLength(2);
-  });
-});

package/src/i18n.test.ts

@@ -1,90 +0,0 @@
-// Unit tests for URL parsing (useParsed logic)
-// We test the pure parsing logic directly since the hook itself uses Svelte runes.
-import { describe, test, expect } from 'bun:test';
-
-/**
- * Parse a hash-based URL into structured route info.
- * This mirrors the logic in useParsed.ts.
- */
-function parseHash(hash: string) {
-  const raw = hash.startsWith('#') ? hash.slice(1) : hash;
-  const [pathPart, queryPart] = raw.split('?');
-  const segments = pathPart.split('/').filter(Boolean);
-  
-  const params: Record<string, string> = {};
-  if (queryPart) {
-    for (const pair of queryPart.split('&')) {
-      const [k, v] = pair.split('=');
-      if (k) params[decodeURIComponent(k)] = decodeURIComponent(v ?? '');
-    }
-  }
-
-  return {
-    resource: segments[0],
-    action: segments[1],
-    id: segments[2],
-    params,
-  };
-}
-
-describe('parseHash (useParsed logic)', () => {
-  test('empty hash', () => {
-    const result = parseHash('');
-    expect(result.resource).toBeUndefined();
-    expect(result.action).toBeUndefined();
-    expect(result.id).toBeUndefined();
-    expect(result.params).toEqual({});
-  });
-
-  test('root hash', () => {
-    const result = parseHash('#/');
-    expect(result.resource).toBeUndefined();
-  });
-
-  test('resource only', () => {
-    const result = parseHash('#/posts');
-    expect(result.resource).toBe('posts');
-    expect(result.action).toBeUndefined();
-    expect(result.id).toBeUndefined();
-  });
-
-  test('resource and action', () => {
-    const result = parseHash('#/posts/create');
-    expect(result.resource).toBe('posts');
-    expect(result.action).toBe('create');
-  });
-
-  test('resource, action, and id', () => {
-    const result = parseHash('#/posts/edit/42');
-    expect(result.resource).toBe('posts');
-    expect(result.action).toBe('edit');
-    expect(result.id).toBe('42');
-  });
-
-  test('with query params', () => {
-    const result = parseHash('#/posts?page=2&sort=name');
-    expect(result.resource).toBe('posts');
-    expect(result.params.page).toBe('2');
-    expect(result.params.sort).toBe('name');
-  });
-
-  test('resource with action and query', () => {
-    const result = parseHash('#/posts/edit/5?tab=details');
-    expect(result.resource).toBe('posts');
-    expect(result.action).toBe('edit');
-    expect(result.id).toBe('5');
-    expect(result.params.tab).toBe('details');
-  });
-
-  test('encoded query params', () => {
-    const result = parseHash('#/search?q=hello%20world&filter=tag%3Djs');
-    expect(result.params.q).toBe('hello world');
-    expect(result.params.filter).toBe('tag=js');
-  });
-
-  test('login route', () => {
-    const result = parseHash('#/login');
-    expect(result.resource).toBe('login');
-    expect(result.action).toBeUndefined();
-  });
-});

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