@svadmin/core 0.22.1 → 0.23.0

package/src/hooks.svelte.ts

@@ -25,7 +25,8 @@ import { createQuery, createInfiniteQuery, createMutation, useQueryClient } from
 import { getAdminOptions } from './options.svelte';
 import { getDataProviderForResource, getDataProvider, getLiveProvider } from './context.svelte';
 import { useParsed } from './useParsed.svelte';
-import { createOvertimeTracker, createLiveSubscription, fireSuccessNotification, fireErrorNotification } from './hook-utils.svelte';
+import { createOvertimeTracker, createLiveSubscription, fireSuccessNotification, fireErrorNotification, checkError } from './hook-utils.svelte';
+import { invalidateByScopes } from './mutation-hooks.svelte';
 import type { NotificationConfig, OvertimeOptions, LiveSubscriptionParams } from './hook-utils.svelte';
 import type { BaseRecord, HttpError, Pagination, Sort, Filter, DataProvider, KnownResources } from './types';
 import type { LiveMode, LiveEvent } from './live.svelte';
@@ -58,7 +59,7 @@ export function useInfiniteList<TData extends BaseRecord = BaseRecord, TError =
     const resource = options.resource ?? parsed.resource ?? '';
     const provider = getDataProviderForResource(resource, options.dataProviderName);
     return {
-    queryKey: [resource, 'infiniteList', options.pagination?.pageSize, options.sorters, options.filters, options.meta],
+    queryKey: [options.dataProviderName, resource, 'infiniteList', options.pagination?.pageSize, options.sorters, options.filters, options.meta],
     queryFn: async ({ pageParam = 1 }) => {
       const result = await provider.getList<TData>({
         resource,
@@ -93,10 +94,15 @@ export function useInfiniteList<TData extends BaseRecord = BaseRecord, TError =
     enabled: options.queryOptions?.enabled ?? true,
   }));
 
+  let lastSuccessAt = 0;
+  let lastErrorAt = 0;
   $effect(() => {
-    if (query.isSuccess && options.successNotification) {
+    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && options.successNotification) {
+      lastSuccessAt = query.dataUpdatedAt;
       fireSuccessNotification(options.successNotification, '', query.data, undefined, options.resource ?? parsed.resource ?? '');
-    } else if (query.isError) {
+    } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
+      lastErrorAt = query.errorUpdatedAt;
+      checkError(query.error);
       fireErrorNotification(options.errorNotification, 'Fetch failed', query.error);
     }
   });
