@svadmin/core 0.34.2 → 0.35.0

package/src/task-hooks.svelte.ts

@@ -2,6 +2,11 @@ import { createMutation, createQuery, useQueryClient } from '@tanstack/svelte-qu
 import { getAdminOptions } from './options.svelte';
 import { captureAdminContext } from './context.svelte';
 import type { AdminContextAccessor } from './context.svelte';
+import {
+  appendTenantCacheKey,
+  queryKeyMatchesTenant,
+  resolveTenantProviderMeta,
+} from './provider-bundle';
 import { checkError, createOvertimeTracker, fireErrorNotification, fireSuccessNotification } from './hook-utils.svelte';
 import type { NotificationConfig, OvertimeOptions } from './hook-utils.svelte';
 import { useTranslation } from './i18n.svelte';
@@ -54,27 +59,41 @@ export function useSubmitTask<
   const mutation = createMutation<TaskHandle<TTask>, TError, UseSubmitTaskMutateParams<TTask>>(() => ({
     mutationFn: async (params) => {
       const provider = normalizeTaskProvider<TTask>(params.taskProvider, adminContext);
-      return provider.submit(params.taskName, params.options);
+      const providerMeta = adminContext.tenant
+        ? {
+            ...(params.options?.meta ?? {}),
+            ...resolveTenantProviderMeta(adminContext.tenant, adminContext.tenantAdapter),
+          }
+        : params.options?.meta;
+      const taskOptions = providerMeta === params.options?.meta
+        ? params.options
+        : { ...params.options, meta: providerMeta };
+      return provider.submit(params.taskName, taskOptions);
     },
     onSuccess: (data, params, context) => {
-      fireSuccessNotification(
-        params.successNotification,
-        i18n.t('task.submitSuccess'),
+      fireSuccessNotification({
+        config: params.successNotification,
+        defaultMessage: i18n.t('task.submitSuccess'),
         data,
-        params.options,
-        params.taskName,
-      );
-      void queryClient.invalidateQueries({ queryKey: ['taskList'] });
+        values: params.options,
+        resource: params.taskName,
+        provider: adminContext.notificationProvider,
+      });
+      void queryClient.invalidateQueries({
+        predicate: (query) => query.queryKey[0] === 'taskList'
+          && queryKeyMatchesTenant(query.queryKey, adminContext.tenantCacheKey),
+      });
       options.mutationOptions?.onSuccess?.(data, params, context);
     },
     onError: (error, params, context) => {
       checkError(error, adminContext);
-      fireErrorNotification(
-        params.errorNotification,
-        i18n.t('task.submitFailed'),
+      fireErrorNotification({
+        config: params.errorNotification,
+        defaultMessage: i18n.t('task.submitFailed'),
         error,
-        params.taskName,
-      );
+        resource: params.taskName,
+        provider: adminContext.notificationProvider,
+      });
       options.mutationOptions?.onError?.(error, params, context);
     },
   }));
@@ -109,7 +128,7 @@ export function useTask<TTask extends TaskRecord = TaskRecord, TError = HttpErro
     const provider = normalizeTaskProvider<TTask>(options.taskProvider, adminContext);
     const queryOptions = options.queryOptions;
     return {
-      queryKey: ['task', options.taskId],
+      queryKey: appendTenantCacheKey(['task', options.taskId], adminContext.tenantCacheKey),
       queryFn: async () => {
         if (!options.taskId) throw new Error('useTask requires a taskId');
         return provider.get(options.taskId);
@@ -131,12 +150,24 @@ export function useTask<TTask extends TaskRecord = TaskRecord, TError = HttpErro
     if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt) {
       lastSuccessAt = query.dataUpdatedAt;
       if (options.successNotification) {
-        fireSuccessNotification(options.successNotification, '', query.data, undefined, options.taskId);
+        fireSuccessNotification({
+          config: options.successNotification,
+          defaultMessage: '',
+          data: query.data,
+          resource: options.taskId,
+          provider: adminContext.notificationProvider,
+        });
       }
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error, adminContext);
-      fireErrorNotification(options.errorNotification, i18n.t('task.fetchFailed'), query.error, options.taskId);
+      fireErrorNotification({
+        config: options.errorNotification,
+        defaultMessage: i18n.t('task.fetchFailed'),
+        error: query.error,
+        resource: options.taskId,
+        provider: adminContext.notificationProvider,
+      });
     }
   });
 
