@svadmin/core 0.52.0 → 0.54.0

package/src/task-hooks.svelte.ts

@@ -1,5 +1,9 @@
 import { definedOptions } from './defined-options';
-import { createMutation,createQuery,useQueryClient } from '@tanstack/svelte-query';
+import { onDestroy } from 'svelte';
+import { createMutation,useQueryClient } from '@tanstack/svelte-query';
+import { createSessionQuery } from './session-query.svelte';
+import { supersededQuerySession } from './query-session.svelte';
+import { captureAuthLiveScope } from './auth-hooks.svelte';
 import { getAdminOptions } from './options.svelte';
 import { captureAdminContext } from './context.svelte';
 import type { AdminContextAccessor } from './context.svelte';
@@ -9,7 +13,7 @@ import {
 import { queryKeyMatches, type QueryKey } from './query-keys';
 import { replaceReactiveMembers } from './reactive-projection';
 import { taskQueryParams, withValidatedTaskProvider } from './task-provider';
-import type { TaskError } from './task-contract';
+import { TaskError, decodeTaskRecord, decodeTaskList } from './task-contract';
 import { checkError,createOvertimeTracker,fireErrorNotification,fireSuccessNotification } from './hook-utils.svelte';
 import type { NotificationConfig,OvertimeOptions } from './hook-utils.svelte';
 import { useTranslation } from './i18n.svelte';
@@ -48,6 +52,19 @@ function scopedTaskKey(key: QueryKey, provider: TaskProvider | undefined): Query
   return [{ ...key[0], params: definedOptions({ taskProvider: providerKey, query: key[0].params }) }];
 }
 
