@svadmin/core 0.34.1 → 0.35.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 { appendTenantCacheKey, queryKeyMatchesTenant } from './provider-bundle';
 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: appendTenantCacheKey([
+      options.dataProviderName, resource, 'one', currentId, queryMeta,
+    ], adminContext.tenantCacheKey),
     queryFn: async () => {
       const result = await provider.getOne<BaseRecord>({ resource, id: currentId as string, meta: queryMeta });
       return result;
@@ -518,12 +527,25 @@ 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,
+        res,
+        invalidateScopes,
+        ['list', 'many'],
+        undefined,
+        options.dataProviderName,
+        (queryKey) => queryKeyMatchesTenant(queryKey, adminContext.tenantCacheKey),
+      );
       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] : [] } });
@@ -563,7 +585,8 @@ export function useForm<
       const targetId = currentId;
       const targetResource = resource;
       const dpN = options.dataProviderName;
-      const dp = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dpN;
+      const dp = (q: { queryKey: readonly unknown[] }) =>
+        queryKeyMatchesTenant(q.queryKey, adminContext.tenantCacheKey) && 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 });
       if (optimisticUpdateMap?.list !== false) {
@@ -584,8 +607,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 +626,15 @@ 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,
+        res,
+        invalidateScopes,
+        ['list', 'many', 'detail'],
+        targetId ?? undefined,
+        options.dataProviderName,
+        (queryKey) => queryKeyMatchesTenant(queryKey, adminContext.tenantCacheKey),
+      );
     },
     onError: (error: unknown, _vars: unknown, context: unknown) => {
       const ctx = context as { previousQueries?: [unknown, unknown][] } | undefined;
@@ -649,7 +685,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 +776,15 @@ 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,
+          safeResource,
+          scopes,
+          ['resourceAll'],
+          safeId ?? undefined,
+          options.dataProviderName,
+          (queryKey) => queryKeyMatchesTenant(queryKey, adminContext.tenantCacheKey),
+        );
         if (!isRecordIdentityCurrent(scheduledIdentity)) return;
         autoSaveStatus = 'saved';
         lastAutoSaveData = submittedValues;
@@ -769,7 +813,11 @@ 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) => queryKeyMatchesTenant(q.queryKey, adminContext.tenantCacheKey)
+          && q.queryKey[0] === options.dataProviderName
+          && q.queryKey[1] === 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 { queryKeyMatchesTenant } from './provider-bundle';
+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();
@@ -106,7 +109,8 @@ export function createLiveSubscription(paramsFn: () => LiveSubscriptionParams):
           params.onLiveEvent?.(event);
           if (liveMode === 'auto') {
             const dpN = params.dataProviderName;
-            const dpMatch = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dpN;
+            const dpMatch = (q: { queryKey: readonly unknown[] }) =>
+              queryKeyMatchesTenant(q.queryKey, adminContext.tenantCacheKey) && q.queryKey[0] === dpN;
             queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === 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

@@ -24,13 +24,14 @@ export type { OvertimeResult, OvertimeOptions, NotificationConfig } from './hook
 import { createQuery, createInfiniteQuery, createMutation, useQueryClient } from '@tanstack/svelte-query';
 import { getAdminOptions } from './options.svelte';
 import { captureAdminContext } from './context.svelte';
+import { appendTenantCacheKey, queryKeyMatchesTenant } from './provider-bundle';
 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 +59,15 @@ 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: appendTenantCacheKey([
+      options.dataProviderName,
+      resource,
+      'infiniteList',
+      options.pagination?.pageSize,
+      options.sorters,
+      options.filters,
+      options.meta,
+    ], adminContext.tenantCacheKey),
     queryFn: async ({ pageParam = 1 }) => {
       const result = await provider.getList<TData>({
         resource,
@@ -99,11 +108,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 +173,9 @@ 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: appendTenantCacheKey([
+      dataProviderName, resource, 'select', allFilters, sorters, pagination, meta,
+    ], adminContext.tenantCacheKey),
     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 +188,9 @@ 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: appendTenantCacheKey([
+            dataProviderName, resource, 'select-defaults', defaultValueIds,
+          ], adminContext.tenantCacheKey),
           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 +228,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 +287,9 @@ 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: appendTenantCacheKey([
+      options.dataProviderName, 'custom', options.url, options.method, options.config, options.meta,
+    ], adminContext.tenantCacheKey),
     queryFn: async () => {
       if (!provider.custom) throw new Error('DataProvider does not support custom method');
       return provider.custom<TData>({
@@ -276,11 +315,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 +351,15 @@ 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,
+          params.resource,
+          params.invalidates,
+          ['list', 'many'],
+          undefined,
+          dataProviderName,
+          (queryKey) => queryKeyMatchesTenant(queryKey, adminContext.tenantCacheKey),
+        );
       }
     },
     onError: (error) => {
@@ -331,17 +389,41 @@ 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,
+        resName,
+        undefined,
+        ['list', 'many'],
+        undefined,
+        params.dataProviderName,
+        (queryKey) => queryKeyMatchesTenant(queryKey, adminContext.tenantCacheKey),
+      );
     },
   }));
 
