@svadmin/core 0.34.2 → 0.36.0

package/src/form-hooks.svelte.ts

@@ -2,10 +2,13 @@ import { useQueryClient } from '@tanstack/svelte-query';
 import { useParsed } from './useParsed.svelte';
 import { getAdminOptions } from './options.svelte';
 import { captureAdminContext } from './context.svelte';
+import { queryKeyMatches } from './query-keys';
 import { createQuery, createMutation } from '@tanstack/svelte-query';
-import { notify } from './notification.svelte';
+import { notifyWithProvider } from './notification.svelte';
+import type { NotificationParams } from './notification.svelte';
 import { useTranslation } from './i18n.svelte';
-import { audit } from './audit';
+import { auditWithProvider } from './audit';
+import type { AuditEntry } from './audit';
 import { HttpError, UndoError } from './types';
 import type { BaseRecord, MutationMode, KnownResources } from './types';
 import { checkError } from './hook-utils.svelte';
@@ -153,6 +156,10 @@ export function useForm<
   const queryClient = useQueryClient();
   const parsed = useParsed();
   const adminOptions = getAdminOptions();
+  const sendNotification = (params: NotificationParams) =>
+    notifyWithProvider(params, adminContext.notificationProvider);
+  const recordAudit = (entry: Omit<AuditEntry, 'timestamp'>) =>
+    auditWithProvider(entry, adminContext.auditLogProvider);
 
   const resource = $derived(options.resource ?? parsed.resource ?? '');
   let action = $state<'create' | 'edit' | 'clone' | 'show'>(options.action ?? (parsed.action === 'list' ? 'create' : parsed.action as 'create' | 'edit' | 'clone' | 'show') ?? 'create');
@@ -441,9 +448,9 @@ export function useForm<
         const msg = Array.isArray(messages) ? messages[0] : messages;
         setFieldError(field, msg);
       }
-      if (errorNotification !== false) notify({ type: 'error', message: typeof errorNotification === 'string' ? errorNotification : (error.message || i18n.t('common.operationFailed')) });
+      if (errorNotification !== false) sendNotification({ type: 'error', message: typeof errorNotification === 'string' ? errorNotification : (error.message || i18n.t('common.operationFailed')) });
     } else {
-      if (errorNotification !== false) notify({ type: 'error', message: typeof errorNotification === 'string' ? errorNotification : (i18n.t('common.operationFailed') + ': ' + error.message) });
+      if (errorNotification !== false) sendNotification({ type: 'error', message: typeof errorNotification === 'string' ? errorNotification : (i18n.t('common.operationFailed') + ': ' + error.message) });
     }
   }
 