@@ -145,7 +151,7 @@ export function useSelect<TData extends BaseRecord = BaseRecord, TOption = { lab
   const query = createQuery<{ data: TData[]; total: number }>(() => {
     const provider = getDataProviderForResource(resource, dataProviderName);
     return {
-    queryKey: [resource, 'select', allFilters, sorters, pagination, meta],
+    queryKey: [dataProviderName, resource, 'select', allFilters, sorters, pagination, meta],
     queryFn: () => provider.getList<TData>({ resource, sorters, filters: allFilters, pagination: { current: 1, pageSize: effectivePageSize }, meta }),
     enabled: options.queryOptions?.enabled ?? true,
     staleTime: options.queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
@@ -158,7 +164,7 @@ export function useSelect<TData extends BaseRecord = BaseRecord, TOption = { lab
     ? createQuery<{ data: TData[] }>(() => {
         const provider = getDataProviderForResource(resource, dataProviderName);
         return {
-          queryKey: [resource, 'select-defaults', defaultValueIds],
+          queryKey: [dataProviderName, resource, 'select-defaults', defaultValueIds],
           queryFn: async () => {
             if (provider.getMany) return provider.getMany<TData>({ resource, ids: defaultValueIds, meta });
             const results = await Promise.all(defaultValueIds.map(id => provider.getOne<TData>({ resource, id, meta })));
@@ -191,6 +197,19 @@ export function useSelect<TData extends BaseRecord = BaseRecord, TOption = { lab
 
   const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
 
+  let lastSuccessAt = 0;
+  let lastErrorAt = 0;
+  $effect(() => {
+    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && options.successNotification) {
+      lastSuccessAt = query.dataUpdatedAt;
+      fireSuccessNotification(options.successNotification, '', query.data, undefined, resource);
+    } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
+      lastErrorAt = query.errorUpdatedAt;
+      checkError(query.error);
+      fireErrorNotification(options.errorNotification, 'Fetch failed', query.error);
+    }
+  });
+
   function onSearchChange(value: string) {
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(() => { searchText = value; }, debounceMs);
@@ -229,7 +248,7 @@ export function useCustom<TData = unknown, TError = HttpError>(options: UseCusto
   const query = createQuery<{ data: TData }, TError>(() => {
     const provider = getDataProvider(options.dataProviderName);
     return {
-    queryKey: ['custom', options.url, options.method, options.config, options.meta],
+    queryKey: [options.dataProviderName, 'custom', options.url, options.method, options.config, options.meta],
     queryFn: async () => {
       if (!provider.custom) throw new Error('DataProvider does not support custom method');
       return provider.custom<TData>({
@@ -250,6 +269,19 @@ export function useCustom<TData = unknown, TError = HttpError>(options: UseCusto
 
   const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
 
+  let lastSuccessAt = 0;
+  let lastErrorAt = 0;
+  $effect(() => {
+    if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && options.successNotification) {
+      lastSuccessAt = query.dataUpdatedAt;
+      fireSuccessNotification(options.successNotification, '', query.data);
+    } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
+      lastErrorAt = query.errorUpdatedAt;
+      checkError(query.error);
+      fireErrorNotification(options.errorNotification, 'Custom request failed', query.error);
+    }
+  });
+
   return { query, get overtime() { return overtime; } };
 }
 
@@ -258,11 +290,19 @@ export function useCustom<TData = unknown, TError = HttpError>(options: UseCusto
 export function useCustomMutation<TData = unknown, TError = HttpError, TVariables = unknown>(dataProviderName?: string) {
   const queryClient = useQueryClient();
 
-  const mutation = createMutation<{ data: TData }, TError, { url: string; method: 'get' | 'post' | 'put' | 'patch' | 'delete'; values?: TVariables; meta?: Record<string, unknown> }>(() => ({
+  const mutation = createMutation<{ data: TData }, TError, { url: string; method: 'get' | 'post' | 'put' | 'patch' | 'delete'; values?: TVariables; query?: Record<string, unknown>; headers?: Record<string, string>; sorters?: Sort[]; filters?: Filter[]; meta?: Record<string, unknown>; invalidates?: string[] | false; resource?: string }>(() => ({
     mutationFn: async (params) => {
       const provider = getDataProvider(dataProviderName);
       if (!provider.custom) throw new Error('DataProvider does not support custom method');
-      return provider.custom<TData>({ url: params.url, method: params.method, payload: params.values, meta: params.meta });
+      return provider.custom<TData>({ url: params.url, method: params.method, payload: params.values, query: params.query, headers: params.headers, sorters: params.sorters, filters: params.filters, meta: params.meta });
+    },
+    onSuccess: (data, params) => {
+      if (params.resource && params.invalidates !== false) {
+        invalidateByScopes(queryClient, params.resource, params.invalidates, ['list', 'many']);
+      }
+    },
+    onError: (error) => {
+      checkError(error);
     },
   }));
 
@@ -290,7 +330,19 @@ export function useCreateMany<TData extends BaseRecord = BaseRecord, TError = Ht
         return { data: results.map(r => r.data) };
       } finally { isMutating = false; }
     },
-    onSuccess: (_d, params) => { queryClient.invalidateQueries({ queryKey: [params.resource ?? resource] }); },
+    onSuccess: (data, params) => {
+      const resName = params.resource ?? resource;
+      fireSuccessNotification(undefined, 'Created successfully', data.data, params.variables, resName);
+      audit({ action: 'create', resource: resName });
+    },
+    onError: (error, params) => {
+      checkError(error);
+      fireErrorNotification(undefined, 'Create many failed', error);
+    },
+    onSettled: (_d, _e, params) => {
+      const resName = params.resource ?? resource;
+      invalidateByScopes(queryClient, resName, undefined, ['list', 'many']);
+    },
   }));
 
   return { mutation, get overtime() { return overtime; } };
@@ -315,7 +367,22 @@ export function useUpdateMany<TData extends BaseRecord = BaseRecord, TError = Ht
         return { data: results.map(r => r.data) };
       } finally { isMutating = false; }
     },
-    onSuccess: (_d, params) => { queryClient.invalidateQueries({ queryKey: [params.resource ?? resource] }); },
+    onSuccess: (data, params) => {
+      const resName = params.resource ?? resource;
+      fireSuccessNotification(undefined, 'Updated successfully', data.data, params.variables, resName);
+      audit({ action: 'update', resource: resName });
+    },
+    onError: (error, params) => {
+      checkError(error);
+      fireErrorNotification(undefined, 'Update many failed', error);
+    },
+    onSettled: (_d, _e, params) => {
+      const resName = params.resource ?? resource;
+      invalidateByScopes(queryClient, resName, undefined, ['list', 'many', 'detail'], undefined);
+      for (const id of params.ids) {
+        queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === id });
+      }
+    },
   }));
 
   return { mutation, get overtime() { return overtime; } };
@@ -340,7 +407,22 @@ export function useDeleteMany<TData extends BaseRecord = BaseRecord, TError = Ht
         return { data: results.map(r => r.data) };
       } finally { isMutating = false; }
     },
-    onSuccess: (_d, params) => { queryClient.invalidateQueries({ queryKey: [params.resource ?? resource] }); },
+    onSuccess: (data, params) => {
+      const resName = params.resource ?? resource;
+      fireSuccessNotification(undefined, 'Deleted successfully', data.data, undefined, resName);
+      audit({ action: 'delete', resource: resName });
+    },
+    onError: (error, params) => {
+      checkError(error);
+      fireErrorNotification(undefined, 'Delete many failed', error);
+    },
+    onSettled: (_d, _e, params) => {
+      const resName = params.resource ?? resource;
+      invalidateByScopes(queryClient, resName, undefined, ['list', 'many']);
+      for (const id of params.ids) {
+        queryClient.removeQueries({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === id });
+      }
+    },
   }));
 
   return { mutation, get overtime() { return overtime; } };
@@ -357,12 +439,13 @@ export function useInvalidate() {
       return;
     }
     const scopes = params.invalidates || ['resourceAll'];
+    const res = params.resource;
     for (const scope of scopes) {
-      if (scope === 'resourceAll') queryClient.invalidateQueries({ queryKey: [params.resource] });
-      else if ((scope === 'detail' || scope === 'one') && params.id) queryClient.invalidateQueries({ queryKey: [params.resource, 'one', params.id] });
-      else if (scope === 'one') queryClient.invalidateQueries({ queryKey: [params.resource, 'one'] });
-      else if (scope === 'list') queryClient.invalidateQueries({ queryKey: [params.resource, 'list'] });
-      else if (scope === 'many') queryClient.invalidateQueries({ queryKey: [params.resource, 'many'] });
+      if (scope === 'resourceAll') queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === res });
+      else if ((scope === 'detail' || scope === 'one') && params.id) queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === res && q.queryKey[2] === 'one' && q.queryKey[3] === params.id });
+      else if (scope === 'one') queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === res && q.queryKey[2] === 'one' });
+      else if (scope === 'list') queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === res && (q.queryKey[2] === 'list' || q.queryKey[2] === 'infiniteList' || q.queryKey[2] === 'select') });
+      else if (scope === 'many') queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === res && q.queryKey[2] === 'many' });
     }
   };
 }

