@svadmin/core 0.34.2 → 0.35.0

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

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