@svadmin/core 0.0.3 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "Core SDK — hooks, types, context, i18n, permissions, router",
   "type": "module",
   "sideEffects": false,

package/src/auth-hooks.svelte.ts

@@ -0,0 +1,293 @@
+// Auth Hooks — reactive wrappers around AuthProvider methods
+// Each hook encapsulates the auth call + loading state + error handling + redirect
+// IMPORTANT: getAuthProvider() must be called at hook creation time (during component init),
+//            not inside mutate(), because Svelte's getContext() only works during init.
+
+import { getAuthProvider } from './context';
+import { navigate } from './router';
+import { toast } from './toast.svelte';
+import { t } from './i18n.svelte';
+import type { AuthActionResult, CheckResult, Identity } from './types';
+
+// ─── useLogin ─────────────────────────────────────────────────
+
+export function useLogin() {
+  const provider = getAuthProvider();
+  let isLoading = $state(false);
+
+  async function mutate(params: Record<string, unknown>): Promise<AuthActionResult> {
+    if (!provider) throw new Error('AuthProvider not configured');
+    isLoading = true;
+    try {
+      const result = await provider.login(params);
+      if (result.success) {
+        toast.success(t('common.operationSuccess'));
+        if (result.redirectTo) navigate(result.redirectTo);
+      } else {
+        const msg = result.error?.message ?? t('common.loginFailed');
+        toast.error(msg);
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : t('common.loginFailed');
+      toast.error(msg);
+      return { success: false, error: { message: msg } };
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  return {
+    mutate,
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useLogout ────────────────────────────────────────────────
+
+export function useLogout() {
+  const provider = getAuthProvider();
+  let isLoading = $state(false);
+
+  async function mutate(params?: Record<string, unknown>): Promise<AuthActionResult> {
+    if (!provider) throw new Error('AuthProvider not configured');
+    isLoading = true;
+    try {
+      const result = await provider.logout(params);
+      if (result.success) {
+        navigate(result.redirectTo ?? '/login');
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : t('common.operationFailed');
+      toast.error(msg);
+      return { success: false, error: { message: msg } };
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  return {
+    mutate,
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useRegister ──────────────────────────────────────────────
+
+export function useRegister() {
+  const provider = getAuthProvider();
+  let isLoading = $state(false);
+
+  async function mutate(params: Record<string, unknown>): Promise<AuthActionResult> {
+    if (!provider?.register) throw new Error('AuthProvider.register not implemented');
+    isLoading = true;
+    try {
+      const result = await provider.register(params);
+      if (result.success) {
+        toast.success(t('auth.registerSuccess'));
+        if (result.redirectTo) navigate(result.redirectTo);
+      } else {
+        const msg = result.error?.message ?? t('common.operationFailed');
+        toast.error(msg);
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : t('common.operationFailed');
+      toast.error(msg);
+      return { success: false, error: { message: msg } };
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  return {
+    mutate,
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useForgotPassword ───────────────────────────────────────
+
+export function useForgotPassword() {
+  const provider = getAuthProvider();
+  let isLoading = $state(false);
+
+  async function mutate(params: Record<string, unknown>): Promise<AuthActionResult> {
+    if (!provider?.forgotPassword) throw new Error('AuthProvider.forgotPassword not implemented');
+    isLoading = true;
+    try {
+      const result = await provider.forgotPassword(params);
+      if (result.success) {
+        toast.success(t('auth.resetLinkSent'));
+      } else {
+        const msg = result.error?.message ?? t('common.operationFailed');
+        toast.error(msg);
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : t('common.operationFailed');
+      toast.error(msg);
+      return { success: false, error: { message: msg } };
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  return {
+    mutate,
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useUpdatePassword ───────────────────────────────────────
+
+export function useUpdatePassword() {
+  const provider = getAuthProvider();
+  let isLoading = $state(false);
+
+  async function mutate(params: Record<string, unknown>): Promise<AuthActionResult> {
+    if (!provider?.updatePassword) throw new Error('AuthProvider.updatePassword not implemented');
+    isLoading = true;
+    try {
+      const result = await provider.updatePassword(params);
+      if (result.success) {
+        toast.success(t('common.operationSuccess'));
+        if (result.redirectTo) navigate(result.redirectTo);
+      } else {
+        const msg = result.error?.message ?? t('common.operationFailed');
+        toast.error(msg);
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : t('common.operationFailed');
+      toast.error(msg);
+      return { success: false, error: { message: msg } };
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  return {
+    mutate,
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useGetIdentity ──────────────────────────────────────────
+
+export function useGetIdentity() {
+  const provider = getAuthProvider();
+  let data = $state<Identity | null>(null);
+  let isLoading = $state(true);
+  let error = $state<Error | null>(null);
+
+  if (provider) {
+    provider.getIdentity().then(identity => {
+      data = identity;
+      isLoading = false;
+    }).catch(err => {
+      error = err instanceof Error ? err : new Error(String(err));
+      isLoading = false;
+      console.warn('[svadmin] useGetIdentity failed:', err);
+    });
+  } else {
+    isLoading = false;
+  }
+
+  return {
+    get data() { return data; },
+    get isLoading() { return isLoading; },
+    get error() { return error; },
+  };
+}
+
+// ─── useIsAuthenticated ──────────────────────────────────────
+
+export function useIsAuthenticated() {
+  const provider = getAuthProvider();
+  let isAuthenticated = $state(false);
+  let isLoading = $state(true);
+
+  if (provider) {
+    provider.check().then((result: CheckResult) => {
+      isAuthenticated = result.authenticated;
+      isLoading = false;
+    }).catch(() => {
+      isAuthenticated = false;
+      isLoading = false;
+    });
+  } else {
+    // No auth provider — treat as authenticated
+    isAuthenticated = true;
+    isLoading = false;
+  }
+
+  return {
+    get isAuthenticated() { return isAuthenticated; },
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useOnError ──────────────────────────────────────────────
+
+/**
+ * Handles errors from data hooks by calling authProvider.onError().
+ * If the provider returns { logout: true }, triggers logout flow.
+ * If it returns { redirectTo }, navigates there.
+ */
+export function useOnError() {
+  const provider = getAuthProvider();
+
+  async function mutate(error: unknown) {
+    if (!provider?.onError) {
+      console.warn('[svadmin] useOnError: authProvider.onError not implemented');
+      return;
+    }
+    try {
+      const result = await provider.onError(error);
+      if (result.logout) {
+        await provider.logout?.();
+        navigate(result.redirectTo ?? '/login');
+      } else if (result.redirectTo) {
+        navigate(result.redirectTo);
+      }
+    } catch (err) {
+      console.warn('[svadmin] useOnError failed:', err);
+    }
+  }
+
+  return { mutate };
+}
+
+// ─── usePermissions ──────────────────────────────────────────
+
+/**
+ * Fetches permissions from authProvider.getPermissions().
+ * Returns a reactive object with data, isLoading, and error.
+ */
+export function usePermissions<T = unknown>() {
+  const provider = getAuthProvider();
+  let data = $state<T | null>(null);
+  let isLoading = $state(true);
+  let error = $state<Error | null>(null);
+
+  if (provider?.getPermissions) {
+    provider.getPermissions().then(permissions => {
+      data = permissions as T;
+      isLoading = false;
+    }).catch(err => {
+      error = err instanceof Error ? err : new Error(String(err));
+      isLoading = false;
+      console.warn('[svadmin] usePermissions failed:', err);
+    });
+  } else {
+    isLoading = false;
+  }
+
+  return {
+    get data() { return data; },
+    get isLoading() { return isLoading; },
+    get error() { return error; },
+  };
+}

package/src/context.ts

@@ -2,10 +2,12 @@
 
 import { getContext, setContext } from 'svelte';
 import type { DataProvider, AuthProvider, ResourceDefinition } from './types';
+import type { RouterProvider } from './router-provider';
 
 const DATA_PROVIDER_KEY = Symbol('data-provider');
 const AUTH_PROVIDER_KEY = Symbol('auth-provider');
 const RESOURCES_KEY = Symbol('resources');
+const ROUTER_PROVIDER_KEY = Symbol('router-provider');
 
 // ─── Setters (called once in App.svelte) ────────────────────────
 
@@ -47,3 +49,13 @@ export function getResource(name: string): ResourceDefinition {
   if (!resource) throw new Error(`Resource "${name}" not found in resource definitions.`);
   return resource;
 }
+
+// ─── Router Provider ────────────────────────────────────────────
+
+export function setRouterProvider(provider: RouterProvider): void {
+  setContext(ROUTER_PROVIDER_KEY, provider);
+}
+
+export function getRouterProvider(): RouterProvider | undefined {
+  return getContext<RouterProvider>(ROUTER_PROVIDER_KEY);
+}

package/src/data-transfer.test.ts

@@ -0,0 +1,118 @@
+// Unit tests for CSV parsing and data-transfer utilities
+import { describe, test, expect } from 'bun:test';
+
+// We test parseCSVLine directly by re-implementing the exported logic
+// since the function is not exported. We test the CSV format contract.
+
+function parseCSVLine(line: string): string[] {
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (ch === '"') {
+        inQuotes = false;
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ',') {
+        result.push(current.trim());
+        current = '';
+      } else {
+        current += ch;
+      }
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+
+describe('parseCSVLine', () => {
+  test('simple comma-separated values', () => {
+    expect(parseCSVLine('a,b,c')).toEqual(['a', 'b', 'c']);
+  });
+
+  test('values with whitespace are trimmed', () => {
+    expect(parseCSVLine(' hello , world , test ')).toEqual(['hello', 'world', 'test']);
+  });
+
+  test('quoted values preserve commas', () => {
+    expect(parseCSVLine('"hello, world",b,c')).toEqual(['hello, world', 'b', 'c']);
+  });
+
+  test('escaped quotes inside quoted values', () => {
+    expect(parseCSVLine('"say ""hello""",b')).toEqual(['say "hello"', 'b']);
+  });
+
+  test('empty values', () => {
+    expect(parseCSVLine('a,,c')).toEqual(['a', '', 'c']);
+  });
+
+  test('single value', () => {
+    expect(parseCSVLine('hello')).toEqual(['hello']);
+  });
+
+  test('empty line', () => {
+    expect(parseCSVLine('')).toEqual(['']);
+  });
+
+  test('quoted value with newline character', () => {
+    expect(parseCSVLine('"line1\nline2",b')).toEqual(['line1\nline2', 'b']);
+  });
+
+  test('mixed quoted and unquoted', () => {
+    expect(parseCSVLine('1,"John Doe","admin@test.com",true')).toEqual([
+      '1', 'John Doe', 'admin@test.com', 'true'
+    ]);
+  });
+});
+
+// CSV row formatting (escape logic from useExport)
+function escapeCSVField(val: unknown): string {
+  const str = val === null || val === undefined ? '' : String(val);
+  return str.includes(',') || str.includes('"') || str.includes('\n')
+    ? `"${str.replace(/"/g, '""')}"`
+    : str;
+}
+
+describe('escapeCSVField', () => {
+  test('simple string passes through', () => {
+    expect(escapeCSVField('hello')).toBe('hello');
+  });
+
+  test('null becomes empty string', () => {
+    expect(escapeCSVField(null)).toBe('');
+  });
+
+  test('undefined becomes empty string', () => {
+    expect(escapeCSVField(undefined)).toBe('');
+  });
+
+  test('string with comma is quoted', () => {
+    expect(escapeCSVField('hello, world')).toBe('"hello, world"');
+  });
+
+  test('string with double quote is escaped', () => {
+    expect(escapeCSVField('say "hi"')).toBe('"say ""hi"""');
+  });
+
+  test('string with newline is quoted', () => {
+    expect(escapeCSVField('line1\nline2')).toBe('"line1\nline2"');
+  });
+
+  test('number is converted to string', () => {
+    expect(escapeCSVField(42)).toBe('42');
+  });
+
+  test('boolean is converted to string', () => {
+    expect(escapeCSVField(true)).toBe('true');
+  });
+});

package/src/hooks.svelte.ts

@@ -190,6 +190,7 @@ export function useNavigation() {
     create: (resource: string) => navigate(`/${resource}/create`),
     edit: (resource: string, id: string | number) => navigate(`/${resource}/edit/${id}`),
     show: (resource: string, id: string | number) => navigate(`/${resource}/show/${id}`),
+    clone: (resource: string, id: string | number) => navigate(`/${resource}/create?clone_id=${id}`),
     goBack: () => history.back(),
     push: (path: string) => navigate(path),
   };
@@ -393,12 +394,17 @@ interface UseFormOptions {
   onMutationError?: (error: Error) => void;
   meta?: Record<string, unknown>;
   validate?: (values: Record<string, unknown>) => Record<string, string> | null;
+  autoSave?: {
+    enabled: boolean;
+    debounce?: number; // ms, default 1000
+    onFinish?: (values: Record<string, unknown>) => Record<string, unknown>; // transform before save
+  };
 }
 
 export function useForm<T = Record<string, unknown>>(options: UseFormOptions) {
   const provider = getDataProvider();
   const queryClient = useQueryClient();
-  const { resource, action, id, redirect = 'list', onMutationSuccess, onMutationError, meta, validate } = options;
+  const { resource, action, id, redirect = 'list', onMutationSuccess, onMutationError, meta, validate, autoSave } = options;
 
   // Validation state
   let errors = $state<Record<string, string>>({});
@@ -496,7 +502,7 @@ export function useForm<T = Record<string, unknown>>(options: UseFormOptions) {
     }
   }
 
-  return {
+  const base = {
     query,
     get formLoading() {
       // @ts-expect-error $ rune prefix — Svelte compiler transforms this
@@ -509,6 +515,35 @@ export function useForm<T = Record<string, unknown>>(options: UseFormOptions) {
     clearErrors,
     clearFieldError,
   };
+
+  // ─── autoSave ─────────────────────────────────────────────
+  let autoSaveStatus = $state<'idle' | 'saving' | 'saved' | 'error'>('idle');
+  let autoSaveTimer: ReturnType<typeof setTimeout> | null = null;
+
+  function triggerAutoSave(values: Record<string, unknown>) {
+    if (!autoSave?.enabled || action === 'create') return;
+    if (autoSaveTimer) clearTimeout(autoSaveTimer);
+
+    autoSaveTimer = setTimeout(async () => {
+      const finalValues = autoSave.onFinish ? autoSave.onFinish(values) : values;
+      autoSaveStatus = 'saving';
+      try {
+        await provider.update<T>({ resource, id: id!, variables: finalValues });
+        queryClient.invalidateQueries({ queryKey: [resource] });
+        autoSaveStatus = 'saved';
+        // Reset to idle after 2s
+        setTimeout(() => { autoSaveStatus = 'idle'; }, 2000);
+      } catch {
+        autoSaveStatus = 'error';
+      }
+    }, autoSave.debounce ?? 1000);
+  }
+
+  return {
+    ...base,
+    triggerAutoSave,
+    get autoSaveStatus() { return autoSaveStatus; },
+  };
 }
 
 // ─── useTable ───────────────────────────────────────────────────

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': '页面未找到',
@@ -105,6 +106,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 +127,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',

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

@@ -4,6 +4,7 @@ export {
   setDataProvider, getDataProvider,
   setAuthProvider, getAuthProvider,
   setResources, getResources, getResource,
+  setRouterProvider, getRouterProvider,
 } from './context';
 export {
   useList, useInfiniteList,
@@ -49,3 +50,14 @@ export type { Action, AccessControlResult, AccessControlFn } from './permissions
 export type { AuditEntry, AuditHandler } from './audit';
 export { useCan } from './useCan';
 export { useExport, useImport } from './data-transfer';
+export {
+  useLogin, useLogout,
+  useRegister, useForgotPassword, useUpdatePassword,
+  useGetIdentity, useIsAuthenticated,
+  useOnError, usePermissions,
+} from './auth-hooks.svelte';
+export { useParsed } from './useParsed';
+export { createHashRouterProvider, createHistoryRouterProvider } from './router-provider';
+export type { RouterProvider } from './router-provider';
+export { inferFieldType, inferResource } from './inferencer';
+export type { InferResult } from './inferencer';