package/src/i18n.svelte.ts

@@ -2,7 +2,7 @@
 
 
 
-const locales: Record<string, Record<string, string>> = {
+let locales = $state<Record<string, Record<string, string>>>({
   'zh-CN': {
     'common.list': '列表',
     'common.prev': '上一页',
@@ -19,6 +19,8 @@ const locales: Record<string, Record<string, string>> = {
     'common.create': '新建',
     'common.edit': '编辑',
     'common.delete': '删除',
+    'common.batchDeletePartialFail': '批量删除部分失败：{failed}/{total} 条未成功',
+    'common.batchDeleteSuccess': '成功删除 {count} 条记录',
     'common.search': '搜索...',
     'common.confirm': '确定',
     'common.loading': '加载中...',
@@ -151,6 +153,8 @@ const locales: Record<string, Record<string, string>> = {
     'validation.minLength': '最少 {min} 个字符',
     'validation.maxLength': '最多 {max} 个字符',
     'validation.invalidEmail': '请输入有效的邮箱地址',
+    'validation.invalidUrl': '请输入有效的 URL 地址',
+    'validation.invalidNumber': '请输入有效的数字',
     'validation.invalidFormat': '格式不正确',
     // Settings
     'settings.title': '设置',
@@ -266,6 +270,8 @@ const locales: Record<string, Record<string, string>> = {
     'common.create': 'Create',
     'common.edit': 'Edit',
     'common.delete': 'Delete',
+    'common.batchDeletePartialFail': 'Batch delete partially failed: {failed}/{total} unsuccessful',
+    'common.batchDeleteSuccess': 'Successfully deleted {count} records',
     'common.search': 'Search...',
     'common.confirm': 'Confirm',
     'common.loading': 'Loading...',
@@ -398,6 +404,8 @@ const locales: Record<string, Record<string, string>> = {
     'validation.minLength': 'Minimum {min} characters',
     'validation.maxLength': 'Maximum {max} characters',
     'validation.invalidEmail': 'Please enter a valid email address',
+    'validation.invalidUrl': 'Please enter a valid URL',
+    'validation.invalidNumber': 'Please enter a valid number',
     'validation.invalidFormat': 'Invalid format',
     // Settings
     'settings.title': 'Settings',
@@ -497,19 +505,18 @@ const locales: Record<string, Record<string, string>> = {
     'profile.passwordChanged': 'Password updated successfully',
     'profile.updatePassword': 'Update Password',
   },
-};
+});
 
 /** Detect best locale from browser language */
 function detectLocale(): string {
-  if (typeof navigator === 'undefined') return 'en'; // Safe default for SSR
+  if (typeof navigator === 'undefined') return 'en';
   const browserLang = navigator.language || navigator.languages?.[0] || 'zh-CN';
-  // Exact match
   if (locales[browserLang]) return browserLang;
-  // Prefix match (e.g., 'zh' → 'zh-CN', 'en-US' → 'en')
   const prefix = browserLang.split('-')[0];
   for (const key of Object.keys(locales)) {
-    if (key.startsWith(prefix)) return key;
+    if (key === browserLang || key.startsWith(prefix + '-')) return key;
   }
+  if (locales[prefix]) return prefix;
   return 'en';
 }
 
@@ -528,8 +535,8 @@ export function getAvailableLocales(): string[] {
 }
 
 export function t(key: string, params?: Record<string, string | number>): string {
-  const locale = locales[currentLocale] ?? locales['en'];
-  let text = locale[key] ?? key;
+  const locale = locales[currentLocale];
+  let text = locale?.[key] ?? locales['en']?.[key] ?? key;
 
   if (params) {
     for (const [k, v] of Object.entries(params)) {
@@ -540,7 +547,11 @@ 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 };
+  locales = { ...locales, [locale]: { ...locales[locale], ...translations } };
+}
+
+export function resetI18n(): void {
+  currentLocale = detectLocale();
 }
 
 /**
@@ -548,14 +559,9 @@ export function addTranslations(locale: string, translations: Record<string, str
  * Tracks locale changes natively.
  */
 export function useTranslation() {
-  const translate = $derived.by(() => {
-    // Read currentLocale so this $derived depends on it
-    const loc = currentLocale;
-    return (key: string, params?: Record<string, string | number>): string => {
-      // Intentionally passing the key to the main t() function which uses currentLocale
-      return t(key, params);
-    };
-  });
+  const translate = (key: string, params?: Record<string, string | number>): string => {
+    return t(key, params);
+  };
   
   return { 
     get t() { return translate; },

package/src/index.ts

@@ -6,6 +6,7 @@ export {
   setResources, getResources, getResource,
   setRouterProvider, getRouterProvider,
   setLiveProvider, getLiveProvider,
+  resetContext,
 } from './context.svelte';
 export type { DataProviderInput } from './context.svelte';
 export {
@@ -26,7 +27,8 @@ export {
   useNotification, useDataProvider,
   useMenu, useBreadcrumb, useThemedLayoutContext,
 } from './hooks.svelte';
-export { matchRoute, navigate, currentPath, setActiveRouterProvider } from './router';
+export { matchRoute, navigate, currentPath, setActiveRouterProvider, beforeEach, afterEach } from './router';
+export type { RouteGuard } from './router';
 export { readURLState, writeURLState } from './url-sync';
 export { setAccessControlProvider, getAccessControlProvider, getAccessControlOptions, canAccessAsync } from './permissions';
 export { useLive, useSubscription, usePublish } from './live.svelte';
@@ -42,12 +44,14 @@ export type { ThemeMode, ColorTheme, ThemeStrategy, ThemeConfig, ColorPreset } f
 export { setUnsavedChanges, getUnsavedChanges, initUnsavedChangesNotifier } from './unsaved-changes.svelte';
 export { setAdminOptions, getAdminOptions, getTextTransformers } from './options.svelte';
 export type { AdminOptions, TextTransformers, OvertimeConfig } from './options.svelte';
+export { checkError } from './hook-utils.svelte';
+export type { NotificationConfig, OvertimeOptions, OvertimeResult, LiveSubscriptionParams } from './hook-utils.svelte';
 
 export * from './query-keys';
-export { HttpError } from './types';
+export { HttpError, UndoError } from './types';
 export type {
   DataProvider, AuthProvider, NotificationProvider, MutationMode,
-  ValidationErrors, CrudOperator, LogicalFilter,
+  ValidationErrors, CrudOperator, LogicalFilter, FieldFilter,
   CustomParams, CustomResult,
   GetListParams, GetListResult,
   GetOneParams, GetOneResult,
@@ -101,3 +105,6 @@ export {
 } from './helpers';
 export { TableState } from './table-state.svelte';
 export type { TableStateOptions } from './table-state.svelte';
+export type { UseInfiniteListOptions } from './hooks.svelte';
+export type { UseSelectOptions } from './hooks.svelte';
+export type { UseFormReturn } from './form-hooks.svelte';

package/src/live.svelte.ts

@@ -16,27 +16,39 @@ export interface LiveProvider {
   subscribe(params: { resource: string; liveParams?: Record<string, unknown>; callback: (event: LiveEvent) => void }): () => void;
   unsubscribe?(params: { resource: string; liveParams?: Record<string, unknown> }): void;
   publish?(event: LiveEvent): void;
+  onConnected?: () => void;
+  onDisconnected?: () => void;
+}
+
+export interface LiveProviderReconnectOptions {
+  enabled?: boolean;
+  retryCount?: number;
+  retryInterval?: number;
 }
 
 // ─── useLive — auto-invalidate queries on real-time events ──────
 
 export function useLive(
-  liveProvider: LiveProvider,
-  resource: string,
-  options?: { liveMode?: LiveMode; onLiveEvent?: (event: LiveEvent) => void }
+  liveProvider: LiveProvider | (() => LiveProvider),
+  resource: string | (() => string),
+  options?: { liveMode?: LiveMode | (() => LiveMode); onLiveEvent?: (event: LiveEvent) => void; liveParams?: Record<string, unknown> | (() => Record<string, unknown>) }
 ): void {
   const queryClient = useQueryClient();
-  const liveMode = options?.liveMode ?? 'auto';
-
-  if (liveMode === 'off') return;
 
   $effect(() => {
-    const unsubscribe = liveProvider.subscribe({
-      resource,
+    const lp = typeof liveProvider === 'function' ? liveProvider() : liveProvider;
+    const res = typeof resource === 'function' ? resource() : resource;
+    const liveMode = typeof options?.liveMode === 'function' ? options.liveMode() : (options?.liveMode ?? 'auto');
+    const liveParams = typeof options?.liveParams === 'function' ? options.liveParams() : options?.liveParams;
+    if (liveMode === 'off') return;
+
+    const unsubscribe = lp.subscribe({
+      resource: res,
+      liveParams,
       callback: (event) => {
         options?.onLiveEvent?.(event);
         if (liveMode === 'auto') {
-          queryClient.invalidateQueries({ queryKey: [resource] });
+          queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === res });
         }
       },
     });
@@ -47,21 +59,25 @@ export function useLive(
 // ─── useSubscription — manual channel subscription ──────────────
 
 interface UseSubscriptionOptions {
-  resource: string;
-  liveProvider: LiveProvider;
+  resource: string | (() => string);
+  liveProvider: LiveProvider | (() => LiveProvider);
   onLiveEvent: (event: LiveEvent) => void;
-  enabled?: boolean;
+  enabled?: boolean | (() => boolean);
+  liveParams?: Record<string, unknown> | (() => Record<string, unknown>);
 }
 
 export function useSubscription(options: UseSubscriptionOptions): void {
-  const { resource, liveProvider, onLiveEvent, enabled = true } = options;
-
-  if (!enabled) return;
-
   $effect(() => {
-    const unsubscribe = liveProvider.subscribe({
-      resource,
-      callback: onLiveEvent,
+    const res = typeof options.resource === 'function' ? options.resource() : options.resource;
+    const lp = typeof options.liveProvider === 'function' ? options.liveProvider() : options.liveProvider;
+    const enabled = typeof options.enabled === 'function' ? options.enabled() : (options.enabled ?? true);
+    const liveParams = typeof options.liveParams === 'function' ? options.liveParams() : options.liveParams;
+    if (!enabled) return;
+
+    const unsubscribe = lp.subscribe({
+      resource: res,
+      liveParams,
+      callback: options.onLiveEvent,
     });
     return unsubscribe;
   });