@svadmin/core 0.53.0 → 0.55.0

package/src/export-hooks.svelte.ts

@@ -1,12 +1,15 @@
 import { captureAdminContext } from './context.svelte';
-import { definedOptions } from './defined-options';
-import { HttpError } from './types';
+import { definedOptions, definedReactiveOptions } from './defined-options';
+import { HttpError, type TaskProvider, type TaskRecord } from './types';
+import { untrack } from 'svelte';
+import { captureAuthLiveScope } from './auth-hooks.svelte';
 import { contractKey, parseContractRecord, type ResourceContract, type ContractSchemas, type ContractRecord } from './resource-contract';
 import type { ContractFilter, ContractSort } from './strict-hooks.svelte';
 import { captureQueryProvider, snapshotListParams } from './query-snapshot';
 import { decodeBaseRecord, decodeListResult } from './record-decoder';
 import { snapshotPlainData } from './plain-data';
-import { downloadData, type ExportFormat } from './export-format';
+import { downloadData, downloadExportArtifact, snapshotExportTaskResult, safeArtifactUrl, type ExportFormat } from './export-format';
+import { useSubmitTask, useTask } from './task-hooks.svelte';
 
 export interface UseExportOptions<S extends ContractSchemas> {
   resource: ResourceContract<S>;
@@ -19,6 +22,12 @@ export interface UseExportOptions<S extends ContractSchemas> {
   format?: ExportFormat;
   meta?: Record<string, unknown>;
   dataProviderName?: string;
+  enabled?: boolean;
+  taskName?: string;
+  taskProvider?: TaskProvider;
+  taskIdempotencyKey?: string;
+  initialTaskId?: string;
+  onTaskSubmitted?: (taskId: string) => void | Promise<void>;
   onError?: (error: HttpError) => void | Promise<void>;
 }
 
@@ -53,6 +62,10 @@ export function useExport<S extends ContractSchemas>(options: UseExportOptions<S
   let isLoading = $state(false);
   let error = $state<HttpError | null>(null);
   let mounted = true;
+  let taskId = $state<string | undefined>(untrack(() => options.initialTaskId));
+  let taskHandledId = $state<string | undefined>();
+  const submitTask = useSubmitTask();
+  const taskMode = $derived(options.taskName !== undefined);
 
   function captureScope() {
     const contract = options.resource;
@@ -63,16 +76,52 @@ export function useExport<S extends ContractSchemas>(options: UseExportOptions<S
     });
     return {
       contract, ...captured,
+      authProvider: context.authProvider, auth: captureAuthLiveScope(context.authProvider),
+      router: context.routerProvider, access: context.accessControlProvider,
+      taskProvider: options.taskProvider ?? context.taskProvider,
+      taskName: options.taskName, idempotencyKey: options.taskIdempotencyKey, format: options.format ?? 'csv',
+      taskQueryKey: options.taskName === undefined ? undefined : JSON.stringify(snapshotPlainData({
+        filters: options.filters ?? [], sorters: options.sorters ?? [],
+        maxItemCount: options.maxItemCount ?? null,
+      })),
       key: JSON.stringify([key, captured.source, context.tenantCacheKey?.__svadminTenant, captured.meta]),
     };
   }
   type Scope = ReturnType<typeof captureScope>;
+  let taskOrigin = $state.raw<Scope | undefined>(
+    untrack(() => {
+      try { return taskId && taskMode ? captureScope() : undefined; }
+      catch { return undefined; }
+    }),
+  );
+  let taskPolling = $state(true);
   let current: { token: object; scope: Scope; promise: Promise<ContractRecord<S>[]> } | undefined;
+  const taskProvider = $derived(options.taskProvider ?? context.taskProvider);
+  const ownedTaskId = $derived(taskOrigin && scopeCurrent(taskOrigin) ? taskId : undefined);
+  const taskQuery = useTask(definedReactiveOptions({
+    get taskId() { return ownedTaskId; },
+    get taskProvider() { return taskProvider; },
+    get queryOptions() {
+      return { enabled: taskMode && !!ownedTaskId && !!taskProvider,
+        refetchInterval: ownedTaskId && taskPolling ? 2000 : false as const };
+    },
+  }));
+
+  function scopeCurrent(scope: Scope, requireEnabled = true): boolean {
+    if (!mounted || (requireEnabled && options.enabled === false) || !scope.auth.isCurrent()) return false;
+    try {
+      const next = captureScope();
+      return next.key === scope.key && next.authProvider === scope.authProvider &&
+        next.router === scope.router && next.access === scope.access &&
+        next.taskName === scope.taskName &&
+        (scope.taskName === undefined || (next.taskProvider === scope.taskProvider &&
+          next.taskName === scope.taskName && next.idempotencyKey === scope.idempotencyKey &&
+          next.format === scope.format && next.taskQueryKey === scope.taskQueryKey));
+    } catch { return false; }
+  }
 
   function isActive(token: object, scope: Scope): boolean {
-    if (!mounted || current?.token !== token) return false;
-    try { return captureScope().key === scope.key; }
-    catch { return false; }
+    return current?.token === token && scopeCurrent(scope);
   }
 
   let initialized = false;
@@ -89,6 +138,23 @@ export function useExport<S extends ContractSchemas>(options: UseExportOptions<S
     previousScope = nextScope;
     initialized = true;
   });
