@svadmin/core 0.0.3 → 0.3.0

package/src/http-error.test.ts

@@ -0,0 +1,85 @@
+// 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.svelte.ts

@@ -19,6 +19,9 @@ const locales: Record<string, Locale> = {
     'common.page': '{current} / {total}',
     'common.export': '导出',
     'common.import': '导入',
+    'common.clone': '克隆',
+    'common.autoSaving': '自动保存中...',
+    'common.autoSaved': '已自动保存',
     'common.selectAll': '全选',
     'common.batchDelete': '批量删除 ({count})',
     'common.unsavedChanges': '有未保存的修改，确定离开吗？',
@@ -37,8 +40,6 @@ const locales: Record<string, Locale> = {
     'common.toggleTheme': '切换主题',
     'common.darkMode': '暗色模式',
     'common.lightMode': '亮色模式',
-    'common.noData': '暂无数据',
-    'common.search': '搜索...',
     'common.detail': '详情',
     'common.loadFailed': '加载失败: {message}',
     'common.pageNotFound': '页面未找到',
@@ -46,6 +47,9 @@ const locales: Record<string, Locale> = {
     'common.retry': '重试',
     'common.yes': '是',
     'common.no': '否',
+    'common.welcome': '欢迎使用 {title}',
+    'common.dashboardHint': '从侧边栏选择一个资源开始。',
+    'common.redirecting': '正在跳转到登录页...',
     // Field
     'field.enterValue': '输入{label}',
     'field.selectPlaceholder': '请选择',
@@ -105,6 +109,9 @@ const locales: Record<string, Locale> = {
     'common.page': '{current} / {total}',
     'common.export': 'Export',
     'common.import': 'Import',
+    'common.clone': 'Clone',
+    'common.autoSaving': 'Auto-saving...',
+    'common.autoSaved': 'Saved',
     'common.selectAll': 'Select All',
     'common.batchDelete': 'Batch Delete ({count})',
     'common.unsavedChanges': 'You have unsaved changes. Leave anyway?',
@@ -123,8 +130,6 @@ const locales: Record<string, Locale> = {
     'common.toggleTheme': 'Toggle theme',
     'common.darkMode': 'Dark mode',
     'common.lightMode': 'Light mode',
-    'common.noData': 'No data',
-    'common.search': 'Search...',
     'common.detail': 'Detail',
     'common.loadFailed': 'Load failed: {message}',
     'common.pageNotFound': 'Page not found',
@@ -132,6 +137,9 @@ const locales: Record<string, Locale> = {
     'common.retry': 'Retry',
     'common.yes': 'Yes',
     'common.no': 'No',
+    'common.welcome': 'Welcome to {title}',
+    'common.dashboardHint': 'Select a resource from the sidebar to get started.',
+    'common.redirecting': 'Redirecting to login...',
     // Field
     'field.enterValue': 'Enter {label}',
     'field.selectPlaceholder': 'Select...',
@@ -219,3 +227,15 @@ export function t(key: string, params?: Record<string, string | number>): string
 export function addTranslations(locale: string, translations: Record<string, string>): void {
   locales[locale] = { ...locales[locale], ...translations };
 }
+
+/**
+ * useTranslation — standard i18n hook
+ * Returns { translate, getLocale, changeLocale }
+ */
+export function useTranslation() {
+  return {
+    translate: t,
+    getLocale,
+    changeLocale: setLocale,
+  };
+}

package/src/i18n.test.ts

@@ -0,0 +1,90 @@
+// 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/index.ts

@@ -1,35 +1,52 @@
 // Core barrel exports
 
 export {
-  setDataProvider, getDataProvider,
+  setDataProvider, getDataProvider, getDataProviderForResource, getDataProviderNames,
   setAuthProvider, getAuthProvider,
   setResources, getResources, getResource,
+  setRouterProvider, getRouterProvider,
 } from './context';
+export type { DataProviderInput } from './context';
 export {
   useList, useInfiniteList,
   useOne, useShow,
   useSelect, useMany,
   useCustom, useApiUrl,
+  useCustomMutation, useInvalidate,
   useCreate, useCreateMany,
   useUpdate, useUpdateMany,
   useDelete, useDeleteMany,
   useForm, useTable,
-  useNavigation,
+  useNavigation, useGo, useBack,
+  useGetToPath, useLink,
   useResource,
+  useLog, useLogList,
+  useModalForm, useDrawerForm, useModal,
+  useOvertime, useRelation,
+  useNotification, useDataProvider,
+  useMenu, useBreadcrumb, useThemedLayoutContext,
 } from './hooks.svelte';
-export { matchRoute, navigate, currentPath } from './router';
+export { matchRoute, navigate, currentPath, setActiveRouterProvider } from './router';
 export { readURLState, writeURLState } from './url-sync';
 export { setAccessControl, canAccess, canAccessAsync } from './permissions';
-export { useLive } from './live';
+export { useLive, useSubscription, usePublish } from './live';
 export { toast } from './toast.svelte';
 export { notify, closeNotification, setNotificationProvider, getNotificationProvider } from './notification.svelte';
-export { t, setLocale, getLocale, getAvailableLocales, addTranslations } from './i18n.svelte';
-export { audit, setAuditHandler } from './audit';
+export { t, setLocale, getLocale, getAvailableLocales, addTranslations, useTranslation } from './i18n.svelte';
+export { audit, setAuditHandler, setAuditLogProvider, getAuditLogProvider } from './audit';
+export type { AuditLogProvider } from './audit';
 export { getTheme, setTheme, toggleTheme, getResolvedTheme, getColorTheme, setColorTheme, colorThemes } from './theme.svelte';
 export type { ThemeMode, ColorTheme } from './theme.svelte';
+export { setUnsavedChanges, getUnsavedChanges, initUnsavedChangesNotifier } from './unsaved-changes.svelte';
+export { setAdminOptions, getAdminOptions, getTextTransformers } from './options';
+export type { AdminOptions, TextTransformers, OvertimeConfig } from './options';
 
+export * from './query-keys';
+export { HttpError } from './types';
 export type {
   DataProvider, AuthProvider, NotificationProvider, MutationMode,
+  ValidationErrors, CrudOperator, LogicalFilter,
+  CustomParams, CustomResult,
   GetListParams, GetListResult,
   GetOneParams, GetOneResult,
   GetManyParams, GetManyResult,
@@ -39,13 +56,39 @@ export type {
   UpdateManyParams, UpdateManyResult,
   DeleteParams, DeleteResult,
   DeleteManyParams, DeleteManyResult,
-  CustomParams, CustomResult,
   Pagination, Sort, Filter, Identity,
   ResourceDefinition, FieldDefinition,
   AuthActionResult, CheckResult,
+  ResourceTypeMap, KnownResources, InferData,
+  BaseRecord,
 } from './types';
-export type { LiveProvider, LiveEvent } from './live';
+export type { InvalidateScope } from './options';
+export type { LiveProvider, LiveEvent, LiveMode } from './live';
 export type { Action, AccessControlResult, AccessControlFn } from './permissions';
 export type { AuditEntry, AuditHandler } from './audit';
 export { useCan } from './useCan';
 export { useExport, useImport } from './data-transfer';
+export type { UseExportOptions, UseImportOptions } from './data-transfer';
+export {
+  useLogin, useLogout,
+  useRegister, useForgotPassword, useUpdatePassword,
+  useGetIdentity, useIsAuthenticated,
+  useOnError, usePermissions,
+} from './auth-hooks.svelte';
+export { useParsed } from './useParsed';
+export * from './useStepsForm.svelte';
+export { createHashRouterProvider, createHistoryRouterProvider } from './router-provider';
+export type { RouterProvider } from './router-provider';
+export { inferFieldType, inferResource } from './inferencer';
+export type { InferResult } from './inferencer';
+export { createWebSocketLiveProvider } from './live-websocket';
+export type { WebSocketLiveProviderOptions } from './live-websocket';
+export { createSSELiveProvider } from './live-sse';
+export type { SSELiveProviderOptions } from './live-sse';
+export { inferFromOpenAPI } from './inferencer-openapi';
+export type { InferFromOpenAPIOptions } from './inferencer-openapi';
+export {
+  getDefaultFilter, getDefaultSortOrder,
+  unionFilters, unionSorters,
+  file2Base64, generateDefaultDocumentTitle,
+} from './helpers';

package/src/inferencer-openapi.test.ts

@@ -0,0 +1,192 @@
+/**
+ * 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);
+  });
+});