@svadmin/core 0.22.0 → 0.23.0

package/src/live-websocket.ts

@@ -27,6 +27,7 @@ export function createWebSocketLiveProvider(options: WebSocketLiveProviderOption
 
   type Callback = (event: LiveEvent) => void;
   const subscribers = new Map<string, Set<Callback>>();
+  const lastParams = new Map<string, Record<string, unknown> | undefined>();
   let ws: WebSocket | null = null;
   let reconnectAttempts = 0;
   let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
@@ -51,6 +52,14 @@ export function createWebSocketLiveProvider(options: WebSocketLiveProviderOption
       status = 'connected';
       reconnectAttempts = 0;
       options.onOpen?.();
+      
+      // Resend subscriptions upon reconnects
+      for (const [res, callbacks] of subscribers.entries()) {
+        if (callbacks.size > 0) {
+          const liveParams = lastParams.get(res);
+          ws?.send(JSON.stringify({ type: 'SUBSCRIBE', resource: res, liveParams }));
+        }
+      }
     };
 
     ws.onmessage = (msgEvent) => {
@@ -107,22 +116,31 @@ export function createWebSocketLiveProvider(options: WebSocketLiveProviderOption
 
 
   return {
-    subscribe({ resource, callback }) {
+    subscribe({ resource, liveParams, callback }) {
       if (!subscribers.has(resource)) {
         subscribers.set(resource, new Set());
       }
       subscribers.get(resource)!.add(callback);
+      lastParams.set(resource, liveParams);
 
       // Ensure connection is open
       if (status === 'disconnected' && typeof WebSocket !== 'undefined') {
         connect();
+      } else if (status === 'connected' && ws && ws.readyState === WebSocket.OPEN) {
+        // If already connected, dispatch subscription payload dynamically
+        ws.send(JSON.stringify({ type: 'SUBSCRIBE', resource, liveParams }));
       }
 
       return () => {
         const callbacks = subscribers.get(resource);
         if (callbacks) {
           callbacks.delete(callback);
-          if (callbacks.size === 0) subscribers.delete(resource);
+          if (callbacks.size === 0) {
+            subscribers.delete(resource);
+            if (status === 'connected' && ws && ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'UNSUBSCRIBE', resource }));
+            }
+          }
         }
         // Auto-disconnect if no subscribers left
         if (subscribers.size === 0) disconnect();

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;
   });

package/src/mutation-hooks.svelte.ts

@@ -1,19 +1,86 @@
 import { createMutation, useQueryClient } from '@tanstack/svelte-query';
 import { getAdminOptions } from './options.svelte';
-import { getDataProviderForResource, getResource } from './context.svelte';
+import { getDataProviderForResource, getResource, getLiveProvider } from './context.svelte';
 import { useParsed } from './useParsed.svelte';
 import { audit } from './audit';
 import { UndoError } from './types';
 import type { BaseRecord, HttpError, CreateParams, UpdateParams, DeleteParams, KnownResources } from './types';
-import { createOvertimeTracker, fireSuccessNotification, fireErrorNotification } from './hook-utils.svelte';
+import { checkError, createOvertimeTracker, fireSuccessNotification, fireErrorNotification } from './hook-utils.svelte';
 import type { NotificationConfig, OvertimeOptions } from './hook-utils.svelte';
 import { toast } from './toast.svelte';
 
+// ─── Helper: publish live events after mutations ────────────────
+
+function publishLiveEvent(resource: string, type: 'created' | 'updated' | 'deleted', ids?: (string | number)[]) {
+  try {
+    const liveProvider = getLiveProvider();
+    if (liveProvider?.publish) {
+      liveProvider.publish({
+        type: type === 'created' ? 'INSERT' : type === 'updated' ? 'UPDATE' : 'DELETE',
+        resource,
+        payload: { ids },
+      });
+    }
+  } catch { /* LiveProvider not configured — skip silently */ }
+}
+
+/**
+ * Invalidate queries by scope. Respects per-mutation `invalidates` override.
+ * Default invalidation scopes per operation:
+ *   - create: ['list', 'many']
+ *   - update: ['list', 'many', 'detail']
+ *   - delete: ['list', 'many']
+ */
+export function invalidateByScopes(
+  queryClient: ReturnType<typeof useQueryClient>,
+  resource: string,
+  scopes: string[] | false | undefined,
+  defaults: string[],
+  id?: string | number
+): void {
+  if (scopes === false) return;
+  const effectiveScopes = (scopes && scopes.length > 0) ? scopes : defaults;
+  for (const scope of effectiveScopes) {
+    if (scope === 'list') queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resource && (q.queryKey[2] === 'list' || q.queryKey[2] === 'infiniteList' || q.queryKey[2] === 'select') });
+    else if (scope === 'many') queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resource && q.queryKey[2] === 'many' });
+    else if ((scope === 'detail' || scope === 'one') && id != null) queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resource && q.queryKey[2] === 'one' && q.queryKey[3] === id });
+    else if (scope === 'resourceAll') queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resource });
+  }
+}
+
+export function deepMerge(target: any, source: any): any {
+  if (!target || typeof target !== 'object') return source;
+  if (!source || typeof source !== 'object') return source;
+  if (Array.isArray(source) || source instanceof Date) return source;
+  const result = { ...target };
+  for (const key in source) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key]) && !(source[key] instanceof Date)) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
 // ─── useCreate ─────────────────────────────────────────────────
 
