@svadmin/core 0.34.1 → 0.35.0

package/src/live.svelte.ts

@@ -1,6 +1,8 @@
 // LiveProvider — Real-time subscription interface + hooks
 
 import { useQueryClient } from '@tanstack/svelte-query';
+import { captureAdminContext } from './context.svelte';
+import { queryKeyMatchesTenant } from './provider-bundle';
 
 // ─── Types ──────────────────────────────────────────────────────
 
@@ -34,6 +36,7 @@ export function useLive(
   options?: { liveMode?: LiveMode | (() => LiveMode); onLiveEvent?: (event: LiveEvent) => void; liveParams?: Record<string, unknown> | (() => Record<string, unknown>); dataProviderName?: string }
 ): void {
   const queryClient = useQueryClient();
+  const adminContext = captureAdminContext();
 
   $effect(() => {
     const lp = typeof liveProvider === 'function' ? liveProvider() : liveProvider;
@@ -51,7 +54,8 @@ export function useLive(
           options?.onLiveEvent?.(event);
           if (liveMode === 'auto') {
             const dpName = options?.dataProviderName;
-            const dpMatch = (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dpName;
+            const dpMatch = (q: { queryKey: readonly unknown[] }) =>
+              queryKeyMatchesTenant(q.queryKey, adminContext.tenantCacheKey) && q.queryKey[0] === dpName;
             queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === res });
           }
         },

package/src/mutation-hooks.svelte.ts

@@ -2,9 +2,10 @@
 import { createMutation, useQueryClient } from '@tanstack/svelte-query';
 import { getAdminOptions } from './options.svelte';
 import { captureAdminContext } from './context.svelte';
+import { queryKeyMatchesTenant } from './provider-bundle';
 import type { AdminContextAccessor } from './context.svelte';
 import { useParsed } from './useParsed.svelte';
-import { audit } from './audit';
+import { auditWithProvider } from './audit';
 import { UndoError } from './types';
 import type { BaseRecord, HttpError, KnownResources } from './types';
 import { checkError, createOvertimeTracker, fireSuccessNotification, fireErrorNotification } from './hook-utils.svelte';
@@ -44,13 +45,14 @@ export function invalidateByScopes(
   scopes: string[] | false | undefined,
   defaults: string[],
   id?: string | number,
-  dataProviderName?: string
+  dataProviderName?: string,
+  queryMatches: (queryKey: readonly unknown[]) => boolean = () => true,
 ): void {
   if (scopes === false) return;
   const effectiveScopes = (scopes && scopes.length > 0) ? scopes : defaults;
   const dpMatch = dataProviderName === undefined
-    ? () => true
-    : (q: { queryKey: readonly unknown[] }) => q.queryKey[0] === dataProviderName;
+    ? (q: { queryKey: readonly unknown[] }) => queryMatches(q.queryKey)
+    : (q: { queryKey: readonly unknown[] }) => queryMatches(q.queryKey) && q.queryKey[0] === dataProviderName;
   for (const scope of effectiveScopes) {
     if (scope === 'list') queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === resource && (q.queryKey[2] === 'list' || q.queryKey[2] === 'infiniteList' || q.queryKey[2] === 'select' || q.queryKey[2] === 'select-defaults') });
     else if (scope === 'many') queryClient.invalidateQueries({ predicate: (q) => dpMatch(q) && q.queryKey[1] === resource && q.queryKey[2] === 'many' });
@@ -133,21 +135,50 @@ export function useCreate<TData extends BaseRecord = BaseRecord, TError = HttpEr
     onMutate: options.mutationOptions?.onMutate,
     onSuccess: (data, params, context) => {
       const resName = params.resource ?? defaultResource;
-      fireSuccessNotification(params.successNotification, 'Created successfully', data.data, params.variables, resName);
+      fireSuccessNotification({
+        config: params.successNotification,
+        defaultMessage: 'Created successfully',
+        data: data.data,
+        values: params.variables,
+        resource: resName,
+        provider: adminContext.notificationProvider,
+      });
       const res = adminContext.getResource(resName);
       const pk = res.primaryKey ?? 'id';
       const newId = (data.data as Record<string, unknown>)[pk];
-      audit({ action: 'create', resource: resName, recordId: String(newId) });
+      auditWithProvider(
+        {
+          action: 'create',
+          resource: resName,
+          recordId: String(newId),
+          meta: adminContext.getProviderMeta(resName),
+        },
+        adminContext.auditLogProvider,
+      );
       publishLiveEvent(resName, 'created', newId != null ? [newId as string | number] : undefined, adminContext);
       // Invalidation in onSuccess for create (refine pattern — no optimistic data to reconcile on error)
-      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many'], undefined, params.dataProviderName);
+      invalidateByScopes(
+        queryClient,
+        resName,
+        params.invalidates,
+        ['list', 'many'],
+        undefined,
+        params.dataProviderName,
+        (queryKey) => queryKeyMatchesTenant(queryKey, adminContext.tenantCacheKey),
+      );
       if (typeof options.mutationOptions?.onSuccess === 'function') {
         (options.mutationOptions.onSuccess as (...a: unknown[]) => unknown)(data, params, context);
       }
     },
     onError: (error, params, context) => {
       checkError(error, adminContext);
-      fireErrorNotification(params.errorNotification, 'Create failed', error, params.resource ?? defaultResource);
+      fireErrorNotification({
+        config: params.errorNotification,
+        defaultMessage: 'Create failed',
+        error,
+        resource: params.resource ?? defaultResource,
+        provider: adminContext.notificationProvider,
+      });
       if (typeof options.mutationOptions?.onError === 'function') {
         (options.mutationOptions.onError as (...a: unknown[]) => unknown)(error, params, context);
       }
@@ -233,7 +264,8 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
       const dpN = params.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] === resName });
 