+function taskReadError(error: unknown): Error {
+  try {
+    if (typeof error === 'object' && error !== null) {
+      const code: unknown = Object.getOwnPropertyDescriptor(error, 'code')?.value;
+      if (code === 'QUERY_SESSION_SUPERSEDED') return supersededQuerySession();
+      if (code === 'INVALID_TASK_INPUT' || code === 'INVALID_TASK_RESPONSE' || code === 'TASK_PROVIDER_FAILED') {
+        return new TaskError(code);
+      }
+    }
+  } catch { /* 不执行错误对象中的 getter，也不回显上游诊断。 */ }
+  return new TaskError('TASK_PROVIDER_FAILED');
+}
+
 export interface UseSubmitTaskOptions {
   mutationOptions?: {
     onSuccess?: (data: unknown,variables: unknown,context: unknown) => void;
@@ -70,29 +87,74 @@ export function useSubmitTask(options: UseSubmitTaskOptions={}) {
   const adminOptions=getAdminOptions();
   const queryClient=useQueryClient();
   const overtime=createOvertimeTracker(() => mutation.isPending,options.overtimeOptions??adminOptions.overtime);
-  const submissionScopes = new WeakMap<TaskHandle, ReturnType<AdminContextAccessor['queryKeyMatcher']>>();
+  let disposed = false;
+  onDestroy(() => { disposed = true; });
+  interface SubmissionScope {
+    queryScope: ReturnType<AdminContextAccessor['queryKeyMatcher']>;
+    auth: ReturnType<typeof captureAuthLiveScope>;
+    notification: AdminContextAccessor['notificationProvider'];
+    current: () => boolean;
+  }
+  const submissionScopes = new WeakMap<TaskHandle, SubmissionScope>();
+  const failureScopes = new WeakMap<Error, SubmissionScope>();
 
   const mutation=createMutation<TaskHandle,Error,UseSubmitTaskMutateParams>(() => ({
     mutationFn: async (params) => {
-      const scope = adminContext.queryKeyMatcher();
-      const provider=normalizeTaskProvider(params.taskProvider,adminContext);
-      const providerMeta=adminContext.tenant
-        ? {
-          ...(params.options?.meta??{}),
-          ...resolveTenantProviderMeta(adminContext.tenant,adminContext.tenantAdapter),
-        }
-        :params.options?.meta;
-      const taskOptions=providerMeta===params.options?.meta
-        ? params.options
-        :definedOptions({
-          ...params.options,
-          meta: providerMeta,
-        });
-      const handle = await provider.submit(params.taskName,taskOptions);
-      submissionScopes.set(handle, scope);
-      return handle;
+      const authProvider = adminContext.authProvider;
+      const auth = captureAuthLiveScope(authProvider);
+      const source = params.taskProvider ?? adminContext.taskProvider;
+      const tenant = adminContext.tenantCacheKey?.__svadminTenant;
+      const router = adminContext.routerProvider;
+      const access = adminContext.accessControlProvider;
+      const notification = adminContext.notificationProvider;
+      const scope: SubmissionScope = {
+        queryScope: adminContext.queryKeyMatcher(),
+        auth,
+        notification,
+        current: () => !disposed && auth.isCurrent() && adminContext.authProvider === authProvider
+          && adminContext.tenantCacheKey?.__svadminTenant === tenant
+          && adminContext.routerProvider === router && adminContext.accessControlProvider === access
+          && adminContext.notificationProvider === notification
+          && (params.taskProvider ?? adminContext.taskProvider) === source,
+      };
+      if (!scope.current()) throw supersededQuerySession();
+      try {
+        const provider=normalizeTaskProvider(source,adminContext);
+        const providerMeta=adminContext.tenant
+          ? {
+            ...(params.options?.meta??{}),
+            ...resolveTenantProviderMeta(adminContext.tenant,adminContext.tenantAdapter),
+          }
+          :params.options?.meta;
+        const taskOptions=providerMeta===params.options?.meta
+          ? params.options
+          :definedOptions({
+            ...params.options,
+            meta: providerMeta,
+          });
+        const handle = await provider.submit(params.taskName,taskOptions);
+        submissionScopes.set(handle, scope);
+        return handle;
+      } catch (error) {
+        const failure = error instanceof TaskError ? error : new TaskError('TASK_PROVIDER_FAILED');
+        failureScopes.set(failure, scope);
+        throw failure;
+      }
     },
     onSuccess: (data,params,context) => {
+      const submission = submissionScopes.get(data);
+      if (submission) submissionScopes.delete(data);
+      if (!submission) return;
+      if (submission.auth.isCurrent()) {
+        void queryClient.invalidateQueries({
+          predicate: (query) => queryKeyMatches(query.queryKey,{
+            ...submission.queryScope,
+            kind: 'task',
+            action: 'list',
+          }),
+        });
+      }
+      if (!submission.current()) return;
       fireSuccessNotification({
         config: params.successNotification,
         defaultMessage: i18n.t('task.submitSuccess'),
@@ -100,34 +162,27 @@ export function useSubmitTask(options: UseSubmitTaskOptions={}) {
         values: params.options,
         resource: params.taskName,
         ...definedOptions({
-          provider: adminContext.notificationProvider
+          provider: submission.notification
         })
       });
-      const scope = submissionScopes.get(data);
-      if (scope) {
-        submissionScopes.delete(data);
-        void queryClient.invalidateQueries({
-          predicate: (query) => queryKeyMatches(query.queryKey,{
-            ...scope,
-            kind: 'task',
-            action: 'list',
-          }),
-        });
-      }
-      options.mutationOptions?.onSuccess?.(data,params,context);
+      if (submission.current()) options.mutationOptions?.onSuccess?.(data,params,context);
     },
     onError: (error,params,context) => {
+      const submission = failureScopes.get(error);
+      failureScopes.delete(error);
+      if (!submission?.current()) return;
       checkError(error,adminContext);
+      if (!submission.current()) return;
       fireErrorNotification({
         config: params.errorNotification,
         defaultMessage: i18n.t('task.submitFailed'),
         error,
         resource: params.taskName,
         ...definedOptions({
-          provider: adminContext.notificationProvider
+          provider: submission.notification
         })
       });
-      options.mutationOptions?.onError?.(error,params,context);
+      if (submission.current()) options.mutationOptions?.onError?.(error,params,context);
     },
   }));
 
@@ -157,12 +212,17 @@ export function useTask(
   const i18n=useTranslation();
   const adminOptions=getAdminOptions();
 
-  const query=createQuery<TaskRecord,Error>(() => {
+  const query=createSessionQuery<TaskRecord>(adminContext, () => {
     const activeProvider=options.taskProvider??adminContext.taskProvider;
     const provider=activeProvider? withValidatedTaskProvider(activeProvider):undefined;
     const taskId=options.taskId;
     const queryOptions=options.queryOptions;
     return {
+      resource: taskId ?? '',
+      successNotification: options.successNotification,
+      errorNotification: options.errorNotification ?? i18n.t('task.fetchFailed'),
+      normalizeError: taskReadError,
+      decode: value => decodeTaskRecord(value, taskId),
       queryKey: scopedTaskKey(adminContext.queryKeys().task.one(taskId??''),provider),
       queryFn: async () => {
         if(!provider) throw new Error('TaskProvider not found.');
@@ -184,37 +244,6 @@ export function useTask(
 
   const overtime=createOvertimeTracker(() => query.isLoading,options.overtimeOptions??adminOptions.overtime);
 
-  let lastSuccessAt=0;
-  let lastErrorAt=0;
-  $effect(() => {
-    if(query.isSuccess&&query.dataUpdatedAt>lastSuccessAt) {
-      lastSuccessAt=query.dataUpdatedAt;
-      if(options.successNotification) {
-        fireSuccessNotification({
-          config: options.successNotification,
-          defaultMessage: '',
-          data: query.data,
-          ...definedOptions({ resource: options.taskId }),
-          ...definedOptions({
-            provider: adminContext.notificationProvider
-          })
-        });
-      }
-    } else if(query.isError&&query.errorUpdatedAt>lastErrorAt) {
-      lastErrorAt=query.errorUpdatedAt;
-      checkError(query.error,adminContext);
-      fireErrorNotification({
-        config: options.errorNotification,
-        defaultMessage: i18n.t('task.fetchFailed'),
-        error: query.error,
-        ...definedOptions({ resource: options.taskId }),
-        ...definedOptions({
-          provider: adminContext.notificationProvider
-        })
-      });
-    }
-  });
-
   return replaceReactiveMembers(query,{ get overtime() { return overtime; } });
 }
 
@@ -242,25 +271,46 @@ export function useTaskList(
   const i18n=useTranslation();
   const adminOptions=getAdminOptions();
 
-  const query=createQuery<TaskListResult,Error>(() => {
+  const query=createSessionQuery<TaskListResult>(adminContext, () => {
     const activeProvider=options.taskProvider??adminContext.taskProvider;
     const provider=activeProvider? withValidatedTaskProvider(activeProvider):undefined;
     const params=options.params===undefined? undefined:taskQueryParams(options.params);
+    const callerMeta = params?.['meta'];
+    if (callerMeta !== undefined
+      && (typeof callerMeta !== 'object' || callerMeta === null || Array.isArray(callerMeta))) {
+      throw new TaskError('INVALID_TASK_INPUT');
+    }
+    const tenantMeta = adminContext.tenant
+      ? resolveTenantProviderMeta(adminContext.tenant, adminContext.tenantAdapter)
+      : undefined;
+    const providerParams = params === undefined && tenantMeta === undefined ? undefined : {
+      ...(params ?? {}),
+      ...(tenantMeta ? { meta: { ...(callerMeta ?? {}), ...tenantMeta } } : {}),
+    };
     const dlq=options.dlq??false;
     const queryOptions=options.queryOptions;
+    const resource = dlq ? 'taskDlq' : 'tasks';
+    const successNotification = options.successNotification;
     return {
+      resource,
+      successNotification: typeof successNotification === 'function'
+        ? (data: unknown) => successNotification(data, params, resource)
+        : successNotification,
+      errorNotification: options.errorNotification ?? i18n.t('task.fetchListFailed'),
+      normalizeError: taskReadError,
+      decode: decodeTaskList,
       queryKey: scopedTaskKey(adminContext.queryKeys().task.list(definedOptions({
         list: dlq? 'dlq':'default',
-        params,
+        params: providerParams,
       })),provider),
       queryFn: async () => {
         if(!provider) throw new Error('TaskProvider not found.');
         if(dlq) {
           if(!provider.listDlq) throw new Error('TaskProvider does not implement listDlq');
-          return provider.listDlq(params);
+          return provider.listDlq(providerParams);
         }
         if(!provider.list) throw new Error('TaskProvider does not implement list');
-        return provider.list(params);
+        return provider.list(providerParams);
       },
       enabled: queryOptions?.enabled??true,
       ...definedOptions({
@@ -277,38 +327,6 @@ export function useTaskList(
 
   const overtime=createOvertimeTracker(() => query.isLoading,options.overtimeOptions??adminOptions.overtime);
 
-  let lastSuccessAt=0;
-  let lastErrorAt=0;
-  $effect(() => {
-    if(query.isSuccess&&query.dataUpdatedAt>lastSuccessAt) {
-      lastSuccessAt=query.dataUpdatedAt;
-      if(options.successNotification) {
-        fireSuccessNotification({
-          config: options.successNotification,
-          defaultMessage: '',
-          data: query.data,
-          values: options.params,
-          resource: options.dlq? 'taskDlq':'tasks',
-          ...definedOptions({
-            provider: adminContext.notificationProvider
-          })
-        });
-      }
-    } else if(query.isError&&query.errorUpdatedAt>lastErrorAt) {
-      lastErrorAt=query.errorUpdatedAt;
-      checkError(query.error,adminContext);
-      fireErrorNotification({
-        config: options.errorNotification,
-        defaultMessage: i18n.t('task.fetchListFailed'),
-        error: query.error,
-        resource: options.dlq? 'taskDlq':'tasks',
-        ...definedOptions({
-          provider: adminContext.notificationProvider
-        })
-      });
-    }
-  });
-
   return replaceReactiveMembers(query,{ get overtime() { return overtime; } });
 }
 
@@ -328,19 +346,36 @@ export function useTaskSubscription(
     const enabled=options.enabled??true;
     if(!enabled) return;
 
-    const provider=normalizeTaskProvider(options.taskProvider,adminContext);
+    const authProvider = adminContext.authProvider;
+    const auth = captureAuthLiveScope(authProvider);
+    if (!auth.available) return;
+    const source = options.taskProvider ?? adminContext.taskProvider;
+    const tenant = adminContext.tenantCacheKey?.__svadminTenant;
+    const router = adminContext.routerProvider;
+    const access = adminContext.accessControlProvider;
+    const taskId = options.taskId;
+    const onTask = options.onTask;
+    const onError = options.onError;
+    let active = true;
+    const current = () => active && (options.enabled ?? true) && options.taskId === taskId
+      && (options.taskProvider ?? adminContext.taskProvider) === source
+      && adminContext.authProvider === authProvider && auth.isCurrent()
+      && adminContext.tenantCacheKey?.__svadminTenant === tenant
+      && adminContext.routerProvider === router && adminContext.accessControlProvider === access;
+    const provider=normalizeTaskProvider(source,adminContext);
     if(!provider.subscribe) {
       throw new Error('TaskProvider does not implement subscribe');
     }
 
-    const subscription=provider.subscribe(options.taskId,options.onTask,options.onError);
-
-    if(typeof subscription==='function') {
-      return subscription;
-    }
-
-    if(typeof subscription.unsubscribe==='function') {
-      return () => subscription.unsubscribe();
-    }
+    const subscription=provider.subscribe(taskId,
+      task => { if (current()) onTask(task); },
+      error => { if (current()) onError?.(error); },
+    );
+    return () => {
+      // 先失效，再退订；上游退订时同步发出的最后一条事件也不能进入新会话。
+      active = false;
+      if (typeof subscription === 'function') subscription();
+      else subscription.unsubscribe();
+    };
   });
 }

package/src/types.ts

@@ -405,12 +405,28 @@ export interface MenuItem {
   children?: MenuItem[];
 }
 
+export interface DateInputOptions {
+  min?: string;
+  max?: string;
+  step?: number;
+  /** 仅用于 daterange；其他日期字段由 field.type 决定输入模式。 */
+  rangeMode?: 'date' | 'time' | 'datetime';
+  disabledDate?: (date: string) => boolean;
+  presets?: { label: string; value: { start: string; end: string } }[];
+  /** datetime 字段的输出语义；默认保留本地 datetime-local 字符串。 */
+  valueMode?: 'civil' | 'instant';
+  /** valueMode=instant 时必填的 IANA 时区。 */
+  timeZone?: string;
+  /** 仅用于 datetime，重复本地时刻默认拒绝，允许明确选择较早或较晚的一次。 */
+  disambiguation?: 'reject' | 'earlier' | 'later';
+}
+
 export interface FieldDefinition {
   key: string;
   label: string;
-  type: 'text' | 'number' | 'boolean' | 'date' | 'select' | 'multiselect' | 'tags'
+  type: 'text' | 'number' | 'boolean' | 'date' | 'time' | 'datetime' | 'daterange' | 'select' | 'multiselect' | 'tags'
     | 'textarea' | 'richtext' | 'image' | 'images' | 'json' | 'relation' | 'color'
-    | 'url' | 'email' | 'phone' | 'currency' | 'file' | 'markdown' | 'password' | 'array'
+    | 'url' | 'email' | 'phone' | 'currency' | 'percent' | 'file' | 'markdown' | 'password' | 'array'
     | 'tree-select' | 'treeselect' | 'cascader' | 'transfer' | 'rate' | 'rating' | 'avatar' | 'copy' | 'code';
   required?: boolean;
   searchable?: boolean;
@@ -430,6 +446,19 @@ export interface FieldDefinition {
   changeOnSelect?: boolean;
   separator?: string;
   defaultValue?: unknown;
+  // Numeric input contract
+  min?: number;
+  max?: number;
+  step?: number;
+  precision?: number;
+  currency?: string;
+  locale?: string;
+  scale?: '100' | '1';
+  // 日期输入策略与数值上下限分离，不隐式转换时区。
+  dateInput?: DateInputOptions;
+  // File upload contract
+  accept?: string;
+  maxSize?: number;
   // Relation support
   resource?: string;       // related resource name
   optionLabel?: string;    // field to use as label