@svadmin/core 0.0.6 → 0.3.0

package/src/hooks.svelte.ts

@@ -1,618 +1,365 @@
-// Complete CRUD hooks — 100% Refine-compatible
-// TanStack Query v6 (Svelte 5 runes-native) wrappers
-
-import {
-  createQuery,
-  createMutation,
-  createInfiniteQuery,
-  useQueryClient,
-} from '@tanstack/svelte-query';
-import { getDataProvider } from './context';
-import type { GetListResult, Sort, Filter, Pagination, MutationMode } from './types';
-import { toast } from './toast.svelte';
+// @svadmin/core — Core Data and Hook APIs (Modularized for v0.2.29+)
+
+// ─── Re-exports from modular hook files ─────────────────────────────
+
+export * from './query-hooks.svelte';
+export * from './mutation-hooks.svelte';
+export * from './form-hooks.svelte';
+export * from './table-hooks.svelte';
+export * from './routing-hooks.svelte';
+export * from './utility-hooks.svelte';
+
+// ─── Re-export types from options ─────────────────────────────────
+export type { InvalidateScope, OvertimeConfig } from './options';
+
+// ─── Export shared utilities ────────────────────────────────────────
+
+export { createOvertimeTracker, createLiveSubscription } from './hook-utils.svelte';
+export type { OvertimeResult, OvertimeOptions, NotificationConfig } from './hook-utils.svelte';
+
+// ─── Missing hooks stubs ───────────────────────────────────────────
+// These hooks were in the original monolithic file. They are re-created
+// here as thin wrappers or stubs until they get their own modular files.
+
+import { createQuery, createInfiniteQuery, createMutation, useQueryClient } from '@tanstack/svelte-query';
+import { getAdminOptions } from './options';
+import { getDataProviderForResource, getDataProvider } from './context';
+import { useParsed } from './useParsed';
+import { createOvertimeTracker, fireSuccessNotification, fireErrorNotification } from './hook-utils.svelte';
+import type { NotificationConfig, OvertimeOptions } from './hook-utils.svelte';
+import type { BaseRecord, HttpError, Pagination, Sort, Filter, DataProvider, KnownResources } from './types';
+import type { LiveMode, LiveEvent } from './live';
+import { useList } from './query-hooks.svelte';
+import type { UseListOptions } from './query-hooks.svelte';
 import { audit } from './audit';
-import { navigate } from './router';
-import { t } from './i18n.svelte';
-import { readURLState, writeURLState } from './url-sync';
 
-// ─── useList ────────────────────────────────────────────────────
+// ─── useInfiniteList ────────────────────────────────────────────────
 