+interface MutationContext {
+  _svadmin_ctx?: boolean;
+  userContext?: unknown;
+  previousQueries?: [unknown, unknown][];
+}
+
+interface MutationCallbacks {
+  onMutate?: (variables: unknown) => unknown | Promise<unknown>;
+  onSuccess?: (data: unknown, variables: unknown, context: unknown) => void;
+  onError?: (error: unknown, variables: unknown, context: unknown) => void;
+  onSettled?: (data: unknown | undefined, error: unknown | null, variables: unknown, context: unknown) => void;
+}
+
 export interface UseCreateOptions {
   resource?: KnownResources;
-  mutationOptions?: Record<string, unknown>;
+  mutationOptions?: MutationCallbacks;
   overtimeOptions?: OvertimeOptions;
 }
 
@@ -33,8 +100,7 @@ export function useCreate<TData extends BaseRecord = BaseRecord, TError = HttpEr
   const adminOptions = getAdminOptions();
   const queryClient = useQueryClient();
 
-  let isMutating = $state(false);
-  const overtime = createOvertimeTracker(() => isMutating, options.overtimeOptions ?? adminOptions.overtime);
+  const overtime = createOvertimeTracker(() => mutation.isPending, options.overtimeOptions ?? adminOptions.overtime);
 
   const mutation = createMutation<
     { data: TData },