+  let wasEnabled = untrack(() => options.enabled !== false);
+  $effect.pre(() => {
+    const enabled = options.enabled !== false;
+    const revoked = wasEnabled && !enabled;
+    wasEnabled = enabled;
+    if (current && !scopeCurrent(current.scope)) {
+      current = undefined;
+      isLoading = false;
+      error = null;
+    }
+    if (taskOrigin && (revoked || !scopeCurrent(taskOrigin, false))) {
+      taskOrigin = undefined;
+      taskId = undefined;
+      taskHandledId = undefined;
+      error = null;
+    }
+  });
   $effect(() => () => {
     mounted = false;
     current = undefined;
@@ -106,12 +172,54 @@ export function useExport<S extends ContractSchemas>(options: UseExportOptions<S
     }
   }
 
+  function taskStatus(value: TaskRecord | undefined): 'queued' | 'processing' | 'completed' | 'failed' | 'cancelled' | 'unknown' {
+    const status = String(value?.status ?? '').trim().toLowerCase();
+    if (['pending', 'queued', 'scheduled', 'retry_scheduled'].includes(status)) return 'queued';
+    if (['running', 'processing', 'active', 'leased'].includes(status)) return 'processing';
+    if (['completed', 'complete', 'success', 'succeeded', 'done'].includes(status)) return 'completed';
+    if (['failed', 'error', 'dead_lettered'].includes(status)) return 'failed';
+    if (['cancelled', 'canceled', 'aborted'].includes(status)) return 'cancelled';
+    return 'unknown';
+  }
+
+  const artifact = $derived.by(() => {
+    const task = taskQuery.data;
+    if (!ownedTaskId || !task || taskStatus(task) !== 'completed') return undefined;
+    const result = snapshotExportTaskResult(task.result ?? task.result_data);
+    return result && result.format === taskOrigin?.format && safeArtifactUrl(result.downloadUrl) ? result : undefined;
+  });
+
+  $effect(() => {
+    const task = taskQuery.data;
+    if (!taskMode || !task || !ownedTaskId || taskHandledId === ownedTaskId) return;
+    const status = taskStatus(task);
+    if (status === 'queued' || status === 'processing' || status === 'unknown') return;
+    taskHandledId = ownedTaskId;
+    taskPolling = false;
+    if (status === 'completed' && !artifact) report(new HttpError(
+      'Invalid export task result', 502, undefined, { code: 'INVALID_PROVIDER_RESPONSE' }), options.onError);
+    else if (status === 'failed') report(exportFailure(undefined), options.onError);
+  });
+
+  function downloadTask(): boolean {
+    if (!artifact || !taskOrigin || !scopeCurrent(taskOrigin)) return false;
+    try {
+      downloadExportArtifact(artifact, taskOrigin.contract.name);
+      return true;
+    } catch {
+      report(new HttpError('Invalid export artifact', 502, undefined, { code: 'INVALID_PROVIDER_RESPONSE' }), options.onError);
+      return false;
+    }
+  }
+
   function triggerExport(): Promise<ContractRecord<S>[]> {
     if (!mounted) return Promise.reject(cancelled());
     let onError: UseExportOptions<S>['onError'];
     try {
       const scope = captureScope();
-      if (current?.scope.key === scope.key) return current.promise;
+      if (!scopeCurrent(scope)) return Promise.reject(cancelled());
+      if (current && scopeCurrent(current.scope)) return current.promise;
+      if (scope.taskName !== undefined && ownedTaskId) return Promise.resolve([]);
       previousScope = scope.key;
       initialized = true;
       const batchSize = options.pageSize ?? 20;
@@ -119,6 +227,10 @@ export function useExport<S extends ContractSchemas>(options: UseExportOptions<S
       const format = options.format ?? 'csv';
       const download = options.download ?? true;
       const mapData = options.mapData;
+      const taskName = scope.taskName;
+      const taskSource = scope.taskProvider;
+      const idempotencyKey = scope.idempotencyKey;
+      const onTaskSubmitted = options.onTaskSubmitted;
       onError = options.onError;
       if (!Number.isSafeInteger(batchSize) || batchSize <= 0 ||
           (maxItems !== Infinity && (!Number.isSafeInteger(maxItems) || maxItems < 0)) ||
@@ -141,6 +253,34 @@ export function useExport<S extends ContractSchemas>(options: UseExportOptions<S
       const promise = Promise.resolve().then(async () => {
         try {
           ensureActive();
+          if (taskName !== undefined) {
+            if (!taskName.trim() || !taskSource || !idempotencyKey?.trim() || mapData !== undefined) invalidInput();
+            const task = await submitTask.mutation.mutateAsync({
+              taskName: taskName.trim(),
+              taskProvider: taskSource,
+              successNotification: false,
+              errorNotification: false,
+              options: {
+                idempotencyKey,
+                body: {
+                  protocolVersion: 1,
+                  resource: scope.contract.name,
+                  format,
+                  filters: params.filters ?? [],
+                  sorters: params.sorters ?? [],
+                  ...definedOptions(maxItems === Infinity ? {} : { maxItemCount: maxItems }),
+                },
+                ...definedOptions(scope.meta === undefined ? {} : { meta: scope.meta }),
+              },
+            });
+            ensureActive();
+            taskId = task.id;
+            taskOrigin = scope;
+            taskHandledId = undefined;
+            taskPolling = true;
+            try { void Promise.resolve(onTaskSubmitted?.(task.id)).catch(() => {}); } catch { /* Observer failures do not re-submit. */ }
+            return [];
+          }
           const records: ContractRecord<S>[] = [];
           let page = 1;
           while (records.length < maxItems) {
@@ -187,5 +327,26 @@ export function useExport<S extends ContractSchemas>(options: UseExportOptions<S
     }
   }
 
-  return { triggerExport, get isLoading() { return isLoading; }, get error() { return error; } };
+  return {
+    triggerExport,
+    get isLoading() { return isLoading; },
+    get error() { return error; },
+    get taskId() { return ownedTaskId; },
+    get task() { return ownedTaskId ? taskQuery.data : undefined; },
+    get artifact() { return artifact; },
+    get taskError() { return ownedTaskId ? taskQuery.error : null; },
+    get isTaskPending() {
+      return !!ownedTaskId && !['completed', 'failed', 'cancelled'].includes(taskStatus(taskQuery.data));
+    },
+    get refetchTask() {
+      const origin = taskOrigin;
+      const id = ownedTaskId;
+      const refetch = taskQuery.refetch;
+      return () => {
+        if (!origin || !id || id !== ownedTaskId || !scopeCurrent(origin)) return Promise.reject(cancelled());
+        return refetch();
+      };
+    },
+    downloadTask,
+  };
 }

package/src/filter-values.ts

@@ -0,0 +1,42 @@
+import type { CrudOperator, FieldDefinition } from './types';
+
+export const FILTER_COLLECTION_LIMIT = 100;
+
+export function isNumericFilterField(field: FieldDefinition | undefined): boolean {
+  return field !== undefined && ['number', 'currency', 'percent', 'rating', 'rate'].includes(field.type);
+}
+
+export function isCollectionFilterOperator(operator: string): boolean {
+  return ['in', 'nin', 'between', 'nbetween'].includes(operator);
+}
+
+export function filterOperatorsForField(field: FieldDefinition | undefined): CrudOperator[] {
+  if (!field || field.filterable === false) return [];
+  if (isNumericFilterField(field)) {
+    return ['eq', 'ne', 'lt', 'gt', 'lte', 'gte', 'in', 'nin', 'between', 'nbetween', 'null', 'nnull'];
+  }
+  if (field.type === 'boolean' || field.type === 'select') return ['eq', 'ne', 'in', 'nin', 'null', 'nnull'];
+  if (['date', 'time', 'datetime'].includes(field.type)) return ['eq', 'ne', 'lt', 'gt', 'lte', 'gte', 'null', 'nnull'];
+  return ['eq', 'ne', 'contains', 'ncontains', 'startswith', 'endswith', 'lt', 'gt', 'lte', 'gte', 'in', 'nin', 'null', 'nnull'];
+}
+
+export function isFilterScalarValue(field: FieldDefinition, value: unknown): boolean {
+  if (isNumericFilterField(field)) return typeof value === 'number' && Number.isFinite(value);
+  if (field.type === 'boolean') return typeof value === 'boolean';
+  if (field.type === 'select') return field.options?.some(option => !option.disabled && option.value === value) === true;
+  return typeof value === 'string';
+}
+
+/** 不排序、不去重、不强制转换；非法集合不能退化为无筛选查询。 */
+export function isFilterCollectionValue(field: FieldDefinition | undefined, operator: string, value: unknown): boolean {
+  if (!field || !filterOperatorsForField(field).includes(operator as CrudOperator)
+    || !isCollectionFilterOperator(operator) || !Array.isArray(value)
+    || value.length < 1 || value.length > FILTER_COLLECTION_LIMIT) return false;
+  for (let index = 0; index < value.length; index++) {
+    if (!Object.hasOwn(value, index) || !isFilterScalarValue(field, value[index])) return false;
+  }
+  if (operator === 'between' || operator === 'nbetween') {
+    return value.length === 2 && typeof value[0] === 'number' && typeof value[1] === 'number' && value[0] <= value[1];
+  }
+  return true;
+}

package/src/gantt.ts

@@ -0,0 +1,84 @@
+export interface GanttTaskShape {
+  id: string;
+  title: string;
+  startDay: number;
+  durationDays: number;
+  progress?: number;
+  status?: 'planned' | 'in_progress' | 'completed' | 'delayed';
+  dependencies?: string[];
+  milestone?: boolean;
+}
+
+export type GanttValidationError = 'invalidData' | 'limit' | 'dependency';
+
+export const GANTT_LIMITS = Object.freeze({
+  tasks: 1000,
+  days: 366,
+  cells: 40_000,
+  dependencies: 10_000,
+});
+
+export function validateGantt<T extends GanttTaskShape>(
+  tasks: readonly T[],
+  totalDays: number,
+): GanttValidationError | undefined {
+  if (!Array.isArray(tasks) || !Number.isSafeInteger(totalDays) || totalDays < 1 || totalDays > GANTT_LIMITS.days) {
+    return 'invalidData';
+  }
+  if (tasks.length > GANTT_LIMITS.tasks || tasks.length * totalDays > GANTT_LIMITS.cells) return 'limit';
+  const ids = new Set<string>();
+  const byId = new Map<string, T>();
+  let edgeCount = 0;
+  for (const task of tasks) {
+    if (!task || typeof task.id !== 'string' || !task.id.trim() || ids.has(task.id)
+      || typeof task.title !== 'string' || !task.title.trim()
+      || task.id.length > 1000 || task.title.length > 1000
+      || !Number.isSafeInteger(task.startDay) || task.startDay < 0
+      || !Number.isSafeInteger(task.durationDays)
+      || (task.milestone === true ? task.durationDays !== 0 || task.startDay >= totalDays : task.durationDays < 1)
+      || task.startDay + task.durationDays > totalDays
+      || (task.progress !== undefined && (typeof task.progress !== 'number' || !Number.isFinite(task.progress) || task.progress < 0 || task.progress > 100))
+      || (task.status !== undefined && !['planned', 'in_progress', 'completed', 'delayed'].includes(task.status))) {
+      return 'invalidData';
+    }
+    if ((task.milestone !== undefined && typeof task.milestone !== 'boolean')
+      || (task.dependencies !== undefined && (!Array.isArray(task.dependencies)
+        || task.dependencies.length > GANTT_LIMITS.tasks
+        || new Set(task.dependencies).size !== task.dependencies.length
+        || task.dependencies.some((dependency: unknown) => typeof dependency !== 'string' || !dependency.trim() || dependency.length > 1000)))) {
+      return 'invalidData';
+    }
+    edgeCount += task.dependencies?.length ?? 0;
+    if (edgeCount > GANTT_LIMITS.dependencies) return 'limit';
+    ids.add(task.id);
+    byId.set(task.id, task);
+  }
+  const successors = new Map<string, string[]>();
+  const remaining = new Map<string, number>();
+  const ready: string[] = [];
+  for (const task of tasks) {
+    remaining.set(task.id, task.dependencies?.length ?? 0);
+    if (!task.dependencies?.length) ready.push(task.id);
+    for (const dependency of task.dependencies ?? []) {
+      const parent = byId.get(dependency);
+      if (!parent) return 'dependency';
+      if (parent.startDay + parent.durationDays > task.startDay) return 'dependency';
+      const children = successors.get(dependency) ?? [];
+      children.push(task.id);
+      successors.set(dependency, children);
+    }
+  }
+  // 有界迭代拓扑检查，零时长里程碑成环也必须被拒绝。
+  for (let index = 0; index < ready.length; index++) {
+    const id = ready[index];
+    if (id === undefined) return 'dependency';
+    for (const child of successors.get(id) ?? []) {
+      const pending = remaining.get(child);
+      if (pending === undefined) return 'dependency';
+      const count = pending - 1;
+      remaining.set(child, count);
+      if (count === 0) ready.push(child);
+    }
+  }
+  return ready.length === tasks.length ? undefined : 'dependency';
+}