@@ -176,7 +207,10 @@ export function useTaskList<TTask extends TaskRecord = TaskRecord, TError = Http
     const provider = normalizeTaskProvider<TTask>(options.taskProvider, adminContext);
     const queryOptions = options.queryOptions;
     return {
-      queryKey: ['taskList', options.dlq ? 'dlq' : 'default', options.params],
+      queryKey: appendTenantCacheKey(
+        ['taskList', options.dlq ? 'dlq' : 'default', options.params],
+        adminContext.tenantCacheKey,
+      ),
       queryFn: async () => {
         if (options.dlq) {
           if (!provider.listDlq) throw new Error('TaskProvider does not implement listDlq');
@@ -202,12 +236,25 @@ export function useTaskList<TTask extends TaskRecord = TaskRecord, TError = Http
     if (query.isSuccess && query.dataUpdatedAt > lastSuccessAt) {
       lastSuccessAt = query.dataUpdatedAt;
       if (options.successNotification) {
-        fireSuccessNotification(options.successNotification, '', query.data, options.params, options.dlq ? 'taskDlq' : 'tasks');
+        fireSuccessNotification({
+          config: options.successNotification,
+          defaultMessage: '',
+          data: query.data,
+          values: options.params,
+          resource: options.dlq ? 'taskDlq' : 'tasks',
+          provider: adminContext.notificationProvider,
+        });
       }
     } else if (query.isError && query.errorUpdatedAt > lastErrorAt) {
       lastErrorAt = query.errorUpdatedAt;
       checkError(query.error, adminContext);
-      fireErrorNotification(options.errorNotification, i18n.t('task.fetchListFailed'), query.error, options.dlq ? 'taskDlq' : 'tasks');
+      fireErrorNotification({
+        config: options.errorNotification,
+        defaultMessage: i18n.t('task.fetchListFailed'),
+        error: query.error,
+        resource: options.dlq ? 'taskDlq' : 'tasks',
+        provider: adminContext.notificationProvider,
+      });
     }
   });
 

package/src/types.ts

@@ -382,6 +382,28 @@ export type MutationMode = 'pessimistic' | 'optimistic' | 'undoable';
 
 // ─── ResourceDefinition ───────────────────────────────────────
 
+/** 声明资源使用的传输协议；具体 URL/序列化行为由对应 provider 实现。 */
+export interface ResourceTransportConfig {
+  readonly type: string;
+  readonly endpoint?: string;
+  readonly options?: Readonly<Record<string, unknown>>;
+}
+
+/** 声明资源使用的后端 adapter，不在 Core 内绑定具体运行时实现。 */
+export interface ResourceAdapterConfig {
+  readonly name: string;
+  readonly version?: string;
+  readonly options?: Readonly<Record<string, unknown>>;
+}
+
+/** 每资源的 provider 选择与声明性 transport/adapter 元数据。 */
+export interface ResourceProviderConfig {
+  readonly dataProviderName?: string;
+  readonly transport?: string | ResourceTransportConfig;
+  readonly adapter?: string | ResourceAdapterConfig;
+  readonly meta?: Readonly<Record<string, unknown>>;
+}
+
 export interface ResourceDefinition {
   name: string;
   /** Unique identifier — use when multiple resources share the same `name` but target different DataProviders */
@@ -401,6 +423,9 @@ export interface ResourceDefinition {
   menuOrder?: number;
   /** Navigation group name — resources with the same group are displayed in a collapsible section */
   group?: string;
+  /** DataProvider 选择及声明性 transport/adapter 元数据。 */
+  provider?: ResourceProviderConfig;
+  /** @deprecated 新代码优先使用 `provider.dataProviderName` 选择 DataProvider。 */
   meta?: Record<string, unknown> & { dataProviderName?: string; parent?: string };
 }
 

package/src/useCan.ts

@@ -1,7 +1,8 @@
 // useCan — reactive permission check hook with TanStack Query integration
 
 import { createQuery } from '@tanstack/svelte-query';
-import { canAccessAsync, getAccessControlProvider } from './permissions.svelte';
+import { captureAdminContext } from './context.svelte';
+import { appendTenantCacheKey } from './provider-bundle';
 import type { Action, CanResult } from './permissions.svelte';
 
 export interface UseCanOptions {
@@ -32,11 +33,24 @@ export interface UseCanResult {
  * ```
  */
 export function useCan(options: () => UseCanOptions): UseCanResult {
+  const adminContext = captureAdminContext();
   const query = createQuery<CanResult>(() => {
     const opts = options();
+    const provider = adminContext.accessControlProvider;
     return {
-      queryKey: ['useCan', opts.resource, opts.action, opts.params, opts.meta] as const,
-      queryFn: () => canAccessAsync(opts.resource, opts.action, opts.params, opts.meta),
+      queryKey: appendTenantCacheKey([
+        'useCan', opts.resource, opts.action, opts.params, opts.meta,
+      ], adminContext.tenantCacheKey),
+      queryFn: async () => {
+        if (!provider) return { can: true };
+        const result = await provider.can({
+          resource: opts.resource,
+          action: opts.action,
+          params: opts.params,
+          meta: adminContext.getProviderMeta(opts.resource, opts.meta),
+        });
+        return Array.isArray(result) ? (result[0] ?? { can: false }) : result;
+      },
       enabled: opts.queryOptions?.enabled ?? true,
       staleTime: opts.queryOptions?.staleTime ?? 5 * 60 * 1000,
     };
@@ -44,7 +58,7 @@ export function useCan(options: () => UseCanOptions): UseCanResult {
 
   return {
     get allowed() { 
-      const p = getAccessControlProvider();
+      const p = adminContext.accessControlProvider;
       if (!p) return true;
       return (query.data as CanResult | undefined)?.can ?? false; 
     },

package/src/utility-hooks.svelte.ts

@@ -2,6 +2,7 @@ import { useForm, type UseFormOptions } from './form-hooks.svelte';
 import { useQueryClient } from '@tanstack/svelte-query';
 import { useParsed } from './useParsed.svelte';
 import { captureAdminContext } from './context.svelte';
+import { queryKeyMatchesTenant } from './provider-bundle';
 import { getAdminOptions } from './options.svelte';
 import { t } from './i18n.svelte';
 import type { BaseRecord, HttpError, Filter, KnownResources, ResourceDefinition } from './types';
@@ -39,6 +40,7 @@ export function useModalForm<
   TError = HttpError,
 >(options: UseModalFormOptions<TVariables, TData, TError> = {} as UseModalFormOptions<TVariables, TData, TError>) {
   const queryClient = useQueryClient();
+  const adminContext = captureAdminContext();
   const formState = useForm<TVariables, TData, TError>(options);
   let visible = $state(options.defaultVisible ?? false);
 
@@ -58,7 +60,8 @@ export function useModalForm<
     formState.reset();
     if (options.autoSave?.invalidateOnClose) {
       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;
       queryClient.invalidateQueries({ predicate: (q) => dp(q) && q.queryKey[1] === formState.resource && (q.queryKey[2] === 'list' || q.queryKey[2] === 'infiniteList' || q.queryKey[2] === 'select') });
       queryClient.invalidateQueries({ predicate: (q) => dp(q) && q.queryKey[1] === formState.resource && q.queryKey[2] === 'many' });
       queryClient.invalidateQueries({ predicate: (q) => dp(q) && q.queryKey[1] === formState.resource && q.queryKey[2] === 'one' });
@@ -182,7 +185,33 @@ export function useRelation<TData extends BaseRecord = BaseRecord, TError = Http
 
 // ─── useNotification ────────────────────────────────────────
 export function useNotification() {
-  return { open: toast.info, success: toast.success, error: toast.error, warning: toast.warning };
+  const adminContext = captureAdminContext();
+
+  function sendToast(
+    type: 'success' | 'error' | 'warning' | 'info',
+    message: string,
+    duration?: number,
+    options?: { key?: string },
+  ): void {
+    const provider = adminContext.notificationProvider;
+    if (provider) {
+      provider.open({ type, message, key: options?.key });
+      return;
+    }
+    toast[type](message, duration, options);
+  }
+
+  return {
+    open: (message: string, duration?: number, options?: { key?: string }) =>
+      sendToast('info', message, duration, options),
+    success: (message: string, duration?: number, options?: { key?: string }) =>
+      sendToast('success', message, duration, options),
+    error: (message: string, duration?: number, options?: { key?: string }) =>
+      sendToast('error', message, duration, options),
+    warning: (message: string, duration?: number, options?: { key?: string }) =>
+      sendToast('warning', message, duration, options),
+    close: (key: string) => adminContext.notificationProvider?.close(key),
+  };
 }
 
 // ─── Field-specific hooks (refine-compatible) ─────────────────────