@@ -43,34 +109,31 @@ export function useCreate<TData extends BaseRecord = BaseRecord, TError = HttpEr
   >(() => ({
     ...options.mutationOptions,
     mutationFn: async (params) => {
-      isMutating = true;
       const resName = params.resource ?? defaultResource;
       const provider = getDataProviderForResource(resName, params.dataProviderName);
-      try {
-        return await provider.create<TData, TVariables>({
+      return await provider.create<TData, TVariables>({
           resource: resName,
           variables: params.variables,
           meta: params.meta,
         });
-      } finally {
-        isMutating = false;
-      }
     },
-    onMutate: (options.mutationOptions as any)?.onMutate,
+    onMutate: options.mutationOptions?.onMutate,
     onSuccess: (data, params, context) => {
       const resName = params.resource ?? defaultResource;
-      if (params.invalidates !== false) {
-        queryClient.invalidateQueries({ queryKey: [resName] });
-      }
       fireSuccessNotification(params.successNotification, 'Created successfully', data.data, params.variables, resName);
       const res = getResource(resName);
       const pk = res.primaryKey ?? 'id';
-      audit({ action: 'create', resource: resName, recordId: String((data.data as Record<string, unknown>)[pk]) });
+      const newId = (data.data as Record<string, unknown>)[pk];
+      audit({ action: 'create', resource: resName, recordId: String(newId) });
+      publishLiveEvent(resName, 'created', newId != null ? [newId as string | number] : undefined);
+      // Invalidation in onSuccess for create (refine pattern — no optimistic data to reconcile on error)
+      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many']);
       if (typeof options.mutationOptions?.onSuccess === 'function') {
         (options.mutationOptions.onSuccess as Function)(data, params, context);
       }
     },
     onError: (error, params, context) => {
+      checkError(error);
       fireErrorNotification(params.errorNotification, 'Create failed', error);
       if (typeof options.mutationOptions?.onError === 'function') {
         (options.mutationOptions.onError as Function)(error, params, context);
@@ -88,7 +151,7 @@ export interface UseUpdateOptions {
   id?: string | number;
   mutationMode?: 'pessimistic' | 'optimistic' | 'undoable';
   undoableTimeout?: number;
-  mutationOptions?: Record<string, unknown>;
+  mutationOptions?: MutationCallbacks;
   overtimeOptions?: OvertimeOptions;
 }
 
@@ -103,8 +166,9 @@ export interface UseUpdateMutateParams<TVariables> {
   dataProviderName?: string;
   onCancel?: () => void;
   optimisticUpdateMap?: {
-    detail?: (previous: unknown, variables: TVariables, id?: string | number) => unknown;
-    list?: (previous: unknown, variables: TVariables, id?: string | number) => unknown;
+    detail?: boolean | ((previous: unknown, variables: TVariables, id?: string | number) => unknown);
+    list?: boolean | ((previous: unknown, variables: TVariables, id?: string | number) => unknown);
+    many?: boolean | ((previous: unknown, variables: TVariables, id?: string | number) => unknown);
   };
 }
 
@@ -117,8 +181,7 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
   const mutationMode = options.mutationMode ?? adminOptions.mutationMode ?? 'pessimistic';
   const undoableTimeout = options.undoableTimeout ?? adminOptions.undoableTimeout ?? 5000;
 
-  let isMutating = $state(false);
-  const overtime = createOvertimeTracker(() => isMutating, options.overtimeOptions ?? adminOptions.overtime);
+  const overtime = createOvertimeTracker(() => mutation.isPending, options.overtimeOptions ?? adminOptions.overtime);
 
   const mutation = createMutation<
     { data: TData },
@@ -127,7 +190,6 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
   >(() => ({
     ...options.mutationOptions,
     mutationFn: async (params) => {
-      isMutating = true;
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
       if (targetId == null) throw new Error('useUpdate requires an id');
@@ -142,73 +204,84 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       }
 
       const provider = getDataProviderForResource(resName, params.dataProviderName);
-      try {
-        return await provider.update<TData, TVariables>({
+      return await provider.update<TData, TVariables>({
           resource: resName,
           id: targetId,
           variables: params.variables,
           meta: params.meta,
         });
-      } finally {
-        isMutating = false;
-      }
     },
     onMutate: async (params) => {
-      const userOnMutate = (options.mutationOptions as any)?.onMutate;
+      const userOnMutate = options.mutationOptions?.onMutate;
       const userContext = typeof userOnMutate === 'function' ? await userOnMutate(params) : undefined;
       
       if (mutationMode === 'pessimistic') return { _svadmin_ctx: true, userContext };
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
       
-      await queryClient.cancelQueries({ queryKey: [resName] });
-      const previousDetail = queryClient.getQueryData([resName, 'one', targetId]);
-      const previousList = queryClient.getQueriesData({ queryKey: [resName, 'list'] });
+      await queryClient.cancelQueries({ predicate: (q) => q.queryKey[1] === resName });
+
+      const previousQueries = queryClient.getQueriesData({ predicate: (q) => q.queryKey[1] === resName });
       
       const pk = getResource(resName).primaryKey ?? 'id';
-      const updater = params.optimisticUpdateMap;
+      const updater = params.optimisticUpdateMap ?? { list: true, many: true, detail: true };
       
-      if (updater?.detail) {
-        queryClient.setQueryData([resName, 'one', targetId], (old: unknown) => updater.detail!(old, params.variables, targetId));
-      } else {
-        queryClient.setQueryData([resName, 'one', targetId], (old: Record<string, unknown> | undefined) => old ? { ...old, ...params.variables } : old);
+      if (updater.detail !== false) {
+        const detailFn = updater.detail;
+        if (typeof detailFn === 'function') {
+          queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId }, (old: unknown) => detailFn(old, params.variables, targetId));
+        } else {
+          queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId }, (old: Record<string, unknown> | undefined) => old ? { ...old, data: deepMerge((old as Record<string, unknown>).data || {}, params.variables) } : old);
+        }
       }
       
-      if (updater?.list) {
-        queryClient.setQueriesData({ queryKey: [resName, 'list'] }, (old: unknown) => updater.list!(old, params.variables, targetId));
-      } else {
-        queryClient.setQueriesData({ queryKey: [resName, 'list'] }, (old: unknown) => {
+      if (updater.list !== false) {
+        queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'list' }, (old: unknown) => {
+          if (typeof updater.list === 'function') return updater.list!(old, params.variables, targetId);
           if (!old || typeof old !== 'object' || !('data' in old)) return old;
           const o = old as { data: Record<string, unknown>[] };
-          return { ...o, data: o.data.map((item) => String(item[pk]) === String(targetId) ? { ...item, ...params.variables } : item) };
+          return { ...o, data: o.data.map((item) => String(item[pk]) === String(targetId) ? deepMerge(item, params.variables) : item) };
         });
       }
 
-      return { _svadmin_ctx: true, userContext, previousDetail, previousList };
+      if (updater.many !== false) {
+        queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'many' }, (old: unknown) => {
+          if (typeof updater.many === 'function') return updater.many!(old, params.variables, targetId);
+          if (!old || typeof old !== 'object' || !('data' in old)) return old;
+          const o = old as { data: Record<string, unknown>[] };
+          return { ...o, data: o.data.map((item) => String(item[pk]) === String(targetId) ? deepMerge(item, params.variables) : item) };
+        });
+      }
+
+      return { _svadmin_ctx: true, userContext, previousQueries };
     },
     onSuccess: (data, params, context) => {
-      const extractedCtx = (context as any)?._svadmin_ctx ? (context as any).userContext : context;
+      const extractedCtx = (context as MutationContext)?._svadmin_ctx ? (context as MutationContext).userContext : context;
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
-      if (params.invalidates !== false) {
-        queryClient.invalidateQueries({ queryKey: [resName] });
-      }
       fireSuccessNotification(params.successNotification, 'Updated successfully', data.data, params.variables, resName);
       audit({ action: 'update', resource: resName, recordId: String(targetId) });
+      publishLiveEvent(resName, 'updated', targetId != null ? [targetId] : undefined);
       if (typeof options.mutationOptions?.onSuccess === 'function') {
         (options.mutationOptions.onSuccess as Function)(data, params, extractedCtx);
       }
     },
-    onError: (error, params, context: unknown) => {
-      const extractedCtx = (context as any)?._svadmin_ctx ? (context as any).userContext : context;
+    onSettled: (_data, error, params) => {
+      if (error instanceof UndoError) return;
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
-      const ctx = context as { previousDetail?: unknown; previousList?: [unknown, unknown][] } | undefined;
-      if (ctx?.previousDetail) queryClient.setQueryData([resName, 'one', targetId], ctx.previousDetail);
-      if (ctx?.previousList) {
-        ctx.previousList.forEach(([qk, data]) => queryClient.setQueryData(qk as string[], data));
+      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many', 'detail'], targetId != null ? targetId : undefined);
+    },
+    onError: (error, params, context: unknown) => {
+      const ctx = context as MutationContext | undefined;
+      if (ctx?.previousQueries) {
+        for (const [queryKey, data] of ctx.previousQueries) {
+          queryClient.setQueryData(queryKey as string[], data);
+        }
       }
       if (error instanceof UndoError) return;
+      checkError(error);
+      const extractedCtx = ctx?._svadmin_ctx ? ctx.userContext : context;
       fireErrorNotification(params.errorNotification, 'Update failed', error);
       if (typeof options.mutationOptions?.onError === 'function') {
         (options.mutationOptions.onError as Function)(error, params, extractedCtx);
@@ -226,7 +299,7 @@ export interface UseDeleteOptions {
   id?: string | number;
   mutationMode?: 'pessimistic' | 'optimistic' | 'undoable';
   undoableTimeout?: number;
-  mutationOptions?: Record<string, unknown>;
+  mutationOptions?: MutationCallbacks;
   overtimeOptions?: OvertimeOptions;
 }
 
@@ -251,8 +324,7 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
   const mutationMode = options.mutationMode ?? adminOptions.mutationMode ?? 'pessimistic';
   const undoableTimeout = options.undoableTimeout ?? adminOptions.undoableTimeout ?? 5000;
 
-  let isMutating = $state(false);
-  const overtime = createOvertimeTracker(() => isMutating, options.overtimeOptions ?? adminOptions.overtime);
+  const overtime = createOvertimeTracker(() => mutation.isPending, options.overtimeOptions ?? adminOptions.overtime);
 
   const mutation = createMutation<
     { data: TData },
@@ -261,7 +333,6 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
   >(() => ({
     ...options.mutationOptions,
     mutationFn: async (params) => {
-      isMutating = true;
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
       if (targetId == null) throw new Error('useDelete requires an id');
@@ -276,58 +347,76 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
       }
 
       const provider = getDataProviderForResource(resName, params.dataProviderName);
-      try {
-        return await provider.deleteOne<TData, TVariables>({
+      return await provider.deleteOne<TData, TVariables>({
           resource: resName,
           id: targetId,
           variables: params.variables,
           meta: params.meta,
         });
-      } finally {
-        isMutating = false;
-      }
     },
     onMutate: async (params) => {
-      const userOnMutate = (options.mutationOptions as any)?.onMutate;
+      const userOnMutate = options.mutationOptions?.onMutate;
       const userContext = typeof userOnMutate === 'function' ? await userOnMutate(params) : undefined;
       
       if (mutationMode === 'pessimistic') return { _svadmin_ctx: true, userContext };
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
       
-      await queryClient.cancelQueries({ queryKey: [resName] });
-      const previousList = queryClient.getQueriesData({ queryKey: [resName, 'list'] });
+      await queryClient.cancelQueries({ predicate: (q) => q.queryKey[1] === resName });
+
+      const previousQueries = queryClient.getQueriesData({ predicate: (q) => q.queryKey[1] === resName });
       
       const pk = getResource(resName).primaryKey ?? 'id';
       
-      queryClient.setQueriesData({ queryKey: [resName, 'list'] }, (old: unknown) => {
+      if (targetId != null) queryClient.removeQueries({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId });
+
+      queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'list' }, (old: unknown) => {
+        if (!old || typeof old !== 'object' || !('data' in old)) return old;
+        const o = old as { data: Record<string, unknown>[]; total?: number };
+        const filtered = o.data.filter((item) => String(item[pk]) !== String(targetId));
+        return { ...o, data: filtered, total: (o.total ?? o.data.length) - (o.data.length - filtered.length) };
+      });
+
+      queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'many' }, (old: unknown) => {
         if (!old || typeof old !== 'object' || !('data' in old)) return old;
         const o = old as { data: Record<string, unknown>[] };
         return { ...o, data: o.data.filter((item) => String(item[pk]) !== String(targetId)) };
       });
 
-      return { _svadmin_ctx: true, userContext, previousList };
+      return { _svadmin_ctx: true, userContext, previousQueries };
     },
     onSuccess: (data, params, context) => {
-      const extractedCtx = (context as any)?._svadmin_ctx ? (context as any).userContext : context;
+      const extractedCtx = (context as MutationContext)?._svadmin_ctx ? (context as MutationContext).userContext : context;
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
-      if (params.invalidates !== false) {
-        queryClient.invalidateQueries({ queryKey: [resName] });
+
+      // Remove detail cache entry (refine pattern — no stale show page)
+      if (targetId != null) {
+        queryClient.removeQueries({ predicate: (q) => q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId });
       }
+
       fireSuccessNotification(params.successNotification, 'Deleted successfully', data.data, params.variables, resName);
       audit({ action: 'delete', resource: resName, recordId: String(targetId) });
+      publishLiveEvent(resName, 'deleted', targetId != null ? [targetId] : undefined);
       if (typeof options.mutationOptions?.onSuccess === 'function') {
         (options.mutationOptions.onSuccess as Function)(data, params, extractedCtx);
       }
     },
+    onSettled: (_data, error, params) => {
+      if (error instanceof UndoError) return;
+      const resName = params.resource ?? defaultResource;
+      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many']);
+    },
     onError: (error, params, context: unknown) => {
-      const extractedCtx = (context as any)?._svadmin_ctx ? (context as any).userContext : context;
-      const ctx = context as { previousList?: [unknown, unknown][] } | undefined;
-      if (ctx?.previousList) {
-        ctx.previousList.forEach(([qk, data]) => queryClient.setQueryData(qk as string[], data));
+      const ctx = context as MutationContext | undefined;
+      if (ctx?.previousQueries) {
+        for (const [queryKey, data] of ctx.previousQueries) {
+          queryClient.setQueryData(queryKey as string[], data);
+        }
       }
       if (error instanceof UndoError) return;
+      checkError(error);
+      const extractedCtx = ctx?._svadmin_ctx ? ctx.userContext : context;
       fireErrorNotification(params.errorNotification, 'Delete failed', error);
       if (typeof options.mutationOptions?.onError === 'function') {
         (options.mutationOptions.onError as Function)(error, params, extractedCtx);

package/src/notification.svelte.ts

@@ -4,7 +4,7 @@
 import { toast } from './toast.svelte';
 import type { NotificationProvider } from './types';
 
-let notificationProvider: NotificationProvider | null = null;
+let notificationProvider = $state<NotificationProvider | null>(null);
 
 export function setNotificationProvider(provider: NotificationProvider): void {
   notificationProvider = provider;
@@ -29,10 +29,10 @@ export function notify(params: {
     // Fallback to built-in toast
     const { type, message } = params;
     switch (type) {
-      case 'success': toast.success(message); break;
-      case 'error': toast.error(message); break;
-      case 'warning': toast.warning(message); break;
-      case 'info': toast.info(message); break;
+      case 'success': toast.success(message, undefined, { key: params.key }); break;
+      case 'error': toast.error(message, undefined, { key: params.key }); break;
+      case 'warning': toast.warning(message, undefined, { key: params.key }); break;
+      case 'info': toast.info(message, undefined, { key: params.key }); break;
     }
   }
 }
@@ -43,3 +43,7 @@ export function notify(params: {
 export function closeNotification(key: string): void {
   notificationProvider?.close(key);
 }
+
+export function resetNotificationProvider(): void {
+  notificationProvider = null;
+}