-interface UseListOptions {
-  resource: string;
+export interface UseInfiniteListOptions<TData extends BaseRecord = BaseRecord, TError = HttpError> {
+  resource?: KnownResources;
   pagination?: Pagination;
   sorters?: Sort[];
   filters?: Filter[];
   meta?: Record<string, unknown>;
-  enabled?: boolean;
+  dataProviderName?: string;
+  queryOptions?: { staleTime?: number; enabled?: boolean };
+  successNotification?: NotificationConfig;
+  errorNotification?: NotificationConfig;
+  liveMode?: LiveMode;
+  onLiveEvent?: (event: LiveEvent) => void;
+  overtimeOptions?: OvertimeOptions;
 }
 
-export function useList<T = Record<string, unknown>>(options: UseListOptions) {
-  const provider = getDataProvider();
-  const { resource, pagination, sorters, filters, meta, enabled = true } = options;
+export function useInfiniteList<TData extends BaseRecord = BaseRecord, TError = HttpError>(options: UseInfiniteListOptions<TData, TError> = {}) {
+  const parsed = useParsed();
+  const resource = options.resource ?? parsed.resource ?? '';
+  const adminOptions = getAdminOptions();
+  const provider = getDataProviderForResource(resource, options.dataProviderName);
 
-  return createQuery<GetListResult<T>>(() => ({
-    queryKey: [resource, 'list', { pagination, sorters, filters }],
-    queryFn: () => provider.getList<T>({ resource, pagination, sorters, filters, meta }),
-    enabled,
-  }));
-}
-
-// ─── useInfiniteList ────────────────────────────────────────────
-
-interface UseInfiniteListOptions {
-  resource: string;
-  pageSize?: number;
-  sorters?: Sort[];
-  filters?: Filter[];
-  meta?: Record<string, unknown>;
-  enabled?: boolean;
-}
-
-export function useInfiniteList<T = Record<string, unknown>>(options: UseInfiniteListOptions) {
-  const provider = getDataProvider();
-  const { resource, pageSize = 10, sorters, filters, meta, enabled = true } = options;
-
-  return createInfiniteQuery<GetListResult<T>>(() => ({
-    queryKey: [resource, 'infinite', { sorters, filters }],
-    queryFn: ({ pageParam = 1 }) =>
-      provider.getList<T>({
+  const query = createInfiniteQuery<{ data: TData[]; total: number }, TError>(() => ({
+    queryKey: [resource, 'infiniteList', options.sorters, options.filters, options.meta],
+    queryFn: async ({ pageParam = 1 }) => {
+      const result = await provider.getList<TData>({
         resource,
-        pagination: { current: pageParam as number, pageSize },
-        sorters,
-        filters,
-        meta,
-      }),
-    initialPageParam: 1,
-    getNextPageParam: (lastPage, allPages) => {
-      const totalFetched = allPages.reduce((sum, p) => sum + p.data.length, 0);
-      return totalFetched < lastPage.total ? allPages.length + 1 : undefined;
+        pagination: { current: pageParam as number, pageSize: options.pagination?.pageSize ?? 10 },
+        sorters: options.sorters,
+        filters: options.filters,
+        meta: options.meta,
+      });
+      return result;
     },
-    enabled,
-  }));
-}
-
-// ─── useOne ─────────────────────────────────────────────────────
-
-interface UseOneOptions {
-  resource: string;
-  id: string | number;
-  meta?: Record<string, unknown>;
-  enabled?: boolean;
-}
-
-export function useOne<T = Record<string, unknown>>(options: UseOneOptions) {
-  const provider = getDataProvider();
-  const { resource, id, meta, enabled = true } = options;
-
-  return createQuery(() => ({
-    queryKey: [resource, 'one', id],
-    queryFn: async () => {
-      const result = await provider.getOne<T>({ resource, id, meta });
-      return result.data;
+    initialPageParam: 1,
+    getNextPageParam: (lastPage: { data: TData[]; total: number }, allPages: { data: TData[]; total: number }[]) => {
+      const totalFetched = allPages.reduce((acc: number, p) => acc + (p.data?.length ?? 0), 0);
+      if (totalFetched >= (lastPage.total ?? 0)) return undefined;
+      return allPages.length + 1;
     },
-    enabled: enabled && id != null,
+    enabled: options.queryOptions?.enabled ?? true,
+    staleTime: options.queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
   }));
-}
 
-// ─── useShow (alias for useOne with route awareness) ────────────
+  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
 
-export function useShow<T = Record<string, unknown>>(options: UseOneOptions) {
-  return useOne<T>(options);
+  return { query, get overtime() { return overtime; } };
 }
 
-// ─── useSelect ──────────────────────────────────────────────────
+// ─── useSelect ──────────────────────────────────────────────────────
 
-interface UseSelectOptions {
-  resource: string;
-  optionLabel?: string;
-  optionValue?: string;
-  filters?: Filter[];
+export interface UseSelectOptions<TData extends BaseRecord = BaseRecord, TOption = { label: string; value: string | number }> {
+  resource: KnownResources;
+  optionLabel?: string | ((item: TData) => string);
+  optionValue?: string | ((item: TData) => string | number);
   sorters?: Sort[];
-  enabled?: boolean;
+  filters?: Filter[];
+  defaultValue?: (string | number)[];
+  fetchSize?: number;
+  pagination?: Pagination;
+  debounce?: number;
+  queryOptions?: { staleTime?: number; enabled?: boolean };
+  defaultValueQueryOptions?: { staleTime?: number; enabled?: boolean };
+  meta?: Record<string, unknown>;
+  dataProviderName?: string;
+  onSearch?: (value: string) => Filter[];
+  successNotification?: NotificationConfig;
+  errorNotification?: NotificationConfig;
+  overtimeOptions?: OvertimeOptions;
 }
 
-export function useSelect(options: UseSelectOptions) {
-  const provider = getDataProvider();
-  const {
-    resource, optionLabel = 'name', optionValue = 'id',
-    filters, sorters, enabled = true,
-  } = options;
+export function useSelect<TData extends BaseRecord = BaseRecord, TOption = { label: string; value: string | number }>(options: UseSelectOptions<TData, TOption>) {
+  const { resource, optionLabel = 'title', optionValue = 'id', sorters, filters, pagination, meta, dataProviderName, onSearch, debounce: debounceMs = 300 } = options;
+  const adminOptions = getAdminOptions();
+  const provider = getDataProviderForResource(resource, dataProviderName);
 
-  return createQuery(() => ({
-    queryKey: [resource, 'select', { optionLabel, optionValue, filters }],
-    queryFn: async () => {
-      const result = await provider.getList({ resource, pagination: { current: 1, pageSize: 1000 }, filters, sorters });
-      return result.data.map(item => ({
-        label: String(item[optionLabel] ?? ''),
-        value: String(item[optionValue] ?? ''),
-      }));
-    },
-    enabled,
-    staleTime: 10 * 60 * 1000,
-  }));
-}
+  let searchText = $state('');
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
 
-// ─── useMany ────────────────────────────────────────────────────
+  const searchFilters = $derived.by<Filter[]>(() => {
+    if (!onSearch || !searchText) return [];
+    return onSearch(searchText);
+  });
 
-interface UseManyOptions {
-  resource: string;
-  ids: (string | number)[];
-  meta?: Record<string, unknown>;
-  enabled?: boolean;
-}
+  const allFilters = $derived([...(filters ?? []), ...searchFilters]);
 
-export function useMany<T = Record<string, unknown>>(options: UseManyOptions) {
-  const provider = getDataProvider();
-  const { resource, ids, meta, enabled = true } = options;
+  const effectivePageSize = options.fetchSize ?? pagination?.pageSize ?? 999;
 
-  return createQuery(() => ({
-    queryKey: [resource, 'many', ids],
-    queryFn: async () => {
-      if (provider.getMany) {
-        const result = await provider.getMany<T>({ resource, ids, meta });
-        return result.data;
-      }
-      const results = await Promise.all(ids.map(id => provider.getOne<T>({ resource, id, meta })));
-      return results.map(r => r.data);
-    },
-    enabled: enabled && ids.length > 0,
+  const query = createQuery<{ data: TData[]; total: number }>(() => ({
+    queryKey: [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,
   }));
-}
-
-// ─── useCustom ──────────────────────────────────────────────────
 
-interface UseCustomQueryOptions<T = unknown> {
-  queryKey: unknown[];
-  queryFn: () => Promise<T>;
-  enabled?: boolean;
-}
-
-export function useCustom<T = unknown>(options: UseCustomQueryOptions<T>) {
-  return createQuery(() => ({
-    queryKey: options.queryKey,
-    queryFn: options.queryFn,
-    enabled: options.enabled ?? true,
-  }));
-}
+  // Parallel query to ensure default values are always available in options
+  const defaultValueIds = options.defaultValue ?? [];
+  const defaultValueQuery = defaultValueIds.length > 0
+    ? createQuery<{ data: TData[] }>(() => ({
+        queryKey: [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 })));
+          return { data: results.map(r => r.data) };
+        },
+        enabled: (options.defaultValueQueryOptions?.enabled ?? true) && defaultValueIds.length > 0,
+        staleTime: options.defaultValueQueryOptions?.staleTime ?? Infinity,
+      }))
+    : null;
 
-// ─── useApiUrl ──────────────────────────────────────────────────
+  const selectOptions = $derived.by(() => {
+    const queryResult = query.data as { data: TData[]; total: number } | undefined;
+    const data: TData[] = queryResult?.data ?? [];
+    // Merge default value items if not already in data
+    const defaultQueryResult = defaultValueQuery as { data: { data: TData[] } | undefined } | null;
+    const defaultData: TData[] = defaultQueryResult?.data?.data ?? [];
+    const allData: TData[] = [...data];
+    const existingIds = new Set(data.map((d: TData) => String((d as Record<string, unknown>)[typeof optionValue === 'string' ? optionValue : 'id'])));
+    for (const item of defaultData) {
+      const itemId = String((item as Record<string, unknown>)[typeof optionValue === 'string' ? optionValue : 'id']);
+      if (!existingIds.has(itemId)) allData.push(item);
+    }
+    return allData.map((item: TData) => {
+      const label = typeof optionLabel === 'function' ? optionLabel(item) : String((item as Record<string, unknown>)[optionLabel] ?? '');
+      const value = typeof optionValue === 'function' ? optionValue(item) : (item as Record<string, unknown>)[optionValue];
+      return { label, value } as unknown as TOption;
+    });
+  });
 
-export function useApiUrl(): string {
-  const provider = getDataProvider();
-  return provider.getApiUrl();
-}
+  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
 
-// ─── useNavigation ──────────────────────────────────────────────
+  function onSearchChange(value: string) {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => { searchText = value; }, debounceMs);
+  }
 
-export function useNavigation() {
   return {
-    list: (resource: string) => navigate(`/${resource}`),
-    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),
+    query,
+    get options() { return selectOptions; },
+    get overtime() { return overtime; },
+    onSearchChange,
   };
 }
 
-// ─── useResource ────────────────────────────────────────────────
-
-export { getResource as useResource } from './context';
-
-// ─── Mutation options ───────────────────────────────────────────
+// ─── useCustom ──────────────────────────────────────────────────────
 
-interface UseMutationOptions {
-  showToast?: boolean;
-  auditLog?: boolean;
-  mutationMode?: MutationMode;
+export interface UseCustomOptions<TData = unknown, TError = HttpError> {
+  url: string;
+  method: 'get' | 'post' | 'put' | 'patch' | 'delete';
+  config?: { payload?: unknown; query?: Record<string, unknown>; headers?: Record<string, string>; sorters?: Sort[]; filters?: Filter[] };
+  meta?: Record<string, unknown>;
+  dataProviderName?: string;
+  queryOptions?: { staleTime?: number; enabled?: boolean };
+  successNotification?: NotificationConfig;
+  errorNotification?: NotificationConfig;
+  overtimeOptions?: OvertimeOptions;
 }
 
-// ─── useCreate ──────────────────────────────────────────────────
+export function useCustom<TData = unknown, TError = HttpError>(options: UseCustomOptions<TData, TError>) {
+  const adminOptions = getAdminOptions();
+  const provider = getDataProvider(options.dataProviderName);
 
-export function useCreate<T = Record<string, unknown>>(resource: string, opts?: UseMutationOptions) {
-  const provider = getDataProvider();
-  const queryClient = useQueryClient();
-  const { showToast = true, auditLog = true, mutationMode = 'pessimistic' } = opts ?? {};
-
-  return createMutation(() => ({
-    mutationFn: (variables: Record<string, unknown>) =>
-      provider.create<T>({ resource, variables }),
-    onMutate: mutationMode === 'optimistic'
-      ? async (_variables: Record<string, unknown>) => {
-          await queryClient.cancelQueries({ queryKey: [resource] });
-          const previousData = queryClient.getQueryData([resource, 'list']);
-          return { previousData };
-        }
-      : undefined,
-    onSuccess: (data: { data: T }) => {
-      queryClient.invalidateQueries({ queryKey: [resource] });
-      if (showToast) toast.success(t('common.createSuccess'));
-      if (auditLog) {
-        const record = data.data as Record<string, unknown>;
-        audit({ action: 'create', resource, recordId: record.id as string });
-      }
-    },
-    onError: (error: Error, _variables: Record<string, unknown>, context: { previousData?: unknown } | undefined) => {
-      if (mutationMode === 'optimistic' && context?.previousData) {
-        queryClient.setQueryData([resource, 'list'], context.previousData);
-      }
-      if (showToast) toast.error(t('common.operationFailed') + ': ' + error.message);
+  const query = createQuery<{ data: TData }, TError>(() => ({
+    queryKey: ['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>({
+        url: options.url,
+        method: options.method,
+        payload: options.config?.payload as any,
+        query: options.config?.query,
+        headers: options.config?.headers,
+        sorters: options.config?.sorters,
+        filters: options.config?.filters,
+        meta: options.meta,
+      });
     },
+    enabled: options.queryOptions?.enabled ?? true,
+    staleTime: options.queryOptions?.staleTime ?? adminOptions.reactQuery?.staleTime,
   }));
-}
 
-// ─── useCreateMany ──────────────────────────────────────────────
+  const overtime = createOvertimeTracker(() => query.isLoading, options.overtimeOptions ?? adminOptions.overtime);
 
-export function useCreateMany<T = Record<string, unknown>>(resource: string, opts?: UseMutationOptions) {
-  const provider = getDataProvider();
-  const queryClient = useQueryClient();
-  const { showToast = true, auditLog = true } = opts ?? {};
-
-  return createMutation(() => ({
-    mutationFn: async (variables: Record<string, unknown>[]) => {
-      if (provider.createMany) {
-        return provider.createMany<T>({ resource, variables });
-      }
-      const results = await Promise.all(variables.map(v => provider.create<T>({ resource, variables: v })));
-      return { data: results.map(r => r.data) };
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: [resource] });
-      if (showToast) toast.success(t('common.createSuccess'));
-      if (auditLog) audit({ action: 'create', resource, details: { batch: true } });
-    },
-    onError: (error: Error) => {
-      if (showToast) toast.error(t('common.operationFailed') + ': ' + error.message);
-    },
-  }));
+  return { query, get overtime() { return overtime; } };
 }
 
-// ─── useUpdate ──────────────────────────────────────────────────
-
-interface UpdateVariables {
-  id: string | number;
-  variables: Record<string, unknown>;
-}
+// ─── useCustomMutation ──────────────────────────────────────────────
 
-export function useUpdate<T = Record<string, unknown>>(resource: string, opts?: UseMutationOptions) {
-  const provider = getDataProvider();
+export function useCustomMutation<TData = unknown, TError = HttpError, TVariables = unknown>(dataProviderName?: string) {
+  const provider = getDataProvider(dataProviderName);
   const queryClient = useQueryClient();
-  const { showToast = true, auditLog = true, mutationMode = 'pessimistic' } = opts ?? {};
-
-  return createMutation<{ data: T }, Error, UpdateVariables>(() => ({
-    mutationFn: ({ id, variables }: UpdateVariables) =>
-      provider.update<T>({ resource, id, variables }),
-    onMutate: mutationMode === 'optimistic'
-      ? async ({ id }: UpdateVariables) => {
-          await queryClient.cancelQueries({ queryKey: [resource, 'one', id] });
-          const previousData = queryClient.getQueryData([resource, 'one', id]);
-          return { previousData };
-        }
-      : undefined,
-    onSuccess: (_data: { data: T }, vars: UpdateVariables) => {
-      queryClient.invalidateQueries({ queryKey: [resource] });
-      if (showToast) toast.success(t('common.updateSuccess'));
-      if (auditLog) audit({ action: 'update', resource, recordId: vars.id });
-    },
-    onError: (error: Error) => {
-      if (showToast) toast.error(t('common.operationFailed') + ': ' + error.message);
-    },
-  }));
-}
 
-// ─── useUpdateMany ──────────────────────────────────────────────
-
-export function useUpdateMany<T = Record<string, unknown>>(resource: string, opts?: UseMutationOptions) {
-  const provider = getDataProvider();
-  const queryClient = useQueryClient();
-  const { showToast = true, auditLog = true } = opts ?? {};
-
-  return createMutation(() => ({
-    mutationFn: async ({ ids, variables }: { ids: (string | number)[]; variables: Record<string, unknown> }) => {
-      if (provider.updateMany) {
-        return provider.updateMany<T>({ resource, ids, variables });
-      }
-      const results = await Promise.all(ids.map(id => provider.update<T>({ resource, id, variables })));
-      return { data: results.map(r => r.data) };
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: [resource] });
-      if (showToast) toast.success(t('common.updateSuccess'));
-      if (auditLog) audit({ action: 'update', resource, details: { batch: true } });
-    },
-    onError: (error: Error) => {
-      if (showToast) toast.error(t('common.operationFailed') + ': ' + error.message);
+  const mutation = createMutation<{ data: TData }, TError, { url: string; method: 'get' | 'post' | 'put' | 'patch' | 'delete'; values?: TVariables; meta?: Record<string, unknown> }>(() => ({
+    mutationFn: async (params) => {
+      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 as any, meta: params.meta });
     },
   }));
+
+  return { mutation };
 }
 
-// ─── useDelete ──────────────────────────────────────────────────
+// ─── useCreateMany / useUpdateMany / useDeleteMany ──────────────────
 
-export function useDelete(resource: string, opts?: UseMutationOptions) {
-  const provider = getDataProvider();
+export function useCreateMany<TData extends BaseRecord = BaseRecord, TError = HttpError, TVariables = Record<string, unknown>>(options: { resource?: KnownResources; overtimeOptions?: OvertimeOptions } = {}) {
+  const parsed = useParsed();
+  const resource = options.resource ?? parsed.resource ?? '';
+  const adminOptions = getAdminOptions();
   const queryClient = useQueryClient();
-  const { showToast = true, auditLog = true, mutationMode = 'pessimistic' } = opts ?? {};
-
-  return createMutation(() => ({
-    mutationFn: (id: string | number) =>
-      provider.deleteOne({ resource, id }),
-    onMutate: mutationMode === 'optimistic'
-      ? async (_id: string | number) => {
-          await queryClient.cancelQueries({ queryKey: [resource] });
-          const previousData = queryClient.getQueryData([resource, 'list']);
-          return { previousData };
-        }
-      : undefined,
-    onSuccess: (_data: unknown, id: string | number) => {
-      queryClient.invalidateQueries({ queryKey: [resource] });
-      if (showToast) toast.success(t('common.deleteSuccess'));
-      if (auditLog) audit({ action: 'delete', resource, recordId: id });
-    },
-    onError: (error: Error) => {
-      if (showToast) toast.error(t('common.operationFailed') + ': ' + error.message);
+  let isMutating = $state(false);
+  const overtime = createOvertimeTracker(() => isMutating, options.overtimeOptions ?? adminOptions.overtime);
+
+  const mutation = createMutation<{ data: TData[] }, TError, { resource?: KnownResources; variables: TVariables[]; meta?: Record<string, unknown>; dataProviderName?: string }>(() => ({
+    mutationFn: async (params) => {
+      isMutating = true;
+      const resName = params.resource ?? resource;
+      const provider = getDataProviderForResource(resName, params.dataProviderName);
+      try {
+        if (provider.createMany) return await provider.createMany<TData, TVariables>({ resource: resName, variables: params.variables, meta: params.meta });
+        const results = await Promise.all(params.variables.map(v => provider.create<TData, TVariables>({ resource: resName, variables: v, meta: params.meta })));
+        return { data: results.map(r => r.data) };
+      } finally { isMutating = false; }
     },
+    onSuccess: (_d, params) => { queryClient.invalidateQueries({ queryKey: [params.resource ?? resource] }); },
   }));
-}
 
-// ─── useDeleteMany ──────────────────────────────────────────────
+  return { mutation, get overtime() { return overtime; } };
+}
 
-export function useDeleteMany(resource: string, opts?: UseMutationOptions) {
-  const provider = getDataProvider();
+export function useUpdateMany<TData extends BaseRecord = BaseRecord, TError = HttpError, TVariables = Record<string, unknown>>(options: { resource?: KnownResources; overtimeOptions?: OvertimeOptions } = {}) {
+  const parsed = useParsed();
+  const resource = options.resource ?? parsed.resource ?? '';
+  const adminOptions = getAdminOptions();
   const queryClient = useQueryClient();
-  const { showToast = true, auditLog = true } = opts ?? {};
-
-  return createMutation(() => ({
-    mutationFn: async (ids: (string | number)[]) => {
-      if (provider.deleteMany) {
-        return provider.deleteMany({ resource, ids });
-      }
-      const results = await Promise.all(ids.map(id => provider.deleteOne({ resource, id })));
-      return { data: results.map(r => r.data) };
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: [resource] });
-      if (showToast) toast.success(t('common.deleteSuccess'));
-      if (auditLog) audit({ action: 'delete', resource, details: { batch: true } });
-    },
-    onError: (error: Error) => {
-      if (showToast) toast.error(t('common.operationFailed') + ': ' + error.message);
+  let isMutating = $state(false);
+  const overtime = createOvertimeTracker(() => isMutating, options.overtimeOptions ?? adminOptions.overtime);
+
+  const mutation = createMutation<{ data: TData[] }, TError, { resource?: KnownResources; ids: (string | number)[]; variables: TVariables; meta?: Record<string, unknown>; dataProviderName?: string }>(() => ({
+    mutationFn: async (params) => {
+      isMutating = true;
+      const resName = params.resource ?? resource;
+      const provider = getDataProviderForResource(resName, params.dataProviderName);
+      try {
+        if (provider.updateMany) return await provider.updateMany<TData, TVariables>({ resource: resName, ids: params.ids, variables: params.variables, meta: params.meta });
+        const results = await Promise.all(params.ids.map(id => provider.update<TData, TVariables>({ resource: resName, id, variables: params.variables, meta: params.meta })));
+        return { data: results.map(r => r.data) };
+      } finally { isMutating = false; }
     },
+    onSuccess: (_d, params) => { queryClient.invalidateQueries({ queryKey: [params.resource ?? resource] }); },
   }));
-}
 
-// ─── useForm ────────────────────────────────────────────────────
-// Standalone form hook (like Refine's useForm)
-
-interface UseFormOptions {
-  resource: string;
-  action: 'create' | 'edit' | 'clone';
-  id?: string | number;
-  redirect?: 'list' | 'edit' | 'show' | false;
-  mutationMode?: MutationMode;
-  onMutationSuccess?: (data: unknown) => void;
-  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
-  };
+  return { mutation, get overtime() { return overtime; } };
 }
 
-export function useForm<T = Record<string, unknown>>(options: UseFormOptions) {
-  const provider = getDataProvider();
+export function useDeleteMany<TData extends BaseRecord = BaseRecord, TError = HttpError>(options: { resource?: KnownResources; overtimeOptions?: OvertimeOptions } = {}) {
+  const parsed = useParsed();
+  const resource = options.resource ?? parsed.resource ?? '';
+  const adminOptions = getAdminOptions();
   const queryClient = useQueryClient();
-  const { resource, action, id, redirect = 'list', onMutationSuccess, onMutationError, meta, validate, autoSave } = options;
-
-  // Validation state
-  let errors = $state<Record<string, string>>({});
-
-  function setFieldError(field: string, message: string) {
-    errors = { ...errors, [field]: message };
-  }
-
-  function clearErrors() {
-    errors = {};
-  }
-
-  function clearFieldError(field: string) {
-    const next = { ...errors };
-    delete next[field];
-    errors = next;
-  }
-
-  function runValidation(values: Record<string, unknown>): boolean {
-    clearErrors();
-    if (validate) {
-      const result = validate(values);
-      if (result && Object.keys(result).length > 0) {
-        errors = result;
-        return false;
-      }
-    }
-    return true;
-  }
-
-  // Fetch existing data for edit/clone
-  const query = (action === 'edit' || action === 'clone') && id != null
-    ? createQuery(() => ({
-        queryKey: [resource, 'one', id],
-        queryFn: async () => {
-          const result = await provider.getOne<T>({ resource, id, meta });
-          return result.data;
-        },
-        enabled: id != null,
-      }))
-    : null;
-
-  const createMut = createMutation(() => ({
-    mutationFn: (variables: Record<string, unknown>) =>
-      provider.create<T>({ resource, variables }),
-    onSuccess: (data: { data: T }) => {
-      queryClient.invalidateQueries({ queryKey: [resource] });
-      toast.success(t('common.createSuccess'));
-      const record = data.data as Record<string, unknown>;
-      audit({ action: 'create', resource, recordId: record.id as string });
-      onMutationSuccess?.(data);
-      handleRedirect();
-    },
-    onError: (error: Error) => {
-      toast.error(t('common.operationFailed') + ': ' + error.message);
-      onMutationError?.(error);
+  let isMutating = $state(false);
+  const overtime = createOvertimeTracker(() => isMutating, options.overtimeOptions ?? adminOptions.overtime);
+
+  const mutation = createMutation<{ data: TData[] }, TError, { resource?: KnownResources; ids: (string | number)[]; meta?: Record<string, unknown>; dataProviderName?: string }>(() => ({
+    mutationFn: async (params) => {
+      isMutating = true;
+      const resName = params.resource ?? resource;
+      const provider = getDataProviderForResource(resName, params.dataProviderName);
+      try {
+        if (provider.deleteMany) return await provider.deleteMany<TData>({ resource: resName, ids: params.ids, meta: params.meta });
+        const results = await Promise.all(params.ids.map(id => provider.deleteOne<TData>({ resource: resName, id, meta: params.meta })));
+        return { data: results.map(r => r.data) };
+      } finally { isMutating = false; }
     },
+    onSuccess: (_d, params) => { queryClient.invalidateQueries({ queryKey: [params.resource ?? resource] }); },
   }));
 
-  const updateMut = createMutation(() => ({
-    mutationFn: (variables: Record<string, unknown>) =>
-      provider.update<T>({ resource, id: id!, variables }),
-    onSuccess: (data: { data: T }) => {
-      queryClient.invalidateQueries({ queryKey: [resource] });
-      toast.success(t('common.updateSuccess'));
-      audit({ action: 'update', resource, recordId: id });
-      onMutationSuccess?.(data);
-      handleRedirect();
-    },
-    onError: (error: Error) => {
-      toast.error(t('common.operationFailed') + ': ' + error.message);
-      onMutationError?.(error);
-    },
-  }));
+  return { mutation, get overtime() { return overtime; } };
+}
 
-  function handleRedirect() {
-    if (redirect === 'list') navigate(`/${resource}`);
-    else if (redirect === 'edit' && id) navigate(`/${resource}/edit/${id}`);
-    else if (redirect === 'show' && id) navigate(`/${resource}/show/${id}`);
-  }
+// ─── useInvalidate ──────────────────────────────────────────────────
 
-  async function onFinish(values: Record<string, unknown>) {
-    // Run validation before submitting
-    if (!runValidation(values)) {
-      toast.warning(t('validation.required'));
+export function useInvalidate() {
+  const queryClient = useQueryClient();
+  return (params: { resource?: string; invalidates?: string[] | 'all' | false; id?: string | number; dataProviderName?: string }) => {
+    if (params.invalidates === false) return;
+    if (params.invalidates === 'all' || !params.resource) {
+      queryClient.invalidateQueries();
       return;
     }
-
-    if (action === 'create' || action === 'clone') {
-      // @ts-expect-error $ rune prefix — Svelte compiler transforms this
-      await $createMut.mutateAsync(values);
-    } else {
-      // @ts-expect-error $ rune prefix — Svelte compiler transforms this
-      await $updateMut.mutateAsync(values);
-    }
-  }
-
-  const base = {
-    query,
-    get formLoading() {
-      // @ts-expect-error $ rune prefix — Svelte compiler transforms this
-      return (query ? $query?.isLoading : false) || $createMut.isPending || $updateMut.isPending;
-    },
-    mutation: action === 'edit' ? updateMut : createMut,
-    onFinish,
-    get errors() { return errors; },
-    setFieldError,
-    clearErrors,
-    clearFieldError,
+    queryClient.invalidateQueries({ queryKey: [params.resource] });
   };
+}
 
-  // ─── 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);
-  }
+// ─── useOvertime ────────────────────────────────────────────────────
 
+export function useOvertime(options?: OvertimeOptions) {
+  let isLoading = $state(false);
+  const overtime = createOvertimeTracker(() => isLoading, options);
   return {
-    ...base,
-    triggerAutoSave,
-    get autoSaveStatus() { return autoSaveStatus; },
+    get elapsedTime() { return overtime.elapsedTime; },
+    start() { isLoading = true; },
+    stop() { isLoading = false; },
   };
 }
 
-// ─── useTable ───────────────────────────────────────────────────
-// Standalone table hook (like Refine's useTable)
+// ─── useDataProvider ────────────────────────────────────────────────
 
-interface UseTableOptions {
-  resource: string;
-  pagination?: Pagination;
-  sorters?: Sort[];
-  filters?: Filter[];
-  syncWithLocation?: boolean;
-  meta?: Record<string, unknown>;
+export function useDataProvider(): (dataProviderName?: string) => DataProvider {
+  return (name?: string) => getDataProvider(name);
 }
 
-export function useTable<T = Record<string, unknown>>(options: UseTableOptions) {
-  const { resource, meta, syncWithLocation = false } = options;
-
-  // Read initial state from URL if syncWithLocation
-  let initialPagination = options.pagination ?? { current: 1, pageSize: 10 };
-  let initialSorters = options.sorters ?? [];
-
-  if (syncWithLocation) {
-    const urlState = readURLState();
-    if (urlState.page || urlState.pageSize) {
-      initialPagination = {
-        current: urlState.page ?? initialPagination.current,
-        pageSize: urlState.pageSize ?? initialPagination.pageSize,
-      };
-    }
-    if (urlState.sortField) {
-      initialSorters = [{ field: urlState.sortField, order: urlState.sortOrder ?? 'asc' }];
-    }
-  }
-
-  let pagination = $state<Pagination>(initialPagination);
-  let sorters = $state<Sort[]>(initialSorters);
-  let filters = $state<Filter[]>(options.filters ?? []);
-
-  const query = useList<T>({ resource, pagination, sorters, filters, meta });
-
-  function setSorters(newSorters: Sort[]) { sorters = newSorters; }
-  function setFilters(newFilters: Filter[]) { filters = newFilters; }
-  function setPage(page: number) { pagination = { ...pagination, current: page }; }
-  function setPageSize(size: number) { pagination = { ...pagination, pageSize: size, current: 1 }; }
-
-  // Sync state to URL when syncWithLocation is enabled
-  if (syncWithLocation) {
-    $effect(() => {
-      writeURLState({
-        page: pagination.current,
-        pageSize: pagination.pageSize,
-        sortField: sorters[0]?.field,
-        sortOrder: sorters[0]?.order,
-      });
-    });
-  }
+// ─── useThemedLayoutContext ─────────────────────────────────────────
 
+export function useThemedLayoutContext() {
+  let sidebarCollapsed = $state(false);
   return {
-    query,
-    pagination,
-    sorters,
-    filters,
-    setSorters,
-    setFilters,
-    setPage,
-    setPageSize,
-    get totalPages() {
-      // @ts-expect-error $ rune prefix — Svelte compiler transforms this
-      return Math.ceil(($query.data?.total ?? 0) / (pagination.pageSize ?? 10));
-    },
+    get sidebarCollapsed() { return sidebarCollapsed; },
+    setSidebarCollapsed(v: boolean) { sidebarCollapsed = v; },
+    toggleSidebar() { sidebarCollapsed = !sidebarCollapsed; },
   };
 }
+
+// ─── Logging hooks (legacy aliases) ─────────────────────────────────
+
+export function useLogList(options?: Partial<UseListOptions>) {
+  return useList({ resource: 'logs', ...options });
+}
+
+export const useLog = useLogList;