@@ -275,8 +307,23 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       const extractedCtx = (context as MutationContext)?._svadmin_ctx ? (context as MutationContext).userContext : context;
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
-      fireSuccessNotification(params.successNotification, 'Updated successfully', data.data, params.variables, resName);
-      audit({ action: 'update', resource: resName, recordId: String(targetId) });
+      fireSuccessNotification({
+        config: params.successNotification,
+        defaultMessage: 'Updated successfully',
+        data: data.data,
+        values: params.variables,
+        resource: resName,
+        provider: adminContext.notificationProvider,
+      });
+      auditWithProvider(
+        {
+          action: 'update',
+          resource: resName,
+          recordId: String(targetId),
+          meta: adminContext.getProviderMeta(resName),
+        },
+        adminContext.auditLogProvider,
+      );
       publishLiveEvent(resName, 'updated', targetId != null ? [targetId] : undefined, adminContext);
       if (typeof options.mutationOptions?.onSuccess === 'function') {
         (options.mutationOptions.onSuccess as (...a: unknown[]) => unknown)(data, params, extractedCtx);
@@ -286,7 +333,15 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       if (error instanceof UndoError) return;
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
-      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many', 'detail'], targetId != null ? targetId : undefined, params.dataProviderName);
+      invalidateByScopes(
+        queryClient,
+        resName,
+        params.invalidates,
+        ['list', 'many', 'detail'],
+        targetId != null ? targetId : undefined,
+        params.dataProviderName,
+        (queryKey) => queryKeyMatchesTenant(queryKey, adminContext.tenantCacheKey),
+      );
       if (typeof options.mutationOptions?.onSettled === 'function') {
         (options.mutationOptions.onSettled as (...a: unknown[]) => unknown)(_data, error, params, undefined);
       }
@@ -301,7 +356,13 @@ export function useUpdate<TData extends BaseRecord = BaseRecord, TError = HttpEr
       if (error instanceof UndoError) return;
       checkError(error, adminContext);
       const extractedCtx = ctx?._svadmin_ctx ? ctx.userContext : context;
-      fireErrorNotification(params.errorNotification, 'Update failed', error, params.resource ?? defaultResource);
+      fireErrorNotification({
+        config: params.errorNotification,
+        defaultMessage: 'Update failed',
+        error,
+        resource: params.resource ?? defaultResource,
+        provider: adminContext.notificationProvider,
+      });
       if (typeof options.mutationOptions?.onError === 'function') {
         (options.mutationOptions.onError as (...a: unknown[]) => unknown)(error, params, extractedCtx);
       }
@@ -382,7 +443,8 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
       const dpN = params.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] === resName });
 