@@ -451,7 +458,9 @@ export function useForm<
   // Always create the query — use `enabled` to conditionally activate.
   // This ensures setAction('edit') at runtime will trigger a fetch.
   const query = createQuery(() => ({
-    queryKey: [options.dataProviderName, resource, 'one', currentId, queryMeta],
+    queryKey: adminContext.queryKeys(resource, options.dataProviderName).data.one(resource, currentId ?? '', {
+      meta: queryMeta,
+    }),
     queryFn: async () => {
       const result = await provider.getOne<BaseRecord>({ resource, id: currentId as string, meta: queryMeta });
       return result;
@@ -518,12 +527,23 @@ export function useForm<
     onSuccess: (data: { data: TData }, _vars: unknown, context: unknown) => {
       const ctx = context as { targetResource?: string } | undefined;
       const res = ctx?.targetResource ?? resource;
-      invalidateByScopes(queryClient, res, invalidateScopes, ['list', 'many'], undefined, options.dataProviderName);
+      invalidateByScopes({
+        queryClient,
+        resource: res,
+        scopes: invalidateScopes,
+        defaults: ['list', 'many'],
+        matcher: adminContext.queryKeyMatcher(res, options.dataProviderName),
+      });
       if (!isManualSubmitIdentityCurrent()) return;
-      if (successNotification !== false) notify({ type: 'success', message: typeof successNotification === 'string' ? successNotification : i18n.t('common.createSuccess') });
+      if (successNotification !== false) sendNotification({ type: 'success', message: typeof successNotification === 'string' ? successNotification : i18n.t('common.createSuccess') });
       const pk = adminContext.getResource(res).primaryKey ?? 'id';
       const newId = (data.data as Record<string, unknown>)[pk];
-      audit({ action: 'create', resource: res, recordId: String(newId) });
+      recordAudit({
+        action: 'create',
+        resource: res,
+        recordId: String(newId),
+        meta: adminContext.getProviderMeta(res),
+      });
       try {
         const lp = adminContext.liveProvider;
         if (lp?.publish) lp.publish({ type: 'INSERT', resource: res, payload: { ids: newId != null ? [newId as string | number] : [] } });
@@ -562,12 +582,17 @@ export function useForm<
       if (mutationMode === 'pessimistic') return { targetId: currentId, targetResource: resource };
       const targetId = currentId;
       const targetResource = resource;
-      const dpN = options.dataProviderName;
-      const dp = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dpN;
-      await queryClient.cancelQueries({ predicate: (q) => dp(q) && q.queryKey[1] === resource });
-      const previousQueries = queryClient.getQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resource });
+      const matcher = adminContext.queryKeyMatcher(resource, options.dataProviderName);
+      const dataMatch = (queryKey: readonly unknown[], fields: { action?: string; id?: string | number } = {}) => queryKeyMatches(queryKey, {
+        ...matcher,
+        kind: 'data',
+        resource,
+        ...fields,
+      });
+      await queryClient.cancelQueries({ predicate: (q) => dataMatch(q.queryKey) });
+      const previousQueries = queryClient.getQueriesData({ predicate: (q) => dataMatch(q.queryKey) });
       if (optimisticUpdateMap?.list !== false) {
-        queryClient.setQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resource && q.queryKey[2] === 'list' }, (old: unknown) => {
+        queryClient.setQueriesData({ predicate: (q) => dataMatch(q.queryKey, { action: 'list' }) }, (old: unknown) => {
           if (!old || typeof old !== 'object' || !('data' in old)) return old;
           const o = old as { data: Record<string, unknown>[] };
           const pk = adminContext.getResource(resource).primaryKey ?? 'id';
@@ -575,7 +600,7 @@ export function useForm<
         });
       }
       if (optimisticUpdateMap?.detail !== false && targetId != null) {
-        queryClient.setQueriesData({ predicate: (q) => dp(q) && q.queryKey[1] === resource && q.queryKey[2] === 'one' && q.queryKey[3] === targetId }, (old: Record<string, unknown> | undefined) => old ? { ...old, data: deepMerge((old as Record<string, unknown>).data || {}, variables) } : old);
+        queryClient.setQueriesData({ predicate: (q) => dataMatch(q.queryKey, { action: 'one', id: targetId }) }, (old: Record<string, unknown> | undefined) => old ? { ...old, data: deepMerge((old as Record<string, unknown>).data || {}, variables) } : old);
       }
       return { previousQueries, targetId, targetResource };
     },
@@ -584,8 +609,13 @@ export function useForm<
       const targetId = ctx?.targetId ?? currentId;
       const res = ctx?.targetResource ?? resource;
       if (!isManualSubmitIdentityCurrent()) return;
-      if (successNotification !== false) notify({ type: 'success', message: typeof successNotification === 'string' ? successNotification : i18n.t('common.updateSuccess') });
-      audit({ action: 'update', resource: res, recordId: String(targetId) });
+      if (successNotification !== false) sendNotification({ type: 'success', message: typeof successNotification === 'string' ? successNotification : i18n.t('common.updateSuccess') });
+      recordAudit({
+        action: 'update',
+        resource: res,
+        recordId: String(targetId),
+        meta: adminContext.getProviderMeta(res),
+      });
       try {
         const lp = adminContext.liveProvider;
         if (lp?.publish) lp.publish({ type: 'UPDATE', resource: res, payload: { ids: targetId != null ? [targetId] : [] } });
@@ -598,7 +628,14 @@ export function useForm<
       const ctx = context as { targetId?: string | number; targetResource?: string } | undefined;
       const targetId = ctx?.targetId ?? currentId;
       const res = ctx?.targetResource ?? resource;
-      invalidateByScopes(queryClient, res, invalidateScopes, ['list', 'many', 'detail'], targetId ?? undefined, options.dataProviderName);
+      invalidateByScopes({
+        queryClient,
+        resource: res,
+        scopes: invalidateScopes,
+        defaults: ['list', 'many', 'detail'],
+        id: targetId ?? undefined,
+        matcher: adminContext.queryKeyMatcher(res, options.dataProviderName),
+      });
     },
     onError: (error: unknown, _vars: unknown, context: unknown) => {
       const ctx = context as { previousQueries?: [unknown, unknown][] } | undefined;
@@ -649,7 +686,7 @@ export function useForm<
 
       if (!isRecordIdentityCurrent(submitIdentity)) return;
 
-      if (!runValidation()) { notify({ type: 'warning', message: i18n.t('validation.required') }); return; }
+      if (!runValidation()) { sendNotification({ type: 'warning', message: i18n.t('validation.required') }); return; }
 
       const submittedValues = createPersistenceSnapshot(values);
       if (action === 'create' || action === 'clone') await createMut.mutateAsync(submittedValues);
@@ -740,7 +777,14 @@ export function useForm<
         await provider.update<TData, TVariables>({ resource: safeResource, id: safeId as string | number, variables: submittedValues, meta: safeMeta });
         if (formDestroyed) return;
         const scopes = autoSaveOpts.invalidates ?? ['resourceAll'];
-        invalidateByScopes(queryClient, safeResource, scopes, ['resourceAll'], safeId ?? undefined, options.dataProviderName);
+        invalidateByScopes({
+          queryClient,
+          resource: safeResource,
+          scopes,
+          defaults: ['resourceAll'],
+          id: safeId ?? undefined,
+          matcher: adminContext.queryKeyMatcher(safeResource, options.dataProviderName),
+        });
         if (!isRecordIdentityCurrent(scheduledIdentity)) return;
         autoSaveStatus = 'saved';
         lastAutoSaveData = submittedValues;
@@ -769,7 +813,13 @@ export function useForm<
 
   if (autoSaveOpts?.invalidateOnUnmount) {
     $effect(() => {
-      return () => queryClient.invalidateQueries({ predicate: (q) => q.queryKey[0] === options.dataProviderName && q.queryKey[1] === resource });
+      return () => queryClient.invalidateQueries({
+        predicate: (q) => queryKeyMatches(q.queryKey, {
+          ...adminContext.queryKeyMatcher(resource, options.dataProviderName),
+          kind: 'data',
+          resource,
+        }),
+      });
     });
   }
 

package/src/hook-utils.svelte.ts

@@ -5,7 +5,9 @@ import { useQueryClient } from '@tanstack/svelte-query';
 import type { LiveProvider, LiveEvent, LiveMode } from './live.svelte';
 import { captureAdminContext } from './context.svelte';
 import type { AdminContextAccessor } from './context.svelte';
-import { notify } from './notification.svelte';
+import { dataQueryMatches } from './query-keys';
+import { notifyWithProvider } from './notification.svelte';
+import type { NotificationProvider } from './types';
 
 // ─── Auth Error Delegate ────────────────────────────────────────
 // Delegate auth errors to authProvider.onError() — refine pattern
@@ -88,6 +90,7 @@ export interface LiveSubscriptionParams {
 
 export function createLiveSubscription(paramsFn: () => LiveSubscriptionParams): void {
   const queryClient = useQueryClient();
+  const adminContext = captureAdminContext();
 
   $effect(() => {
     const params = paramsFn();
@@ -105,9 +108,10 @@ export function createLiveSubscription(paramsFn: () => LiveSubscriptionParams):
         callback: (event: LiveEvent) => {
           params.onLiveEvent?.(event);
           if (liveMode === 'auto') {
-            const dpN = params.dataProviderName;
-            const dpMatch = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dpN;
-            queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === params.resource });
+            const matcher = adminContext.queryKeyMatcher(params.resource, params.dataProviderName);
+            queryClient.invalidateQueries({
+              predicate: (q) => dataQueryMatches(q.queryKey, { ...matcher, resource: params.resource }),
+            });
           }
         },
       });
@@ -127,36 +131,44 @@ export type NotificationConfig =
   | ((data?: unknown, values?: unknown, resource?: string) => { message: string; description?: string; type?: 'success' | 'error' })
   | undefined;
 
-export function fireSuccessNotification(
-  config: NotificationConfig,
-  defaultMessage: string,
-  data?: unknown,
-  values?: unknown,
-  resource?: string,
-): void {
+export interface SuccessNotificationRequest {
+  config: NotificationConfig;
+  defaultMessage: string;
+  data?: unknown;
+  values?: unknown;
+  resource?: string;
+  provider?: NotificationProvider | null;
+}
+
+export interface ErrorNotificationRequest {
+  config: NotificationConfig;
+  defaultMessage: string;
+  error?: unknown;
+  resource?: string;
+  provider?: NotificationProvider | null;
+}
+
+export function fireSuccessNotification(request: SuccessNotificationRequest): void {
+  const { config, defaultMessage, data, values, resource, provider } = request;
   if (config === false) return;
   if (!config && !defaultMessage) return;
   if (typeof config === 'function') {
     const result = config(data, values, resource);
-    notify({ type: 'success', message: result.message, description: result.description });
+    notifyWithProvider({ type: 'success', message: result.message, description: result.description }, provider);
     return;
   }
-  notify({ type: 'success', message: config || defaultMessage });
+  notifyWithProvider({ type: 'success', message: config || defaultMessage }, provider);
 }
 
-export function fireErrorNotification(
-  config: NotificationConfig,
-  defaultMessage: string,
-  error?: unknown,
-  resource?: string,
-): void {
+export function fireErrorNotification(request: ErrorNotificationRequest): void {
+  const { config, defaultMessage, error, resource, provider } = request;
   if (config === false) return;
   if (!config && !defaultMessage) return;
   if (typeof config === 'function') {
     const result = config(error, undefined, resource);
-    notify({ type: 'error', message: result.message, description: result.description });
+    notifyWithProvider({ type: 'error', message: result.message, description: result.description }, provider);
     return;
   }
   const errMsg = error instanceof Error ? error.message : String(error ?? '');
-  notify({ type: 'error', message: config || `${defaultMessage}${errMsg ? ': ' + errMsg : ''}` });
+  notifyWithProvider({ type: 'error', message: config || `${defaultMessage}${errMsg ? ': ' + errMsg : ''}` }, provider);
 }

package/src/hooks.svelte.ts

@@ -17,20 +17,19 @@ export type { InvalidateScope, OvertimeConfig } from './options.svelte';
 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.
+// ─── Additional core hooks ─────────────────────────────────────────
 
 import { createQuery, createInfiniteQuery, createMutation, useQueryClient } from '@tanstack/svelte-query';
 import { getAdminOptions } from './options.svelte';
 import { captureAdminContext } from './context.svelte';
+import { queryKeyMatches } from './query-keys';
 import { useParsed } from './useParsed.svelte';
 import { createOvertimeTracker, createLiveSubscription, fireSuccessNotification, fireErrorNotification, checkError } from './hook-utils.svelte';
 import { invalidateByScopes, publishLiveEvent } 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';
-import { audit } from './audit';
+import { auditWithProvider } from './audit';
 
 // ─── useInfiniteList ────────────────────────────────────────────────
 
@@ -58,7 +57,12 @@ export function useInfiniteList<TData extends BaseRecord = BaseRecord, TError =
     const resource = options.resource ?? parsed.resource ?? '';
     const provider = adminContext.getDataProviderForResource(resource, options.dataProviderName);
     return {
-    queryKey: [options.dataProviderName, resource, 'infiniteList', options.pagination?.pageSize, options.sorters, options.filters, options.meta],
+    queryKey: adminContext.queryKeys(resource, options.dataProviderName).data.infiniteList(resource, {
+      pageSize: options.pagination?.pageSize,
+      sorters: options.sorters,
+      filters: options.filters,
+      meta: options.meta,
+    }),
     queryFn: async ({ pageParam = 1 }) => {
       const result = await provider.getList<TData>({
         resource,
@@ -99,11 +103,23 @@ export function useInfiniteList<TData extends BaseRecord = BaseRecord, TError =
   $effect(() => {
     if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && options.successNotification) {
       lastSuccessAt = query.dataUpdatedAt;
-      fireSuccessNotification(options.successNotification, '', query.data, undefined, options.resource ?? parsed.resource ?? '');
+      fireSuccessNotification({
+        config: options.successNotification,
+        defaultMessage: '',
+        data: query.data,
+        resource: options.resource ?? parsed.resource ?? '',
+        provider: adminContext.notificationProvider,
+      });
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error, adminContext);
-      fireErrorNotification(options.errorNotification, 'Fetch failed', query.error, options.resource ?? parsed.resource ?? '');
+      fireErrorNotification({
+        config: options.errorNotification,
+        defaultMessage: 'Fetch failed',
+        error: query.error,
+        resource: options.resource ?? parsed.resource ?? '',
+        provider: adminContext.notificationProvider,
+      });
     }
   });
 
@@ -152,7 +168,12 @@ export function useSelect<TData extends BaseRecord = BaseRecord, TOption = { lab
   const query = createQuery<{ data: TData[]; total: number }>(() => {
     const provider = adminContext.getDataProviderForResource(resource, dataProviderName);
     return {
-    queryKey: [dataProviderName, resource, 'select', allFilters, sorters, pagination, meta],
+    queryKey: adminContext.queryKeys(resource, dataProviderName).data.select(resource, {
+      filters: 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,
@@ -165,7 +186,10 @@ export function useSelect<TData extends BaseRecord = BaseRecord, TOption = { lab
     ? createQuery<{ data: TData[] }>(() => {
         const provider = adminContext.getDataProviderForResource(resource, dataProviderName);
         return {
-          queryKey: [dataProviderName, resource, 'select-defaults', defaultValueIds],
+          queryKey: adminContext.queryKeys(resource, dataProviderName).data.selectDefaults(resource, {
+            ids: defaultValueIds,
+            meta,
+          }),
           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 })));
@@ -203,11 +227,23 @@ export function useSelect<TData extends BaseRecord = BaseRecord, TOption = { lab
   $effect(() => {
     if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && options.successNotification) {
       lastSuccessAt = query.dataUpdatedAt;
-      fireSuccessNotification(options.successNotification, '', query.data, undefined, resource);
+      fireSuccessNotification({
+        config: options.successNotification,
+        defaultMessage: '',
+        data: query.data,
+        resource,
+        provider: adminContext.notificationProvider,
+      });
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error, adminContext);
-      fireErrorNotification(options.errorNotification, 'Fetch failed', query.error, resource);
+      fireErrorNotification({
+        config: options.errorNotification,
+        defaultMessage: 'Fetch failed',
+        error: query.error,
+        resource,
+        provider: adminContext.notificationProvider,
+      });
     }
   });
 
@@ -250,7 +286,12 @@ export function useCustom<TData = unknown, TError = HttpError>(options: UseCusto
   const query = createQuery<{ data: TData }, TError>(() => {
     const provider = adminContext.getDataProvider(options.dataProviderName);
     return {
-    queryKey: [options.dataProviderName, 'custom', options.url, options.method, options.config, options.meta],
+    queryKey: adminContext.queryKeys(undefined, options.dataProviderName).custom.call(
+      options.url,
+      options.url,
+      options.method,
+      { config: options.config, meta: options.meta },
+    ),
     queryFn: async () => {
       if (!provider.custom) throw new Error('DataProvider does not support custom method');
       return provider.custom<TData>({
@@ -276,11 +317,22 @@ export function useCustom<TData = unknown, TError = HttpError>(options: UseCusto
   $effect(() => {
     if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt && options.successNotification) {
       lastSuccessAt = query.dataUpdatedAt;
-      fireSuccessNotification(options.successNotification, '', query.data);
+      fireSuccessNotification({
+        config: options.successNotification,
+        defaultMessage: '',
+        data: query.data,
+        provider: adminContext.notificationProvider,
+      });
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error, adminContext);
-      fireErrorNotification(options.errorNotification, 'Custom request failed', query.error, '');
+      fireErrorNotification({
+        config: options.errorNotification,
+        defaultMessage: 'Custom request failed',
+        error: query.error,
+        resource: '',
+        provider: adminContext.notificationProvider,
+      });
     }
   });
 
@@ -301,7 +353,13 @@ export function useCustomMutation<TData = unknown, TError = HttpError, TVariable
     },
     onSuccess: (data, params) => {
       if (params.resource && params.invalidates !== false) {
-        invalidateByScopes(queryClient, params.resource, params.invalidates, ['list', 'many'], undefined, dataProviderName);
+        invalidateByScopes({
+          queryClient,
+          resource: params.resource,
+          scopes: params.invalidates,
+          defaults: ['list', 'many'],
+          matcher: adminContext.queryKeyMatcher(params.resource, dataProviderName),
+        });
       }
     },
     onError: (error) => {
@@ -331,17 +389,38 @@ export function useCreateMany<TData extends BaseRecord = BaseRecord, TError = Ht
     },
     onSuccess: (data, params) => {
       const resName = params.resource ?? resource;
-      fireSuccessNotification(undefined, 'Created successfully', data.data, params.variables, resName);
-      audit({ action: 'create', resource: resName });
+      fireSuccessNotification({
+        config: undefined,
+        defaultMessage: 'Created successfully',
+        data: data.data,
+        values: params.variables,
+        resource: resName,
+        provider: adminContext.notificationProvider,
+      });
+      auditWithProvider(
+        { action: 'create', resource: resName, meta: adminContext.getProviderMeta(resName) },
+        adminContext.auditLogProvider,
+      );
       publishLiveEvent(resName, 'created', undefined, adminContext);
     },
     onError: (error, params) => {
       checkError(error, adminContext);
-      fireErrorNotification(undefined, 'Create many failed', error, params.resource ?? resource);
+      fireErrorNotification({
+        config: undefined,
+        defaultMessage: 'Create many failed',
+        error,
+        resource: params.resource ?? resource,
+        provider: adminContext.notificationProvider,
+      });
     },
     onSettled: (_d, _e, params) => {
       const resName = params.resource ?? resource;
-      invalidateByScopes(queryClient, resName, undefined, ['list', 'many'], undefined, params.dataProviderName);
+      invalidateByScopes({
+        queryClient,
+        resource: resName,
+        defaults: ['list', 'many'],
+        matcher: adminContext.queryKeyMatcher(resName, params.dataProviderName),
+      });
     },
   }));
 
@@ -365,19 +444,48 @@ export function useUpdateMany<TData extends BaseRecord = BaseRecord, TError = Ht
     },
     onSuccess: (data, params) => {
       const resName = params.resource ?? resource;
-      fireSuccessNotification(undefined, 'Updated successfully', data.data, params.variables, resName);
-      audit({ action: 'update', resource: resName });
+      fireSuccessNotification({
+        config: undefined,
+        defaultMessage: 'Updated successfully',
+        data: data.data,
+        values: params.variables,
+        resource: resName,
+        provider: adminContext.notificationProvider,
+      });
+      auditWithProvider(
+        { action: 'update', resource: resName, meta: adminContext.getProviderMeta(resName) },
+        adminContext.auditLogProvider,
+      );
       publishLiveEvent(resName, 'updated', params.ids, adminContext);
     },
     onError: (error, params) => {
       checkError(error, adminContext);
-      fireErrorNotification(undefined, 'Update many failed', error, params.resource ?? resource);
+      fireErrorNotification({
+        config: undefined,
+        defaultMessage: 'Update many failed',
+        error,
+        resource: params.resource ?? resource,
+        provider: adminContext.notificationProvider,
+      });
     },
     onSettled: (_d, _e, params) => {
       const resName = params.resource ?? resource;
-      invalidateByScopes(queryClient, resName, undefined, ['list', 'many', 'detail'], undefined, params.dataProviderName);
+      invalidateByScopes({
+        queryClient,
+        resource: resName,
+        defaults: ['list', 'many', 'detail'],
+        matcher: adminContext.queryKeyMatcher(resName, params.dataProviderName),
+      });
       for (const id of params.ids) {
-        queryClient.invalidateQueries({ predicate: (q) => q.queryKey[0] === params.dataProviderName && q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === id });
+        queryClient.invalidateQueries({
+          predicate: (q) => queryKeyMatches(q.queryKey, {
+            ...adminContext.queryKeyMatcher(resName, params.dataProviderName),
+            kind: 'data',
+            resource: resName,
+            action: 'one',
+            id,
+          }),
+        });
       }
     },
   }));
@@ -402,19 +510,47 @@ export function useDeleteMany<TData extends BaseRecord = BaseRecord, TError = Ht
     },
     onSuccess: (data, params) => {
       const resName = params.resource ?? resource;
-      fireSuccessNotification(undefined, 'Deleted successfully', data.data, undefined, resName);
-      audit({ action: 'delete', resource: resName });
+      fireSuccessNotification({
+        config: undefined,
+        defaultMessage: 'Deleted successfully',
+        data: data.data,
+        resource: resName,
+        provider: adminContext.notificationProvider,
+      });
+      auditWithProvider(
+        { action: 'delete', resource: resName, meta: adminContext.getProviderMeta(resName) },
+        adminContext.auditLogProvider,
+      );
       publishLiveEvent(resName, 'deleted', params.ids, adminContext);
     },
     onError: (error, params) => {
       checkError(error, adminContext);
-      fireErrorNotification(undefined, 'Delete many failed', error, params.resource ?? resource);
+      fireErrorNotification({
+        config: undefined,
+        defaultMessage: 'Delete many failed',
+        error,
+        resource: params.resource ?? resource,
+        provider: adminContext.notificationProvider,
+      });
     },
     onSettled: (_d, _e, params) => {
       const resName = params.resource ?? resource;
-      invalidateByScopes(queryClient, resName, undefined, ['list', 'many'], undefined, params.dataProviderName);
+      invalidateByScopes({
+        queryClient,
+        resource: resName,
+        defaults: ['list', 'many'],
+        matcher: adminContext.queryKeyMatcher(resName, params.dataProviderName),
+      });
       for (const id of params.ids) {
-        queryClient.removeQueries({ predicate: (q) => q.queryKey[0] === params.dataProviderName && q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === id });
+        queryClient.removeQueries({
+          predicate: (q) => queryKeyMatches(q.queryKey, {
+            ...adminContext.queryKeyMatcher(resName, params.dataProviderName),
+            kind: 'data',
+            resource: resName,
+            action: 'one',
+            id,
+          }),
+        });
       }
     },
   }));
@@ -426,22 +562,27 @@ export function useDeleteMany<TData extends BaseRecord = BaseRecord, TError = Ht
 
 export function useInvalidate() {
   const queryClient = useQueryClient();
+  const adminContext = captureAdminContext();
   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({ predicate: (q) => q.queryKey[0] === params.dataProviderName });
+      queryClient.invalidateQueries({
+        predicate: (q) => queryKeyMatches(q.queryKey, {
+          ...adminContext.queryKeyMatcher(undefined, params.dataProviderName),
+          kind: 'data',
+        }),
+      });
       return;
     }
-    const scopes = params.invalidates || ['resourceAll'];
     const res = params.resource;
-    const dpMatch = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === params.dataProviderName;
-    for (const scope of scopes) {
-      if (scope === 'resourceAll') queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === res });
-      else if ((scope === 'detail' || scope === 'one') && params.id) queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === res && q.queryKey[2] === 'one' && q.queryKey[3] === params.id });
-      else if (scope === 'detail' || scope === 'one') queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === res && q.queryKey[2] === 'one' });
-      else if (scope === 'list') queryClient.invalidateQueries({ predicate: (q) => dpMatch(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) => dpMatch(q) && q.queryKey[1] === res && q.queryKey[2] === 'many' });
-    }
+    invalidateByScopes({
+      queryClient,
+      resource: res,
+      scopes: params.invalidates || ['resourceAll'],
+      defaults: ['resourceAll'],
+      id: params.id,
+      matcher: adminContext.queryKeyMatcher(res, params.dataProviderName),
+    });
   };
 }