@svadmin/core 0.22.1 → 0.23.0

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

package/src/options.svelte.ts

@@ -54,33 +54,56 @@ const defaultTextTransformers: TextTransformers = {
   singular: (text: string) => text.endsWith('s') ? text.slice(0, -1) : text,
 };
 
-const defaultOptions: AdminOptions = {
-  mutationMode: 'pessimistic',
-  warnWhenUnsavedChanges: false,
-  syncWithLocation: false,
-  liveMode: 'auto',
-  disableServerSideValidation: false,
-  undoableTimeout: 5000,
-  textTransformers: defaultTextTransformers,
-  redirect: { afterCreate: 'list', afterEdit: 'list', afterClone: 'list' },
-  breadcrumb: 'default',
-  disableRouteChangeHandler: false,
-};
+function createDefaultOptions(): AdminOptions {
+  return {
+    mutationMode: 'pessimistic',
+    warnWhenUnsavedChanges: false,
+    syncWithLocation: false,
+    liveMode: 'auto',
+    disableServerSideValidation: false,
+    undoableTimeout: 5000,
+    textTransformers: defaultTextTransformers,
+    redirect: { afterCreate: 'list', afterEdit: 'list', afterClone: 'list' },
+    breadcrumb: 'default',
+    disableRouteChangeHandler: false,
+  };
+}
 
-let adminOptions = $state<AdminOptions>(defaultOptions);
+let adminOptions = $state<AdminOptions>(createDefaultOptions());
 
-export function setAdminOptions(options: AdminOptions): void {
-  adminOptions = {
-    ...defaultOptions,
-    ...options,
-    textTransformers: { ...defaultTextTransformers, ...options.textTransformers },
-  };
+export function setAdminOptions(options: AdminOptions, merge?: boolean): void {
+  if (merge) {
+    adminOptions = {
+      ...adminOptions,
+      ...options,
+      textTransformers: { ...adminOptions.textTransformers, ...options.textTransformers },
+      redirect: { ...adminOptions.redirect, ...options.redirect },
+      reactQuery: { ...adminOptions.reactQuery, ...options.reactQuery },
+      title: { ...adminOptions.title, ...options.title },
+      overtime: { ...adminOptions.overtime, ...options.overtime },
+    };
+  } else {
+    const defaults = createDefaultOptions();
+    adminOptions = {
+      ...defaults,
+      ...options,
+      textTransformers: { ...defaultTextTransformers, ...options.textTransformers },
+      redirect: { ...defaults.redirect, ...options.redirect },
+      reactQuery: { ...defaults.reactQuery, ...options.reactQuery },
+      title: { ...defaults.title, ...options.title },
+      overtime: { ...defaults.overtime, ...options.overtime },
+    };
+  }
 }
 
 export function getAdminOptions(): AdminOptions {
   return adminOptions;
 }
 
+export function resetAdminOptions(): void {
+  adminOptions = createDefaultOptions();
+}
+
 /** Get the resolved text transformers (always returns full set) */
 export function getTextTransformers(): TextTransformers {
   const opts = getAdminOptions();

package/src/permissions.ts

@@ -67,6 +67,10 @@ export function getAccessControlProvider(): AccessControlProvider | null {
   return provider;
 }
 
+export function resetAccessControlProvider(): void {
+  provider = null;
+}
+
 /** Get global button options from the AccessControlProvider */
 export function getAccessControlOptions() {
   return provider?.options ?? {};