@@ -365,19 +447,49 @@ 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,
+        resName,
+        undefined,
+        ['list', 'many', 'detail'],
+        undefined,
+        params.dataProviderName,
+        (queryKey) => queryKeyMatchesTenant(queryKey, adminContext.tenantCacheKey),
+      );
       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) => queryKeyMatchesTenant(q.queryKey, adminContext.tenantCacheKey)
+            && q.queryKey[0] === params.dataProviderName
+            && q.queryKey[1] === resName
+            && q.queryKey[2] === 'one'
+            && q.queryKey[3] === id,
+        });
       }
     },
   }));
@@ -402,19 +514,48 @@ 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,
+        resName,
+        undefined,
+        ['list', 'many'],
+        undefined,
+        params.dataProviderName,
+        (queryKey) => queryKeyMatchesTenant(queryKey, adminContext.tenantCacheKey),
+      );
       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) => queryKeyMatchesTenant(q.queryKey, adminContext.tenantCacheKey)
+            && q.queryKey[0] === params.dataProviderName
+            && q.queryKey[1] === resName
+            && q.queryKey[2] === 'one'
+            && q.queryKey[3] === id,
+        });
       }
     },
   }));
@@ -426,15 +567,21 @@ 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) => queryKeyMatchesTenant(q.queryKey, adminContext.tenantCacheKey)
+          && q.queryKey[0] === params.dataProviderName,
+      });
       return;
     }
     const scopes = params.invalidates || ['resourceAll'];
     const res = params.resource;
-    const dpMatch = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === params.dataProviderName;
+    const dpMatch = (q: { queryKey: readonly unknown[] }) =>
+      queryKeyMatchesTenant(q.queryKey, adminContext.tenantCacheKey)
+        && 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 });

package/src/index.ts

@@ -8,9 +8,31 @@ export {
   setLiveProvider, getLiveProvider,
   setTaskProvider, getTaskProvider,
   createAdminContext, provideAdminContext, getAdminContext, captureAdminContext,
+  provideTenantContext, getTenantContext, getProviderBundle,
   resetContext,
 } from './context.svelte';
 export type { DataProviderInput, AdminContextSource, AdminContextValue, AdminContextAccessor } from './context.svelte';
+export {
+  appendTenantCacheKey,
+  createProviderBundle,
+  createTenantCacheKey,
+  defaultTenantAdapter,
+  isTenantCacheKey,
+  queryKeyMatchesTenant,
+  resolveTenantProviderMeta,
+  withProviderMeta,
+  withTenantDataProvider,
+} from './provider-bundle';
+export type {
+  ProviderBundle,
+  ProviderMetaInput,
+  ProviderMetaResolver,
+  TenantAdapter,
+  TenantCacheIdentity,
+  TenantCacheKey,
+  TenantContext,
+  TenantId,
+} from './provider-bundle';
 export {
   useList, useInfiniteList,
   useOne, useShow,
@@ -36,10 +58,17 @@ export { readURLState, writeURLState } from './url-sync';
 export { setAccessControlProvider, getAccessControlProvider, getAccessControlOptions, canAccessAsync, createFeatureGate } from './permissions.svelte';
 export { useLive, useSubscription, usePublish } from './live.svelte';
 export { toast, getToastQueue, consumeToastQueue, getPromiseQueue, consumePromiseQueue, resetToast } from './toast.svelte';
-export { notify, closeNotification, setNotificationProvider, getNotificationProvider } from './notification.svelte';
+export {
+  notify,
+  notifyWithProvider,
+  closeNotification,
+  setNotificationProvider,
+  getNotificationProvider,
+} from './notification.svelte';
+export type { NotificationParams } from './notification.svelte';
 export { t, setLocale, getLocale, getAvailableLocales, addTranslations, useTranslation, setI18nProvider, getI18nProvider, createI18nScope, provideI18nScope, getI18nScope, resetI18n } from './i18n.svelte';
 export type { I18nProvider, I18nScope, I18nScopeOptions } from './i18n.svelte';
-export { audit, setAuditHandler, setAuditLogProvider, getAuditLogProvider } from './audit';
+export { audit, auditWithProvider, setAuditHandler, setAuditLogProvider, getAuditLogProvider } from './audit';
 export type { AuditLogProvider } from './audit';
 export { setChatProvider, getChatProvider, setChatContext, getChatContext, setAgentProvider, getAgentProvider, registerApproval, resolveApproval, hasPendingApprovals, resetChatProvider } from './chatProvider.svelte';
 export type { ChatProvider, ChatMessage, ChatContext, ChatAction, AgentProvider, AgentEvent, AgentOptions, AdminTool, AdminToolParameter, ToolResult } from './chatProvider.svelte';
@@ -67,7 +96,8 @@ export type {
   DeleteParams, DeleteResult,
   DeleteManyParams, DeleteManyResult,
   Pagination, Sort, Filter, Identity,
-  ResourceDefinition, FieldDefinition, MenuItem,
+  ResourceDefinition, ResourceProviderConfig, ResourceTransportConfig, ResourceAdapterConfig,
+  FieldDefinition, MenuItem,
   AuthActionResult, CheckResult,
   ResourceTypeMap, KnownResources, InferData,
   BaseRecord, Role, AuditLog