@@ -414,11 +476,32 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
 
       // Remove detail cache entry (refine pattern — no stale show page)
       if (targetId != null) {
-        queryClient.removeQueries({ predicate: (q) => q.queryKey[0] === params.dataProviderName && q.queryKey[1] === resName && q.queryKey[2] === 'one' && q.queryKey[3] === targetId });
+        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] === targetId,
+        });
       }
 
-      fireSuccessNotification(params.successNotification, 'Deleted successfully', data.data, params.variables, resName);
-      audit({ action: 'delete', resource: resName, recordId: String(targetId) });
+      fireSuccessNotification({
+        config: params.successNotification,
+        defaultMessage: 'Deleted successfully',
+        data: data.data,
+        values: params.variables,
+        resource: resName,
+        provider: adminContext.notificationProvider,
+      });
+      auditWithProvider(
+        {
+          action: 'delete',
+          resource: resName,
+          recordId: String(targetId),
+          meta: adminContext.getProviderMeta(resName),
+        },
+        adminContext.auditLogProvider,
+      );
       publishLiveEvent(resName, 'deleted', targetId != null ? [targetId] : undefined, adminContext);
       if (typeof options.mutationOptions?.onSuccess === 'function') {
         (options.mutationOptions.onSuccess as (...a: unknown[]) => unknown)(data, params, extractedCtx);
@@ -428,7 +511,15 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
       if (error instanceof UndoError) return;
       const resName = params.resource ?? defaultResource;
       const targetId = params.id ?? defaultId;
-      invalidateByScopes(queryClient, resName, params.invalidates, ['list', 'many'], targetId != null ? targetId : undefined, params.dataProviderName);
+      invalidateByScopes(
+        queryClient,
+        resName,
+        params.invalidates,
+        ['list', 'many'],
+        targetId != null ? targetId : undefined,
+        params.dataProviderName,
+        (queryKey) => queryKeyMatchesTenant(queryKey, adminContext.tenantCacheKey),
+      );
       if (typeof options.mutationOptions?.onSettled === 'function') {
         (options.mutationOptions.onSettled as (...a: unknown[]) => unknown)(_data, error, params, undefined);
       }
@@ -443,7 +534,13 @@ export function useDelete<TData extends BaseRecord = BaseRecord, TError = HttpEr
       if (error instanceof UndoError) return;
       checkError(error, adminContext);
       const extractedCtx = ctx?._svadmin_ctx ? ctx.userContext : context;
-      fireErrorNotification(params.errorNotification, 'Delete failed', error, params.resource ?? defaultResource);
+      fireErrorNotification({
+        config: params.errorNotification,
+        defaultMessage: 'Delete failed',
+        error,
+        resource: params.resource ?? defaultResource,
+        provider: adminContext.notificationProvider,
+      });
       if (typeof options.mutationOptions?.onError === 'function') {
         (options.mutationOptions.onError as (...a: unknown[]) => unknown)(error, params, extractedCtx);
       }

package/src/notification.svelte.ts

@@ -17,14 +17,20 @@ export function getNotificationProvider(): NotificationProvider | null {
 /**
  * Send a notification through the configured provider, or fall back to toast.
  */
-export function notify(params: {
+export interface NotificationParams {
   type: 'success' | 'error' | 'warning' | 'info';
   message: string;
   description?: string;
   key?: string;
-}): void {
-  if (notificationProvider) {
-    notificationProvider.open(params);
+}
+
+/** Send through an explicitly scoped provider, with the built-in toast as fallback. */
+export function notifyWithProvider(
+  params: NotificationParams,
+  provider: NotificationProvider | null | undefined,
+): void {
+  if (provider) {
+    provider.open(params);
   } else {
     const { type, message, description } = params;
     const fullMessage = description ? `${message}: ${description}` : message;
@@ -37,6 +43,10 @@ export function notify(params: {
   }
 }
 
+export function notify(params: NotificationParams): void {
+  notifyWithProvider(params, notificationProvider);
+}
+
 /**
  * Close a notification by key (only works with custom provider).
  */

package/src/provider-bundle.ts

@@ -0,0 +1,200 @@
+import type {
+  AgentProvider,
+  ChatProvider,
+} from './chatProvider.svelte';
+import type { AuditLogProvider } from './audit';
+import type { AccessControlProvider } from './permissions.svelte';
+import type { LiveProvider } from './live.svelte';
+import type { RouterProvider } from './router-provider';
+import type {
+  AuthProvider,
+  BaseRecord,
+  CreateManyParams,
+  CreateManyResult,
+  CreateParams,
+  CreateResult,
+  CustomParams,
+  CustomResult,
+  DataProvider,
+  DeleteManyParams,
+  DeleteManyResult,
+  DeleteParams,
+  DeleteResult,
+  GetListParams,
+  GetListResult,
+  GetManyParams,
+  GetManyResult,
+  GetOneParams,
+  GetOneResult,
+  NotificationProvider,
+  TaskProvider,
+  UpdateManyParams,
+  UpdateManyResult,
+  UpdateParams,
+  UpdateResult,
+} from './types';
+
+export type DataProviderInput = DataProvider | Record<string, DataProvider>;
+
+/**
+ * 一等 Provider 配置对象。字段名与现有独立 provider API 保持一致，
+ * 因此调用方可以渐进地从多个 props 迁移为一个 typed bundle。
+ */
+export interface ProviderBundle {
+  readonly dataProvider: DataProviderInput;
+  readonly authProvider?: AuthProvider | null;
+  readonly accessControlProvider?: AccessControlProvider | null;
+  readonly liveProvider?: LiveProvider;
+  readonly auditLogProvider?: AuditLogProvider | null;
+  readonly notificationProvider?: NotificationProvider | null;
+  readonly chatProvider?: ChatProvider | null;
+  readonly agentProvider?: AgentProvider | null;
+  readonly taskProvider?: TaskProvider;
+  readonly routerProvider?: RouterProvider;
+  readonly tenantAdapter?: TenantAdapter;
+}
+
+/** 保留传入对象的精确类型，同时执行 ProviderBundle 的编译期校验。 */
+export function createProviderBundle<const TBundle extends ProviderBundle>(bundle: TBundle): TBundle {
+  return bundle;
+}
+
+export type TenantId = string | number;
+export type TenantCacheIdentity = string | number;
+
+/** 请求树内的租户状态；不得通过模块级变量在 SSR 请求之间共享。 */
+export interface TenantContext {
+  readonly tenantId: TenantId;
+  readonly meta?: Readonly<Record<string, unknown>>;
+}
+
+/**
+ * 将标准 TenantContext 投影到具体后端所需的 provider meta 与 cache identity。
+ * Core 始终额外写入标准 `tenantId`，adapter 不能覆盖该字段。
+ */
+export interface TenantAdapter {
+  readonly getProviderMeta?: (tenant: TenantContext) => Readonly<Record<string, unknown>>;
+  readonly getCacheIdentity?: (tenant: TenantContext) => TenantCacheIdentity;
+}
+
+export interface TenantCacheKey {
+  readonly __svadminTenant: TenantCacheIdentity;
+}
+
+export const defaultTenantAdapter: Required<TenantAdapter> = {
+  getProviderMeta: (tenant) => tenant.meta ?? {},
+  getCacheIdentity: (tenant) => tenant.tenantId,
+};
+
+export function resolveTenantProviderMeta(
+  tenant: TenantContext,
+  adapter: TenantAdapter = defaultTenantAdapter,
+): Record<string, unknown> {
+  return {
+    ...(tenant.meta ?? {}),
+    ...(adapter.getProviderMeta?.(tenant) ?? {}),
+    tenantId: tenant.tenantId,
+  };
+}
+
+export function createTenantCacheKey(
+  tenant: TenantContext,
+  adapter: TenantAdapter = defaultTenantAdapter,
+): TenantCacheKey {
+  return {
+    __svadminTenant: adapter.getCacheIdentity?.(tenant) ?? tenant.tenantId,
+  };
+}
+
+export function isTenantCacheKey(value: unknown): value is TenantCacheKey {
+  return Boolean(
+    value
+      && typeof value === 'object'
+      && Object.keys(value).length === 1
+      && '__svadminTenant' in value
+      && (typeof value.__svadminTenant === 'string' || typeof value.__svadminTenant === 'number'),
+  );
+}
+
+export function appendTenantCacheKey(
+  queryKey: readonly unknown[],
+  tenantCacheKey: TenantCacheKey | undefined,
+): readonly unknown[] {
+  return tenantCacheKey ? [...queryKey, tenantCacheKey] : queryKey;
+}
+
+export function queryKeyMatchesTenant(
+  queryKey: readonly unknown[],
+  tenantCacheKey: TenantCacheKey | undefined,
+): boolean {
+  const candidate = queryKey.at(-1);
+  const keyTenant = isTenantCacheKey(candidate) ? candidate : undefined;
+  if (!tenantCacheKey) return keyTenant === undefined;
+  return keyTenant?.__svadminTenant === tenantCacheKey.__svadminTenant;
+}
+
+export interface ProviderMetaInput {
+  readonly resource?: string;
+  readonly meta?: Record<string, unknown>;
+}
+
+export type ProviderMetaResolver = (input: ProviderMetaInput) => Record<string, unknown> | undefined;
+
+/**
+ * 为 DataProvider 的所有标准操作增量注入 meta；未声明的扩展字段仍由原 provider 保留。
+ */
+export function withProviderMeta(provider: DataProvider, resolveMeta: ProviderMetaResolver): DataProvider {
+  const adapted: DataProvider = {
+    ...provider,
+    getList: <TData extends BaseRecord = BaseRecord>(params: GetListParams): Promise<GetListResult<TData>> =>
+      provider.getList<TData>({ ...params, meta: resolveMeta(params) }),
+    getOne: <TData extends BaseRecord = BaseRecord>(params: GetOneParams): Promise<GetOneResult<TData>> =>
+      provider.getOne<TData>({ ...params, meta: resolveMeta(params) }),
+    create: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: CreateParams<TVariables>): Promise<CreateResult<TData>> =>
+      provider.create<TData, TVariables>({ ...params, meta: resolveMeta(params) }),
+    update: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: UpdateParams<TVariables>): Promise<UpdateResult<TData>> =>
+      provider.update<TData, TVariables>({ ...params, meta: resolveMeta(params) }),
+    deleteOne: <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: DeleteParams<TVariables>): Promise<DeleteResult<TData>> =>
+      provider.deleteOne<TData, TVariables>({ ...params, meta: resolveMeta(params) }),
+    getApiUrl: () => provider.getApiUrl(),
+  };
+
+  const getMany = provider.getMany?.bind(provider);
+  if (getMany) {
+    adapted.getMany = <TData extends BaseRecord = BaseRecord>(params: GetManyParams): Promise<GetManyResult<TData>> =>
+      getMany<TData>({ ...params, meta: resolveMeta(params) });
+  }
+  const createMany = provider.createMany?.bind(provider);
+  if (createMany) {
+    adapted.createMany = <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: CreateManyParams<TVariables>): Promise<CreateManyResult<TData>> =>
+      createMany<TData, TVariables>({ ...params, meta: resolveMeta(params) });
+  }
+  const updateMany = provider.updateMany?.bind(provider);
+  if (updateMany) {
+    adapted.updateMany = <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: UpdateManyParams<TVariables>): Promise<UpdateManyResult<TData>> =>
+      updateMany<TData, TVariables>({ ...params, meta: resolveMeta(params) });
+  }
+  const deleteMany = provider.deleteMany?.bind(provider);
+  if (deleteMany) {
+    adapted.deleteMany = <TData extends BaseRecord = BaseRecord, TVariables = unknown>(params: DeleteManyParams<TVariables>): Promise<DeleteManyResult<TData>> =>
+      deleteMany<TData, TVariables>({ ...params, meta: resolveMeta(params) });
+  }
+  const custom = provider.custom?.bind(provider);
+  if (custom) {
+    adapted.custom = <TData = unknown, TVariables = unknown>(params: CustomParams<TVariables>): Promise<CustomResult<TData>> =>
+      custom<TData, TVariables>({ ...params, meta: resolveMeta(params) });
+  }
+
+  return adapted;
+}
+
+export function withTenantDataProvider(
+  provider: DataProvider,
+  tenant: TenantContext,
+  adapter: TenantAdapter = defaultTenantAdapter,
+): DataProvider {
+  return withProviderMeta(provider, ({ meta }) => ({
+    ...(meta ?? {}),
+    ...resolveTenantProviderMeta(tenant, adapter),
+  }));
+}

package/src/query-hooks.svelte.ts

@@ -1,6 +1,7 @@
 import { createQuery } from '@tanstack/svelte-query';
 import { getAdminOptions } from './options.svelte';
 import { captureAdminContext } from './context.svelte';
+import { appendTenantCacheKey } from './provider-bundle';
 import { useParsed } from './useParsed.svelte';
 import {
   checkError,
@@ -109,7 +110,9 @@ export function useList<TData extends BaseRecord = BaseRecord, TError = HttpErro
     const filters = [...parentFilters, ...(explicitFilters ?? [])];
 
     return {
-      queryKey: [opts.dataProviderName, resource, 'list', pagination, sorters, filters, meta],
+      queryKey: appendTenantCacheKey([
+        opts.dataProviderName, resource, 'list', pagination, sorters, filters, meta,
+      ], adminContext.tenantCacheKey),
       queryFn: async () => provider.getList<TData>({
         resource,
         pagination,
@@ -150,12 +153,24 @@ export function useList<TData extends BaseRecord = BaseRecord, TError = HttpErro
     if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt) {
       lastSuccessAt = query.dataUpdatedAt;
       if (opts.successNotification) {
-        fireSuccessNotification(opts.successNotification, '', query.data, undefined, getResource());
+        fireSuccessNotification({
+          config: opts.successNotification,
+          defaultMessage: '',
+          data: query.data,
+          resource: getResource(),
+          provider: adminContext.notificationProvider,
+        });
       }
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error, adminContext);
-      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error, getResource());
+      fireErrorNotification({
+        config: opts.errorNotification,
+        defaultMessage: 'Fetch failed',
+        error: query.error,
+        resource: getResource(),
+        provider: adminContext.notificationProvider,
+      });
     }
   });
 
