@svadmin/core 0.0.6 → 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

@@ -47,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': '请选择',
@@ -134,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...',
@@ -221,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/index.ts

@@ -1,36 +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,
@@ -40,16 +56,19 @@ 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,
@@ -57,7 +76,19 @@ export {
   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);
+  });
+});