@@ -195,7 +210,10 @@ export function useOne<TData extends BaseRecord = BaseRecord, TError = HttpError
     const queryOptions = opts.queryOptions;
 
     return {
-      queryKey: [opts.dataProviderName, resource, 'one', id, opts.meta],
+      queryKey: appendTenantCacheKey(
+        [opts.dataProviderName, resource, 'one', id, opts.meta],
+        adminContext.tenantCacheKey,
+      ),
       queryFn: async () => {
         if (id == null) throw new Error('useOne requires an id');
         const result = await provider.getOne<TData>({
@@ -238,12 +256,24 @@ export function useOne<TData extends BaseRecord = BaseRecord, TError = HttpError
     if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt) {
       lastSuccessAt = query.dataUpdatedAt;
       if (opts.successNotification) {
-        fireSuccessNotification(opts.successNotification, '', query.data, undefined, getResource());
+        fireSuccessNotification({
+          config: opts.successNotification,
+          defaultMessage: '',
+          data: query.data,
+          resource: getResource(),
+          provider: adminContext.notificationProvider,
+        });
       }
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error, adminContext);
-      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error, getResource());
+      fireErrorNotification({
+        config: opts.errorNotification,
+        defaultMessage: 'Fetch failed',
+        error: query.error,
+        resource: getResource(),
+        provider: adminContext.notificationProvider,
+      });
     }
   });
 
@@ -300,7 +330,10 @@ export function useMany<TData extends BaseRecord = BaseRecord, TError = HttpErro
     const provider = adminContext.getDataProviderForResource(resource, dataProviderName);
 
     return {
-      queryKey: [dataProviderName, resource, 'many', ids, meta],
+      queryKey: appendTenantCacheKey(
+        [dataProviderName, resource, 'many', ids, meta],
+        adminContext.tenantCacheKey,
+      ),
       queryFn: async () => {
         if (!ids.length) return { data: [] };
         if (provider.getMany) {
@@ -341,12 +374,24 @@ export function useMany<TData extends BaseRecord = BaseRecord, TError = HttpErro
     if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt) {
       lastSuccessAt = query.dataUpdatedAt;
       if (opts.successNotification) {
-        fireSuccessNotification(opts.successNotification, '', query.data, undefined, opts.resource);
+        fireSuccessNotification({
+          config: opts.successNotification,
+          defaultMessage: '',
+          data: query.data,
+          resource: opts.resource,
+          provider: adminContext.notificationProvider,
+        });
       }
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error, adminContext);
-      fireErrorNotification(opts.errorNotification, 'Fetch failed', query.error, opts.resource);
+      fireErrorNotification({
+        config: opts.errorNotification,
+        defaultMessage: 'Fetch failed',
+        error: query.error,
+        resource: opts.resource,
+        provider: adminContext.notificationProvider,
+      });
     }
   });